经典并查集（原文作者gemire）

http://blog.csdn.net/gemire/article/details/20566907

Description

动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。 
现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。 
有人用两种说法对这N个动物所构成的食物链关系进行描述： 
第一种说法是"1 X Y"，表示X和Y是同类。 
第二种说法是"2 X Y"，表示X吃Y。 
此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。 
1） 当前的话与前面的某些真的话冲突，就是假话； 
2） 当前的话中X或Y比N大，就是假话； 
3） 当前的话表示X吃X，就是假话。 
你的任务是根据给定的N（1 <= N <= 50,000）和K句话（0 <= K <= 100,000），输出假话的总数。 

Input

第一行是两个整数N和K，以一个空格分隔。 
以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。 
若D=1，则表示X和Y是同类。 
若D=2，则表示X吃Y。

Output

只有一个整数，表示假话的数目。

Sample Input

100 7
1 101 1 
2 1 2
2 2 3 
2 3 3 
1 1 3 
2 3 1 
1 5 5

Sample Output

3

最终AC代码：

[cpp]  view plain copy print ?

1. #include<iostream>  
2. using namespace std;  
3. const int MAX_N = 50010;  
4. int set[MAX_N];  
5. int r[MAX_N];  
6. void init(int n)  
7. {  
8.     for (int i = 0; i <= n; i++)  
9.     {  
10.         set[i] = i;  
11.         r[i] = 0;  
12.     }  
13. }  
14. //原理如下：  
15. //首先，集合里的每个点我们都记录它与它这个集合(或者称为子树)的根结点的相对关系relation。0表示它与根结点为同类，1表示它吃根结点，2表示它被根结点吃。  
16. //那么判断两个点a, b的关系，我们令p = Find(a), q = Find(b)，即p, q分别为a, b子树的根结点。  
17. //1. 如果p != q，说明a, b暂时没有关系，那么关于他们的判断都是正确的，然后合并这两个子树。这里是关键，如何合并两个子树使得合并后的新树能保证正确呢？  
18. //这里我们规定只能p合并到q(刚才说过了，启发式合并的优化效果并不那么明显，如果我们用启发式合并，就要推出两个式子，而这个推式子是件比较累的活...所以  
19. //一般我们都规定一个子树合到另一个子树)。那么合并后，p的relation肯定要改变，那么改成多少呢？这里的方法就是找规律，列出部分可能的情况，就差不多能推出  
20. //式子了。这里式子为 : tree[p].relation = (tree[b].relation - tree[a].relation + 2 + d) % 3; 这里的d为判断语句中a, b的关系。还有个问题，我们是否需要  
21. //遍历整个a子树并更新每个结点的状态呢？答案是不需要的，因为我们可以在Find()函数稍微修改，即结点x继承它的父亲(注意是前父亲，因为路径压缩后父亲就会改变)，  
22. //即它会继承到p结点的改变，所以我们不需要每个都遍历过去更新。  
23. //2. 如果p = q，说明a, b之前已经有关系了。那么我们就判断语句是否是对的，同样找规律推出式子。即if((tree[b].relation + d + 2) % 3 != tree[a].relation),   
24. //那么这句话就是错误的。  
25. //3. 再对Find()函数进行些修改，即在路径压缩前纪录前父亲是谁，然后路径压缩后，更新该点的状态(通过继承前父亲的状态，这时候前父亲的状态是已经更新的)。  
26. int cha(int x)  
27. {  
28.     if (x == set[x])  
29.         return x;  
30.     int tx = cha(set[x]);  
31.     //关键,此处要理解，若上一次合并两个高度为2的树，合并后一棵树高度变为3，则在下一次查询时完成所有结点状态的更新。  
32.     //查找中的更新 压缩路径中的更新  
33.     r[x] = (r[x] + r[set[x]]) % 3;  
34.     //return tx; 错误，要完成路径的更新  
35.     return set[x] = tx;  
36. }  
37. void unite(int x, int y, int type)  
38. {  
39.     int tx = cha(x);  
40.     int ty = cha(y);  
41.     set[ty] = tx;//合并这两棵树  
42.     r[ty] = (r[x] + type - 1 - r[y] + 3) % 3;//关键，修改相对关系  
43.     return;  
44. }  
45. int main()  
46. {  
47. #ifdef ONLINE_JUDGE  
48. #else  
49.     freopen("D:\\in.txt", "r", stdin);  
50.     freopen("D:\\out.txt", "w", stdout);  
51. #endif  
52.     int n(0), m(0);  
53.     scanf("%d%d", &n, &m);  
54.     init(n);  
55.     int type(0), x(0), y(0);  
56.     int ans(0);  
57.     for (int i = 1; i <= m; i++)  
58.     {  
59.         scanf("%d%d%d", &type, &x, &y);  
60.         if (x > n || y > n || (type == 2 && x == y))  
61.         {  
62.             ans++;  
63.             continue;  
64.         }  
65.         if (cha(x) == cha(y))//在同一棵树中  
66.         {  
67.             if ((r[y] - r[x] + 3) % 3 != (type - 1))  
68.             {  
69.                 ans++;  
70.             }  
71.         }  
72.         else  
73.         {  
74.             (unite(x, y, type));//不在一棵树中，则合并  
75.         }  
76.     }  
77.     printf("%d\n", ans);  
78. }  

