最大人工岛

/*
 * 思路：
 * 1. 使用流的方式遍历矩阵中的每一个0，尝试将其变为1并计算岛屿面积。
 * 2. 使用递归计算岛屿面积。
 * 3. 使用流收集最大面积。
 */

import java.util.Arrays;

public class Solution {
    private int n;
    private int[][] grid;
    private final int[] dX = {-1, 1, 0, 0};
    private final int[] dY = {0, 0, -1, 1};

    public int largestIsland(int[][] grid) {
        this.n = grid.length;
        this.grid = grid;

        return Arrays.stream(grid)
                .flatMapToInt(row -> Arrays.stream(row))
                .filter(cell -> cell == 0)
                .map(cell -> {
                    grid[cell / n][cell % n] = 1;
                    int area = Arrays.stream(grid)
                            .mapToInt(row -> Arrays.stream(row)
                                    .map(this::calculateArea)
                                    .max()
                                    .orElse(0))
                            .max()
                            .orElse(0);
                    grid[cell / n][cell % n] = 0;
                    return area;
                })
                .max()
                .orElse(0);
    }

    private int calculateArea(int cell) {
        return Arrays.stream(new int[]{-1, 1, 0, 0})
                .flatMap(dx -> Arrays.stream(new int[]{0, 0, -1, 1})
                        .map(dy -> dfs(cell / n + dx, cell % n + dy, new boolean[n][n])))
                .sum() + 1;
    }

    private int dfs(int x, int y, boolean[][] visited) {
        if (x < 0 || x >= n || y < 0 || y >= n || grid[x][y] == 0 || visited[x][y]) {
            return 0;
        }
        visited[x][y] = true;
        return 1 + Arrays.stream(new int[]{-1, 1, 0, 0})
                .flatMap(dx -> Arrays.stream(new int[]{0, 0, -1, 1})
                        .map(dy -> dfs(x + dx, y + dy, visited)))
                .sum();
    }
}