算法---LeetCode 695. 岛屿的最大面积

1. 题目

原题链接

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

示例 1:
[[0,0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,1,1,0,1,0,0,0,0,0,0,0,0],
[0,1,0,0,1,1,0,0,1,0,1,0,0],
[0,1,0,0,1,1,0,0,1,1,1,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,0,1,1,0,0,0,0]]

对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1 。
示例 2:
[[0,0,0,0,0,0,0,0]]
对于上面这个给定的矩阵, 返回 0。

注意: 给定的矩阵grid 的长度和宽度都不超过 50。
Related Topics 深度优先搜索 数组
👍 502 👎 0

2. 题解

2.1 解法1: DFS

沉岛思想, 当遇到为 1 的格子记录面积并加1

递归函数

参数: 当前格子的坐标 i, j;
作用及返回值: 计算以某个 1 为起点的岛屿面积大小, 返回该岛屿面积
终止条件: i,j 超界, 或该位置不为1, 即不为岛屿, 直接返回 0

    class Solution {
        public int maxAreaOfIsland(int[][] grid) {
            int ans = 0;
            for (int i = 0; i < grid.length; i++) {
                for (int j = 0; j < grid[0].length; j++) {
                    // 若该位置为岛屿, 则开始计算该岛屿的面积
                    if (grid[i][j] == 1) {
                        ans = Math.max(ans, dfs(i, j, grid));
                    }
                }
            }
            return ans;
        }
        public int dfs(int i, int j, int[][] grid) {
            if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0) {
                return 0;
            }
            // 避免重复计算
            grid[i][j] = 0;
            // 初始面积为 1
            int num = 1;
            num += dfs(i + 1, j, grid);
            num += dfs(i - 1, j, grid);
            num += dfs(i, j + 1, grid);
            num += dfs(i, j - 1, grid);
            return num;
        }
    }

参考: Java标准DFS解法，100%，无全局变量。简洁易懂。

2.2 解法2: BFS (队列非递归)

每次遍历使用队列计算其面积, 然后滚动比较其最大面积, 其中队列中用数组保存 i,j坐标

注意:
1.每次开始循环前 需要重置 面积
2.每次入队前就需要将该位置置 0 , 否则可能会有重复计算, 同时将面积+1

    class Solution {
        public int maxAreaOfIsland(int[][] grid) {
            int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
            int ans = 0;
            int curArea = 0;
            for (int i = 0; i < grid.length; i++) {
                for (int j = 0; j < grid[0].length; j++) {
                    if (grid[i][j] == 1) {
                        // 每次开始循环前 需要重置 面积
                        curArea = 1;
                        grid[i][j] = 0;
                        Queue<int[]> queue = new LinkedList<>();
                        queue.offer(new int[]{i, j});
                        while (!queue.isEmpty()) {
                            int[] temp = queue.poll();
                            int x = temp[0], y = temp[1];

                            for (int k = 0; k < dir.length; k++) {
                                int newX = x + dir[k][0];
                                int newY = y + dir[k][1];
                                if (newX >= 0 && newX < grid.length && newY >= 0 && newY < grid[0].length && grid[newX][newY] == 1) {
                                    // 这里注意在每次入队前就需要将该位置置 0 , 否则可能会有重复计算, 同时将面积+1
                                    curArea++;
                                    grid[newX][newY] = 0;
                                    queue.offer(new int[]{newX, newY});
                                }
                            }
                        }
                    }
                    ans = Math.max(ans, curArea);
                }
            }
            return ans;
        }

    }

参考:「695. 岛屿的最大面积」标准dfs, 递归与非递归