并查集总结

并查集详解
并查集基础
推荐看了基础知识再来看此文

背景：
在做leetcode时的总结。
题目链接

这道题中的关键词是连通,看到连通两个字样，十有八九就是并查集类型的题目。结尾附赠并查集模板。
我们将互相连通的电脑压缩成一个点，若最后存在 N 个点，通过观察可以发现只需要 N - 1 条线就可以进行相连。

那接下来的问题就是如何去寻找这 N - 1 条线。

考虑每一条线，如果线的两头已经连通（find§ == find(q)），则这条线是多余的，可以拿去当做 N - 1 条线的其中一条。
我们可以将一个连通块看作一棵树。

JAVA代码块

class Solution {
    int[] father;
    int[] sz; //sz[i] 代表以 i 为根节点的树的节点数量，每次把小树合并到大树里面
    int num; //连通块的数量

    public int find(int p) {
        if (p != father[p]) {
            p = find(father[p]);
        }
        return p;
    }
    public void union(int p, int q) {
        int i = find(p);
        int j = find(q);
        if (i == j) return;
        num -= 1;
        if (sz[i] < sz[j]) {
            father[i] = j;
            sz[j] += sz[i];
        } else {
            father[j] = i;
            sz[i] += sz[j];
        }
    }

    public void initUF(int n) {
        father = new int[n];
        sz = new int[n];
        num = n;
        for (int i = 0; i < n; i++) {
            father[i] = i;
            sz[i] = 1;
        }
    }
    public int makeConnected(int n, int[][] connections) {
        initUF(n);
        // 多余的线缆数量
        int cnt = 0;
        for (int[] c : connections) {
            int f = c[0], t = c[1];
            // 两个点已经连通，不需要这个线缆
            if (find(f) == find(t)) {
                cnt += 1;
                continue;
            }
            union(f, t);
        }
        // 所需要的线缆数量
        int cnt2 = num - 1;
        if (cnt < cnt2) {
            return -1;
        }
        return cnt2;
    }
}

并查集模板
版本一：加权快速合并
class Solution {
    int[] father;
    int[] sz;
    int num;

    public int find(int p) {
        if (p != father[p]) {
            p = find(father[p]);
        }
        return p;
    }
    public void union(int p, int q) {
        int i = find(p);
        int j = find(q);
        if (i == j) return;
        num -= 1;
		//加权
        if (sz[i] < sz[j]) {
            father[i] = j; //合并
            sz[j] += sz[i];
        } else {
            father[j] = i;
            sz[i] += sz[j];
        }
    }

    public void initUF(int n) {
        father = new int[n];
        sz = new int[n];
        num = n;
        for (int i = 0; i < n; i++) {
            father[i] = i;
            sz[i] = 1;
        }
    }
    public int makeConnected(int n, int[][] connections) {
        initUF(n);
        // 多余的线缆数量
        int cnt = 0;
        for (int[] c : connections) {
            int f = c[0], t = c[1];
            // 两个点已经连通，不需要这个线缆
            if (find(f) == find(t)) {
                cnt += 1;
                continue;
            }
            union(f, t);
        }
        // 所需要的线缆数量
        int cnt2 = num - 1;
        if (cnt < cnt2) {
            return -1;
        }
        return cnt2;
    }
}

版本二：路径压缩的加权快速合并

int[] father;
int[] sz;
int num;
public int find(int p) {
    if (p != father[p]) {
        father[p] = find(father[p]); //路径压缩，，所有的点指向根节点，提高效率
    }
    return father[p];
}
public void union(int p, int q) {
    int i = find(p);
    int j = find(q);
    if (i == j) return;
    num -= 1;
    if (sz[i] < sz[j]) {
        father[i] = j;
        sz[j] += sz[i];
    } else {
        father[j] = i;
        sz[i] += sz[j];
    }
}

public void initUF(int n) {
    father = new int[n];
    sz = new int[n];
    num = n;
    for (int i = 0; i < n; i++) {
        father[i] = i;
        sz[i] = 1;
    }
}