本系列是这本算法教材的扩展：《算法竞赛入门到进阶》(京东 当当) 清华大学出版社

本文web地址：https://blog.csdn.net/weixin_43914593

PDF下载地址：https://github.com/luoyongjun999/code 其中的“补充资料”

如有建议，请联系：（1）QQ 群，567554289；（2）作者QQ，15512356

??本篇包括：

??（1）1~3节，是《算法竞赛入门到进阶》书中原有的内容。

??（2）4节“带权并查集”，是扩展内容。

0 并查集简介

??并查集（Disjoint Set）是一种非常精巧而实用的数据结构，它主要用于处理一些不相交集合的合并问题。经典的应用有：连通子图、最小生成树Kruskal算法[ 参考本书第10章“10.10.2 kruskal算法”。]和最近公共祖先（Least Common Ancestors, LCA）等。

??并查集在算法竞赛中极为常见。

??通常用“帮派”的例子来说明并查集的应用背景。一个城市中有n个人，他们分成不同的帮派；给出一些人的关系，例如1号、2号是朋友，1号、3号也是朋友，那么他们都属于一个帮派；在分析完所有的朋友关系之后，问有多少帮派，每人属于哪个帮派。给出的n可能是10^6^的。

??读者可以先思考暴力的方法，以及复杂度。如果用并查集实现，不仅代码很简单，而且复杂度可以达到O(logn)。

??并查集：将编号分别为1~n的n个对象划分为不相交集合，在每个集合中，选择其中某个元素代表所在集合。在这个集合中，并查集的操作有：初始化、合并、查找。

??本文比较全面地介绍了并查集：

??（1）并查集的基本操作。

??（2）并查集的优化：合并和路径压缩。

??（3）带权并查集。

??并查集的基本应用是集合问题；加上权值之后，利用并查集的合并和查询优化，可以对权值所代表的具体应用进行高效的操作。

1 并查集的基本操作

??（1）初始化。定义数组int s[]是以结点i为元素的并查集，开始的时候，还没有处理点与点之间的朋友关系，所以每个点属于独立的集，并且以元素i的值表示它的集s[i]，例如元素1的集s[1]=1。

??下面是图解，左边给出了元素与集合的值，右边画出了逻辑关系。为了便于讲解，左边区分了结点i和集s：把集的编号加上了下划线；右边用圆圈表示集，方块表示元素。

图1 并查集的初始化

??（2）合并，例如加入第一个朋友关系(1, 2)。在并查集s中，把结点1合并到结点2，也就是把结点1的集1改成结点2的集2。

图2 合并(1, 2)

??（3）合并，加入第二个朋友关系(1, 3)。查找结点1的集，是2，再递归查找元素2的集是2，然后把元素2的集2合并到结点3的集3。此时，结点1、2、3都属于一个集。右图中，为简化图示，把元素2和集2画在了一起。

图3 合并(1, 3)

??（4）合并，加入第三个朋友关系(2, 4)。结果如下，请读者自己分析。

图4 合并(2, 4)

??（5）查找。上面步骤中已经有查找操作。查找元素的集，是一个递归的过程，直到元素的值和它的集相等，就找到了根结点的集。从上面的图中可以看到，这棵搜索树的高度，可能很大，复杂度是O(n)的，变成了一个链表，出现了树的“退化”现象。

??（6）统计有多少个集。如果s[i] = i，这是一个根结点，是它所在的集的代表；统计根结点的数量，就是集的数量。

?例题

??下面以hdu 1213为例子，实现上述操作。http://acm.hdu.edu.cn/showproblem.php?pid=1213

??有n个人一起吃饭，有些人互相认识。认识的人想坐在一起，而不想跟陌生人坐。例如A认识B，B认识C，那么A、B、C会坐在一张桌子上。

??给出认识的人，问需要多少张桌子。

??一张桌子是一个集，合并朋友关系，然后统计集的数量即可。下面的代码是并查集操作的具体实现。

#include
using namespace std;
const int maxn = 1050;
int s[maxn];
void init_set(){ //初始化
for(int i = 1; i <= maxn; i++)
s[i] = i;
}
int find_set(int x){ //查找
return x==s[x]? x:find_set(s[x]);
}
void merge_set(int x, int y){ //合并
x = find_set(x);
y = find_set(y);
if(x != y) s[x] = s[y]; //把x合并到y上，y的根成为x的根
}
int main (){
int t, n, m, x, y;
cin >> t;
while(t--){
cin >> n >> m;
init_set();
for(int i = 1; i <= m; i++){
cin >> x >> y;
merge_set(x, y);
}
int ans = 0;
for(int i = 1; i <= n; i++) //统计有多少个集
if(s[i] == i)
ans++;
cout < }
return 0;
}

