并查集总结及相关例题

一、关于并查集

定义

并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。

集合定义方法： “代表元法”，即每个集合选择一个固定的元素，作为整个集合的“代表”。

基本操作

合并：合并两个集合。

查询：查询元素所属集合。

实际操作时，我们会使用一个点来代表整个集合，即一个元素的根结点。

具体实现

建立一个数组fa [ ]或者pre[ ]，表示一个并查集。fa[ i ]表示i的父节点。

• 初始化 ：每一个点都是一个集合，因此自己的父节点就是自己 fa[ i ]=i

• 查询 ：每一个节点不断寻找自己的父节点，若此时自己的父节点就是自己，那么该点为集合的根结点，返回该点。

• 修改 ：合并两个集合只需要合并两个集合的根结点，即fa[RootA]=RootB，其中RootA，RootB是两个元素的根结点。

• 路径压缩 ：实际上，我们在查询过程中只关心根结点是什么，并不关心这棵树的形态(有一些题除外)。因此我们可以在查询操作的时候将访问过的每个点都指向树根，这样的方法叫做路径压缩。

二、代码实现

查询操作

int find(int x)
{
    if(fa[x] == x)
        return x;
    else
        return find(fa[x]);
}

我们用递归的写法实现对代表元素的查询：一层一层访问父节点，直至根节点（根节点的标志就是父节点是本身）。要判断两个元素是否属于同一个集合，只需要看它们的根节点是否相同即可。

合并操作

inline void merge(int i, int j)
{
    fa[find(i)] = find(j);
}

合并操作也是很简单的，先找到两个集合的代表元素，然后将前者的父节点设为后者即可。当然也可以将后者的父节点设为前者。

路径压缩

int find(int x)
{
    if(x == fa[x])
        return x;
    else
    {
        fa[x] = find(fa[x]);  //父节点设为根节点
        return fa[x];         //返回父节点
    }
}

也常常写作一行

int find(int x)
{
    return x == fa[x] ? x : (fa[x] = find(fa[x]));
}

按秩合并

由于路径压缩只在查询时进行，也只压缩一条路径，所以并查集最终的结构仍然可能是比较复杂的。我们应该把简单的树往复杂的树上合并，而不是相反。因为这样合并后，到根节点距离变长的节点个数比较少。

我们用一个数组rank[]记录每个根节点对应的树的深度（如果不是根节点，其rank相当于以它作为根节点的子树的深度）。一开始，把所有元素的rank（秩）设为1。合并时比较两个根节点，把rank较小者往较大者上合并。

初始化：

void init(int n)
{
    for (int i = 1; i <= n; ++i)
    {
        fa[i] = i;
        rank[i] = 1;
    }
}

合并操作：

void merge(int i, int j)
{
    int x = find(i), y = find(j);    //先找到两个根节点
    if (rank[x] <= rank[y])
        fa[x] = y;
    else
        fa[y] = x;
    if (rank[x] == rank[y] && x != y)
        rank[y]++;   //如果深度相同且根节点不同，则新的根节点的深度+1
}

三、例题

题目地址：戳这里

例1、P1551 亲戚

题目大意：现给出某个亲戚关系图，求任意给出的两个人是否具有亲戚关系。
这是典序的并查集入门题。

#include<iostream>
#include <set>
#include<algorithm>
using namespace std;
int f[5005];
int find(int x)
{
	if (x != f[x])
		f[x] = find(f[x]);
	return f[x];
}
//find函数也可以这么写
/*
int find(int x)
{
	if (x == f[x])
		return x;
	return f[x] = find2(f[x]);//并查集
}
*/
int main()
{
	int n, m, p;
	cin >> n>>m>>p;
	 int x, y;
	for (int i = 1; i <= n; i++)
		f[i] = i;
	for ( int i = 1; i <= m; i++)
	{
		cin >> x >> y;
		f[find(x)] = find(y);
	}
	for (int i = 1; i <= p; i++)
	{
		cin >> x >> y;
		if (find(x) == find(y))
			cout << "Yes" << endl;
		else
			cout << "No" << endl;
	}
}

例2、P1536 村村通

大概题意：给出每条道路直接连通的城镇。目标是使全市任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要相互之间可达即可）。计算出最少还需要建设多少条道路？
思路：输入两个村庄后就把它们连起来，路径压缩，输入完毕后用i从1循环到n，所以如果i的父亲为它本身的话（代表出现了一个集合），ans+1。答案要减1，因为三个点中只需用两条线连接，无需用三条线连接。

#include<iostream>
#include <set>
#include<algorithm>
using namespace std;
int f[5005];
int find(int x)
{
	if (x != f[x])
		f[x] = find(f[x]);
	return f[x];
}
void merge(int x, int y)
{//合并
	int a = find(f[x]);
	int b = find(f[y]);
	f[a] = b;
}
int main()
{
	int n, m;
	while (cin >> n)
	{
		if (n == 0)
			return 0;
		cin >> m;
		int x, y;
		int ans = 0;
		for (int i = 1; i <= n; i++)
			f[i] = i;
		for (int i = 1; i <= m; i++)
		{
			cin >> x >> y;
			merge(x, y);
		}
		for (int i = 1; i <= n; i++)
		{
			if (f[i] == i)
				ans++;
		}
		cout << ans - 1 << endl;
	}
}

例3、P1621 集合

题目大意：给你了所有 [a,b] 范围内的整数。一开始每个整数都属于各自的集合。每次你需要选择两个属于不同集合的整数，如果这两个整数拥有大于等于 p的公共质因数，那么把它们所在的集合合并。最后有多少个集合。
思路：也是并查集的题，找出大于等于p的质因数，然后在 [a,b] 范围内拥有该质因数的树，将其合并。

#include<iostream>
#include <set>
#include<algorithm>
using namespace std;
#define maxn 100010
int f[maxn];
int vis[maxn];//标记是否被筛掉
int prime[maxn];//素数数组
int find(int x)
{
	if (x != f[x])
		f[x] = find(f[x]);
	return f[x];
}
void merge(int x, int y)
{
	int a = find(f[x]);
	int b = find(f[y]);
	f[a] = b;
}
int main()
{
	int a, b, p;
	cin >> a >> b >> p;
	for (int i = a; i <= b; i++)
	{
		f[i] = i;
	}
	int cnt = 1;
	for (int i = 2; i <= b; i++)
	{
		if (!vis[i])
			prime[cnt++] = i;
		for (int j = 2 * i; j <= b; j += i)
		{
			vis[j] = 1;
		}
	}
	for (int i = 1; i < cnt; i++)
	{
		if (prime[i] >=p)
		{
			int t = a / prime[i];
			if (a % prime[i] != 0)
				t++;
			for (int j = t+1; j * prime[i] <= b; j++)
				merge(j * prime[i], t * prime[i]);
		}
	}
	int ans = 0;//答案
	for (int i = a; i <= b; i++)
	{
		if (i == f[i])
			ans++;
	}
	cout << ans << endl;
}