[浅显易懂] 数据结构之并查集(基础篇)

前言:

对并查集基础篇的讲解，我们将按照"是什么——为什么——怎么做——怎么进一步优化——更高级的应用"的逻辑顺序进行，浅显易懂地带领大家认识并查集。而对于更高级的应用"边带权并查集"与"拓展域并查集", 基础篇中我们对其只会做粗略了解，更详细的介绍请关注并查集进阶篇讲解。并查集的优化方案"按秩合并"也将放在进阶篇中详细阐述，基础篇只会涉及路径压缩的优化。

并查集代码非常短，但考题往往比较灵活，需要深入理解。如果对原理实在不理解可以仔细体会一下代码模板如何在题目中应用。

内容概要:

• 并查集是一种数据结构，用于处理不相交可合并集合的关系
• 对于并查集，核心操作是"并"(合并两个集合)和"查"(查找两个元素的代表元素并判断是否属于同一集合)
• 并查集通过"代表元"法，即通过判断两个元素是否有同一个根节点来判断是否属于同一集合，构成连通块/构成父亲孩子结点表示两个元素具有相同的性质。
• 查询操作: 递归or递推访问父节点, 直到p[x] = x
• 合并操作: 通过查询操作找到两个元素的根节点，让其中一个根节点成为另一个的父节点, p[find(a)] = find(b)
• 对并查集查询的优化策略有"路径压缩"和"按秩合并", 任一优化均可使并查集查询操作时间复杂度降为O(log n), 同时采用两种优化的并查集可以使查询复杂度接近常数(反阿克曼函数)
• 并查集可以维护额外信息，以此用来处理多种传递关系，高级应用有边带权并查集和拓展域并查集。

正文目录

• 并查集是什么?——处理不交集合并查询的数据结构

• 并查集能做什么?——“并"和"查”

• 如何让并查集实现功能?——找代表元

• 如何进一步优化效率? —— 路径压缩和按秩合并

• 代码汇总

• 题目清单

• 更高级的应用? ——边带权与拓展域

并查集是什么

我们以家族族谱为例。

现在给你两个家族的族谱以及来自两个家族的三个人A、B、C， 如何判断两个人属于同一家族呢？
我们寻根溯祖，如果发现有两个人的祖先相同，则认为两个人是属于同一家族的。在日常生活中我们也经常说"朋友的朋友是朋友"、“亲戚的亲戚是亲戚”，这些都是并查集在生活中的应用。

并查集是表示连续、传递关系的数据结构，用于处理不交集合并查询操作。并查集的每一个结合都是一棵树，树根表示这个集合的公共祖先。

以 “朋友的朋友是朋友” 为例，由A是B的朋友，B是C是朋友，我们可以推出A和C是朋友，这便是传递性。(其实这里还有A是B的朋友，那么B也是A的朋友的传递性)。如果有人与B或者C构成朋友关系，可以根据传递性推出来他们也都与A构成朋友关系。可以看出，并查集擅长动态维护具有传递性的关系

在这个图中，连通块上的所有人都有共同的朋友A，因此他们也都互为朋友

并查集能做什么?

并查集，顾名思义便是能实现"并"和"查"的集合。

"并"指的是合并两个集合，即把有相同性质的两个集合合并成一个集合；
"查"指的是查找两个元素的公共祖先(根节点)并判断两个元素是否属于同一个集合

如何高效地实现合并和查询操作便是我们要考虑的问题。

如何让并查集实现功能?

具有相同性质的元素节点连接形成一棵棵关系树，不同的关系树又通过新出现的相同性质互相连接，最终构成庞大的关系森林，因此并查集实际上是一个森林(若干个树的集合)

维护某一个具有相同性质的元素组成的集合时，我们不需要去看这个集合中的每一个元素，只需要在这个集合中选择一个"代表元素" , 以维护这个代表元素的信息来维护整个集合。这种方法称为"代表元"法。如上面"朋友的朋友"的例子，我们选择元素A为代表元素，如果B和C的共同朋友都是A，那么他们也一定是朋友。

每一个关系树的"代表元素", 即为这棵树的根节点

由于我们维护的是元素之间的归属关系，我们只关心元素间是否具有某种共同的属性, 即如果性质相同就让他们成为"一根绳上的蚂蚱"，构成连通关系，即构成父亲节点与孩子节点。

给出两个元素a和b的一个新的关系，我们只需要让a和b所属的关系树合并为一棵关系树即可，即让a所在关系树的代表元素作为b的一个孩子结点或让b所在关系树的代表元素作为a的孩子结点。不断给出新的元素间的新的关系，也只需要不断地去维护这些关系树即可。

我们用一个一维数组p来记录整个关系森林，p[x]表示的为x的父亲节点。最初所有元素都指向自己(p[i] = i)， 代表 每个元素自己最初所具有的性质。

查找操作:
记函数find(x)为查找x的根节点。对于查询操作，在查询当前元素节点的归属时，只需要不断访问该元素的父亲节点，递推访问p[x] ，即x = p[x] ，或递归访问p[x], find(p[x]), 直到达到这条关系树的根节点(根节点为当前关系树的代表元素， x = p[x] 代表找到了根节点)

合并操作:
合并a和b时，递归找a和b的根节点(代表元素), 让b(a)的代表元素成为a(b)的代表元素的父节点,即p[find(a)] = find(b) 或 p[find(b)] = find(a)

如何进一步优化效率?

我们已经了解了并查集的功能以及其实现的原理，接下来我们分析其时间复杂度及其优化方案。

