图的遍历-剑指Offer105最大岛屿面积问题(Java实现Dfs、Bfs)

Jkl_0317

于 2023-02-03 21:45:10 发布

阅读量254

点赞数

文章标签：深度优先广度优先 leetcode 算法

本文链接：https://blog.csdn.net/Fhakjfksakln/article/details/128876469

版权

这篇文章介绍了如何使用广度优先搜索(BFS)、深度优先搜索(DFS)以及递归方法在给定的二维网格中找到并计算最大的岛屿面积。算法会遍历0和1组成的网格，1代表土地，通过标记已访问的单元格来避免重复计算。

摘要由CSDN通过智能技术生成

剑指 Offer II 105. 岛屿的最大面积

给定一个由 0 和 1 组成的非空二维数组 grid ，用来表示海洋岛屿地图。
一个岛屿是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
找到给定的二维数组中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

基于队列实现BFS

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int ans = 0;
        boolean[][] used = new boolean[grid.length][grid[0].length];
        for(int i = 0;i < grid.length;i++){
            for(int j = 0;j < grid[0].length;j++){
                if(grid[i][j] == 1 && !used[i][j]){
                    int area = getArea(grid,used,i,j);
                    ans = Math.max(area,ans);
                }
            }
        }
        return ans;
    }

    public int getArea(int[][] grid,boolean[][] used,int i,int j){
        
        used[i][j] = true;
        int area = 1;
        int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
        
        for(int[] dir : dirs){
            int r = i + dir[0];
            int c = j + dir[1];
            if(r >= 0 &&
            r < grid.length &&
            c >= 0 &&
            c < grid[0].length &&
            !used[r][c] &&
            grid[r][c] == 1){
                area += getArea(grid,used,r,c);
            }
        }

        
        return area;
    }

}

基于栈实现DFS

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int ans = 0;
        boolean[][] used = new boolean[grid.length][grid[0].length];
        for(int i = 0;i < grid.length;i++){
            for(int j = 0;j < grid[0].length;j++){
                if(grid[i][j] == 1 && !used[i][j]){
                    int area = getArea(grid,used,i,j);
                    ans = Math.max(area,ans);
                }
            }
        }
        return ans;
    }

    public int getArea(int[][] grid,boolean[][] used,int i,int j){
        
        Stack<int[]> stack = new Stack<>();
        stack.add(new int[]{i,j});
        used[i][j] = true;
        int area = 0;
        int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
        while(!stack.isEmpty()){
            int[] post = stack.pop();
            area++;
            for(int[] dir : dirs){
                int r = post[0] + dir[0];
                int c = post[1] + dir[1];
                if(r >= 0 &&
                r < grid.length &&
                c >= 0 &&
                c < grid[0].length &&
                !used[r][c] &&
                grid[r][c] == 1){
                    stack.add(new int[]{r,c});
                    used[r][c] = true;
                }
            }

        }
        return area;
    }

}

基于递归实现DFS

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int ans = 0;
        boolean[][] used = new boolean[grid.length][grid[0].length];
        for(int i = 0;i < grid.length;i++){
            for(int j = 0;j < grid[0].length;j++){
                if(grid[i][j] == 1 && !used[i][j]){
                    int area = getArea(grid,used,i,j);
                    ans = Math.max(area,ans);
                }
            }
        }
        return ans;
    }

    public int getArea(int[][] grid,boolean[][] used,int i,int j){
        
        used[i][j] = true;
        int area = 1;
        int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
        
        for(int[] dir : dirs){
            int r = i + dir[0];
            int c = j + dir[1];
            if(r >= 0 &&
            r < grid.length &&
            c >= 0 &&
            c < grid[0].length &&
            !used[r][c] &&
            grid[r][c] == 1){
                area += getArea(grid,used,r,c);
            }
        }

        
        return area;
    }

}