算法笔记【三】并查集

定义

1、一种用于管理元素分组情况的数据结构
2、每一个集合用一个树来储存，树根的编号就是这个集合的编号，每个节点存储他的父节点，p[x]就表示x的父节点

代码实现

初始化操作，所有节点都指向自己，其中n为节点个数来表示有n个元素，这里的f数组就是用来表示父亲的编号

 for(int i=1;i<=n;i++)  f[i]=i;

其中最重要的还是优雅find函数,就是寻找这个节点的祖宗节点，px表示的就是x这个节点的父亲

//返回x所在集合的编号+路径压缩
int find(int x)
{
    //最终实现了路径压缩
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

优化

1. 路径压缩，find函数在执行过程中就是使用了路径压缩
2. 按秩合并（优化效果并不是很明显），不太常用

基本操作

1. 将两个集合合并 ：

	int pa = find(a);
    int pb = find(b);
    f[pa]=pb;

2. 判断两个元素是否在一个集合之中：判断两个的树根是否一致

	find(a)==find(b)

3. 如何判断树根：

    if(find(x)==x){
        cout<<"x是树根";
    }else{
        cout<<"x不是树根";
    }

时间复杂度

近乎O（1）

例题解析

01 合并集合

模板题

题目描述

一共有 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。

每个结果占一行。

代码说明

#include<iostream>
using namespace std;
const int N = 100010;
int p[N];
int n,m;
char c;
int find(int x){
    if(p[x] != x){
        p[x] = find(p[x]);
    }
    return p[x];
}
int main(){
    cin>>n>>m;
    for(int i = 1; i <= n; i++) p[i] = i;
    while(m--){
        int a,b;
        cin>>c>>a>>b;
        int fa = find(a);
        int fb = find(b);
        if(c == 'M'){
            p[fa] = fb;
        }
        if(c == 'Q'){
            if(fa == fb){
                cout<<"Yes"<<endl;
            }else{
                cout<<"No"<<endl;
            }
        }
    }
    
    return 0;
}

02 连通块中点的数目

题目描述

给定一个包含 n 个点（编号为 1∼n）的无向图，初始时图中没有边。

现在要进行 m 个操作，操作共有三种：

C a b，在点 a 和点 b 之间连一条边，a 和 b 可能相等；
Q1 a b，询问点 a 和点 b 是否在同一个连通块中，a 和 b 可能相等；
Q2 a，询问点 a 所在连通块中点的数量；

输入格式

第一行输入整数 n 和 m。

接下来 m 行，每行包含一个操作指令，指令为 C a b，Q1 a b 或 Q2 a 中的一种。

输出格式

对于每个询问指令 Q1 a b，如果 a 和 b 在同一个连通块中，则输出 Yes，否则输出 No。

对于每个询问指令 Q2 a，输出一个整数表示点 a 所在连通块中点的数量

每个结果占一行。

思路

在本题中， 虽然说是一个无向图， 但是我们没有必要去建立这个图。 题目中要求的输出每个点所在来的连通块中点的数量以及判断两个两个点是否在一个连通块中。 我们可以用并查集来做， 对于每个点， 我们维护一个数据， 用来记录这个点所在连通块中点的数量。 如果说对于两个点a，b; 存在a指向b的一条边的话， 就让a所在的集合与b所在的集合进行合并。判断两个点是否在一个连通块中，就是判断两个的祖宗节点是否是一致的

代码

#include<iostream>
using namespace std;
const int N = 100010;
int n,m;
int cnt[N];
int p[N];
string str;
int find(int x){
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}
int main(){
    cin>>n>>m;
    for(int i = 1; i <= n; i++){
        p[i] = i;
        cnt[i] = 1;
    }
    while(m--){
        int a,b;
        cin>>str;
        if(str == "C"){
             cin>>a>>b;
            int fa = find(a);
            int fb = find(b);
            if(fa != fb){
                p[fa] = fb;
                cnt[fb] += cnt[fa];
            } 
        }else if(str == "Q1"){
            cin>>a>>b;
            int fa = find(a);
            int fb = find(b);
            if(fa == fb) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }else if(str == "Q2"){
            cin>>a;
            int fa = find(a);
            cout<<cnt[fa]<<endl;
        }
    }
    return 0;
}

03 食物链

题目描述

动物王国中有三类动物 A,B,C，这三类动物的食物链构成了有趣的环形。

A 吃 B，B 吃 C，C 吃 A。

现有 N 个动物，以 1∼N 编号。

每个动物都是 A,B,C 中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这 N 个动物所构成的食物链关系进行描述：

第一种说法是 1 X Y，表示 X 和 Y 是同类。

第二种说法是 2 X Y，表示 X 吃 Y。

此人对 N 个动物，用上述两种说法，一句接一句地说出 K 句话，这 K 句话有的是真的，有的是假的。

当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

当前的话与前面的某些真的话冲突，就是假话；
当前的话中 X 或 Y 比 N 大，就是假话；
当前的话表示 X 吃 X，就是假话。
你的任务是根据给定的 N 和 K 句话，输出假话的总数。

输入格式

第一行是两个整数 N 和 K，以一个空格分隔。

以下 K 行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中 D 表示说法的种类。

若 D=1，则表示 X 和 Y 是同类。

若 D=2，则表示 X 吃 Y。

输出格式

只有一个整数，表示假话的数目。

思路

代码

#include<iostream>
using namespace std;
const int N = 50010;
int d[N];//描述的是第 i 个节点到其父节点的距离
int p[N];//维护这个并查集
int find(int x){
    if(p[x] != x){
        int t = find(p[x]);
        d[x] += d[p[x]];
        p[x] = t;
    }
    return p[x];
}
int main(){
    int res = 0;
    int n,T;
    cin>>n>>T;
    for(int i = 1; i <= n; i++) p[i] = i;
    while(T--){
        int t,x,y;
        cin>>t>>x>>y;
        if(x > n || y > n){
            res ++;
            continue;
        }else{
            // 分别求出两个点的祖宗节点
            int px = find(x);
            int py = find(y);
            // 如果说 t == 1 说明两者是同类
            if(t == 1){
                // 两者在同一个集合之中
                if(px == py){
                    // 如果说两者到根节点的距离 模 3 不同，说明就不是同一类
                    if((d[x] - d[y]) % 3 != 0){
                        res++;
                    }
                }else if(px != py){
                    p[px] = py;
                    d[px]  = d[y] - d[x]; 
                }
                
            }
            // 如果说 t == 2 说明 x 吃 y
            else{
                //如果说两个点在同一个集合之中
                if(px == py){
                    int r = (d[x] - d[y] -1) % 3;
                    if(r != 0){
                        res ++;
                    }
                }else if(px != py){
                    p[px] = py;
                    d[px] = d[y] + 1 - d[x];
                }
                
            }
        }
        
    }
    cout<<res<<endl;
    return 0;
}