显然合并两个集合的时间复杂度为O(1), 而查询的时间复杂度平均为O(log n), 在极端的条件下复杂度为O(n), 若n为1e5, 每次查询都要经过1e5次操作，在有限时间内可查询的次数屈指可数。

路径压缩

在寻找根节点的路径上，所有经过的点(即x的父亲节点,父亲节点的父亲节点…)最终到达的是同一个根节点，因此我们可以把当前查询的路径上的所有点的父亲节点都指向根节点，这样查找的时候就不需要回溯去找父亲节点了，路径压缩后查询的时间复杂度将变为O(1)。路径压缩的具体代码可以看代码汇总部分。

按秩合并

另一种优化方法为按秩合并。"秩"可以理解为未进行路径压缩时树的深度。每次在合并的时候，将秩小的树根作为秩大的树根的子节点。
按秩合并会在进阶篇详细介绍，这里只做简单说明。

单独使用路径压缩和按秩合并都会使平均复杂度变为O(log n)，如果两个优化都使用,查询的时间复杂接近于常数(反阿克曼函数)
有关各种情况下并查集时间复杂度的详细内容可以看这篇文章:
并查集各种情况下的时间复杂度

代码汇总

//并查集的存储
int p[N]; //n为结点总数, p存的是每个结点的父节点

//并查集初始化
void init()
{
	for(int i = 1; i <= n; i++) p[i] = i; //每一个起始元素最初都是一个独立的集合
}

//并查集查找递推版本(未优化)
int find(int x)
{
    while(x != p[x]) //x不是根节点,继续往上找
    {
        x = p[x]; //获取自己的父亲节点
    }
    return x; //x是根节点，返回
}

//并查集查找递归版本(未优化)
void find(int x)
{
    if(x == p[x]) return x; //找到根节点，返回根节点编号x
    else return find(p[x]); //递归判断x的父亲节点是否为根节点
}

//并查集合并
void merge(int a, int b)
{
    p[find(a)] = find(b);
}

//并查集查找 路径压缩优化 递推
int find(int x)
{
    int tmp = x; 
    while(x != p[x])
    {
        x = p[x];
    }
    //这里x已经成为了根节点,需要把路径上所有的节点的父节点改成根节点
    while(tmp != p[tmp])
    {
        int tt = tmp; //tmp会被p[tmp]覆盖掉,暂存tmp
        tmp = p[tmp]; //向上走
        p[tt] = x; //替换下面的点为根节点x
    }
    return x;
}

//并查集查找 路径压缩优化 递归
int find(x)
{
    if(x != p[x]) p[x] = find(p[x]);
    return p[x];
}

题目清单

合并集合
P1551 亲戚
P1536 村村通 (求连通块个数)
连通块中点的数量 (求连通块中中元素个数)
P1525 关押罪犯 (带权or种类并查集)
食物链 (带权or种类并查集)
银河英雄传说 (带权并查集)
可持久化并查集加强版 (按秩合并)

• 村村通

要求每两个点之间都有通路，告诉你现有的路，问你还需要额外建多少条路

把所有的连通块看成一个整体的点，要让n个连通块之间彼此连通也就是让n个点之间有n-1条线两两连接，
因此ans为连通块的个数 - 1

#include <bits/stdc++.h>

using namespace std;

#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
const int N = 1010;

int p[N];
bool is_root[N];
int find(int x)
{
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    IOS
    int n, m;
    while(cin >> n >> m)
    {
        memset(p, 0, sizeof p);
        memset(is_root, 0, sizeof is_root); //多组输入要注意初始化
        for(int i = 1; i <= n; i++)
        {
            p[i] = i;
        }
        while(m--)
        {
            int a, b;
            cin >> a >> b;
            if(find(a) != find(b))
            {
                p[find(a)] = find(b);
            }
        }
        for(int i = 1; i <= n; i++)
        {
            is_root[find(i)] = true; //每一个都找父节点，并把根节点标记为true → 连通块的个数
        }
        int cnt = 0;
        for(int i = 1; i <= n; i++)
        {
            cnt += is_root[i]; //连通块的个数就是根节点的个数的和
        }
        cout << cnt - 1 << endl;

    }
    return 0;
}

连通块中点的数量

(统计连通块中点的个数 → 原根节点元素个数加到新根节点上)
#include <bits/stdc++.h>

using namespace std;

const int N = 100010;
int p[N], cnt[N]; //只保证根节点的cnt有意义即可

int find(int x)
{
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}
int main()
{
    int n, m;
    cin >> n >> m;

    int a, b;
    for(int i = 1; i <= n; i++)
    {
        p[i] = i;
        cnt[i] = 1;
    }
    while(m--)
    {
        string s;
        cin >> s;
        if(s == "C")
        {
            cin >> a >> b;
            if(find(a) != find(b)) 
            {
                cnt[find(b)] += cnt[find(a)]; //原集合合并到新集合，只需把原集合根节点存储的个数加到新集合的根节点上
                p[find(a)] = find(b);
            }

        }
        else if(s == "Q1")
        {
            cin >> a >> b;
            if(find(a) != find(b))
            {
                cout << "No" << endl;
            }
            else cout << "Yes" << endl;
        }
        else
        {
            cin >> a;
            cout << cnt[find(a)] << endl;
        }
    }

    return 0;
}

更高级的应用? ——边带权与拓展域

并查集可以维护额外信息，以此可以处理多种关系(如敌对，同类、捕食与天敌)， 重要的种类并查集与带权并查集将会在进阶篇中详细去讲。

并查集基础篇到此结束，欢迎点赞收藏评论~