代码如下：

[cpp]  view plain copy print ?

1. #include<iostream>  
2. #include<vector>  
3. #include<algorithm>  
4. #include<functional>  
5. #include<iterator>  
6. #include<cstdio>  
7. #include<queue>  
8. using namespace std;  
9. //并查集  
10. const int MAX_N = 50010;  
11. const int MAX_K = 100010;  
12. int set[MAX_N*3];//父亲  
13. int height[MAX_N*3];//树的高度  
14. int T[MAX_K],X[MAX_K],Y[MAX_K];  
15. //并查集  
16. //初始化n个元素  
17. void init(int n)  
18. {  
19.     for (int i = 0; i < n; i++)  
20.     {  
21.         set[i] = i;//set[x]==x时，x是所在树的根  
22.         height[i] = 0;  
23.     }  
24. }  
25. //查 查询x所在树的根  
26. int cha(int x)  
27. {  
28.     int r = x;  
29.     while (set[r] != r)  
30.         r = set[r];  
31.     int i = x;  
32.     int j(0);  
33.     while (i != r)//路径压缩  
34.     {  
35.         j = set[i];  
36.         set[i] = r;  
37.         i = j;  
38.     }  
39.     return r;  
40. }  
41. //并  合并x和y所属的集合  
42. void unite(int x, int y)  
43. {  
44.     x = cha(x);  
45.     y = cha(y);  
46.     if (x == y)  
47.         return ;  
48.     if (height[x] < height[y])  
49.     {  
50.         set[x] = y;  
51.     }  
52.     else  
53.     {  
54.         set[y] = x;  
55.         if (height[x] == height[y])  
56.             height[x]++;  
57.     }  
58. }  
59. //判断x和y是否属于同一个集合  
60. bool same(int x, int y)  
61. {  
62.     return cha(x) == cha(y);  
63. }  
64. int main()  
65. {  
66. #ifdef ONLINE_JUDGE    
67. #else    
68.     freopen("D:\\in.txt", "r", stdin);  
69.     freopen("D:\\out.txt", "w", stdout);  
70. #endif // ONLINE_JUDEG  
71.     int n(0), k(0);  
72.     int ans(0);  
73.     scanf("%d%d", &n, &k);  
74.       
75.     for (int i = 0; i < k; i++)  
76.     {  
77.         scanf("%d%d%d", &T[i], &X[i], &Y[i]);  
78.     }  
79.     //初始化并查集，元素x,x+n,x+2*n分别代表x-A,x-B,x-C  
80.     init(n * 3);  
81.     ans = 0;  
82.     for (int i = 0; i < k; i++)  
83.     {  
84.         int t = T[i];//信息的类型  
85.         int x = X[i] - 1;  
86.         int y = Y[i] - 1;//把输入变成0--N-1的范围  
87.   
88.         //不正确的编号   
89.         if (x < 0 || y < 0 || x >= n || y >= n)  
90.         {  
91.             ans++;  
92.             continue;  
93.         }  
94.               
95.         if (t == 1)//“x 和 y 属于同一类”的信息  
96.         {  
97.             if (same(x,y+n)||same(x,y+2*n))  
98.             {  
99.                 ans++;  
100.             }  
101.             else  
102.             {  
103.                 unite(x, y);  
104.                 unite(x + n, y + n);  
105.                 unite(x + n * 2, y + n * 2);  
106.             }  
107.         }  
108.         else// "x吃y的信息"  
109.         {  
110.             if (same(x, y) || same(x, y + 2 * n))  
111.             {  
112.                 ans++;  
113.             }  
114.             else  
115.             {  
116.                 unite(x, y + n);  
117.                 unite(x + n, y + 2 * n);  
118.                 unite(x + 2 * n, y);  
119.             }  
120.         }  
121.               
122.     }  
123.     printf("%d\n", ans);  
124.       
125.     return 0;  
126. }  

