并查集详解 (转)

 1 int pre[1000 ];
 2 int find(int x)                                  //查找根节点
 3 { 
 4     int r=x;
 5     while ( pre[r ] != r )                       //返回根节点 r
 6           r=pre[r ];
 7  
 8     int i=x , j ;
 9     while( i != r )                              //路径压缩
10     {
11          j = pre[ i ]; // 在改变上级之前用临时变量  j 记录下他的值 
12          pre[ i ]= r ; //把上级改为根节点
13          i=j;
14     }
15     return r ;
16 }
17  
18 
19 
20  //判断x y是否连通，如果已经连通，就不用管了 
21 如果不连通，就把它们所在的连通分支合并起,
22 void join(int x,int y) 
23 {
24     int fx=find(x),fy=find(y);
25     if(fx!=fy)
26         pre[fx ]=fy;
27 }
28  

1 int find(int x)              //查找我（x）的掌门
2 {
3     int r=x;                 //委托 r 去找掌门
4     while (pre[r ]!=r)       //如果r的上级不是r自己（也就是说找到的大侠他不是掌门 = =）
5     r=pre[r ] ;              // r 就接着找他的上级，直到找到掌门为止。
6     return  r ;              //掌门驾到~~~
7 }

1 void join(int x,int y)                             //我想让虚竹和周芷若做朋友
2 {
3     int fx=find(x),fy=find(y);                     //虚竹的老大是玄慈，芷若MM的老大是灭绝
4     if(fx!=fy)                                     //玄慈和灭绝显然不是同一个人
5     pre[fx ]=fy;                                   //方丈只好委委屈屈地当了师太的手下啦
6 }

  1 #include <iostream>  
  2 using namespace std;  
  3   
  4 #define N 1000  
  5 int leader[N + 1] = {0}; // 先搞一个充分大的数组  
  6   
  7 // 初始化  
  8 void setLeader()  
  9 {  
 10     int i = 1;  
 11     for(i = 1; i <= N; i++)  
 12     {  
 13         leader[i] = i; // 初始化时， 将自己初始化为自己的领导  
 14     }  
 15 }  
 16   
 17 // 查找领导， 看看究竟是谁(实际上， 还可以进行路径压缩优化)  
 18 int findLeader(int n)   
 19 {  
 20     int r = n;  
 21     while(leader[r] != r)  
 22     {  
 23         r = leader[r]; // 没找到的话， 一直往上找  
 24     }  
 25   
 26     return r;  
 27 }  
 28   
 29 // 将两个领导带领的团队融合, 从此， leaderX和leaderY建立了新的统一战线， 是一个大家庭团队了  
 30 void uniteSet(int leaderX, int leaderY)  
 31 {  
 32     leader[leaderX] = leaderY;  // leader[leaderY] = leaderX;  
 33 }  
 34   
 35 // 输入数组, 每一行表示一个集合关系， 比如第一行表示3和4属于一个集合团队  
 36 int input[] =   
 37 {  
 38     3, 4,  
 39     4, 2,  
 40     7, 6,   
 41     5, 1,  
 42     3, 9,  
 43     11, 8,  
 44     6, 10,  
 45     9, 13,  
 46     11, 12,  
 47 };  
 48   
 49 // 测试数组， 测试每行的两个整数是否属于同一个大的家庭团队  
 50 int test[] =  
 51 {  
 52     3, 2,  
 53     9, 4,  
 54     7, 10,  
 55     6, 7,  
 56     13, 4,  
 57     8, 12,  
 58   
 59     6, 9,  
 60     4, 7,  
 61     11, 10,  
 62     1, 2,  
 63     12, 13,  
 64     7, 13,  
 65 };  
 66   
 67   
 68 int main()  
 69 {  
 70     int numberOfSets = 13; // 总共有13个元素， 即1, 2, 3, 4, ...., 13  
 71   
 72     // 初始化领导  
 73     setLeader();  
 74   
 75     int i = 0;  
 76     int j = 0;  
 77     int n = sizeof(input) / sizeof(input[0]) / 2;  
 78     for(j = 0; j < n; j++)  
 79     {  
 80         int u = input[i++];  
 81         int v = input[i++];  
 82           
 83         // 找领导  
 84         u = findLeader(u);  
 85         v = findLeader(v);  
 86   
 87         // 领导不相等， 则融合着两个团队， 合二为一  
 88         if(u != v)  
 89         {  
 90             uniteSet(u, v);  
 91             numberOfSets--;  
 92         }  
 93     }  
 94   
 95     i = 0;  
 96     n = sizeof(test) / sizeof(test[0]) / 2;  
 97     for(j = 0; j < n; j++)  
 98     {  
 99         int u = test[i++];  
100         int v = test[i++];  
101           
102         // 找领导  
103         u = findLeader(u);  
104         v = findLeader(v);  
105   
106         // 如果领导不相同， 则不属于一个团队； 如果两个领导相同， 则肯定属于一个团队  
107         if(u != v)  
108         {  
109             cout << "NO" << endl;  
110         }  
111         else  
112         {  
113             cout << "YES" << endl;  
114         }  
115     }  
116   
117   
118     // 其实， 经合并后， 最后的集合是4个：  
119     // {3, 4, 2, 9, 13}, {7, 6, 10,}, {5, 1}, {11, 8, 12}  
120     cout << numberOfSets << endl;  
121   
122     return 0;  
123 }