并查集之讲解篇

l         并查集：(union-find sets)

一种简单的用途广泛的集合. 并查集是若干个不相交集合，能够实现较快的合并和判断元素所在集合的操作，应用很多，如其求无向图的连通分量个数等。最完美的应用当属：实现Kruskar算法求最小生成树。

l         并查集的精髓（即它的三种操作，结合实现代码模板进行理解）：

1、Make_Set(x) 把每一个元素初始化为一个集合

初始化后每一个元素的父亲节点是它本身，每一个元素的祖先节点也是它本身（也可以根据情况而变）。

2、Find_Set(x) 查找一个元素所在的集合

查找一个元素所在的集合，其精髓是找到这个元素所在集合的祖先！这个才是并查集判断和合并的最终依据。
判断两个元素是否属于同一集合，只要看他们所在集合的祖先是否相同即可。
合并两个集合，也是使一个集合的祖先成为另一个集合的祖先，具体见示意图

3、Union(x,y) 合并x,y所在的两个集合

合并两个不相交集合操作很简单：
利用Find_Set找到其中两个集合的祖先，将一个集合的祖先指向另一个集合的祖先。如图

 

l         并查集的优化

1、Find_Set(x)时 路径压缩
寻找祖先时我们一般采用递归查找，但是当元素很多亦或是整棵树变为一条链时，每次Find_Set(x)都是O(n)的复杂度，有没有办法减小这个复杂度呢？
答案是肯定的，这就是路径压缩，即当我们经过"递推"找到祖先节点后，"回溯"的时候顺便将它的子孙节点都直接指向祖先，这样以后再次Find_Set(x)时复杂度就变成O(1)了，如下图所示；可见，路径压缩方便了以后的查找。

2、Union(x,y)时 按秩合并
即合并的时候将元素少的集合合并到元素多的集合中，这样合并之后树的高度会相对较小。

 

 

 

 

数据结构——并查集的应用

并查集是一种简单的数据结构，相对于其他数据结构来说，编程难度很小，也很灵活，适当的find函数与Union函数便可以解决很多问题。

[cpp]  view plain copy print ?

1. int find(int x){  
2.     if(x==parent[x])  return x;  
3.     return parent[x]=find(parent[x]);  
4. }  
5. void Union(int a,int b){  
6.     int pa=find(a);  
7.     int pb=find(b);  
8.     if(pa!=pb) parent[pa]=pb;  
9. }  

 

并查集的应用：

并和查有关的集合操作

并查集可以用于相关的集合操作，如判定一个无向图是否有环，输出一个无向图的连通分量个数，kruscal最小生成树的操作。一些基于集合，有添加其它性质的集合操作。

例题：

TOJ2469 Friends

题目描述：有n个人，m对朋友关系，朋友关系对称且可传递，求有几个朋友圈。

分析：事实上是求一个无向图的连通分量数，并查集轻松搞定。

 

TOJ3294 Building Blcok

题目描述：一开始有n个Block，分别放置在地面上，有P个操作，操作有两种类型：

M a b如果a，b没有在一个Block组里，把包含a Block的Block组放在包含b的Block组之上。

C a 输出有多少个Block被压在了a之下。

分析：定义parent同并查集的一般操作，cnt表示有多少块Block[x]被压在x之下，size[x]表示以x为根的Block组一共有多少个Block.

 

[cpp]  view plain copy print ?

1. #include <cstdio>  
2. #include <cstring>  
3. using namespace std;  
4. #define MAX 30030  
5. int par[MAX],cnt[MAX],size[MAX];  
6.   
7. void init(int n)  
8. {  
9.     for(int i=0;i<n;i++)  
10.     {  
11.         par[i]=i;  
12.         cnt[i]=0;  
13.         size[i]=1;  
14.     }  
15. }  
16. int find(int x)  
17. {  
18.     if(x==par[x])    return x;  
19.     int tmp=par[x];  
20.     par[x]=find(par[x]);  
21.     cnt[x]+=cnt[tmp];  
22.     return par[x];  
23. }   
24.   
25. void Union(int a,int b,int pa,int pb)  
26. {  
27.     par[pa]=pb;  
28.     cnt[pa]+=size[pb];  
29.     size[pb]+=size[pa];  
30. }   
31.   
32. int main()  
33. {  
34.     int n,a,b,pa,pb;  
35.     char move[10];  
36.     while(scanf("%d",&n)!=EOF)  
37.     {  
38.         init(MAX);  
39.         for(int i=0;i<n;i++)  
40.         {  
41.             scanf("%s",move);  
42.             if(move[0]=='M')  
43.             {  
44.                 scanf("%d%d",&a,&b);  
45.                 pa=find(a);  
46.                 pb=find(b);  
47.                 if(pa!=pb)    Union(a,b,pa,pb);  
48.             }  
49.             else if(move[0]=='C')  
50.             {  
51.                 scanf("%d",&a);  
52.                 find(a);  
53.                 printf("%d\n",cnt[a]);  
54.             }  
55.         }  
56.     }  
57.     return 0;  
58. }  

 

