并查集(union)模板

并查集模板1(常用)

1. int findset(int x)//查    
2. {    
3.     if(x != father[x])    
4.         father[x]=findset(father[x]);//查的过程中进行路径压缩，有效加快并查集运算    
5.     return father[x];    
6. }    
7.     
8. int unionset(int a, int b)//并    
9. {    
10.     int x=findset(a);    
11.     int y=findset(b);    
12. 
    
13.     if(x != y)     //不在同一根上，进行合并操作
    1.  
       1.    
14.         father[y]=x;
15.     return 0;    
16. }   

并查集模板2

1. int parent[Max]; //记录结点的双亲   
2. 
   
3. int rank[Max];   //记录结点的深度  
4.   
5. void init(int n)   //初始化   
6. {  
7.    int i;  
8.    for(i=0;i<=n;i++)  
9.    {  
10.       parent[i]=i;  
11.       rank[i]=1;   
12.    }  
13. }   
14. int find(int x)    //查找   
15. {  
16.    int t=x, temp;  
17.    while(parent[x]!=x) //找所属集合，即根结点        
18.          
19.          x=parent[x];  //x为最终找到的根节点    
20.    
21.     while(parent[t]!=x)    
22.     {   
23.        //路径压缩，使深度不为1的点向上浮。  
24.        temp=parent[t];     
25.        parent[t]=x;          
26.        rank[t]=1;      
27.        t=temp;    
28.     }   
29.    return x;   
    1. 1. //x为最终找到的根节点 
30. }  
31. 
    
32. void merge(int x,int y)    //合并   
33. {    
34.      int tx=find(x);     
35.      int ty=find(y);    
36.      if(tx!=ty)  //路径压缩 ，合并操作，离根距离更远的节点，向近的合并靠拢  
37.      {  
38.         if (rank[tx]<rank[ty])    
39.         {  
40.            parent[ty]=tx;  
41.            rank[ty]+=rank[tx];   
42.            rank[tx]=1;        
43.         }  
44.         else    
45.         {  
46.            parent[tx]=ty;  
47.            rank[tx]+=rank[ty];  
48.            rank[ty]=1;        
49.         }       
50.     }   
51. }