[杂记]算法: 并查集

0. 引言

我们考虑如何计算一个图连通分量的个数. 假定简单无向图$G$有两个连通分量(子图)$G_1,G_2$, 如下图所示:

一个很自然的想法是, 要想求连通分量个数, 我们可以使用Full-DFS算法, 也就是我们从某个点开始深度优先搜索, 并标记访问过的元素. 随后挨个顶点判断, 如果某个点没有被访问过, 则接着从该点进行深度优先搜索, 这样深度优先搜索的次数就是连通量的个数.

除此之外, 我们还可以用并查集来求图中连通分量的个数. 并查集, 顾名思义, 有并与查两部分. 并, 就是合并(join, union), 即利用某种规则将两个顶点合并为一个连通分量. 查, 就是查询(find), 用以查询某个节点所属连通分量的代表性节点.

例如, 某个单位里, 有两个帮派. 一个员工A和另一个员工B相遇了, 两个人想知道自己是不是同属一个帮派. 于是, 两个人可以互相报上自己帮派的老大, 是局长还是书记. 如果两个人的老大一样, 则两个人就是同属一个帮派, 否则不是.

抽象出来, 我们将每个连通分量都选出一个代表的节点, 这个节点就是老大, 该连通分量中其他的节点或直接, 或间接地与老大相连. 一个单位帮派的个数可以用老大的个数来代表.

下面说具体如何去并, 查

1. 查, find

一个连通图总可以表示成一个生成树(例如, 单位里的一个帮派总可以捋出来一个上下级关系), 例如, $G_1$子图中, 假设每个节点有编号, 那么假定有如图的一种连接关系(生成树):

1是老大, 下面是2, 3, 4是老末. 如果我们用一个数组$parent[N]$表示这种上下级关系, 也就是$parent[i]=j$表示i的上级为j, 则上图的关系可以表示为:

parent[4] = 2
parent[2] = 1
parent[3] = 1
parent[1] = 1

所以, 只有老大的上级才是他自己. 如果给我们一个4, 想查一下, 4的老大是谁? 我们就可以这样一层一层查上去:

parent[4] = 2
parent[2] = 1
parent[1] = 1, Done!!!

当找到满足parent[i] = i的i, 就表示找到了老大(子图的代表)为i.

我们可以用代码这样表示:

int find(int x) {
	while (parent[x] != x) x = parent[x];  // 只要没找到, 就沿着上级继续找
	return x;  // 找到了, 返回
}

但是, 假如一个倒霉催的结构是这样的:

那我们就需要花费$O(n)$的时间去找, 这是因为不平衡的树会带来更大的时间复杂度(最坏的情况为$O(n)$). 为此, 既然我们只是找老大, 我们直接让每个人直接对老大负责不好么?

我们如何做到这一点? 我们用递归来实现. 对于不满足parent[i] = i的i, 我们直接让i的上级parent[i]等于老大, 也就是parent[i] = find(parent[i]), 这样递归下去就可以达到上图的结果. 需要说明的是, 这样整理好之后, 以后的查询才会省时间. 换言之, 第一次是不会节约时间的. 于是现在的find函数可以写为:

int find(int i) {
	if (parent[i] != i)   // 没有找到
		parent[i] = find(parent[i]);  // 让i的上级是老大
	
	return parent[i];  // 返回老大
}

2. 并, union, join

如果说, 单位里的两个派别准备重修旧好, 也就是两个派别要合并. 然而, 一个派别只能有一个老大, 所以两个派别的老大就必须有一个要屈尊, 不再当老大, 成为另一个老大的下属, 这样的话, 不论两个派别的哪个人, 最终都可以查询到新的老大, 这就是并的过程, 用下图表示:

代码这么来描述:

void unoin(int x, int y){  // 合并俩派别, x, y为其中的成员
	int px = find(x), py = find(y);  // 找到他们各自的老大
	if (px != py) parent[px] = py;  // 让px的老大的老大为py
}

那么假如我们想指定一种合并的规则, 应该如何做呢? 假设我们标记节点的深度, 如图所示:

因此, 为了不让树产生退化(合并后左右子树的高度差尽可能小), 我们将深度小的合并到深度大的. 如果二者的深度相同, 则可以随便指定一个作为新老大, 随后将新老大的权值加1, 如图:

代码如下:

void unoin(int x, int y) {
	// 寻找x, y的老大
	int px = find(x), py = find(y);
	if (px != py) {
	
		// 如果x的权重大 让y的老大为x
		if (rank[px] > rank[py]) parent[py] = px;
		else {  // 否则 让x的老大为y
			if (rank[px] == rank[py]) rank[py]++; // 如果权重相等 则先将y的权重加1
			parent[px] = py;
		}
	}
}

3. 例题

下面用几道例题说明并查集的使用. 难度从低到高.

3.1 最长连续序列

题目链接: LeetCode128

这个题让我们在数组中找到一个最长的连续数字序列. 如果我们将元素视为图里的节点, 每一段连续的数字序列作为一个子图, 就是要找到节点最多的子图.

