695. 岛屿的最大面积

image.png

递归解法

执行用时：3 ms, 在所有 Java 提交中击败了72.95% 的用户 内存消耗：38.8 MB, 在所有 Java 提交中击败了84.91% 的用户

  1. class Solution {
  2.     // 存储是否遍历过
  3.     private boolean[][] gridTemp;
  4.     // 存储当前岛屿面积
  5.     private int count;
  6.     // 定义上下左右方向
  7.     private int[][] dire = new int[][]{
  8.             new int[]{0, 1},
  9.             new int[]{0, -1},
  10.             new int[]{1, 0},
  11.             new int[]{-1, 0}
  12.     };
  14.     public int maxAreaOfIsland(int[][] grid) {
  15.         int rowCount = grid.length;
  16.         int colCount = grid[0].length;
  17.         gridTemp = new boolean[rowCount][colCount];
  18.         int max = 0;
  19.         for (int i = 0; i < rowCount; i++) {
  20.             for (int j = 0; j < colCount; j++) {
  21.                 if (!gridTemp[i][j]) {
  22.                     count = 0;
  23.                     calculateAreaRecursion(grid, i, j);
  24.                     max = Math.max(count, max);
  25.                 }
  26.             }
  27.         }
  28.         return max;
  29.     }
  31.     public void calculateAreaRecursion(int[][] grid, int x, int y) {
  32.         // 判断坐标是是否越界
  33.         if (!(x >= 0 && x < grid.length && y >= 0 && y < grid[0].length)) return;
  34.         // 如果遍历过，返回
  35.         if (gridTemp[x][y]) return;
  36.         // 将当前坐标更新为已遍历
  37.         gridTemp[x][y] = true;
  39.         // 如果当前是岛屿，面积加一，
  40.         if (grid[x][y] == 1) {
  41.             count++;
  42.             // 递归遍历上下左右节点
  43.             for (int[] d : dire) {
  44.                 calculateAreaRecursion(grid, x + d[0], y + d[1]);
  45.             }
  46.         }
  47.     }
  48. }