题目描述

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1:

输入:
[
[‘1’,‘1’,‘1’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘0’,‘0’]
]
输出: 1

示例 2:

输入:
[
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘1’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘1’,‘1’]
]
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-islands
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

主要思想

深度优先搜索

扫描网格，找到数字为‘1’的坐标，进行深度优先搜索，每一个被搜索到的1都更改为0，防止重复搜索，
深度搜索了多少次，那么就有多少个岛屿。

广度优先搜索

扫描网格，找到数字为‘1’的坐标，将其放入队列，进行广度优先搜索，每一个被搜索到的1都更改为0，队列为空的时候结束，广度搜索了多少次，那么就有多少个岛屿。

代码实现

摘自官网
https://leetcode-cn.com/problems/number-of-islands/solution/dao-yu-shu-liang-by-leetcode/

深度优先搜索

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';//将数值为1的坐标值改为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 >= 0 && grid[r][c-1] == '1') dfs(grid, r, c - 1);
        //判断此陆地右边是不是陆地
        if (c + 1 < nc && grid[r][c+1] == '1') dfs(grid, r, c + 1);
    }

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

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

广度优先搜索

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();//网格纵向长度
        if (!nr) return 0;
        int nc = grid[0].size();//网格横向长度

        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') {
                        //如果是陆地，那么入队列，然后将值改为0
                            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;
    }
};