算法第四版- 1.5 Union-find

最新推荐文章于 2024-04-26 22:25:06 发布

原创最新推荐文章于 2024-04-26 22:25:06 发布 · 204 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #面试

算法第四版专栏收录该内容

16 篇文章

订阅专栏

本文详细解读了算法第四版中的并查集实现，通过LC第200题岛屿数量为例，介绍了find()和unite()操作，包括路径压缩和按秩合并技巧。后续还列举了其他经典并查集问题及其解法，适用于解决数据结构相关问题。

算法第四版- 1.5 Union-find

并查集

文章目录

算法第四版- 1.5 Union-find
并查集
1.前情介绍
2.习题分析
- 1)LC第200题--岛屿数量
- 2)其他题目

1.前情介绍

1.4 算法分析，没啥内容，不写了。
关于并查集的基础知识，找到一篇很好的文章，直接放链接吧。
并查集-知乎大佬

2.习题分析

1)LC第200题–岛屿数量

一道很经典的并查集，
find()用到了路径压缩
unite()用到了按秩合并

 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();
    }
};