并查集Disjoint_set

先看看参考一：https://blog.csdn.net/major_zhang/article/details/52130308

再看看参考二：https://www.jianshu.com/p/fc17847b0a31

参考一讲得非常好，但是只使用了并查集两个主要优化中的"路径压缩"优化，并且我觉得很多情况下采用递归的写法要比采用循环的写法要易懂很多。

本文将使用C++实现并查集并使用“按秩合并”和”路径压缩“优化并查集

什么是并查集（Disjoint-set）

对于一个集合S={a1, a2, …, an-1, an}，我们还可以对集合S进一步划分: S1,S2,…,Sm-1,Sm，我们希望能够快速确定S中的两两元素是否属于S的同一子集。

举个栗子，S={0，1, 2, 3, 4, 5, 6}，如果我们按照一定的规则对集合S进行划分,假设划分后为S1={1, 2, 4}, S2={3, 6}，S3={0, 5}，任意给定两个元素，我们如何确定它们是否属于同一子集？某些合并子集后，又如何确定两两关系？基于此类问题便出现了并查集这种数据结构。

并查集有两个基本操作：
• Find: 查找元素所属子集
• Union：合并两个子集为一个新的集合

并查集的基本结构

我们可以使用树这种数据结构来表示集合，不同的树就是不同的集合，并查集中包含了多棵树，表示并查集中不同的子集，树的集合是森林，所以并查集属于森林。
若集合S={0, 1, 2, 3, 4, 5, 6}，最初每一个元素都是一棵树。

对于Union操作，我们只需要将两棵树合并，例如合并0、1、2得到S1={0, 1, 2},合并3和4得到S2={3, 4}

对于Find操作，我们只需要返回该元素所在树的根节点。所以，如果我们想要比较判断1和2是否在一个集合，只需要通过Find(1)和Find(2)返回各自的根节点比较是否相等便可。已知树中的一个节点，找到其根节点的时间复杂度为O(D)，D为节点的深度。

我们可以使用数组来表示树，数组下标表示树的一个节点，该下表所对应的值表示树的父节点。例如P[i]表示元素i的父节点。
对于图2中的集合，我们可以存储在下面的数组中（第二行为数组下标）

0	0	0	3	3	5
0	1	2	3	4	5

对于树的根节点，我们规定其元素值为其本身（即父节点为自己）。

未优化前的C++实现

我们使用一个parent数组存储树，先实现未经优化的版本。对于Find操作，代码非常简单

int find(int x)
{
    return parent[x] == x ? x : find(parent[x]);
}

该代码比较元素x的父节点parent[x]是否等于x自身，如果是便说明找到了根节点（根节点的父节点是自身），直接返回；否则，把x的父节点parent[x]传入find，直到找到根节点。

下面是union操作

void to_union(int x1, int x2) 
{
    int p1 = find(x1);
    int p2 = find(x2);
    parent[p1] = p2;
}

传入两个元素，分别找到根节点，使根节点p1的父节点为p2，即将p1为根节点的这棵树合并到p2为根节点的树上。

下面是完整代码：

#include <vector>
class DisjSet
{
private:
    std::vector<int> parent;

public:
    DisjSet(int max_size) : parent(std::vector<int>(max_size))
    {
        // 初始化每一个元素的根节点都为自身
        for (int i = 0; i < max_size; ++i)
            parent[i] = i;
    }
    int find(int x)
    {
        return parent[x] == x ? x : find(parent[x]);
    }
    void to_union(int x1, int x2)
    {
        parent[find(x1)] = find(x2);
    }
    // 判断两个元素是否属于同一个集合
    bool is_same(int e1, int e2)
    {
        return find(e1) == find(e2);
    }
};

上面的实现，可以看出每一次Find操作的时间复杂度为O(H)，H为树的高度，由于我们没有对树做特殊处理，所以树的不断合并可能会使树严重不平衡，最坏情况每个节点都只有一个子节点，如下图3（第一个点为根节点）

此时Find操作的时间复杂度为O(n)，这显然不是我们想要的。

下面引入两个优化的方法。

优化后实现

并查集的优化
方法一：
"按秩合并"。实际上就是在合并两棵树时，将高度较小的树合并到高度较大的树上。这里我们使用“秩”(rank)代替高度，秩表示高度的上界，通常情况我们令只有一个节点的树的秩为0，严格来说，rank + 1才是高度的上界；两棵秩分别为r1、r2的树合并，如果秩不相等，我们将秩小的树合并到秩大的树上，这样就能保证新树秩不大于原来的任意一棵树。如果r1与r2相等，两棵树任意合并，并令新树的秩为r1 + 1。

