[LeetCode] 200岛屿数量(DFS BFS) + 695岛屿最大面积(DFS)

200 岛屿数量

1.深度优先DFS：遍历二维数组时遇到1，则说明遇到一个岛，岛数+1，dfs遍历后岛置为0

class Solution {
private:
    //dfs结束后该岛屿已全部置为0
    void dfs(vector<vector<char>>& grid, int r,int c) { //r c为开始遍历的1的坐标
        int rn = grid.size(); //grid行数
        int cn = grid[0].size(); //grid列数
        //遍历过的节点置为0，避免重复遍历
        grid[r][c] = '0';
        //向下一行遍历(下一行该位置为1，且下一行没超过底部)
        if(r-1>=0 && grid[r-1][c]=='1') 
            dfs(grid,r-1,c);
        //向上一行遍历
        if(r+1<rn && 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<cn && grid[r][c+1]=='1')
            dfs(grid,r,c+1);
    }

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

        int ans = 0;
        for(int r=0;r<rn;r++) {
            for(int c=0;c<cn;c++) {
                if(grid[r][c]=='1') {
                    //岛屿数量+1，dfs后该岛就无了
                    ++ans;
                    dfs(grid,r,c);
                }
            }
        }
        return ans;
    }
};

2.广度遍历BFS：把遇到的1都放进队列

class Solution {
public:
    //广度优先
    int numIslands(vector<vector<char>>& grid) {
        int rn = grid.size();
        if(!rn) return 0;
        int cn = grid[0].size();
        int ans = 0;

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

695 岛屿最大面积

DFS：原理遍历地图（二维数组），遇到陆地元素时，从该元素向四周扩散（4个方向的dfs）寻找陆地元素。

技巧：遍历过的陆地元素1，为了防止重复遍历，将其置为0.

class Solution {
private:
    int dfs(vector<vector<int>>& grid, int x, int y) {
        //终止条件：递归边界
        if(x < 0 || x == grid.size())
            return 0;
        else if (y < 0 || y == grid[0].size())
            return 0;
        else if (grid[x][y] == 0) //(x,y)非陆地
            return 0;
        //遍历过的土地，置为0
        grid[x][y] = 0;
        //
        int sum = 1;
        //从0到3，分别对应上下左右的移动
        int xMov[4] {-1, 1,  0, 0};
        int yMov[4] { 0, 0, -1, 1};
        for(int i = 0; i < 4; i++) {
            int nextX = x + xMov[i];
            int nextY = y + yMov[i];
            sum += dfs(grid, nextX, nextY);
        }
        return sum;
    }

public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int ans = 0;
        for(int i = 0; i < grid.size(); i++) {
            for(int j = 0; j < grid[0].size(); j++) {
                if(grid[i][j] == 1)
                    ans = max(ans, dfs(grid, i, j) );
            }
        }
        return ans;
    }
};