TOJ3732 Dragon Balls

题目描述：悟空在寻找龙珠，一共有n个龙珠，m条操作。操作有两种。

T a b 表示把a龙珠所在的城里的所有龙珠运到b所在的城里

Q a 表示对a的询问，要求输出x a所在的城， y a所在的城里一共有多少个龙珠， z a经过几次到达现在所在的城的。

分析：定义parent同并查集的一般操作，step表示经过几步到达现在所在的城，size表示该城里的龙珠数。

[cpp]  view plain copy print ?

1. #include <cstdio>  
2. #include <cstring>  
3. using namespace std;  
4. #define MAX 10010  
5. int par[MAX],step[MAX],size[MAX];  
6.   
7. void init(int n)  
8. {  
9.     for(int i=1;i<=n;i++)  
10.     {  
11.         par[i]=i;  
12.         step[i]=0;  
13.         size[i]=1;  
14.     }  
15. }  
16.   
17. int find(int x)  
18. {  
19.     if(x==par[x])    return x;  
20.     int tmp=par[x];  
21.     par[x]=find(tmp);  
22.     step[x]+=step[tmp];  
23.     return par[x];  
24. }   
25.   
26. void Union(int a,int b)  
27. {  
28.     int pa=find(a);  
29.     int pb=find(b);  
30.     par[pa]=pb;  
31.     size[pb]+=size[pa];  
32.     step[pa]++;  
33. }  
34.   
35. int main()  
36. {  
37.     int T,n,m,a,b,t=1;  
38.     scanf("%d",&T);  
39.     while(T--)  
40.     {  
41.         printf("Case %d:\n",t++);  
42.         scanf("%d%d",&n,&m);  
43.         init(n);  
44.         for(int i=0;i<m;i++)  
45.         {  
46.             char move;  
47.             getchar();  
48.             move=getchar();  
49.             if(move=='T')  
50.             {  
51.                 scanf("%d%d",&a,&b);  
52.                 Union(a,b);  
53.             }  
54.             else  
55.             {  
56.                 scanf("%d",&a);  
57.                 int pa=find(a);  
58.                 printf("%d %d %d\n",pa,size[pa],step[a]);  
59.             }  
60.         }  
61.     }  
62.     return 0;      
63. }  

 

种类相关并查集操作

    题目中出现的元素分为一些种类，描述中会给出相关的描述信息，判断描述的正确性，即是否有悖于之前对这些元素种类的描述。一般可以增加一个kind属性来表示元素的种类。

例题：

POJ1182 食物链

题目大意：有A，B，C三种动物A吃B，B吃C，C吃A。有两种描述：

1 a b表示a与b是同类

2 a b 表示a吃b

判断有多少句假话（假话题目中有定义，主要是判断是否与之前的描述相悖）

分析：增加属性kind，kind[x]=0,表示与根同类，kind[x]=1,表示吃根，kind[x]=2表示被根吃。

[cpp]  view plain copy print ?

1. #include <cstdio>  
2. #include <cstring>  
3. using namespace std;  
4. #define MAX 50050  
5. int par[MAX],rel[MAX];  
6.   
7. void init(int n)  
8. {  
9.     for(int i=1;i<=n;i++)  
10.     {  
11.         par[i]=i;  
12.         rel[i]=0;  
13.     }  
14. }  
15.   
16. int find(int x)  
17. {  
18.     if(par[x]==x)    return x;  
19.     int tmp=par[x];  
20.     par[x]=find(tmp);  
21.     rel[x]=(rel[tmp]+rel[x])%3;  
22.     return par[x];  
23. }  
24.   
25. void union_set(int x,int y,int px,int py,int d)  
26. {  
27.     par[px]=py;  
28.     rel[px]=(rel[y]-rel[x]+2+d)%3;  
29. }  
30.   
31. int main()  
32. {  
33.     int T,n,m,a,b,pa,pb,k,r;  
34.     scanf("%d%d",&n,&m);  
35.     {  
36.         init(n);  
37.         r=0;  
38.         for(int i=0;i<m;i++)  
39.         {  
40.             scanf("%d%d%d",&k,&a,&b);  
41.             if(a>n||b>n)    {    r++;    continue;}  
42.             if(k==2&&a==b)    {    r++;    continue;}  
43.             pa=find(a);  
44.             pb=find(b);  
45.             if(pa==pb)  
46.             {  
47.                 if((rel[b]+k+2)%3!=rel[a])    r++;  
48.             }  
49.             else    union_set(a,b,pa,pb,k);  
50.         }  
51.         printf("%d\n",r);  
52.     }  
53. }  
54.    

 

