深度优先：827. 最大人工岛 + 京东2019春招笔试（着火）+695. 岛屿的最大面积

1、827. 最大人工岛（深度优先）

在二维地图上， 0代表海洋， 1代表陆地，我们最多只能将一格 0 海洋变成 1变成陆地。

进行填海之后，地图上最大的岛屿面积是多少？（上、下、左、右四个方向相连的 1 可形成岛屿）

示例 1:

输入: [[1, 0], [0, 1]]
输出: 3
解释: 将一格0变成1，最终连通两个小岛得到面积为 3 的岛屿。

示例 2:

输入: [[1, 1], [1, 0]]
输出: 4
解释: 将一格0变成1，岛屿的面积扩大为 4。

示例 3:

输入: [[1, 1], [1, 1]]
输出: 4
解释: 没有0可以让我们变成1，面积依然为 4。

说明:

1 <= grid.length = grid[0].length <= 50
0 <= grid[i][j] <= 1

public int largestIsland(int[][] grid) {
        if (grid == null || grid.length == 0)
            return 0;

        int max = 0;
        int row = grid.length;
        int col = grid[0].length;
        //一定要有这个，为了解决这个情况{{1}}
        boolean hasZero = false;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == 0) {
                    hasZero = true;
                    grid[i][j] = 1;
                    int cur = dfs(grid, i, j, row, col, new boolean[row][col]);
                    if (cur == row * col)
                        return cur;

                    if (cur > max) {
                        max = cur;
                    }
                    grid[i][j] = 0;
                }
            }
        }
        return hasZero ? max : row * col;
    }

    private int dfs(int[][] grid, int i, int j, int row, int col, boolean[][] booleans) {
        //这样的情况，返回0
        if (i < 0 || j < 0 || i >= row || j >= col || grid[i][j] == 0 || booleans[i][j])
            return 0;

        booleans[i][j] = true;
        return 1 + dfs(grid, i + 1, j, row, col, booleans) + dfs(grid, i - 1, j, row, col, booleans) + dfs(grid, i, j + 1, row, col, booleans) + dfs(grid, i, j - 1, row, col, booleans);
    }

2、京东2019春招笔试（着火，深度优先）

思路：
找到根节点左右子树，节点个数最多的就是所求。

//深度优先
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String nStr = sc.nextLine();
            int n = Integer.parseInt(nStr);
            int[][] edges = new int[n][2];
            for (int i = 0; i < n - 1; i++) {
                String str = sc.nextLine();
                String[] strings = str.split(" ");
                edges[i][0] = Integer.parseInt(strings[0]);
                edges[i][1] = Integer.parseInt(strings[1]);
            }

            HashMap<Integer, ArrayList<Integer>> hashMap = new HashMap<>();
            for (int i = 0; i < n; i++) {
                if (hashMap.containsKey(edges[i][1])) {
                    hashMap.get(edges[i][1]).add(edges[i][0]);
                } else {
                    ArrayList<Integer> arrayList = new ArrayList<>();
                    arrayList.add(edges[i][0]);
                    hashMap.put(edges[i][1], arrayList);
                }
            }
            ArrayList<Integer> arrayList = hashMap.get(1);
            int res = 0;
            for (int i : arrayList) {
                int temp = dfs(hashMap, i);
                if (temp > res) {
                    res = temp;
                }
            }
            System.out.println(res);
        }
    }

    private static int dfs(HashMap<Integer, ArrayList<Integer>> hashMap, int num) {
        int count = 1;
        if (hashMap.get(num) == null)
            return count;
        for (int i : hashMap.get(num)) {
            count += dfs(hashMap, i);
        }
        return count;
    }

3、

给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)

示例 1:

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

示例 2:

[[0,0,0,0,0,0,0,0]]

对于上面这个给定的矩阵, 返回 0。

注意: 给定的矩阵grid 的长度和宽度都不超过 50。

代码：

注意点：遍历过grid[i][j]=1后，令grid[i][j]=-1

public int maxAreaOfIsland(int[][] grid) {
        int row=grid.length;
        int col=grid[0].length;

        int max=0;

        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(grid[i][j]==1){
                    int cur=dfs(grid,i,j,row,col);
                    if(cur==row*col){
                        return cur;
                    }
                    if(cur>max){
                        max=cur;
                    }
                }
            }
        }
        return max;
    }

    private int dfs(int[][] grid, int i, int j, int row, int col) {
        if(i<0||j<0||i>=row||j>=col||grid[i][j]==0||grid[i][j]==-1)
            return 0;

        grid[i][j]=-1;
        return 1+dfs(grid,i+1,j,row,col)+dfs(grid,i-1,j,row,col)+dfs(grid,i,j+1,row,col)+dfs(grid,i,j-1,row,col);
    }