为此, 我们对于数组元素num, 假如num + 1也在数组中, 则将num所在的子图与num + 1所在的子图并在一起. 除此之外, 我们还需要用一个额外的哈希表记录每个子图的大小, 键为子图的老大, 值为子图的大小.

代码:

class Solution {
public:
    unordered_map<int, int> pre, regionResult;  // pre: 储存父节点 regionResult: 节点所在连通域面积

    int find(int x) {  // 查
        if (x == pre[x]) return x;
        else {
            pre[x] = find(pre[x]);
            return pre[x];
        }

    }

    int merge(int x, int y) {  // 并
        x = find(x), y = find(y);
        if (x == y) return regionResult[x];

        // 若不相等 并到一起
        pre[y] = x;
        regionResult[x] += regionResult[y];  // 把大小加一起并返回
        return regionResult[x];
    }

    int longestConsecutive(vector<int>& nums) {
        if (!nums.size()) return 0;
        int result = 1;
        
        // 初始化
        for (int num : nums) {
            pre[num] = num;
            regionResult[num] = 1;
        }

        // 合并相邻数 并更新结果 注意只合并num与num+1 不需要合并num与num-1 否则重复

        for (int num : nums) {
            if (pre.count(num + 1))
                result = max(result, merge(num, num + 1));
        }

        return result;
    }
};

3.2. 危险程度

题目链接: Acwing4796

这个题是说, 有一个试管, 初始时危险值为1. 现在往里面导入物质, 假如要倒入的物质可以和试管里面任一一种物质反应, 则将危险值乘2. 问可以达到的最大危险值为多少.

我们可以构建图来解决这个问题. 假如a与b反应, b与c反应, 则a, b, c可以构成一个连通子图. 于是n个物质就构成了若干个连通子图, 每个子图中的物质可以与子图中其他若干个物质发生反应. 所以, 对于一个有t个节点的子图, 可以达到最大的危险值为$2^{t-1}$, 证明如下:

例如假设四种物质a,b,c,d的反应关系如下(如果不是严格的树(即有环), 也一定可以等价成如下的形式):

那么只要按照广度优先搜索的顺序倒入a->b->c->d, 就可以达到2^3=8的危险度. 且不同子图间是孤立的, 因此假设一共有k个子图, 每个子图的节点个数分别为$a_0,...,a_{k-1}$, 则最大的危险程度为
$$2^{a_0-1}\cdot 2^{a_1-1}\cdot \cdot \cdot \cdot 2^{a_{k-1}-1}=2^{n-k}$$

为此, 我们只需要求出连通子图的个数即可.

代码:

#include 
#include 
#include 

using namespace std;

const int N = 1010;

int parent[N];  // parent数组

int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]);
    }
    
    return parent[x];
}
int main()
{
    int n, m;
    cin >> n >> m;
    
    // 初始化并查集 每个指向自己
    for (int i = 0; i < n; i ++ )
        parent[i] = i;
        
    int result = n;  // 初始n个子图
    while (m -- ) {
        int x, y;  
        cin >> x >> y;  // 能反应的两种物质
        
        // 找到老大
        x = find(x); y = find(y);
        
        if (x != y) {  // 合并两个子图
            parent[x] = y;
            result --;
        }
        
    }
    
    cout << (1LL << (n - result)) << "\n";
    return 0;
    
}

3.3. 岛屿数量

题目链接: LeetCode200

这个题的一种做法是, 跟玩扫雷一样, 但凡是扫到一个1, 那么执行深度优先搜索, 将与其相连的1都扫成0. 这样再碰到下一个1时, 一定是另一个岛屿, 所以岛屿的数量就是执行深度优先搜索的次数. 代码:

class Solution {
private:
    int rows = 0, cols = 0;
public:
    void dfs(vector<vector<char>>& grid, int row, int col) {

        grid[row][col] = '0';  // 标记为0
        // 上下左右, 深度优先
        if (row > 0 && grid[row - 1][col] == '1') dfs(grid, row - 1, col);
        if (col > 0 && grid[row][col - 1] == '1') dfs(grid, row, col - 1);
        if (row < rows - 1 && grid[row + 1][col] == '1') dfs(grid, row + 1, col);
        if (col < cols - 1 && grid[row][col + 1] == '1') dfs(grid, row, col + 1); 

    }
    int numIslands(vector<vector<char>>& grid) {
        this->rows = grid.size();
        this->cols = grid[0].size();
        int result = 0;

        for (int row = 0; row < rows; row ++) {
            for (int col = 0; col < cols; col ++) {
                if (grid[row][col] == '1') {
                    dfs(grid, row, col);
                    result ++;
                }
            }
        }

        return result;
    }
};

也可以用并查集来做. 每个'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])
                parent[rooty] = rootx;
            else {
                if (rank[rootx] == rank[rooty]) rank[rooty] ++;
                parent[rootx] = rooty;
            }
            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();
    }
};