TOJ1706 A Bug’s life

题目大意：给出n个点m条边（无向边），寻找是否有奇环。可用bfs或者dfs黑白染色，用并查集则是顶点种类为2.kind[x]=0表示与根同色，kind[x]=1表示与根异色。

[cpp]  view plain copy print ?

1. #include <cstdio>  
2. #include <cstring>  
3. using namespace std;  
4. #define MAX 2050  
5. int par[MAX],rel[MAX];  
6.   
7. void init(int n)  
8. {  
9.     for(int i=1;i<=n;i++)  
10.     {  
11.         par[i]=i;  
12.         rel[i]=0;  
13.     }  
14. }  
15.   
16. int find(int x)  
17. {  
18.     if(par[x]==x)    return x;  
19.     int tmp=par[x];  
20.     par[x]=find(tmp);  
21.     rel[x]^=rel[tmp];  
22.     return par[x];  
23. }  
24.   
25. void union_set(int x,int y,int px,int py)  
26. {  
27.     par[py]=px;  
28.     rel[py]=(rel[y]==rel[x]);  
29. }  
30.   
31. int main()  
32. {  
33.     int T,n,m,a,b,pa,pb,r;  
34.     scanf("%d",&T);  
35.     for(int t=1;t<=T;t++)  
36.     {  
37.         scanf("%d%d",&n,&m);  
38.         init(n);  
39.         r=0;  
40.         for(int i=0;i<m;i++)  
41.         {  
42.             scanf("%d%d",&a,&b);  
43.             if(!r)  
44.             {  
45.                 pa=find(a);  
46.                 pb=find(b);  
47.                 if(pa==pb)    r=(rel[a]==rel[b]);  
48.                 else    union_set(a,b,pa,pb);  
49.             }  
50.         }  
51.         printf("Scenario #%d:\n",t);  
52.         printf("%s bugs found!\n\n",r?"Suspicious":"No suspicious");  
53.     }  
54. }  

 

POJ1733 Parity Game

题目大意：有长度为n的0，1串，给出描述，a b even or a b odd表示a b区间1的个数的奇偶性，判断前多少条描述是成立的。ss

分析：设属性sum，区间a b的1的个数的奇偶性，与sum[b]和sum[a-1]的奇偶性相同，即若a b even表示sum[b]，sum[a-1]同奇偶，否则异奇偶。sum[x]=0,表示与根同奇偶，sum[x]=1表示与根异奇偶。由于该题区间范围过大，需要离散化。

[cpp]  view plain copy print ?

1. #include <cstdio>  
2. #include <cstring>  
3. #include <map>  
4. #include <algorithm>  
5. using namespace std;  
6. #define MAX 5010  
7. int par[2*MAX],rel[2*MAX],ind[2*MAX];  
8. struct node  
9. {  
10.     int s,e;  
11.     bool Isodd;  
12. }query[MAX];  
13. map<int ,int>M;  
14.   
15. void init(int n)  
16. {  
17.     M.clear();  
18.     for(int i=0;i<=n;i++)  
19.     {  
20.         par[i]=i;  
21.         rel[i]=0;  
22.     }  
23. }  
24.   
25. int find(int x)  
26. {  
27.     if(x==par[x])    return x;  
28.     int tmp=par[x];  
29.     par[x]=find(tmp);  
30.     rel[x]^=rel[tmp];  
31.     return par[x];  
32. }  
33.   
34. void union_set(int a,int b,int pa,int pb,int d)  
35. {  
36.     par[pb]=pa;  
37.     rel[pb]=rel[b]^rel[a]^d;  
38. }  
39.   
40. int main()  
41. {  
42.     int n,m;  
43.     scanf("%d%d",&n,&m);  
44.     {  
45.         int a,b,pa,pb,i;  
46.         char str[10];  
47.         init(2*m);  
48.         for(i=0;i<m;i++)  
49.         {  
50.             scanf("%d%d%s",&a,&b,str);  
51.             b++;  
52.             query[i].s=a;  
53.             query[i].e=b;  
54.             query[i].Isodd=(str[0]=='o');  
55.             ind[i<<1]=a;  
56.             ind[i<<1|1]=b;  
57.         }  
58.         sort(ind,ind+2*m);  
59.         for(i=0;i<2*m;i++)  
60.             M[ind[i]]=i+1;  
61.         for(i=0;i<m;i++)  
62.         {  
63.             a=M[query[i].s];  
64.             b=M[query[i].e];  
65.             pa=find(a);  
66.             pb=find(b);  
67.             if(pa==pb)  
68.             {   
69.                 if((rel[a]^rel[b])!=query[i].Isodd)    break;  
70.             }  
71.             else union_set(a,b,pa,pb,query[i].Isodd);  
72.         }  
73.         printf("%d\n",i);  
74.     }  
75.     return 0;  
76. }  

 

