并查集

第一次遇到并查集这个数据结构，发现这是一种很高效的算法，便打算纪录下来；

当题目给定多条整数对，我们需要设计数据结构来保存已知的所有整数对的足够多的信息，并用它们来判断一对新对象是否是相连的；
并查集就适用于这种动态连通性问题。

union-find算法有这五种方法
* UF
* void union()
* int find()
* bool connected
* int count

代码实现

class WeightUF {
private:
    int * id;
    int * sz;
    int * rank;
    int count;

public:
    WeightUF(int N) {
        count = N;
        id = new int[N];
        sz = new int[N];
        rank = new int[N];
        for (int i = 0; i < N; i++) {
            id[i] = i;
            rank[i] = 0;
            sz[i] = 1;
        }
    }

    ~WeightUF() {
        delete [] id;
        delete [] sz;
        delete [] rank;
    }

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

    int getCount() {
        return count;
    }

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

    void connect(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];
            if (sz[i] == sz[j])
                rank[i]++;
        }
        count--;
    }

};

上面的算法直接使用了（按秩合并）路径压缩的加权quick-union算法；
比较quick-find和quick-union；

quick-union是为了解决quick-find中union没输入一对数据都需要扫描整个id数组，虽然find只需要访问一次数组，但是归并需要平方级别的复杂程度；

而weight quick-union则是为了解决随意的将一棵树连接到另一棵树上，于是记录每棵树的大小并总是将较小的树连接到较大的树上；

---

性能比较

算法	构造函数	union	find
quick-find算法	N	N	1
quick-union算法	N	树的高度	树的高度
加权quick-union	N	logN	logN
使用路径压缩的加权quick-union	N	接近1	接近1
理想情况	N	1	1