并查集基本概况

目录

详情可看：https://zhuanlan.zhihu.com/p/93647900

定义：

基本思路：

问题一：

 问题二：

问题三：

优化思路：

例题：836合并集合

---

详情可看：https://zhuanlan.zhihu.com/p/93647900

定义：

并查集被很多OIer认为是最简洁而优雅的数据结构之一，主要用于解决一些元素分组的问题。它管理一系列不相交的集合，并支持两种操作：

• 合并（Union）：把两个不相交的集合合并为一个集合。
• 查询（Find）：查询两个元素是否在同一个集合中。

基本思路：

问题一：

判断树根：除根节点外，每个节点存储的值都为该点的父亲节点，如果当一个节点的父亲节点指向它本身时，则表示该点为父亲节点，我们可以在初始化步骤将每棵树中节点的父亲节点指向自己（因为初始化时每棵树里只有一个节点，即为根节点）。

 问题二：

求x节点的集合编号：从x节点开始遍历，每次都更新成它的父亲节点，直到该节点的父亲节点指向自己，即该节点为根节点，其编号也就为x的集合编号。

问题三：

合并两个集合： 设当前x为某个集合的根节点，y为另一个集合的根节点，让p[x]指向y即可，

p[x]=y,则表示将集合x放入集合y中，即两个集合合并。（反之，p[y]=x也可）

优化思路：

 但根据以上思路，在求x的集合编号时可以发现，遍历的次数和树的高度成正比，时间复杂度依旧过高，所以可以进一步优化路径压缩，也就是在边历x节点到根节点的过程中，将路径上经过的每一个点都指向根节点，这样就可以保证在下次遍历到这个点时可以直接找到根节点。

拓展：

路径压缩：

      路径压缩就相当于把路径上的所有结点的父亲结点都指向根节点，查找的时候就不用一直回溯去找父亲结点了，因此查询的复杂度降到了O (1)。

例题：836合并集合

836. 合并集合

•    题目
•    提交记录
•    讨论
•    题解
•    视频讲解

一共有 nn 个数，编号是 1∼n1∼n，最开始每个数各自在一个集合中。

现在要进行 mm 个操作，操作共有两种：

1. M a b，将编号为 aa 和 bb 的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；
2. Q a b，询问编号为 aa 和 bb 的两个数是否在同一个集合中；

输入格式

第一行输入整数 nn 和 mm。

接下来 mm 行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。

输出格式

对于每个询问指令 Q a b，都要输出一个结果，如果 aa 和 bb 在同一集合内，则输出 Yes，否则输出 No。

每个结果占一行。

数据范围

1≤n,m≤1051≤n,m≤105

输入样例：

4 5
M 1 2
M 3 4
Q 1 2
Q 1 3
Q 3 4

输出样例：

Yes
No
Yes

【代码参考】

#include<iostream>
using namespace std;
const int N=1e5+10;
int p[N];
int n,m;
int find(int x){//寻找 x的祖宗节点，以及路径压缩 
	if(p[x]!=x) p[x]=find(p[x]);
	return p[x];//此时的p[x]在递归的操作下存储的值为根节点的编号
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		p[i]=i;
	}
	char q[2];
	int a,b;
	while(m--){
		scanf("%s%d%d",q,&a,&b);
		if(q[0]=='M'){
			p[find(a)]=find(b); //表示将a,b两个集合合并，
		}else{
			if(find(a)==find(b))cout<<"Yes"<<endl; //如果两个点的根节点一样，则输出Yes
			else cout<<"No"<<endl;
		}
	}
	return 0;
}

例题：837连通块中点的数量

给定一个包含 nn 个点（编号为 1∼n1∼n）的无向图，初始时图中没有边。

现在要进行 mm 个操作，操作共有三种：

1. C a b，在点 aa 和点 bb 之间连一条边，aa 和 bb 可能相等；
2. Q1 a b，询问点 aa 和点 bb 是否在同一个连通块中，aa 和 bb 可能相等；
3. Q2 a，询问点 aa 所在连通块中点的数量；

输入格式

第一行输入整数 nn 和 mm。

接下来 mm 行，每行包含一个操作指令，指令为 C a b，Q1 a b 或 Q2 a 中的一种。

输出格式