TOJ3413 How Many Answers Are Wrong

题目大意：上题的强化版给出任意的n个数，和m条描述，描述为 a b c即a到b的和c，判断有多少条描述是错误的。

分析：设属性sum，a b c表示sum[b]-sum[a-1]=c,sum[x]表示x与x所在集合的根的差。

[cpp]  view plain copy print ?

1. #include <cstdio>  
2. #include <cstring>  
3. using namespace std;  
4. #define MAX 200010  
5. int par[MAX],rel[MAX];  
6.   
7. void init(int n)  
8. {  
9.     for(int i=0;i<=n;i++)  
10.     {  
11.         par[i]=i;  
12.         rel[i]=0;  
13.     }  
14. }  
15.   
16. int find(int x)  
17. {  
18.     if(x==par[x])    return x;  
19.     int tmp=par[x];  
20.     par[x]=find(tmp);  
21.     rel[x]+=rel[tmp];  
22.     return par[x];  
23. }  
24.   
25. void union_set(int a,int b,int pa,int pb,int d)  
26. {  
27.     par[pb]=pa;  
28.     rel[pb]=rel[a]-rel[b]+d;  
29. }  
30.   
31. int main()  
32. {  
33.     int n,m;  
34.     while(scanf("%d%d",&n,&m)!=EOF)  
35.     {  
36.         int a,b,pa,pb,d,r=0;  
37.         init(n);  
38.         for(int i=0;i<m;i++)  
39.         {  
40.             scanf("%d%d%d",&a,&b,&d);  
41.             a--;  
42.             pa=find(a);  
43.             pb=find(b);  
44.             if(pa==pb)  
45.             {   
46.                 if(rel[b]-rel[a]!=d)    r++;  
47.             }  
48.             else union_set(a,b,pa,pb,d);  
49.         }  
50.         printf("%d\n",r);  
51.     }  
52.     return 0;  
53. }  

 

用于优化

并查集更多地应用于dp或者贪心中的优化，用来降低复杂度。

例题：

TOJ1681 Supermarket

题目大意：有n件物品，每件物品有两个属性，p和d，表示在第d天之前将该物品卖出可以获得p的收益，假设一天至多能卖一件货物。问最多能获得的收益值。

分析：思想贪心。对货物按收益值进行排序，优先安排出售获益大的商品，对于每件商品可以把它安排在可以安排的最晚的那一天，即d之前的最晚的一天。如果直接暴力，则对于每件货物都需要从d天到第一天进行搜索，找出没有被安排的一天。时间复杂度O(nK),K是d的复杂度。考虑使用并查集优化，定义parent表示在d之前的可用时间（即题目中需要搜索出的时间）。对于每件货物设b=find(d),若b>0则该物品可安排，进行Union（b，b-1）的合并（b应该合并到b-1上），否则该货物无法安排

[cpp]  view plain copy print ?

1. #include <cstdio>  
2. #include <cstring>  
3. #include <vector>  
4. #include <algorithm>  
5. using namespace std;  
6. #define MAX 10010  
7. #define MP make_pair  
8.    
9. int par[MAX];  
10.   
11. void init(int n)  
12. {  
13.     for(int i=0;i<=n;i++)  
14.         par[i]=i;  
15. }  
16.   
17. int find(int x)  
18. {  
19.     if(x==par[x])    return x;  
20.     return par[x]=find(par[x]);  
21. }  
22.   
23. void union_set(int a,int b){    par[a]=b;}  
24.   
25. vector<pair<int,int> > task;  
26.   
27. int main()  
28. {  
29.     int n,a,b,mx;  
30.     while(scanf("%d",&n)!=EOF)  
31.     {  
32.         task.clear();  
33.         mx=0;  
34.         for(int i=0;i<n;i++)  
35.         {  
36.             scanf("%d%d",&a,&b);  
37.             task.push_back(MP(a,b));  
38.             if(b>mx)    mx=b;  
39.         }  
40.         sort(task.begin(),task.end());  
41.         init(mx);  
42.         int ans=0;  
43.         for(int i=n-1;i>=0;i--)  
44.         {  
45.             b=find(task[i].second);  
46.             if(b>0)  
47.             {  
48.                 ans+=task[i].first;  
49.                 union_set(b,b-1);  
50.             }  
51.         }  
52.         printf("%d\n",ans);  
53.     }  
54.     return 0;  
55. }  

 

