Leetcode200. 岛屿数量

---

200. 岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/number-of-islands

方法一：深度优先搜索

代码如下：

class Solution {
public:
    bool isInArea(vector<vector<char>>& grid, int i, int j) {
        return i >= 0 && i < grid.size() && j >= 0 && j < grid[0].size();
    }

    void dfs(vector<vector<char>>& grid, int i, int j) {
        if (!isInArea(grid, i, j)) return;
        if (grid[i][j] != '1') return;
        grid[i][j] = '2';
        dfs(grid, i + 1, j);
        dfs(grid, i - 1, j);
        dfs(grid, i, j + 1);
        dfs(grid, i, j - 1);
    }

    int numIslands(vector<vector<char>>& grid) {
        //DFS深度优先搜索
        int ans = 0;
        for (int i = 0; i < grid.size(); i++) {
            for (int j = 0; j < grid[0].size(); j++) {
                if (grid[i][j] == '1') {
                    dfs(grid, i, j);
                    ans++;
                }
            }
        }
        return ans;
    }
};

方法二：并查集

代码如下：

//并查集
class UnionFind {
private:
    vector<int> parent;    // parent[i]表示第i个元素所指向的父节点
    vector<int> rank;      // rank[i]表示以i为根的集合所表示的树的层数
    int count;             // 记录岛屿的数量
public:
    //构造函数
    UnionFind(vector<vector<char>>& grid) {
        count = 0;    //初始化数量为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);   //将二维数组的坐标映射到一维数组：第i * n + j个节点，指向的父节点是自己
                    count++;
                }else parent.push_back(-1);        //遇到水，所有水节点指向的父节点相同（定义虚拟父节点-1）（水节点不计入count内）
                rank.push_back(1);                 //目前所有树的层数为1
            }
        }
    }
    
    //查找过程, 查找元素i所对应的集合编号
    //O(rank[i])复杂度, rank[i]为树的高度
    int find(int i) {
        if (parent[i] != i) parent[i] = find(parent[i]);    //路径压缩
        return parent[i];
    }

    //合并
    //合并两元素的时候，需要比较根节点i集合的层数，整个过程是 O(rank[i])复杂度，rank[i]为树的高度。
    void unite(int x, int y) {
        int rootx = find(x);
        int rooty = find(y);
        if (rootx != rooty) {
            //将层数少的树合并入层数多的树，不会增加树的层数
            if (rank[rootx] < rank[rooty]) parent[rootx] = rooty;
            else if (rank[rooty] < rank[rootx]) parent[rooty] = rootx;
            else {  //rank[rootx] == rank[rooty]
                parent[rooty] = parent[rootx];
                rank[rootx] += 1;
            }
            count--;
        }
    }

    //获取岛屿的数量
    int getCount() {
        return count;   
    }
};

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int m = grid.size();              //矩阵的行数
        int n = grid[0].size();           //矩阵的列数
        if (m == 0) return 0;

        UnionFind uf(grid);
        //遍历整个矩阵，如果遇到值为'1'的单元格，则遍历该单元格水平方向和竖直方向的四个单元格，若也为1，则合并
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') {
                    grid[i][j] = '2';     //遍历过这个单元格
                    if (i - 1 >= 0 && grid[i - 1][j] == '1') uf.unite(i * n + j, (i - 1) * n + j);
                    if (i + 1 < m && grid[i + 1][j] == '1') uf.unite(i * n + j, (i + 1) * n + j);
                    if (j - 1 >= 0 && grid[i][j - 1] == '1') uf.unite(i * n + j, i * n + j - 1);
                    if (j + 1 < n && grid[i][j + 1] == '1') uf.unite(i * n + j, i * n + j + 1);
                }
            }
        }
        return uf.getCount();
    }
};

---

参考资料

岛屿数量 _力扣官方题解
岛屿类问题的通用解法、DFS 遍历框架
并查集基础 _菜鸟教程