对于每个询问指令 Q1 a b，如果 aa 和 bb 在同一个连通块中，则输出 Yes，否则输出 No。

对于每个询问指令 Q2 a，输出一个整数表示点 aa 所在连通块中点的数量

每个结果占一行。

数据范围

1≤n,m≤1051≤n,m≤105

输入样例：

5 5
C 1 2
Q1 1 2
Q2 1
C 2 5
Q2 5

输出样例：

Yes
2
3

 【代码参考】

#include<iostream>
using namespace std;
const int N=1e5+10;
int p[N],siz[N];
int n,m;
int find(int x){//路径压缩+寻找祖宗节点 
	if(p[x]!=x)p[x]=find(p[x]);
	return p[x];
}
int main(){
	cin>>n>>m;
	int a,b;
	for(int i=1;i<=n;i++){
		p[i]=i;
		siz[i]=1;
	}
	while(m--){
		char op[4];
		scanf("%s",op);
		if(op[0]=='C'){
			scanf("%d%d",&a,&b);
			if(find(a)==find(b))continue;
			siz[find(b)]+=siz[find(a)];
			p[find(a)]=find(b);
		}
		else if(op[1]=='1'){
			scanf("%d%d",&a,&b);
			if(find(a)==find(b))cout<<"Yes"<<endl;
			else cout<<"No"<<endl; 
		}
		else{
			scanf("%d",&a);
			cout<<siz[find(a)]<<endl;
		}
	}
	return 0; 
} 

例题：240食物链

动物王国中有三类动物 A,B,CA,B,C，这三类动物的食物链构成了有趣的环形。

AA 吃 BB，BB 吃 CC，CC 吃 AA。

现有 NN 个动物，以 1∼N1∼N 编号。

每个动物都是 A,B,CA,B,C 中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这 NN 个动物所构成的食物链关系进行描述：

第一种说法是 1 X Y，表示 XX 和 YY 是同类。

第二种说法是 2 X Y，表示 XX 吃 YY。

此人对 NN 个动物，用上述两种说法，一句接一句地说出 KK 句话，这 KK 句话有的是真的，有的是假的。

当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

1. 当前的话与前面的某些真的话冲突，就是假话；
2. 当前的话中 XX 或 YY 比 NN 大，就是假话；
3. 当前的话表示 XX 吃 XX，就是假话。

你的任务是根据给定的 NN 和 KK 句话，输出假话的总数。

输入格式

第一行是两个整数 NN 和 KK，以一个空格分隔。

以下 KK 行每行是三个正整数 D，X，YD，X，Y，两数之间用一个空格隔开，其中 DD 表示说法的种类。

若 D=1D=1，则表示 XX 和 YY 是同类。

若 D=2D=2，则表示 XX 吃 YY。

输出格式

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

数据范围

1≤N≤500001≤N≤50000,
0≤K≤1000000≤K≤100000

输入样例：

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

输出样例：

3

【题目解析】

本题如果按照并查集的思路来写，就需要考虑如何维护一个集合内部的关系（即A吃B，B吃C，C吃A），并考虑如何进行合并与查询操作。

基本思路：

我们根据在一个集合内每个节点距根节点的距离来定义该节点与根节点以及其父亲节点的关系

【代码参考】

#include<iostream>
using namespace std;
const int N=1e5+10;
int p[N],d[N];
int n,k;
int cnt=0;
int find(int x){
	if(p[x]!=x){
		int t=find(p[x]);//用t保存根节点的编号 
		d[x]=d[x]+d[p[x]];
		p[x]=t;
	}
	return p[x];
}
int main(){
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		p[i]=i;
	}
	while(k--){
		int s,x,y;
		cin>>s>>x>>y;
		if(x>n||y>n)cnt++;
		else{
			int px=find(x),py=find(y);
			if(s==1){
				if(px==py&&(d[x]-d[y])%3)cnt++;
				else if(px!=py){
					p[px]=py;
					d[px]=d[y]-d[x];
				}
			}else{
				if(px==py&&(d[x]-d[y]-1)%3)cnt++;
				else if(px!=py){
					p[px]=py;
					d[px]=d[y]-d[x]+1;
				}
			}
		}
	}
	cout<<cnt;
	return 0;
}