1. subject

Give you a size of m x n The binary matrix of grid .

Islands It's made up of some neighboring 1 ( Representing land ) A combination of components , there 「 adjacent 」 Ask for two 1 Must be in In four horizontal or vertical directions adjacent . You can assume grid The four edges of are all 0（ Representative water ） Surrounded by a .

The area of the island is the value of 1 Number of cells .

Calculate and return grid The largest island area in . If there were no Islands , Then the return area is 0 .

Example 1：

 Input ：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]]
 Output ：6
 explain ： The answer should not be  11 , Because the island can only contain horizontal or vertical  1 .

Example 2：
Input ：grid = [[0,0,0,0,0,0,0,0]]
Output ：0

Tips ：
m == grid.length
n == grid[i].length
1 <= m, n <= 50
grid[i][j] by 0 or 1

source ： Power button （LeetCode）
link ：https://leetcode-cn.com/problems/max-area-of-island

2. Ideas

（1）DFS
This question is actually LeetCode_DFS_ secondary _200. Number of Islands This deformation problem , It's just dfs Function submerges the island at the same time , To record the area of the island .

3. Code implementation （Java）

// Ideas 1————DFS
class Solution {
    
    public int maxAreaOfIsland(int[][] grid) {
    
        //res Record the maximum area of the island , The initial value is 0
        int res = 0;
        int m = grid.length;
        int n = grid[0].length;
        // Traverse grid
        for (int i = 0; i < m; i++) {
    
            for (int j = 0; j < n; j++) {
    
                if (grid[i][j] == 1) {
    
                    // Submerge the island , And update res
                    res = Math.max(res, dfs(grid, i, j));
                }
            }
        }
        return res;
    }

    // Drown and (i, j) Adjacent land , And return to the flooded land area 
    public int dfs(int[][] grid, int i, int j) {
    
        int m = grid.length;
        int n = grid[0].length;
        // Check the boundary conditions 
        if (i < 0 || j < 0 || i >= m || j >= n) {
    
            return 0;
        }
        if (grid[i][j] == 0) {
    
            // This location is sea water , Go straight back to 
            return 0;
        }
        // take (i, j) Turn into sea water 
        grid[i][j] = 0;
        return  dfs(grid, i - 1, j) +
                dfs(grid, i + 1, j) +
                dfs(grid, i, j - 1) +
                dfs(grid, i, j + 1) + 1;
    }
}