其他的解题思路：

今天做了经典的食物链，在总结网上其它做法后，小结如下：

题意：一共就三种动物，如果A吃B，B吃C==》C吃A；

                                    A吃B，A吃C==》B、C为同类

                              A被B吃，A被C吃==》B、C为同类

用并查集来做：

两种动物之间的关系通过于根节点的相对关系得出，所以关键是路径压缩与合并两个集合时的动物与根节点相对关系的变化，其实也可认为是一个问题，因为路径压缩中的变化其实是合并集合产生的子问题。

用delta【i】来表示i和i的父节点的关系，rank[i]=0/1/2分别表示 i 与父亲是同类、被父亲吃、吃父亲。

先讲合并操作：

设tx为x的父亲，ty是y的父亲，所以delta[x]表示x和tx的关系，delta[y]表示y与ty的关系，现在，合并操作要将ty的父亲置为tx，所以delta[ty]的值就要发生相应的改变，即产生了新的ty与tx的关系；

那么，如何求这个关系呢？有两种方法：第一种，可以通过实际数据推出来，

tx       ty

|          |

x   ~    y

知道了tx与x的关系，x与y的关系，y与ty的关系，tx与ty的关系自然就推出来了

type表示x与y的关系0为同类，1为x吃y

 

type	0	0	0	0	1	1	1	1	1
delta[x]	0	0	0	1	0	1	2	2	1
delta[y]	0	1	2	2	2	2	1	2	1
delta[ty]	0	2	1	2	2	0	2	1	1

 所以有：

[cpp]  view plain copy print ?

1. void unio{    
2.    fa[ty]=tx;  
3.      delta[ty]=(delta[x]-delta[y]+type+3)%3;  
4. }  

仔细再想想，tx-x 、x-y、y-ty，是不是很像向量形式，于是便有了一般化的结论：来自北大discuss

tx       ty

|          |

x   ~    y

对于集合里的任意两个元素x，y而言，它们之间必定存在着某种联系，

因为并查集中的元素均是有联系的，否则也不会被合并到当前集合中。那么我们

就把这2个元素之间的关系量转化为一个偏移量，以食物链的关系而言，不妨假设

x->y 偏移量0时 x和y同类

x->y 偏移量1时 x吃y

x->y 偏移量2时 x被y吃，也就是y吃x

有了这些基础，我们就可以在并查集中完成任意两个元素之间的关系转换了。

不妨继续假设，x的当前集合根节点tx，y的当前集合根节点ty，x->y的偏移值为d-1（题中给出的询问已知条件）

(1)如果tx和ty不相同，那么我们把ty合并到tx上，并且更新deltx[ty]值（注意：deltx[i]表示i的当前集合根节点到i的偏移量！！！！）

    此时 tx->ty = tx->x + x->y + y->ty，可能这一步就是所谓向量思维模式吧

    上式进一步转化为：tx->ty = (deltx[x]+d-1+3-deltx[y])%3 = deltx[ty]，（模3是保证偏移量取值始终在[0,2]间）

(2)如果tx和ty相同，那么我们就验证x->y之间的偏移量是否与题中给出的d-1一致

    此时 x->y = x->tx + tx->y = x->tx + ty->y，

    上式进一步转化为：x->y = (3-deltx[x]+deltx[y])%3，
    若一致则为真，否则为假。

牛的想法啊！

凡人就模仿着学习啦~哈哈

接下来把这个想法再运用到路径压缩中：

ffx   

|      \

fx      \

|         /

|     /

x     

路径压缩过程中会将fx的父亲变为x的父亲，所以要改变相对关系，即偏移量。

ffx->fx+fx->x=ffx->x;

转换成：delta[x]=(delta[fx]+delta[x])%3;

即

[cpp]  view plain copy print ?

1. int find(int x){  
2.      if(x==fa[x]) return x;  
3.      int tx=find(fa[x]);  
4.      delta[x]=(delta[x]+delta[fa[x]])%3;  
5.      return fa[x]=tx;  
6. }  

完整代码如下

