数据结构之并查集

1.并查集

1.1 并查集思想

• 用集合中的一个元素代表集合。主要用于解决一些元素分组的问题。它管理一系列不相交的集合，并支持两种操作：合并，把两个不相交的集合合并为一个集合；查询，查询两个元素是否在同一个集合中。

1.2 并查集经典问题

• 亲戚 分析：这是一道并查集中的经典问题，也是一道模板题。参考代码：

#include<bits/stdc++.h>
using namespace std;
const int N=5005;
int father[N];
int sz[N];
//初始化
void init(int n){
	for(int i=1;i<=n;i++){
		father[i]=i;
		sz[i]=1;
	}
} 
//查找
int find(int x){
	if(x==father[x]) return x;
	return father[x]=find(father[x]);
}
//合并
void join(int x,int y){
	int rx=find(x),ry=find(y);
	if(rx==ry) return ;
	if(sz[rx]>sz[ry]){
		father[ry]=rx;
	}else{
		father[rx]=ry;
		if(sz[rx]==sz[ry]) sz[ry]++;
	}
}
int main()
{
	int n,m,p;
	cin>>n>>m>>p;
	init(n);
	for(int i=0;i<m;i++){
		int x,y;cin>>x>>y;
		join(x,y);
	}
	for(int i=0;i<p;i++){
		int x,y;cin>>x>>y;
		if(find(x)==find(y)) cout<<"Yes";
		else cout<<"No";
		cout<<endl;
	}
	return 0;
}

1.3 并查集经题目应用

• 修改数组

2.带权并查集

2.1 带权并查集定义

• 带权并查集：一般的并查集主要记录节点之间的链接关系，而没有其他的具体的信息，仅仅代表某个节点与其父节点之间存在联系，它多用来判断图的连通性，而有的时候在这些边中添加一些额外的信息可以更好的处理需要解决的问题，在每条边中记录额外的信息的并查集就是带权并查集。

2.2 带权并查集路径压缩

• 带权并查集我们可以看到它的每一条边都记录了每个节点到根节点的一个权值，这个权值根据具体的问题而定，一般都是两个节点之间的某一种相对的关系，但是考虑到权值就会有两个问题：
  a…每个节点都记录的是与根节点之间的权值，那么在Find的路径压缩过程中，权值也应该做相应的更新，因为在路径压缩之前，每个节点都是与其父节点链接着，那个Value自然也是与其父节点之间的权值
  b.在两个并查集做合并的时候，权值也要做相应的更新，因为两个并查集的根节点不同。
• 核心代码：

int find(int x)
{
	if (x==parent[x]){
		return x;
	}else{
		int root = parent[x];
		parent[x] = find(parent[x]);
		value[x] += value[root];//重点
		return parent[x];
	}
}

2.3 带权并查集合并

现在是已知x所在的并查集根节点为px，y所在的并查集根节点为py，如果有了x、y之间的关系，要将px并到py上，如果不考虑权值直接修改parent就行了，但是现在是带权并查集，必须得求出px与py这条边的权值是多少，很显然x到py的两条路径的权值之和应该相同，就不难得出上面代码所表达的更新式。但是需要注意并不是每个问题都是这样更新的，有时候可能会做取模之类的操作，具体问题还需要具体分析；

int px = find(x);
int py = find(y);
if (px != py){
	parent[px] = py;
	value[px] = -value[x] + value[y] + s;
}

2.4 带权并查集经典题目1

• 题目描述：有N个数，不知道它们具体的值，但是知道某两个数之间（包括这两个数）的所有数之和，现在给出M个这样的区间和信息，需要判断有多少个这样的区间和与前边已知的区间和存在矛盾，输出该矛盾的个数。其中1 <= N <= 200000, 1 <= M <= 40000。例如给出区间和[1,4]为20，[3,4]为15，再给出[1,2]为30，显然这个[1,2]的值就有问题，它应该为20-15=5。链接：How Many Answers Are Wrong
• 样例输入：
  10 5
  1 10 100
  7 10 28
  1 3 32
  4 6 41
  6 6 1
• 样例输出：
  1
