数据结构 —— 并查集（笔记及裸题）

本文链接：https://blog.csdn.net/m0_46272108/article/details/108864519

本文详细介绍了并查集这一数据结构的原理和操作，包括如何合并集合以及快速查询元素是否属于同一集合。通过提供清晰易读的C++代码模板，展示了并查集在处理连通性问题上的高效性。并查集优化方法中的路径压缩能够实现近乎O(1)的时间复杂度。此外，还展示了如何利用并查集计算连通块中点的数量。

摘要由CSDN通过智能技术生成

并查集

- 原理

代码短但是特别精巧。

原理

将两个集合合并
询问两个元素是否在一个集合当中（并查集的时间复杂度近乎 $O (1)$ ）
基本原理：每一个集合用一颗树来表示。树根的编号就是整个集合的编号。每个节点存储它的父节点，p[x]表示x的父节点

问题1：如何判断树根？
如果是树根的话 → $i f (p r e [x] = = x)$ ，除了根节点之外 $p r e [x] \neq = x$

问题2：如何求x的集合编号？
$w h i l e (p r e [x]! = x) x = p r e [x]$ ;只要x不是树根，就一直往上走。
其实就是解决第二点，询问两个元素是否在一个集合当中，分别求一下x的编号和y的编号。

问题3：如何合并两个集合？（加一条边，把一颗树作为另一颗树的儿子即可。）
假设pre[x]是x的集合编号，pre[y]是y的集合编号。合并就是 $p r e [x] = y$ ;

并查集优化： 找到根节点之后，把整个路径的点，全部指向根节点。（很好加速）
近乎O(1)的时间复杂度。（优化：路径压缩）（待查：按指合并）

合并集合

一共有n个数，编号是1~n，最开始每个数各自在一个集合中。
现在要进行m个操作，操作共有两种：

“M a b”，将编号为a和b的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；
“Q a b”，询问编号为a和b的两个数是否在同一个集合中；
输入格式
第一行输入整数n和m。

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

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

每个结果占一行。

数据范围
$1≤n,m≤10^5$
输入样例：

输出样例：

Yes
No
Yes

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
 
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
// #define int ll
#define INF 0x3f3f3f3f
using namespace std;
int read()
{
	int w = 1, s = 0;
	char ch = getchar();
	while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { s = s * 10 + ch - '0';    ch = getchar(); }
	return s * w;
//最大公约数
}
int gcd(int x,int y) {
    if(x<y) swap(x,y);//很多人会遗忘，大数在前小数在后
    //递归终止条件千万不要漏了，辗转相除法
    return x % y ? gcd(y, x % y) : y;
}
int lcm(int x,int y)//计算x和y的最小公倍数
{
    return x * y / gcd(x, y);//使用公式
}
//------------------------ 以上是我常用模板与刷题几乎无关 ------------------------//
const int N = 100010;

int n, m;
int pre[N];//father数组，记录每个元素的父节点。

int find(int x)//返回x的祖宗节点+路径压缩
{
    if (pre[x] != x)
        pre[x] = find(pre[x]);
    return pre[x];
}

int main()
{
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        pre[i] = i; 
    }
    while (m--) {
        //scanf 如果是%c, 会读一些空格，换行符
        //用字符串读字母，scanf("%s", op);
        //scanf("%c", &op)即可，‘’会自动过滤0~n个空格、tab、换行等空字符。
        char op[2];//operation
        
        int a, b;
        scanf("%s%d%d", op, &a, &b);
        
        if (op[0] == 'M') {
            //a的祖宗节点的父亲 == b的祖宗节点
            pre[find(a)] = find(b);//find()返回祖宗节点+路径压缩
        } else {
            //如果find(a) == find(b) ，即两个祖宗节点一样，就是在同一个集合里。
            if (find(a) == find(b)) {
                puts("Yes");
            } else {
                puts("No");
            }
        }
    }
    return 0;
}

附上一个清晰易读的并查集模板

class UnionAndFind {
private:
    int cnt;                // 记录连通分量的个数
    vector<int> pre;     // 节点x的父节点为parent[x]

public:
    // 构造函数
    UnionAndFind(int n) {
        // 初始时互不连通，连通数为n，每个节点的父节点为它自身
        cnt = n;
        pre = vector<int>(n);
        for (int i = 0; i < n; i++)
            pre[i] = i;
    }

    // 合并p和q所在的两个连通分量
    void Union(int p, int q) {
        int rp = Find(p);
        int rq = Find(q);
        if (rp == rq) return ;
        // 将两棵树合并
        pre[rp] = rq;
        cnt--;
    }

    // 查找节点x的根节点
    int Find(int x) {
        // 根节点的特征是parent[x] == x
        while (pre[x] != x) {
            pre[x] = pre[pre[x]];
            x = pre[x];
        }
        return x;
    }

    // 返回当前连通分量的个数
    int count() {
        return cnt;
    }

    // 判断p和q两个节点是否连通
    bool connected(int p, int q) {
        int rp = Find(p);
        int rq = Find(q);
        return rp == rq;
    }
};

连通块中点的数量

在这里插入图片描述

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
 
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
// #define int ll
#define INF 0x3f3f3f3f
using namespace std;
int read()
{
	int w = 1, s = 0;
	char ch = getchar();
	while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { s = s * 10 + ch - '0';    ch = getchar(); }
	return s * w;
//最大公约数
}
int gcd(int x,int y) {
    if(x<y) swap(x,y);//很多人会遗忘，大数在前小数在后
    //递归终止条件千万不要漏了，辗转相除法
    return x % y ? gcd(y, x % y) : y;
}
int lcm(int x,int y)//计算x和y的最小公倍数
{
    return x * y / gcd(x, y);//使用公式
}
//------------------------ 以上是我常用模板与刷题几乎无关 ------------------------//
const int N = 100010;

int n, m;
int pre[N];//father数组，记录每个元素的父节点。
int cnt[N];//cnt表示每个集合里面元素的个数
//每个集合都是一棵树，保证根节点

int find(int x)//返回x的祖宗节点+路径压缩
{
    if (pre[x] != x)//如果当前节点x不是根节点的话，就会往上走一层。
        pre[x] = find(pre[x]);//就返回父节点的祖宗节点
    return pre[x];
}

int main()
{
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        p[i] = i; 
        cnt[i] = 1;//刚开始每个集合只有一个点
    }
    while (m--) {
        //scanf 如果是%c, 会读一些空格，换行符
        //用字符串读字母，scanf("%s", op);
        //scanf("%c", &op)即可，‘’会自动过滤0~n个空格、tab、换行等空字符。
        char op[2];//operation
        
        int a, b;
        scanf("%s%d%d", op, &a, &b);
        
        if (op[0] == 'C') {
            scanf("%d%d",&a, &b);
            if (find(a) == find(b))//如果a和b在同一个集合里面，则不需要做任何操作了。
                continue;
            cnt[find(b)] += cnt[find(a)];//在当前这颗树的基础上加上另一颗树的节点数就可以了
            //a的祖宗节点的父亲 == b的祖宗节点
            pre[find(a)] = find(b);//find()返回祖宗节点+路径压缩
        } else if(op[1] == '1') {
            scanf("%d%d",&a, &b);
            //如果find(a) == find(b) ，即两个祖宗节点一样，就是在同一个集合里。
            if (find(a) == find(b)) {
                puts("Yes");
            } else {
                puts("No");
            }
        } else {
            scanf("%d",&a);
            printf("%d\n", cnt[find(a)]);
        }
    }
    return 0;
}