[cpp]  view plain copy print ?

1. #include<stdio.h>  
2. #include<string.h>  
3. int delta[50005],fa[50005];  
4. int n,k;  
5. void init(){  
6.     for(int i=1;i<=n;i++){  
7.         delta[i]=0;  
8.         fa[i]=i;  
9.     }  
10. }  
11. int find(int x){  
12.      if(x==fa[x]) return x;  
13.      int tx=find(fa[x]);  
14.      delta[x]=(delta[x]+delta[fa[x]])%3；//关键  
15.      return fa[x]=tx;  
16. }  
17. int unio(int x,int y,int type){  
18.      if(x>n||y>n) return 1;  
19.      if(type==1&&x==y) return 1;  
20.      int tx=find(x);  
21.      int ty=find(y);  
22.      if(tx==ty){  
23.             if((delta[y]-delta[x]+3)%3!=type)//也用向量的思维思考，两种动物都在集合里了，判断一下是否与输入的话相一致  
24. //x->y=x->tx+ty->y,因为tx=ty，即根节点相同，所以x与y的关系表示为(-delta[x]+delta[y]+3)%3,与type比较即可  
25.                return 1;  
26.             else return 0;  
27.      }  
28.      else  {  
29.         fa[ty]=tx;  
30.         delta[ty]=(delta[x]-delta[y]+type+3)%3;//关键  
31.         return 0;  
32.      }  
33. }  
34. int main(){  
35.     int type;  
36.     int i,wrong,x,y;  
37.     while(scanf("%d%d",&n,&k)==2){  
38.         wrong=0;  
39.     init();  
40.     for(i=1;i<=k;i++){  
41.          scanf("%d%d%d",&type,&x,&y);  
42.          if(unio(x,y,type-1))  
43.              wrong++;  
44.     }  
45.     printf("%d\n",wrong);  
46.     }  
47.     return 0;  
48. }  

一个小技巧：

本人用并查集解的，推导相互之间的关系时废了很长时间。以下这个小技巧或许可以帮助大家少走一点弯路

kind[a]=0表示a与父节点属于同一类。kind[a]=1表示a吃父节点。kind[a]=2表示父节点吃a。 （后二种情况下的赋值可以改变，但对后续有点小影响）

1.有一种关系b是a父节点，c是b父节点， a与c的关系可以表示为 (kind[a]+kind[b])%3 （延续性，适用于多个节点的延续，如3个节点根据二次计算即可完成）

2.b是a的父节点，表示为kind[a]. 若父子节点相互反转，即a是b的父节点，kind[b]=(3-kind[a])%3 （反转性）

根据延续性和反转性可计算任何两个节点之间的关系，以下是几个例子：

现在讨论并查集中用到关系的3中情况：
(i):find中的更新，x的父节点是y，y的父节点为根节点，将关系更新为x的父节点为根节点，表示为：kind[x]=(kind[x]+kind[y])%3;
(ii)并查集中的合并。 假设x的父节点是xx y的父节点是yy x和y的关系为d。
若将xx的父节点更新为yy，则 kind[xx]=kind[x]的反转（即xx的父节点为x）+d（x的父节点为y）+kind[y]（y的父节点为yy），
简化为kind[xx]=(3-kind[x]+d+kind[y])%3.
(iii)并查集中判断x，y是否冲突
x和y的父节点都为同一个根节点，知道kind[x],kind[y],d（表示x和y的关系）

3-kind[x](x的反转，根节点->x)+d（x->y）+kind[y](y->根节点) 根据延续性这个式子表示为 根节点->根节点的关系 即 （3-kind[x]+d+kind[y])%3==0

另外一个人的思路：

并查集顾名思义就是并和查，但是这样去理解太抽象了，就从POJ1182此题来分析吧。

并查集的特点是，通过操作将有关联的集合合并，其中集合有这样的特点：

任何2个集合都没有重复元素，我们称之为完全不相交。（这个很重要）

还有一个特点借用一句话来表明集合的关系：

x和y是亲戚，y和z是亲戚，那么x和z也是亲戚。如果x,y是亲戚，那么x的亲戚都是y的亲戚，y的亲戚也都是x的亲戚。

这就是集合中的元素关系，放入此题看看是不是很适合形容此题各种小动物的关系。

下面有一段来自POJ discuss 中的对话 很经典  如果懂了 并查集的概念就懂了

我的理解是，对于集合里的任意两个元素a,b而言，它们之间必定存在着某种联系，