• 思考：矛盾产生的唯一情况：某个区间的值可以由前边的区间求出来，而又给出了这个区间错误的值。
• 参考代码：

#include<iostream>
using namespace std;
const int N=200000+5;
int father[N],value[N];
int sz[N];
int res=0;
int find(int x){
	if(x==father[x]){
		return x;
	}else{
		int root=father[x];
		father[x]=find(father[x]);
		value[x]+=value[root];
		return father[x];
	}
}
void join(int x,int y,int s){
	int rx=find(x),ry=find(y);
	if(rx==ry){
		if((value[x]-value[y])!=s) res++;
	}else{
		father[rx]=ry;
		value[rx]=-value[x]+value[y]+s;
	} 
}
void init(int& n){
	res=0;
	for(int i=0;i<=n;i++){
		value[i]=0;
		father[i]=i;
	}
}
int main()
{
	int n,m;
	while(cin>>n>>m){
		init(n);
		for(int i=0;i<m;i++){
			int x,y,s;
			cin>>x>>y>>s;
			x--;
			join(x,y,s);
		}
		cout<<res<<endl;
	}
	return 0;
}

2.5 带权并查集经典题目2

• 链接：分数调查
• 描述：小Hi的学校总共有N名学生，编号1-N。学校刚刚进行了一场全校的古诗文水平测验。 学校没有公布测验的成绩，所以小Hi只能得到一些小道消息，例如X号同学的分数比Y号同学的分数高S分。 小Hi想知道利用这些消息，能不能判断出某两位同学之间的分数高低？
• 输入
  第一行包含三个整数N, M和Q。N表示学生总数，M表示小Hi知道消息的总数，Q表示小Hi想询问的数量。 以下M行每行三个整数，X, Y和S。表示X号同学的分数比Y号同学的分数高S分。 以下Q行每行两个整数，X和Y。表示小Hi想知道X号同学的分数比Y号同学的分数高几分。
  对于50%的数据，1 <= N, M, Q <= 1000
  对于100%的数据，1 <= N, M, Q<= 100000 1 <= X, Y <= N -1000 <= S <= 1000
  数据保证没有矛盾。
• 输出
  对于每个询问，如果不能判断出X比Y高几分输出-1。否则输出X比Y高的分数。
• 样例输入
  10 5 3
  1 2 10
  2 3 10
  4 5 -10
  5 6 -10
  2 5 10
  1 10
  1 5
  3 5
• 样例输出
  -1
  20
  0
• 分析：这道题给的都是相对关系，显然可以用带权并查集来做，权值就是子节点比父节点多的分数，询问能求解的情况就是两个人同属于一个并查集的情况。
• 参考代码：

#include<bits/stdc++.h>
using namespace std;
const int N=100000+5;
int father[N],value[N];
int find(int x){
	if(x==father[x]){
		return x;
	}else{
		int root=father[x];
		father[x]=find(father[x]);
		value[x]+=value[root];
		return father[x];
	}
}
void join(int x,int y,int s){
	int rx=find(x),ry=find(y);
	if(rx==ry){
		return ;
	}else{
		father[rx]=ry;
		value[rx]=-value[x]+value[y]+s;
	} 
}
void init(int& n){
	for(int i=0;i<=n;i++){
		value[i]=0;
		father[i]=i;
	}
}
int main()
{
	int n,m,q;
	cin>>n>>m>>q;
	init(n);
	for(int i=0;i<m;i++){
		int x,y,s;
		cin>>x>>y>>s;
		join(x,y,s);
	}
	for(int i=0;i<q;i++){
		int x,y;
		cin>>x>>y;
		if(find(x)!=find(y)){
			cout<<"-1";
		}else{
			cout<<value[x]-value[y];
		}
		cout<<endl;
	}
	return 0;
}

3.种类并查集

3.1 种类并查集定义

• 种类并查集可以维护敌人的敌人是朋友这样的关系，这种说法不够准确，较为本质地说，种类并查集（包括普通并查集）维护的是一种循环对称的关系，所以如果是三个及以上的集合，只要每个集合都是等价的，且集合间的每个关系都是等价的。

3.2 种类并查集定义经典题目1

