leetcode上面的一些bfs和dfs的题目

dfs和bfs的相关题目，dfs可以使用递归实现，bfs使用quene实现。

题目描述：

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

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

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

示例 1:

输入:
11110
11010
11000
00000
输出: 1
示例 2:

输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

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

• DFS（使用递归来进行遍历）

class Solution {
public:
    void dfs(vector<vector<char>>& grid, int n,int m)
    {
        grid[n][m]='0';

        if(n-1>=0&&grid[n-1][m]=='1')  dfs(grid, n-1,m);
        if(m-1>=0&&grid[n][m-1]=='1')  dfs(grid,n,m-1);
        if(n+1<grid.size()&&grid[n+1][m]=='1')  dfs(grid,n+1,m);
        if(m+1<grid[0].size()&&grid[n][m+1]=='1')  dfs(grid,n,m+1);
    }
    int numIslands(vector<vector<char>>& grid) {
        int count=0;
        int row=grid.size();
        if(row==0)
            return 0;
        int rol=grid[0].size();
        for(int i=0;i<row;i++){
            for(int j=0;j<rol;j++){
                if(grid[i][j]=='1'){
                   count++;
                   dfs(grid, i,j);
                }
            }
        }
        return count;
    }
};

• BFS（使用quene实现）

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') {
                            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;
    }
};

待补充题目…