因为并查集中的元素均是有联系的，否则也不会被合并到当前集合中。那么我们

就把这2个元素之间的关系量转化为一个偏移量，以食物链的关系而言，不妨假设

a->b 偏移量0时 a和b同类

a->b 偏移量1时 a吃b

a->b 偏移量2时 a被b吃，也就是b吃a

有了这些基础，我们就可以在并查集中完成任意两个元素之间的关系转换了。

不妨继续假设，a的当前集合根节点aa，b的当前集合根节点bb，a->b的偏移值为d-1（题中给出的询问已知条件）

(1)如果aa和bb不相同，那么我们把bb合并到aa上，并且更新delta[bb]值（delta[i]表示i的当前集合根节点到i的偏移量）

    此时aa->bb = aa->a + a->b+ b->bb，可能这一步就是所谓向量思维模式吧

   上式进一步转化为：aa->bb = (delta[a]+d-1+3-delta[b])%3 =delta[bb]，（模3是保证偏移量取值始终在[0,2]间）

(2)如果aa和bb相同，那么我们就验证a->b之间的偏移量是否与题中给出的d-1一致

    此时a->b = a->aa + aa->b =a->aa + bb->b，

   上式进一步转化为：a->b = (3-delta[a]+delta[b])%3，

   若一致则为真，否则为假。

以上来自DICUSS中 Magic347 大牛给我的启发。很强大啊！有了这个A此题不费吹灰之力啊！

[cpp]  view plain copy print ?

