leetcode【中等】200、岛屿数量 / 463、岛屿周长 / 695、岛屿的最大面积

岛屿问题汇总

200、岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
一堆1连在一起算一个岛屿，岛屿的上下左右为0或者边界

思路：dfs

1. 主函数中遍历， 当遇到 grid[i][j] == '1' 时，从此点开始 dfs，岛屿数 count + 1
2. dfs： 目前指针(i, j)，从 (i, j) 向此点的上下左右 (i+1,j),(i-1,j),(i,j+1),(i,j-1) 做深度搜索。遇到边界（数组边界+遇到水）则终止；
   同时，执行 grid[i][j] = '0'，以免之后重复搜索相同岛屿。

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        res=0
        m,n=len(grid),len(grid[0])

        def dfs(i,j):
            if not 0<=i<m or not 0<=j<n or grid[i][j]=='0':
                return
            grid[i][j]='0'
            dfs(i+1,j)
            dfs(i-1,j)
            dfs(i,j+1)
            dfs(i,j-1)

        for i in range(m):
            for j in range(n):
                if grid[i][j]=='1':
                    dfs(i,j)
                    res+=1
        return res

class Solution {
    public int numIslands(char[][] grid) {
        int m=grid.length,n=grid[0].length;
        int res=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]=='1'){
                    dfs(grid,i,j);
                    res+=1;
                }
            }
        }
        return res;
    }

    public void dfs(char[][] grid,int i,int j){
        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length 
        		|| grid[i][j] != '1'){
            return;
        }
        grid[i][j]='0';
        dfs(grid,i+1,j);
        dfs(grid,i-1,j);
        dfs(grid,i,j-1);
        dfs(grid,i,j+1);
    }
}

463、岛屿周长

只有一块岛屿，计算周长

class Solution:
    def islandPerimeter(self, grid: List[List[int]]) -> int:
        m,n=len(grid),len(grid[0])

        def dfs(i,j):
            if not 0<=i<m or not 0<=j<n:#遇到边界
                return 1
            if grid[i][j]==0:#遇到海水边界
                return 1
            if grid[i][j]==2:#遇到已遍历的陆地
                return 0
            grid[i][j]=2
            return dfs(i+1,j)+dfs(i-1,j)+dfs(i,j+1)+dfs(i,j-1)

       
        for i in range(m):
            for j in range(n):
                if grid[i][j]==1:
                    return dfs(i,j)#只有一个岛屿
        return 0

class Solution {
    public int islandPerimeter(int[][] grid) {
        int m=grid.length,n=grid[0].length;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1){
                    return dfs(grid,i,j);                   
                }
            }
        }
        return 0;
    }
    public int dfs(int[][] grid,int i,int j){
        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length ) return 1;
        if(grid[i][j]==0) return 1;
        if(grid[i][j]==2) return 0;
        grid[i][j]=2;
        return dfs(grid,i+1,j)+dfs(grid,i-1,j)+dfs(grid,i,j+1)+dfs(grid,i,j-1);
    }
}

695、岛屿的最大面积

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int res=0;
        int m=grid.length,n=grid[0].length;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1){                   
                    res=Math.max(res,dfs(grid,i,j));
                }
            }
        }
        return res;
    }
    public int dfs(int[][]grid,int i,int j){
        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length 
        		|| grid[i][j] ==0){
            return 0;
        }
        grid[i][j]=0;
        int cur=1;
        cur+=dfs(grid,i+1,j);
        cur+=dfs(grid,i-1,j);
        cur+=dfs(grid,i,j-1);
        cur+=dfs(grid,i,j+1);
        return cur;
    }
}