——对并查集的优化问题

并查集的模板化操作

最开始的并查集是这个样子的

int find(int r)
{
    while(r!=bin[r])
    {
        r=bin[r];
    }
    return r;//不断向上查找父节点，直至找到父节点
}
void unite(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x!=y)
	fa[x]=y;//不论树高直接莽上去连接
}

其中find 为查找函数
	unite为链接函数

当数据足够多时，上面的基本方法就不顶用了
我们最好做如下 的优化
首先优化find函数
实现途径是路径压缩

基本思想是将其子节点全部跟父节点相连

于是有了

int find(int x)
	{
		if(fa[x]==x)
		return x;
		else
		return fa[x]=find(fa[x]); //直接连接到根节点
	}

再而就是对unite函数的优化
即为按秩合并

void unite(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x==y)
	return ;
	if(rk[x]<rk[y])//rk[]数组是树高的意思，不断选取树高更矮的作为根节点连接
	fa[x]=y;
	else 
	{fa[y]=x;
	if(rk[x]==rk[y])
	rk[x]++;//树高相同时合并一定会增加树高
}}

下面来一次实战例题

某个家族人员过于庞大，要判断两个是否是亲戚，确实还很不容易，现在给出某个亲戚关系图，判断两个人是否具有亲戚关系。

题目描述
规定：x和y是亲戚，y和z是亲戚，那么x和z也是亲戚。如果x,y是亲戚，那么x的亲戚都是y的亲戚，y的亲戚也都是x的亲戚。

输入格式
第一行：三个整数n,m,p，（n<=5000,m<=5000,p<=5000），分别表示有n个人，m个亲戚关系，询问p对亲戚关系。

以下m行：每行两个数Mi，Mj，1<=Mi，Mj<=N，表示Mi和Mj具有亲戚关系。

接下来p行：每行两个数Pi，Pj，询问Pi和Pj是否具有亲戚关系。

输出格式
P行，每行一个’Yes’或’No’。表示第i个询问的答案为“具有”或“不具有”亲戚关系。

输入输出样例
输入
6 5 3
1 2
1 5
3 4
5 2
1 3
1 4
2 3
5 6
输出
Yes
Yes
No

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1005;
int fa[maxn],rk[maxn];
int inti(int n)
	{
	for(int i=1;i<=n;i++)
		{
		fa[i]=i;
		rk[i]=0;}//初始化各节点
		
	}
int find(int x)
	{
		if(fa[x]==x)
		return x;
		else
		return fa[x]=find(fa[x]); 
	}
void unite(int x,int y)
	{
	x=find(x);
	y=find(y);
		if(x==y)
		return ;
		if(rk[x]<rk[y])
		fa[x]=y;
		else 
		{fa[x]=y;
		if(rk[x]==rk[y])
		rk[x]++;
	}}
bool same(int x,int y)
{
	return find(x)==find(y);
}//查询函数

int main()
	{	int n,m,p,a,b;
		cin>>n>>m>>p;
		inti(n);
			for(int i=1;i<=m;i++)
			{	cin>>a>>b;
				unite(a,b);
				
		}
			for(int i=1;i<=p;i++)
			{
				cin>>a>>b;
				if(same(a,b))
				printf("Yes\n");
				else
				printf("No\n"); 
		}
		return 0;
 	} 

经过两次优化程序的效率已然大大提高了！