18、队列与BFS和DSF——岛屿数量（C++版）

题目描述

---

1、BFS（广度优先搜索算法）

该岛屿的特征为上下左右的‘1’相连接为一个岛屿，而仅斜对角线的‘1’相邻则不为同一岛屿。因此该问题就可变成查找上下左右相邻的‘1’直至没有相邻的‘1’时，则找到了一个岛屿。因此可选用BFS，在BFS算法中的边界条件便为移动过程中是否在问题规定的行值和列值中。而本问题的大边界条件则是行数和列数是否为0或者空。

首先，考虑采取BFS算法，每当获取到一个‘1’时，就把该位置的‘1’变为0，以防被重复查询。该算法需要获取行值和列值，因此就需要两个变量进行存储，便有了int row,col。

而C++中有pair<T1,T2>可将T1与T2共同存至一个变量中方便对BFS的整体边界条件进行判断，即是否有可继续搜索的相邻的‘1’，因此便有了neighbors。若搜索至无‘1’则，调出循环，完成了一个岛屿的搜索。

然后，再改变行、列号一个一个位置的遍历进行搜索。

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';
                    //构建将两个数据合为一个的neighbors变量
                    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;
    }
};

拓展知识：
C++中pair的用法

2、DFS（深度优先搜索算法）

DFS采取的策略与BFS的区别是：BFS是在某一点处的上下左右顺序进行查询遍历，而DFS则从某一点处的上开始，不断地延伸使用上下左右查询的策略，直至查询到没有时，便回到上一个点处，再进行查询。

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

参考文章：
LeetCode 200：岛屿数量 Number of Islands

岛屿数量-力扣

LeetCode 队列与BFS–岛屿的数量