??复杂度：上述程序，查找find_set()、合并merge_set()的搜索深度是树的长度，复杂度都是O(n)，性能比较差。下面介绍合并和查询的优化方法，优化之后，查找和合并的复杂度都小于O(logn)。

2 合并的优化

??合并元素x和y时，先搜到它们的根结点，然后再合并这两个根结点，即把一个根结点的集改成另一个根结点。这两个根结点的高度不同，如果把高度较小的集合并到较大的集上，能减少树的高度。下面是优化后的代码，在初始化时用height[i]定义元素i的高度，在合并时更改。

int height[maxn];
void init_set(){
for(int i = 1; i <= maxn; i++){
s[i] = i;
height[i]=0; //树的高度
}
}
void merge_set(int x, int y){ //优化合并操作
x = find_set(x);
y = find_set(y);
if (height[x] == height[y]) {
height[x] = height[x] + 1; //合并，树的高度加一
s[y] = x;
}
else{ //把矮树并到高树上，高树的高度保持不变
if (height[x] else s[y] = x;
}
}

3 查询的优化——路径压缩

??在上面的查询程序find_set()中，查询元素i所属的集，需要搜索路径找到根结点，返回的结果是根结点。这条搜索路径可能很长。如果在返回的时候，顺便把i所属的集改成根结点，那么下次再搜的时候，就能在O(1)的时间内得到结果。

图5 路径压缩

??程序如下：

int find_set(int x){
if(x != s[x])
s[x] = find_set(s[x]); //路径压缩
return s[x];
}

?? 这个方法称为路径压缩，因为整个搜索路径上的元素，在递归过程中，从元素i到根结点的所有元素，它们所属的集都被改为根结点。路径压缩不仅优化了下次查询，而且也优化了合并，因为合并时也用到了查询。

??上面代码用递归实现，如果数据规模太大，担心爆栈，可以用下面的非递归代码：

int find_set(int x){
int r = x;
while ( s[r] != r ) r=s[r]; //找到根结点
int i = x, j;
while(i != r){
j = s[i]; //用临时变量j记录
s[i]= r ; //把路径上元素的集改为根结点
i = j;
}
return r;
}

4 带权并查集

??前面讲解了并查集的基本应用：处理集合问题。并查集的高效，主要是利用了合并和查询的优化。在这些基本应用中，点之间只有简单的归属关系，而没有权值。如果在点之间加上权值，并查集的应用会更广泛。

??如果读者联想到树这种数据结构，会发现，并查集实际上是在维护若干棵树。并查集的合并和查询优化，实际上是在改变树的形状，把原来“细长”的、操作低效的大量“小树”，变成了“粗短”的、操作高效的少量“大树”。如果在原来的“小树”上，点之间有权值，那么经过并查集的优化之变成“大树”后，这些权值的操作也变得高效了。

4.1 带权值的路径压缩和合并

??定义一个权值数组d[]，结点i到父结点的权值为记为d[i]。

??（1）带权值的路径压缩

?? 下面的图，是加上权值之后的路径压缩。原来的权值d[]，经过压缩之后，更新为d[]‘，例如d[1]‘=d[1]+d[2]+d[3]。

?? 需要注意的是，这个例子中，权值是相加的关系，比较简单；在具体的题目的中，可能有相乘、异或等等符合题意的操作。

??相应地，在这个权值相加的例子中，把路径压缩的代码改为：

int find_set(int x){
if(x != s[x]) {
int t = s[x]; //记录父结点
s[x] = find_set(s[x]); //路径压缩。递归最后返回的是根结点
d[x] += d[t]; //权值更新为x到根节点的权值
}
return s[x];
}

??注意代码中的细节。原来的d[x]是点x到它的父结点的权值，经过路径压缩后，x直接指向根节点，d[x]也更新为x到根结点的权值。这是通过递归实现的。

??代码中，先用t记录x的原父结点；在递归过程中，最后返回的是根节点；最后将当前节点的权值加上原父结点的权值（注意：经过递归，此时父结点也直接指向根节点，父结点的权值也已经更新为父结点直接到根结点的权值了），就得到当前节点到根节点的权值。

??（2）带权值的合并

?? 在合并操作中，把点x与到点y合并，就是把x的根结点fx合并到y的根结点fy。在fx和fy之间增加权值，这个权值要符合题目的要求。

4.2 例题

?? 下面用2个经典例题讲解带权并查集，hdu 3038和poj 1182。

??（1）例题1：hdu 3038

?问题描述

??给出区间[a, b]，区间之和为v。输入m组数据，每输入一组，判断此组条件是否与前面冲突，最后输出与前面冲突的数据的个数。比如先给出[1, 5]区间和为100，再给出区间[1, 2]的和为200，肯定有冲突。

?题解

??本题是本节讲解的带权值并查集的直接应用。如果能想到可以把序列建模为并查集，就能直接套用模板了。

#include
using namespace std;
const int maxn =200010;
int s[maxn]; //集合
int d[maxn]; //权值：记录当前结点到根结点的距离
int ans;
void init_set(){ //初始化
for(int i = 0; i <= maxn; i++)
{ s[i] = i; d[i] = 0; }
}
int find_set(int x){ //带权值的路径压缩
if(x != s[x]) {
int t = s[x]; //记录父结点
s[x] = find_set(s[x]); //路径压缩。递归最后返回的是根结点
d[x] += d[t]; //权值更新为x到根节点的权值
}
return s[x];
}
void merge_set(int a, int b,int v){ //合并
int roota = find_set(a), rootb = find_set(b);
if(roota == rootb){
if(d[a] - d[b] != v)
ans++;
}
else{
s[roota] = rootb; //合并
d[roota] = d[b]- d[a] + v;
}
}
int main(){
int n,m;
while(scanf("%d%d",&n,&m)!=EOF){
init_set();
ans = 0;
while(m--){
int a,b,v;
scanf("%d%d%d",&a,&b,&v);
a--;
merge_set(a, b, v);
}
printf("%d\n",ans);
}
return 0;
}

??（2）例题2：poj 1182 食物链 http://poj.org/problem?id=1182

?问题描述

??动物王国中有三类动物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），输出假话的总数。

?题解

??这一题中的权值比较有趣，它不是上一题中相加的关系。把权值d[]记录为两个动物在食物链上的相对关系。下面用d(A->B)表示A、B的关系，d(A->B) = 0表示同类，d(A->B) = 1表示A吃B，d(A->B) = 2表示A被B吃。

??这一题难点在权值的更新。考虑三个问题：

??（i）路径压缩时，如何更新权值。

??若d(A->B) =1，d(B->C) = 1，求d(A->c)。因为A吃B，B吃C，那么C应该吃A，得d(A->C)=2；

??若d(A->B) =2，d(B->C) =2，求d(A->c)。因为B吃A，C吃B，那么A应该吃C，得d(A->C)=1；

??若d(A->B) = 0，d(B->C) =1，求d(A->c)。因为A、B同类，B吃C，那么A应该吃C，得d(A->C)=1；

??找规律知：d(A->C) = (d(A->B) + d(B->C) ) % 3，因此关系值的更新是累加再模3。

??（ii）合并时，如何更新权值。本题的权值更新是取模操作，内容见下面的代码。

??（iii）如何判断矛盾。如果已知A与根节点的关系，B与根节点的关系，如何求A、B之间的关系？内容见下面的代码。

??下面是代码。

#include
#include
using namespace std;
const int maxn = 50005;
int s[maxn]; //集合
int d[maxn]; // 0：同类； 1：吃； 2：被吃
int ans;
void init_set(){ //初始化
for(int i = 0; i <= maxn; i++)
{ s[i] = i; d[i] = 0; }
}
int find_set(int x){ //带权值的路径压缩
if(x != s[x]) {
int t = s[x]; //记录父结点
s[x] = find_set(s[x]); //路径压缩。递归最后返回的是根结点
d[x] = (d[x] + d[t]) % 3; //权值更新为x到根节点的权值
}
return s[x];
}
void merge_set(int x, int y, int relation){ //合并
int rootx = find_set(x);
int rooty = find_set(y);
if (rootx == rooty){
if ((relation - 1) != ((d[x] - d[y] + 3) % 3)) //判断矛盾
ans++;
}
else {
s[rootx] = rooty; //合并
d[rootx] = (d[y] - d[x] + relation - 1) % 3; //更新权值
}
}
int main(){
int n, k; cin >> n >> k;
init_set();
ans = 0;
while (k--){
int relation, x, y;
scanf("%d%d%d",&relation,&x,&y);
if ( x > n || y > n || (relation == 2 && x == y ) )
ans++;
else
merge_set(x,y,relation);
}
cout < return 0;
}

5 习题

poj 2524 Ubiquitous Religions，并查集简单题。

poj 1611 The Suspects，简单题。

poj 1703 Find them, Catch them。

poj 2236 Wireless Network。

poj 2492 A Bug‘s Life。

poj 1988 Cube Stacking。

poj 1182食物链，经典题。

hdu 3635 Dragon Balls。

hdu 1856 More is better。

hdu 1272 小希的迷宫。

hdu 1325 Is It A Tree。

hdu 1198 Farm Irrigation。

hdu 2586 How far away，最近公共祖先，并查集+深搜。

hdu 6109 数据分割，并查集+启发式合并。

6 参考文献

poj 1182的不同解法，参考[1][2]：

[1]《算法竞赛进阶指南》李煜东，河南电子音像出版社，用“扩展域”的并查集求解poj1182。

[2]《挑战程序设计竞赛》秋叶拓哉，人民邮电出版社，用普通并查集求解poj1182。

[3]leetcode上有一个并查集题目集：https://leetcode-cn.com/tag/union-find/