十六、数据结构——并查集

一、基本思路

1、基本概念

• 特点：思维性强，代码比较简短
• 用法：
• • 1. 将两个集合进行合并
• • 2. 询问两个元素是否在同一个集合中

//暴力解法：
belong[x] = a;	// 可以用一个belong数组存取属于那个数组，x属于a数组
if（belong[x] == belong[y]） //判断复杂度O(1)
// 但假如将两个集合进行合并，那将非常耗时 =》因为需要把一个弄到另一个

• 由此，引出并查集操作——用近乎O(1)的复杂度完成上述操作
• 特点：
• • 1. 用树的形式来文虎所有集合——不一定是二叉树，可能有很多子节点
• • 2. 每个集合的编号，就是根节点编号
• • 3. 对于每个节点，都存储下它的父节点 p[x] ，查询上一个节点的途径
• • 4. 若查某个节点属于哪个集合，则可以一直沿着 p[x] 向上查找，最终找到根节点
• • 5. 注意与Trie树的存储方式不同，每个节点代表的都是一个集合元素，而不是将每个元素进行更细致的拆分

2、原理及问题实现

• 基本原理：

• • 每个集合都用一棵树来表示，树根的编号就是整个集合的编号（本身数值）；每个节点p[x]存储着他的父节点，只有根节点满足p[x] = x。

• 问题1：如何判断是否是根节点

if（p[x] == x） // 用x值来代表根节点，除了根节点都不满足这个条件

• 问题2：如何求解节点 x 所在集合的编号

while(p[x] != x) x = p[x];
// 只要不是根节点，我就一直沿着父节点向上走
// 此时复杂度依旧很高，后续会进行优化求解

• 问题3：如何合并两个集合

• 解决办法：
• • 直接将其中的一颗树的根节点，搬到另一棵树的某个位置（一般是搬到另一个数的根节点下面），然后将搬移的树的根节点的父节点修改为现在的新树根节点。

• 其中p[x]是原 x 集合的编号，p[y] 是原集合 y 的编号——> p[x] = y

3、问题优化

• 路径压缩算法

• 方法：
• • 在进行根节点查找的时候，将路径上的每个节点的父节点都指向根节点

二、Java、C语言模板实现

//Java 模板实现
// 并查集核心原理实现 —— findRoot 函数的实现

// 查找模板
static int findRoot(int x){
	// 判断是否是根节点
	if(p[x] != x) {
	// 1.递归求解父节点的父节点，直到找到根节点返回
	// 2.最后的赋值操作，让路径上的全部节点的父节点都变味了根节点————路径压缩算法
		p[x] = findRoot(p[x]);
	}
	return p[x];
}

// 合并操作
// 将另一个集合的根节点移动到另一个集合的根节点下面
p[findRoot(a)] = findRoot(b);

