算法 - 並查集

前言

用於解決動態連通性問題，能動態連接兩個點，並且判斷兩個點是否連通。

方法	描述
UF(int N)	構造一個大小爲 N 的並查集
void union(int p, int q)	連接 p 和 q 節點
int find(int p)	查找 p 所在的連通分量編號
boolean connected(int p, int q)	判斷 p 和 q 節點是否連通

public abstract class UF {

    protected int[] id;

    public UF(int N) {
        id = new int[N];
        for (int i = 0; i < N; i++) {
            id[i] = i;
        }
    }

    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

    public abstract int find(int p);

    public abstract void union(int p, int q);
}

Quick Find

可以快速進行 find 操作，也就是可以快速判斷兩個節點是否連通。

需要保證同一連通分量的所有節點的 id 值相等。

但是 union 操作代價卻很高，需要將其中一個連通分量中的所有節點 id 值都修改爲另一個節點的 id 值。

public class QuickFindUF extends UF {

    public QuickFindUF(int N) {
        super(N);
    }


    @Override
    public int find(int p) {
        return id[p];
    }


    @Override
    public void union(int p, int q) {
        int pID = find(p);
        int qID = find(q);

        if (pID == qID) {
            return;
        }

        for (int i = 0; i < id.length; i++) {
            if (id[i] == pID) {
                id[i] = qID;
            }
        }
    }
}

Quick Union

可以快速進行 union 操作，只需要修改一個節點的 id 值即可。

但是 find 操作開銷很大，因爲同一個連通分量的節點 id 值不同，id 值只是用來指向另一個節點。因此需要一直向上查找操作，直到找到最上層的節點。

public class QuickUnionUF extends UF {

    public QuickUnionUF(int N) {
        super(N);
    }


    @Override
    public int find(int p) {
        while (p != id[p]) {
            p = id[p];
        }
        return p;
    }


    @Override
    public void union(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot != qRoot) {
            id[pRoot] = qRoot;
        }
    }
}

這種方法可以快速進行 union 操作，但是 find 操作和樹高成正比，最壞的情況下樹的高度爲節點的數目。

加權 Quick Union

爲了解決 quick-union 的樹通常會很高的問題，加權 quick-union 在 union 操作時會讓較小的樹連接較大的樹上面。

理論研究證明，加權 quick-union 算法構造的樹深度最多不超過 logN。

public class WeightedQuickUnionUF extends UF {

    // 保存節點的數量信息
    private int[] sz;


    public WeightedQuickUnionUF(int N) {
        super(N);
        this.sz = new int[N];
        for (int i = 0; i < N; i++) {
            this.sz[i] = 1;
        }
    }


    @Override
    public int find(int p) {
        while (p != id[p]) {
            p = id[p];
        }
        return p;
    }


    @Override
    public void union(int p, int q) {

        int i = find(p);
        int j = find(q);

        if (i == j) return;

        if (sz[i] < sz[j]) {
            id[i] = j;
            sz[j] += sz[i];
        } else {
            id[j] = i;
            sz[i] += sz[j];
        }
    }
}

路徑壓縮的加權 Quick Union

在檢查節點的同時將它們直接鏈接到根節點，只需要在 find 中添加一個循環即可。

比較

算法	union	find
Quick Find	N	1
Quick Union	樹高	樹高
加權 Quick Union	logN	logN
路徑壓縮的加權 Quick Union	非常接近 1	非常接近 1