岛屿题目合集

力扣200 岛屿数量

方法一：DFS

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

    public void dfs(char[][] grid,int i,int j){
        if(i<0||i>=grid.length||j<0||j>=grid[0].length||grid[i][j]=='0'){
            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);
    }

方法二：BFS

注意bfs方法出现过的问题：超时

之前写的代码：

这样写导致在bfs算法里将每个坐标都访问了一遍，造成时间过长，但其实grid[i][j]='0'的话就不需要再访问了，而grid[i][j]周围的'1'会经过其它'1'上下左右遍历到。

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

    private void bfs(char[][] grid,int i,int j){
        Queue<int[]> queue=new LinkedList<>();
        queue.add(new int[]{i,j});
        while(!queue.isEmpty()){
            int[] cur=queue.poll();
            int left=cur[0];
            int right=cur[1];
            grid[left][right]='0';
            if(left>0&&grid[left-1][right]=='1') queue.add(new int[]{left-1,right});
            if(left<grid.length-1&&grid[left+1][right]=='1') queue.add(new int[]{left+1,right});
            if(right>0&&grid[left][right-1]=='1') queue.add(new int[]{left,right-1});
            if(right<grid[0].length-1&&grid[left][right+1]=='1') queue.add(new int[]{left,right+1});
        }
    }
}

修改后：

    public int numIslands(char[][] grid){
        int count=0;
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(grid[i][j]=='1') {
                    bfs(grid, i, j);
                    count++;
                }
                
            }
        }
        return count;
    }

    public void bfs(char[][] grid,int i,int j){
        Queue<int[]> queue=new LinkedList<>();
        queue.add(new int[]{i,j});
        while(!queue.isEmpty()){
            int[] array=queue.poll();
            i=array[0];
            j=array[1];
            if(i>=0&&i<grid.length&&j>=0&&j<grid[0].length&&grid[i][j]=='1'){
                grid[i][j]='0';
                queue.add(new int[]{i+1,j});
                queue.add(new int[]{i-1,j});
                queue.add(new int[]{i,j+1});
                queue.add(new int[]{i,j-1});
            }
        }
    }

力扣695 岛屿的最大面积

    public int maxAreaOfIsland(int[][] grid) {
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(grid[i][j]==1){
                    count=0;
                    dfs(grid,i,j);
                }
            }
        }
        return max;
    }

    int max=0;
    int count=0;//每个岛的面积
    private void dfs(int[][] grid,int i,int j){
        if(i<0||i>=grid.length||j<0||j>=grid[0].length||grid[i][j]!=1) return;
        count++;
        grid[i][j]=0;
        dfs(grid,i-1,j);
        dfs(grid,i+1,j);
        dfs(grid,i,j-1);
        dfs(grid,i,j+1);
        max=Math.max(max,count);
    }

public int maxAreaOfIsland(int[][] grid) {
        int max=0;
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(grid[i][j]==1){
                    max=Math.max(bfs(grid,i,j),max);
                }
            }
        }
        return max;
    }

    private int bfs(int[][] grid,int i,int j){
        Queue<int[]> queue=new LinkedList<>();
        queue.add(new int[]{i,j});
        int count=0;
        while(!queue.isEmpty()){
            for(int k=queue.size();k>0;k--) {
                int[] array = queue.poll();
                int m=array[0];
                int n=array[1];
                if(m>=0&&m<grid.length&&n>=0&&n<grid[0].length&&grid[m][n]==1){
                    count++;
                    grid[m][n]=0;
                    queue.add(new int[]{m-1,n});
                    queue.add(new int[]{m+1,n});
                    queue.add(new int[]{m,n-1});
                    queue.add(new int[]{m,n+1});
                }
            }
        }
        return count;
    }