方法二：
“路径压缩”。在执行Find的过程中，将路径上的所有节点都直接连接到根节点上。

同时使用这两种方法的平均时间复杂度为 $O(\alpha (n))$ ，$\alpha (n)$是$n=f(x)=A(x,x)$的反函数，$A(x,x)$是阿克曼函数，$A(x,x)$增长率非常之高，所以在n非常大的时候， $\alpha (n)$依然小于5。

下面是采用"按秩合并"与“路径压缩”两中优化算法的实现
C++实现二（优化版）

#include<iostream>
#include<vector>
using namespace std;

class Disjoint_set{
private:
    vector<int> parent;
    vector<int> rank;//秩
public:
    //初始化类的成员vector,最好用初始化列表
    Disjoint_set(int maxSize):rank(maxSize),parent(maxSize){
        for(int i=0;i<maxSize;i++){
            parent[i]=i;//都是自己的掌门人
        }
    }
    int find(int t)//找掌门人,注意路径压缩
    {
        return parent[t]==t?t:(parent[t]=find(parent[t]));
    }
    void to_union(int t1,int t2)//门派融合，注意按秩合并
    {
        int f1=find(t1);
        int f2=find(t2);
        if(f1!=f2){//注意，掌门人不同才合并
            if(rank[f1]>rank[f2])
                parent[f2]=f1;
            else
            {
                parent[f1]=f2;

                if(rank[f1]==rank[f2])//同秩合并，会加一
                    rank[f2]++;
            }
        }
    }
    bool is_same(int t1,int t2)//查看掌门人是否相同
    {
        return find(t1)==find(t2);
    }
};

总结
时间复杂度
采用“路径压缩”与“按秩合并”优化的并查集每个操作的平均时间复杂度为 $O(\alpha (n))$ ，$\alpha (n)$是$n=f(x)=A(x,x)$的反函数，$A(x,x)$是阿克曼函数，$A(x,x)$增长率非常之高，所以在$n$非常大的时候， $\alpha (n)$依然小于5。

空间复杂度
$O(n)$，$n$为元素的数量

leetcode例题

200. 岛屿数量
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1:
输入:
[
[‘1’,‘1’,‘1’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘0’,‘0’]
]
输出: 1

示例 2:
输入:
[
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘1’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘1’,‘1’]
]
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

利用并查集的解法：
为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则将其与相邻四个方向上的 1 在并查集中进行合并。

最终岛屿的数量就是并查集中连通分量的数目。

class UnionFind {
public:
    UnionFind(vector<vector<char>>& grid) {
        count = 0;
        int m = grid.size();
        int n = grid[0].size();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == '1') {
                    parent.push_back(i * n + j);
                    ++count;
                }
                else {
                    parent.push_back(-1);
                }
                rank.push_back(0);
            }
        }
    }

    int find(int i) {
        if (parent[i] != i) {
            parent[i] = find(parent[i]);
        }
        return parent[i];
    }

    void unite(int x, int y) {
        int rootx = find(x);
        int rooty = find(y);
        if (rootx != rooty) {
            if (rank[rootx] < rank[rooty]) {
                swap(rootx, rooty);
            }
            parent[rooty] = rootx;
            if (rank[rootx] == rank[rooty]) rank[rootx] += 1;
            --count;
        }
    }

    int getCount() const {
        return count;
    }

private:
    vector<int> parent;
    vector<int> rank;
    int count;
};

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();
        if (!nr) return 0;
        int nc = grid[0].size();

        UnionFind uf(grid);
        int num_islands = 0;
        for (int r = 0; r < nr; ++r) {
            for (int c = 0; c < nc; ++c) {
                if (grid[r][c] == '1') {
                    grid[r][c] = '0';
                    if (r - 1 >= 0 && grid[r-1][c] == '1') uf.unite(r * nc + c, (r-1) * nc + c);
                    if (r + 1 < nr && grid[r+1][c] == '1') uf.unite(r * nc + c, (r+1) * nc + c);
                    if (c - 1 >= 0 && grid[r][c-1] == '1') uf.unite(r * nc + c, r * nc + c - 1);
                    if (c + 1 < nc && grid[r][c+1] == '1') uf.unite(r * nc + c, r * nc + c + 1);
                }
            }
        }

        return uf.getCount();
    }
};