岛屿数量问题（个人模板）

前言

计算网格中岛屿的数量，经典的岛屿问题可以用三种方法解决：DFS、BFS和并查集算法
原题链接

题目

岛屿数量

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

示例 1：

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

示例 2：

输入：grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
输出：3

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 300
• grid[i][j] 的值为 '0' 或 '1'

解题思路

运用DFS（深度优先算法）、BFS（宽度优先算法）和并查集算法

1.DFS

优先一直考虑一个方向搜索，直到不能搜索再换另外一个方向。借助递归实现。

代码

class Solution {
public:
    //深度优先搜索
    void dfs(vector<vector<char>>& grid, int x, int y, int m, int n){
        //递归终止条件
        if (x < 0 || x >= m || y < 0 || y >= n || grid[x][y] == '0') return ;
        grid[x][y] = '0'; //搜索过的地点置0,防止重复搜索一个地点(沉没岛屿)

        dfs(grid, x, y + 1, m, n); //搜索上面的区块
        dfs(grid, x, y - 1, m, n); //下面
        dfs(grid, x + 1, y, m, n); //右边
        dfs(grid, x - 1, y, m, n); //左边
    }

    int numIslands(vector<vector<char>>& grid) {
            int i, j, m = grid.size(), n = grid[0].size(), cnt = 0;

            for (i = 0; i < m; i++){
                for (j = 0; j < n; j++){
                    if (grid[i][j] == '1'){
                        dfs(grid, i, j, m, n);
                        cnt++; //搜索完一个岛屿后计数加一并沉没岛屿
                    }
                }
            }

            return cnt;
    }
};

2.BFS

先从一个岛屿出发，逐步搜索周边岛屿，类似水滴落进水池中泛起涟漪的效果。需要借助队列实现。

代码

class Solution {
public:
    //宽度优先搜索
    int m_x[4] = {0, 0, -1, 1};
    int m_y[4] = {1, -1, 0, 0};
    void bfs(vector<vector<char>>& grid, int x, int y, int m, int n){
        queue<pair<int, int>> queue;
        queue.push({x, y});
        grid[x][y] = '0'; //入队就是遍历过的地点,然后置0

        while (!queue.empty()){
            int n_x = queue.front().first;
            int n_y = queue.front().second;
            queue.pop();

            //进行周边四个区域的搜索(上下左右)
            for (int i = 0; i < 4; i++){
                x = n_x + m_x[i];
                y = n_y + m_y[i];
                if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == '1'){
                    queue.push({x, y});
                    grid[x][y] = '0';
                }
            }
        }

    }

    int numIslands(vector<vector<char>>& grid) {
            int i, j, m = grid.size(), n = grid[0].size(), cnt = 0;

            for (i = 0; i < m; i++){
                for (j = 0; j < n; j++){
                    if (grid[i][j] == '1'){
                        bfs(grid, i, j, m, n);
                        cnt++;
                    }
                }
            }

            return cnt;
    }
};

3.并查集

利用岛屿连通性解决，有几个连通域就是多少个岛屿。

代码

class Solution {
public:
    //并查集
    vector<int> parent;
    int cnt; //集合元素总数

    int find(int x){ //找元素的祖宗
        if (x == parent[x]) return x;

        parent[x] = find(parent[x]);
        return parent[x];
    }

    void merge(int x, int y){ //合并集合
        x = find(x);
        y = find(y);
        if (x == y) return ;
        parent[x] = y;
        cnt--; //合并一次集合总数减一
    }

    int numIslands(vector<vector<char>>& grid) {
        int i, j, m = grid.size(), n = grid[0].size();
        cnt = m * n;
        parent.resize(cnt);

        for (i = 0; i < cnt; i++) parent[i] = i;
        for (i = 0; i < m; i++){
            for (j = 0; j < n; j++){
                if (grid[i][j] == '1'){
                    //二维坐标转一维坐标
                    if (i > 0 && grid[i - 1][j] == '1') merge(i * n + j, (i - 1) * n + j);
                    if (j > 0 && grid[i][j - 1] == '1') merge(i * n + j, i * n + j - 1);
                } 
                else cnt--; //之前初始化集合总数还包括了海洋,要将海洋从集合中剔除
            }
        }

        return cnt;
    }
};

尾言

个人刷题总结的模板，有问题可以帮我指明