力扣200. 岛屿数量（深度、广度遍历、矩阵、数组）C++

给你一个由 '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'

解法一：深度优先 

class Solution {
private:
    void dfs(vector<vector<char>>& grid, int r, int c) {
        int nr = grid.size();
        int nc = grid[0].size();

        grid[r][c] = '0';
        if (r - 1 >= 0 && grid[r - 1][c] == '1')
            dfs(grid, r - 1, c);
        if (r + 1 < nr && grid[r + 1][c] == '1')
            dfs(grid, r + 1, c);
        if (c + 1 < nc && grid[r][c + 1] == '1')
            dfs(grid, r, c + 1);
        if (c - 1 >= 0 && grid[r][c - 1] == '1')
            dfs(grid, r, c - 1);
    }

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

        int num_islands=0;

        for(int r=0;r<nr;r++){
            for(int c=0;c<nc;c++){
                if(grid[r][c]=='1'){
                    ++num_islands;
                    dfs(grid,r,c);
                }
            }
        }
        return num_islands;
    }
};

代码中定义了一个私有函数dfs，用来进行深度优先搜索。dfs函数的作用是将与当前位置相连的所有陆地都标记为水域，即将字符'1'修改为字符'0'。具体实现是通过递归调用dfs函数来进行遍历，对当前位置上、下、左、右四个方向进行检查，如果相连的位置是陆地（即字符为'1'），则继续递归调用dfs函数。

公有函数numIslands是整个算法的入口。它首先获取矩阵的行数nr和列数nc，然后对矩阵进行遍历。如果当前位置是岛屿（即字符为'1'），则将岛屿数量加1，并调用dfs函数将与该岛屿相连的所有陆地都标记为水域。

最后，函数返回岛屿数量。

整个算法的思路是利用深度优先搜索来遍历矩阵中的每个岛屿，并将与其相连的陆地都标记为水域，从而统计出岛屿的数量。

解法二：广度优先 

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

        int num_islands = 0;
        for (int r = 0; r < nr; r++) {
            for (int c = 0; c < nc; c++) {
                if (grid[r][c] == '1') {
                    ++num_islands;
                    grid[r][c] = '0';
                    queue<pair<int, int>> neighbors;
                    neighbors.push({r, c});
                    while (!neighbors.empty()) {
                        auto rc = neighbors.front();
                        neighbors.pop();
                        int row = rc.first, col = rc.second;
                        if (row - 1 >= 0 && grid[row - 1][col] == '1') {
                            neighbors.push({row - 1, col});
                            grid[row - 1][col] = '0';
                        }
                        if (row + 1 < nr && grid[row + 1][col] == '1') {
                            neighbors.push({row + 1, col});
                            grid[row + 1][col] = '0';
                        }
                        if (col - 1 >= 0 && grid[row][col - 1] == '1') {
                            neighbors.push({row, col - 1});
                            grid[row][col - 1] = '0';
                        }
                        if (col + 1 < nc && grid[row][col + 1] == '1') {
                            neighbors.push({row, col + 1});
                            grid[row][col + 1] = '0';
                        }
                    }
                }
            }
        }
        return num_islands;
    }
};

与之前的代码相比，主要区别在于使用了队列来存储待访问的岛屿的位置，从而实现广度优先搜索。

具体实现如下：

• 遍历整个矩阵，如果当前位置是岛屿（字符为'1'），则将岛屿数量加1，并将当前位置标记为水域（字符改为'0'）。
• 创建一个队列neighbors，将当前位置加入队列。
• 开始循环，直到队列为空。每次循环取出队列的头部元素，即当前待访问的岛屿位置。
• 对当前位置的上、下、左、右四个方向进行检查，如果相邻位置是岛屿（字符为'1'），则将相邻位置加入队列neighbors，并将相邻位置标记为水域（字符改为'0'）。
• 循环结束后，所有与当前岛屿相连的陆地都被标记为水域。
• 继续遍历下一个岛屿。

最后，函数返回岛屿数量。

整个算法的思路是利用广度优先搜索来遍历矩阵中的每个岛屿，并将与其相连的陆地都标记为水域，从而统计出岛屿的数量。与深度优先搜索相比，广度优先搜索使用了队列来存储待访问的岛屿位置，从而实现广度优先遍历的效果。