695. 岛屿的最大面积（中等）

1. 题目描述

题目中转：695. 岛屿的最大面积

2.详细题解

    该题是典型的深度优先搜索题，深度优先搜索的基本思想是：从某个节点出发，尽可能深地搜索图的分支，直到达到叶子节点或图中所有可达的节点都被访问过。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这个过程一直进行到已发现从源节点可达的所有节点为止。
  深度优先搜索可以通过递归或栈（非递归）两种方式来实现。在刷题或者竞赛过程中，为节约时间，建议使用递归方式，但在实际工程应用中，一般使用栈的方式实现，使用栈更易理解，且更不易出现递归栈满的情况。
  具体算法如下：

• Step1：初始化：矩阵的行数和列数$m,n$，最大岛屿面积$area$，为便于遍历上下左右四个方向定义的数组；
• Step2：双重循环依次遍历矩阵中的每一个元素:$行列索引分别为i,j$；
• Step3：如果元素值为$1$；
•   $(i,j)$处元素改为0，压入栈，初始岛屿面积为1；
•   单层循环，循环条件为堆栈不为空；依次判断上下左右四个位置的元素，值为$1$的将索引压入栈，岛屿面积增加1；
• Step4：保留最大岛屿面积；
• Step5：返回岛屿面积。

3.代码实现

3.1 Python

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        directions = [0, 1, 0, -1, 0]
        m, n = len(grid), len(grid[0])
        area = 0
        for i in range(0, m):
            for j in range(0, n):
                if grid[i][j] == 1:
                    cur_area = 1
                    grid[i][j] = 0
                    stack = [(i, j)]
                    while len(stack) > 0:
                        r, c = stack.pop()
                        for k in range(4):
                            x = r + directions[k]
                            y = c + directions[k+1]
                            if 0 <= x < m and 0 <= y < n and grid[x][y] == 1:
                                cur_area += 1
                                grid[x][y] = 0
                                stack.append((x, y))
                    area = max(area, cur_area)
        return area

3.2 Java

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int area = 0;
        int m = grid.length;
        int n = grid[0].length;
        int[] directions = {0, 1, 0, -1, 0};
        for (int i=0; i<m; i++){
            for (int j=0; j<n; j++){
                if (grid[i][j] == 1){
                    int curArea = 1;
                    grid[i][j] = 0;
                    Stack<int[]> stack = new Stack<>();
                    stack.push(new int[]{i, j});
                    while (!stack.isEmpty()){
                        int[] curr = stack.pop();
                        int r = curr[0];
                        int c = curr[1];
                        for (int k=0; k < 4; k++){
                            int x = r + directions[k];
                            int y = c + directions[k+1];
                            if (x >=0 && x < m && y >=0 && y<n && grid[x][y] == 1){
                                ++curArea;
                                grid[x][y] = 0;
                                stack.push(new int[]{x, y});
                            }
                        }
                    }
                    area = Math.max(area, curArea);
                }
            }
        }
        return area;
    }
}

  执行用时不必过于纠结，对比可以发现，对于python和java完全相同的编写，java的时间一般是优于python的；至于编写的代码的执行用时击败多少对手，执行用时和网络环境、当前提交代码人数等均有关系，可以尝试完全相同的代码多次执行用时也不是完全相同，只要确保自己代码的算法时间复杂度满足相应要求即可，也可以通过点击分布图查看其它coder的code。