```c
// C语言实现，此处是yxc实现
(1)朴素并查集：

    int p[N]; //存储每个点的祖宗节点

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);


(2)维护size的并查集：

    int p[N], size[N];
    //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        size[i] = 1;
    }

    // 合并a和b所在的两个集合：
    size[find(b)] += size[find(a)];
    p[find(a)] = find(b);


(3)维护到祖宗节点距离的并查集：

    int p[N], d[N];
    //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x)
        {
            int u = find(p[x]);
            d[x] += d[p[x]];
            p[x] = u;
        }
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        d[i] = 0;
    }

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);
    d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量

作者：yxc
链接：https://www.acwing.com/blog/content/404/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

三、例题题解

// java题解实现
import java.io.*;

public class Main {
    static int N = 100010;
    static int[] parent = new int[N];
    static int findParent(int x){
        if(parent[x] != x) {
            parent[x] = findParent(parent[x]);
            // 此处做了两件事，一是递归寻找根节点，直到满足x = p[x]
            // 二是，进行了路径压缩，让这条路上的每个节点p【x】都变成了递归返回的根节点
        }
        return parent[x];
    }

    public static void main(String[] args) throws IOException {
        StreamTokenizer input = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter output = new PrintWriter(new OutputStreamWriter(System.out));

        input.nextToken();
        int n = (int)input.nval;
        input.nextToken();
        int m = (int) input.nval;

        for (int i = 1; i <= n; i++) {          // 1 - n 个数的数，每个数都是自己一个集合的根节点
            parent[i] = i;                      // 根节点特性
        }

        for (int i = 0; i < m; i++) {
            // 进行指令输入
            input.nextToken();
            String order = input.sval;
            input.nextToken();
            int a = (int)input.nval;
            input.nextToken();
            int b = (int) input.nval;

            switch (order){
                case "M":
                    parent[findParent(a)] = findParent(b);          // 将a的根节点接到b的根节点下面，也就是a的根节点的父亲成了b的根节点
                    break;
                case "Q":
                    if (findParent(a) == findParent(b)){
                        output.println("Yes");
                    }else {
                        output.println("No");
                    }
            }

        }

        output.flush();
        output.close();
    }
}

import java.io.*;

public class Main {
    static int N = 100010;
    static int[] p = new int[N];
    static int[] size = new int[N];

    static int findRoot(int x) {
        if (x != p[x]) {
            p[x] = findRoot(p[x]);
        }
        return p[x];
    }


    public static void main(String[] args) throws IOException {
        StreamTokenizer input = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter output = new PrintWriter(new OutputStreamWriter(System.out));

        input.nextToken();
        int n = (int) input.nval;
        input.nextToken();
        int m = (int) input.nval;

        // 进行初始化集合创建
        for (int i = 1; i <= n; i++) {
            p[i] = i;
            size[i] = 1;
        }

        for (int i = 0; i < m; i++) {
            input.nextToken();
            String order = input.sval;
            int a, b, rootA, rootB;

            switch (order) {
                case "C":
                    input.nextToken();
                    a = (int) input.nval;
                    input.nextToken();
                    b = (int) input.nval;
                    rootA = findRoot(a);
                    rootB = findRoot(b);
                    if (rootA != rootB) {
                        p[rootA] = rootB;
                        size[rootB] += size[rootA];
                    }
                    break;
                case "Q1":
                    input.nextToken();
                    a = (int) input.nval;
                    input.nextToken();
                    b = (int) input.nval;
                    rootA = findRoot(a);
                    rootB = findRoot(b);
                    if (rootA == rootB) {
                        output.println("Yes");
                    }else {
                        output.println("No");
                    }
                    break;
                case "Q2":
                    input.nextToken();
                    a = (int) input.nval;
                    rootA = findRoot(a);
                    output.println(size[rootA]);
                    break;

            }


        }
        output.flush();
        output.close();


    }
}

import java.io.*;

public class Main {
    static int N = 50010;
    static int[] p = new int[N];
    static int[] d = new int[N];

    static int findRoot(int x){
        if (p[x] != x){
            int t = findRoot(p[x]);     // 此处要先进行递归处理，在最里面一层，在p[x]不变的情况下初始化dx，因为初始化之后，经过了路径压缩，px直接就是根节点了，无法初始化dx
            d[x] += d[p[x]];            // dx为一开始为x到父节点距离，而更新之后变为x到根节点之间的距离 = dx + 父节点到根节点距离
            p[x] = t;                   // 递归得到根节点
        }
        return p[x];
    }
    public static void main(String[] args) throws IOException {
        StreamTokenizer input = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter output = new PrintWriter(new OutputStreamWriter(System.out));

        input.nextToken();
        int n = (int) input.nval;
        input.nextToken();
        int k = (int) input.nval;
        int res = 0;                    // 假话个数

        for (int i = 1; i <= n; i++) {
            p[i] = i;
        }

        for (int i = 0; i < k; i++) {
            input.nextToken();
            int dd = (int) input.nval;
            input.nextToken();
            int x = (int) input.nval;
            input.nextToken();
            int y = (int) input.nval;

            if (x > n || y > n){
                res++;
            }else{
                int px = findRoot(x);
                int py = findRoot(y);

                // 距离为1 ： 表示可以吃根节点
                // 距离为2 ： 表示被根节点吃
                // 距离为0 ： 表示和根节点是同类
                if (dd == 1){
                    if (px == py && (d[x] - d[y])%3 != 0){      // 判断两个在不在一个集合 + 根据距离判断是不是同一类
                        res++;
                    }

                    if (px != py){                              // 不在一个集合，则合并为一个
                        p[px] = py;                             // x根节点接到y根节点上面
                        d[px] = d[y] - d[x];                    // 原x根节点到根节点之间的距离求解，没加入则默认为对的，即同类
                    }
                }
                if (dd == 2){
                    if (px == py && (d[x] - d[y] - 1)%3 != 0){  // 判断是否在一个集合 + 根据距离判断吃的循环是否正确
                        res++;
                    }

                    if (px != py){
                        p[px] = py;
                        d[px] = d[y] - d[x] + 1;
                    }

                }


            }

        }

        output.println(res);
        output.flush();
        output.close();

    }
}