1.  #include<iostream>    
2. using namespace std;    
3. int N,K,D,X,Y;    
4. int father[50001];//father[i]表示i的父节点    
5. int offset_v[50001];//offset_V[i]表示i与源节点的偏移量    
6. int false_word=0;//错误的话的个数  
7. void init()//初始化    
8. {    
9.     for (int i=0;i<=N;i++)    
10.     {    
11.         father[i]=i;    
12.         offset_v[i]=0;    
13.     }        
14. }    
15. int find_zx(int a)    
16. {    
17.         
18.     if(father[a]==a)    
19.     {    
20.        return a;       
21.     }        
22.     int t=father[a];    
23.     father[a]=find_zx(father[a]);        
24.     offset_v[a]=(offset_v[a]+offset_v[t])%3;    
25.     return father[a];    
26. }    
27. void union_jh(int a,int b,int d)    
28. {    
29.    int zxa=find_zx(a);    
30.    int zxb=find_zx(b);    
31.    father[zxb]=zxa;    
32.    offset_v[zxb]=(offset_v[a]+d-offset_v[b]+3)%3;      
33.    return ;    
34. }    
35. int main()    
36. {       
37.         
38.    scanf("%d %d",&N,&K);    
39.    init();    
40.    for(int i=0;i<K;i++)    
41.    {    
42.        scanf("%d %d %d",&D,&X,&Y);    
43.        if(X>N||Y>N||(D==2&&X==Y))    
44.        {    
45.           false_word++;    
46.           continue;    
47.        }    
48.        if (find_zx(X)==find_zx(Y))    
49.        {    
50.            if((offset_v[Y]-offset_v[X]+3)%3!=D-1)    
51.            {                   
52.                false_word++;    
53.            }    
54.        }    
55.        else    
56.        {    
57.           union_jh(X,Y,D-1);               
58.        }    
59.    }    
60.    printf("%d\n",false_word);    
61.        
62.    return 0;    

另外一个大牛的思路，有助于理解：

并查集，顾名思义，干的就是“并”和“查”两件事。很多与集合相关的操作都可以用并查集高效的解决。

       两个操作代码：
       int Find(int x)
       {
          if (tree[x].parent != x)
          {
              tree[x].parent = Find(tree[x].parent);
          }
          return tree[x].parent;
       }

       void Merge(int a, int b, int p, int q, int d)
       {
          if (tree[q].depth > tree[p].depth) tree[p].parent = q;
          else
          {
              tree[q].parent = p;
              if (tree[p].depth == tree[q].depth) tree[p].depth++;
          }
       }
       其中Find()函数用了路径压缩优化，而Merge()函数用了启发式合并的优化(个人感觉有了路径压缩，启发式合并优化的效果并不明显，而经常因为题目和代码的限制，启发式合并会被我们省略)。

       提到并查集就不得不提并查集最经典的例子：食物链。
       POJ 1182 食物链
       http://acm.pku.edu.cn/JudgeOnline/problem?id=1182
       题目告诉有3种动物，互相吃与被吃，现在告诉你m句话，其中有真有假，叫你判断假的个数(如果前面没有与当前话冲突的，即认为其为真话)
这题有几种做法，我以前的做法是每个集合(或者称为子树，说集合的编号相当于子树的根结点，一个概念)中的元素都各自分为A, B, C三类，在合并时更改根结点的种类，其他点相应更改偏移量。但这种方法公式很难推，特别是偏移量很容易计算错误。
下面来介绍一种通用且易于理解的方法：
首先，集合里的每个点我们都记录它与它这个集合(或者称为子树)的根结点的相对关系relation。0表示它与根结点为同类，1表示它吃根结点，2表示它被根结点吃。
那么判断两个点a, b的关系，我们令p = Find(a), q = Find(b)，即p, q分别为a, b子树的根结点。
       1. 如果p != q，说明a, b暂时没有关系，那么关于他们的判断都是正确的，然后合并这两个子树。这里是关键，如何合并两个子树使得合并后的新树能保证正确呢？这里我们规定只能p合并到q(刚才说过了，启发式合并的优化效果并不那么明显，如果我们用启发式合并，就要推出两个式子，而这个推式子是件比较累的活...所以一般我们都规定一个子树合到另一个子树)。那么合并后，p的relation肯定要改变，那么改成多少呢？这里的方法就是找规律，列出部分可能的情况，就差不多能推出式子了。这里式子为 : tree[p].relation = (tree[b].relation - tree[a].relation + 2 + d) % 3; 这里的d为判断语句中a, b的关系。还有个问题，我们是否需要遍历整个a子树并更新每个结点的状态呢？答案是不需要的，因为我们可以在Find()函数稍微修改，即结点x继承它的父亲(注意是前父亲，因为路径压缩后父亲就会改变)，即它会继承到p结点的改变，所以我们不需要每个都遍历过去更新。
       2. 如果p = q，说明a, b之前已经有关系了。那么我们就判断语句是否是对的，同样找规律推出式子。即if ( (tree[b].relation + d + 2) % 3 != tree[a].relation ), 那么这句话就是错误的。
       3. 再对Find()函数进行些修改，即在路径压缩前纪录前父亲是谁，然后路径压缩后，更新该点的状态(通过继承前父亲的状态，这时候前父亲的状态是已经更新的)。
       核心的两个函数为：
       int Find(int x)
       {
           int temp_p;
          if (tree[x].parent != x)
          {
              // 因为路径压缩，该结点的与根结点的关系要更新(因为前面合并时可能还没来得及更新).
              temp_p = tree[x].parent;
              tree[x].parent = Find(tree[x].parent);
              // x与根结点的关系更新(因为根结点变了)，此时的temp_p为它原来子树的根结点.
              tree[x].relation = (tree[x].relation + tree[temp_p].relation) % 3;
          }
          return tree[x].parent;
       }

       void Merge(int a, int b, int p, int q, int d)
       {
          // 公式是找规律推出来的.
          tree[p].parent = q; // 这里的下标相同，都是tree[p].
          tree[p].relation = (tree[b].relation - tree[a].relation + 2 + d) % 3;
       }

       而这种纪录与根结点关系的方法，适用于几乎所有的并查集判断关系(至少我现在没遇到过不适用的情况…可能是自己做的还太少了…)，所以向大家强烈推荐～～

       搞定了食物链这题，基本POJ上大部分基础并查集题目就可以顺秒了，这里仅列个题目编号: POJ 1308 1611 1703 1984 1986(LCA Tarjan算法 + 并查集) 1988 2236 2492 2524。

       下面来讲解几道稍微提高点的题目:
       POJ 1456 Supermarket
       http://acm.pku.edu.cn/JudgeOnline/problem?id=1456
       这道题贪心的思想很明显，不过O(n^2)的复杂度明显不行，我们可以用堆进行优化，这里讲下并查集的优化方法(很巧妙)。我们把连续的被占用的区间看成一个集合(子树)，它的根结点为这个区间左边第一个未被占用的区间。
先排序，然后每次判断Find(b[i])是否大于0，大于0说明左边还有未被占用的空间，则占用它，然后合并(b[i], Find(b[i]) – 1)即可。同样这里我们规定只能左边的子树合并到右边的子树(想想为什么～～)。

       POJ 1733 Parity game
       http://acm.pku.edu.cn/JudgeOnline/problem?id=1733
       这题同样用类似食物链的思想。
首先我们先离散化，因为原来的区间太大了(10^9)，我们可以根据问题数目离散成(10^4)。我们要理解，这里的离散化并不影响最终的结果，因为区间里1的奇偶个数与区间的大小无关(这句话有点奇怪，可以忽略...)，然后每次输入a, b，我们把b++，如果他俩在一个集合内，那么区间[a, b]里1的个数相当于b.relation ^ a.relation，判断对错即可。如果不在一个集合内，合并集合(这里我们规定根结点小的子树合并根结点大的，所以要根据不同情况推式子)，修改子树的根结点的状态，子树的其他结点状态通过Find()函数来更新。

       hdu 3038 How Many Answers Are Wrong
       http://acm.hdu.edu.cn/showproblem.php?pid=3038
       上面那题的加强版，不需要离散化，因为区间的和与区间的大小有关(和上面的那句话对比下，同样可以忽略之…)，做法与上面那题差不多，只是式子变了，自己推推就搞定了。但这题还有个条件，就是每个点的值在[0, 100]之间，那么如果a, b不在一个子树内，我们就合并，但在合并之前还要判断合并后会不会使得区间的和不合法，如果会说明该合并是非法的，那么就不合并，同样认为该句话是错误的。

       POJ 1417 True Liars(难)
       http://acm.pku.edu.cn/JudgeOnline/problem?id=1417
       并查集 + DP(或搜索)。
       题目中告诉两种人，一种只说真话，一种只说假话。然后告诉m条语句，问是否能判断哪些人是只说真话的那类人。
       其实并查集部分跟食物链还是相似，而且种类变少了一种，更容易了。我们可以通过并查集把有关系的一些人合并到一个集合内(具体方法参见食物链讲解)。
       现在的问题转化为，有n个集合，每个集合都有a, b连个数字，现在要求n个集合中各跳出一个数(a或者b)，使得他们之和等于n1(说真话的人数)。而这个用dp可以很好的解决，用f[i][j]表示到第i个集合和为j个的情况数，我们还用过pre[i][j]记录当前选的是a还是b，用于后面判断状态。方程为f[i][j] = f[i – 1][j – a] + f[i – 1][j – b], j >= a, j >= b。如果最后f[n][n1] == 1说明是唯一的情况，输出该情况，否则输出 “no”(多解算no)
       注意点 : 
       1. 这题的m, n1, n2都有可能出现0，可以特殊处理，也可以一起处理。
       2. 按上面的dp写法，f[i][j]可能会很大，因为n可以达到三位数。其实我们关心的只是f[i][j] 等于0，等于1，大于1三种情况，所以当f[i][j] > 1时，我们都让它等于2即可。

       POJ 2912 Rochambeau(难)
       http://acm.pku.edu.cn/JudgeOnline/problem?id=2912
       Baidu Star 2006 Preliminary的题目，感觉出的很好，在并查集题目中算是较难的了。其实这题跟食物链完全一个磨子，同样三类食物，同样的互相制约关系。所以食物链代码拿过来改都不需要改。但这题有个judge，他可以出任意手势。于是我们的做法是，枚举每个小孩为judge，判断他为judge时在第几句话出错err[i](即到第几句话能判断该小孩不是judge)。
       1. 如果只有1个小孩是judge时全部语句都是正确的，说明该小孩是judge，那么判断的句子数即为其他小孩的err[i]的最大值。如果
       2. 如果每个小孩的都不是judge(即都可以找到出错的语句)，那么就是impossible。
       3. 多于1个小孩是judge时没有找到出错的语句，就是Can not determine。

        ZOJ 3261 Connections in Galaxy War
        http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=3563
        nuaa 1087 联通or不连通
        http://acm.nuaa.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1087
        两题做法差不多，都是反过来的并查集题目，先对边集排序，然后把要删去的边从二分在边集中标记。然后并查集连接没有标记的边集，再按查询反向做就可。第一题合并结点时按照题目要求的优先级合并即可。
　   
       这里介绍的并查集题目，主要都是处理些集合之间的关系(这是并查集的看家本领～～)，至于并查集还有个用处就在求最小生成树的Kruskal算法中，那个是图论中求最小生成树的问题(一般这个难点不在于并查集，它只是用于求最小生成树的一种方法)，就不在这里赘述了～～