• 关押罪犯
• 分析：我们可以开两倍的空间，前一倍空间表示该下标的朋友，后一倍空间表示下标的朋友，于是我们就可以通过这样的表示来完成题目的要求。
• 参考代码：

#include<bits/stdc++.h>
using namespace std;
const int N=40000+5;
const int M=100000+5;
int father[N],sz[N];
struct Arr{
	int x,y,w;
};
bool cmp(Arr a,Arr b){
	return a.w>b.w;
}
int find(int x){
	if(x==father[x]){
		return x;
	}else{
		father[x]=find(father[x]);
		return father[x];
	}
}
void join(int x,int y){
	int rx=find(x),ry=find(y);
	if(rx==ry) return ;
	if(sz[rx]>sz[y]){
		father[ry]=rx;
	}else{
		father[rx]=ry;
	}
	if(sz[rx]==sz[ry]) sz[rx]++;
}
void init(int& n){
	for(int i=0;i<=2*n;i++){
		father[i]=i;
		sz[i]=0;
	}
}
int main()
{
	int n,m;
	cin>>n>>m;
	init(n);
	Arr arr[m];
	for(int i=0;i<m;i++){
		int x,y,w;
		cin>>arr[i].x>>arr[i].y>>arr[i].w;
	}
	sort(arr,arr+m,cmp);
	for(int i=0;i<m;i++){
		if(find(arr[i].x)==find(arr[i].y)){
			cout<<arr[i].w;
			return 0;
		}else{
			join(arr[i].x+n,arr[i].y);
			join(arr[i].x,arr[i].y+n);
		}
	}
	cout<<'0';
	return 0;
}

3.3 种类并查集定义经典题目2

• 食物链
• 分析：我们这道题可以仿照第一道经典题目解决，同时我们也可以真正去使用种类并查集解决问题。
• a.路径压缩时，如何更新Value
  如果现在有A->B为1，B->C为1，怎么求A->C？显然A吃B，B吃C，那么由题意C应该吃A，那么A->C应该为2；
  如果现在有A->B为2，B->C为2，怎么求A->C？显然B吃A，C吃B，那么由题意A应该吃C，那么A->C应该为1；
  如果现在有A->B为0，B->C为1，怎么求A->C？显然A、B同类，B吃C，那么由题意A应该吃C，那么A->C应该为1；
  找规律不难发现，A->C = (A->B + B->C) % 3，因此关系值的更新需要累加再模3。
• b.区间合并时，如何更新Value
  由1不难发现，本题的Value更新无非就是多了个取模操作，因此不难验证区间合并的更新操作应该为：
  value[fx] = (-value[x] + relation + value[y]) % 3
• c.如何判断是否矛盾
  不同于分数、区间和，可以直接相减得到计算结果，这里要解决如果已知A与根节点的关系，B与根节点的关系，如何求A、B之间的关系？由于关系值的计算要模3，因此A->B=(A->C - B->C + 3) % 3，加三是为了避免负数的影响。将A->B与题目给的Relation值判等比较即可。
• 注意，本题给的relation值都是1或2，在实际处理的时候，这个值应该减1。
• 参考代码：

#include<iostream>
using namespace std;
const int N=50000+5;
int father[N],value[N];
int res=0;
int find(int x){
	if(x==father[x]){
		return x;
	}else{
		int root=father[x];
		father[x]=find(father[x]);
		value[x]=(value[x]+value[root])%3;
		return father[x];
	}
}
void join(int x,int y,int s){
	int rx=find(x),ry=find(y);
	if(rx==ry){
		if((value[x]-value[y]+3)%3!=s){
			res++;
		}
	}else{
		father[rx]=ry;
		value[rx]=(-value[x]+value[y]+s+3)%3;
	}
}
void init(int& n){
	for(int i=0;i<=n;i++){
		father[i]=i;
	}
}
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	init(n);
	for(int i=0;i<m;i++){
		int s,x,y;
		scanf("%d%d%d",&s,&x,&y);
		if(x>n||y>n){
			res++;
			continue;
		}
		if(s==1){
			join(x,y,s-1);
		}else{
			if(x==y){
				res++;
			}else{
				join(x,y,s-1);
			}
		}
	}
	cout<<res;
	return 0;
}