给你一个大小为 ​​m x n​​​ 的二进制矩阵 ​​grid​​ 。

岛屿 是由一些相邻的 ​​1​​​ (代表土地) 构成的组合，这里的「相邻」要求两个 ​​1​​ 必须在 水平或者竖直的四个方向上 相邻。你可以假设 ​​grid​​​ 的四个边缘都被 ​​0​​（代表水）包围着。

岛屿的面积是岛上值为 ​​1​​ 的单元格的数目。

计算并返回 ​​grid​​​ 中最大的岛屿面积。如果没有岛屿，则返回面积为 ​​0​​ 。

示例 1：

LeetCode 695. 岛屿的最大面积_复杂度分析

输入：grid = [[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：

输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

提示：

  • ​​m == grid.length​​
  • ​​n == grid[i].length​​
  • ​​1 <= m, n <= 50​​
  • ​​grid[i][j]​​​ 为 ​​0​​​ 或 ​​1​​

二、方法一

深度优先搜索

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        if (grid == null || grid.length == 0) {
            return 0;
        }
        int res = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                if (grid[i][j] == 1) {
                    int a = getArea(i, j, grid);
                    res = Math.max(res, a);
                }
            }
        }
        return res;
    }
    public int getArea(int x, int y, int[][] grid) {
        if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] != 1) {
            return 0;
        }
    
        grid[x][y] = 2;
        return 1 + 
               getArea(x + 1, y, grid) +
               getArea(x - 1, y, grid) +
               getArea(x, y + 1, grid) +
               getArea(x, y - 1, grid) ;
    }
}

复杂度分析

  • 时间复杂度：O(R×C)。其中 R 是给定网格中的行数，C 是列数。我们访问每个网格最多一次。
  • 空间复杂度：O(R×C)，递归的深度最大可能是整个网格的大小，因此最大可能使用 OO(R×C) 的栈空间。

三、方法二

广度优先搜索

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        if (grid == null || grid.length == 0) {
            return 0;
        }
        int res = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
               Queue<int[]> queue = new LinkedList<>();
               int cur = 0;
               queue.add(new int[]{i, j});
               while (!queue.isEmpty()) {
                   int[] pos = queue.poll();
                   int x = pos[0];
                   int y = pos[1];
                   if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] != 1) {
                    continue;
        }
                   grid[x][y] = 2;
                   cur++;
                   queue.add(new int[]{x + 1, y});
                   queue.add(new int[]{x - 1, y});
                   queue.add(new int[]{x, y + 1});
                   queue.add(new int[]{x, y - 1});
               }
               res = Math.max(cur, res);
            }
        }
        return res;
    }
}

复杂度分析

  • 时间复杂度：O(R×C)。其中 R 是给定网格中的行数，C 是列数。我们访问每个网格最多一次。
  • 空间复杂度：O(R×C)，递归的深度最大可能是整个网格的大小，因此最大可能使用 OO(R×C) 的栈空间。