反向进行并查集操作 

与并查集不同，给出一个图中原有的一些边，然后给出操作，操作不是向图中添加边，而是在已有的边上，将边删除。对于该种情况，需要把首先读入所有操作，把要求删除的边全部删除，再按照从后往前的顺序处理操作，这样删边操作又重新转化为了添边的操作。

例题：

ZOJ3261 Connections in Galaxy War

题目大意：有n个卫星，每个卫星有一个power值，初始时这些卫星之间有若干条边，有两种操作一种是删边，另一种是查询，查询卫星a，即要求找出与卫星a直接或间接相连的卫星中power值大于该卫星的拥有最大power值的卫星，若两卫星power值相同且最大输出编号小的那个。

分析：按上述方法，先删边，再反向处理操作，注意该题优先级的描述，再Union中要分类处理。

[cpp]  view plain copy print ?

1. #include <cstdio>  
2. #include <cstring>  
3. #include <iostream>  
4. #include <set>  
5. using namespace std;  
6. #define MAXN 10010  
7. #define MAXM 50010  
8.   
9. int query[MAXM][2];  
10. int par[MAXN],power[MAXN];  
11. int ans[MAXM];  
12. set<int> g[MAXN];  
13.   
14. void init(int n)  
15. {  
16.     for(int i=0;i<n;i++)  
17.     {  
18.         par[i]=i;  
19.         g[i].clear();  
20.         scanf("%d",&power[i]);  
21.     }  
22. }  
23.   
24. int find(int x)  
25. {  
26.     if(x==par[x])    return x;  
27.     return par[x]=find(par[x]);  
28. }  
29.   
30. void Union(int a,int b)  
31. {  
32.       
33.     int pa=find(a);  
34.     int pb=find(b);  
35.     if(power[pa]<power[pb])    par[pa]=pb;  
36.     else if(power[pa]>power[pb])    par[pb]=pa;  
37.     else  
38.     {  
39.         if(pa<pb)    par[pb]=pa;  
40.         else par[pa]=pb;  
41.     }  
42.   
43. }  
44.   
45. int main()  
46. {  
47.     int n,m,q,b=0;  
48.     while(scanf("%d",&n)!=EOF)  
49.     {  
50.         if(b)    printf("\n");  
51.         b=1;  
52.         init(n);  
53.         scanf("%d",&m);  
54.         int a,b;  
55.         char str[20];  
56.         for(int i=0;i<m;i++)  
57.         {  
58.             scanf("%d%d",&a,&b);  
59.             if(a>b)    swap(a,b);  
60.             g[a].insert(b);  
61.         }  
62.         scanf("%d",&q);  
63.         for(int i=0;i<q;i++)  
64.         {  
65.             scanf("%s",str);  
66.             if(str[0]=='d')  
67.             {  
68.                 scanf("%d%d",&a,&b);  
69.                 if(a>b)    swap(a,b);  
70.                 query[i][0]=a;    query[i][1]=b;  
71.                 g[a].erase(g[a].find(b));  
72.             }  
73.             else  
74.             {  
75.                 scanf("%d",&a);  
76.                 query[i][0]=a;    query[i][1]=-1;  
77.             }  
78.         }  
79.         for(int i=0;i<n;i++)  
80.         {  
81.             for(set<int>::iterator it=g[i].begin();it!=g[i].end();it++)  
82.                 Union(i,*it);  
83.         }  
84.         int cnt=0;  
85.         for(int i=q-1;i>=0;i--)  
86.         {  
87.             if(query[i][1]==-1)  
88.             {  
89.                 int tmp=find(query[i][0]);  
90.                 if(power[tmp]==power[query[i][0]]) ans[cnt++]=-1;  
91.                 else    ans[cnt++]=tmp;  
92.             }  
93.             else    Union(query[i][0],query[i][1]);  
94.         }  
95.         for(int i=cnt-1;i>=0;i--)  
96.         printf("%d\n",ans[i]);  
97.     }  
98. }  
99.