黑白翻转棋

/*
 * 思路：
 * 使用 Java Stream 来简化代码流程，依然是遍历所有空位并计算最多翻转的棋子数。
 * 使用 List 存储所有可能的翻转数量，最后取最大值。
 */
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FlipChessStream {
    private static final int[][] DIRECTIONS = {
        {0, 1}, {0, -1}, {1, 0}, {-1, 0}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}
    };

    public int maxFlip(String[] chessboard) {
        return Arrays.stream(chessboard)
            .flatMapToInt(row -> Arrays.stream(row.split("")))
            .collect(Collectors.toList())
            .stream()
            .mapToInt(ch -> chessboard.length * chessboard[0].length())
            .map(idx -> {
                int x = idx / chessboard[0].length();
                int y = idx % chessboard[0].length();
                return chessboard[x].charAt(y) == '.' ? countFlips(chessboard, x, y) : 0;
            })
            .max().orElse(0);
    }

    private int countFlips(String[] board, int x, int y) {
        return Arrays.stream(DIRECTIONS)
            .mapToInt(dir -> flipDirection(board, x, y, dir[0], dir[1]))
            .sum();
    }

    private int flipDirection(String[] board, int x, int y, int dx, int dy) {
        int nx = x + dx, ny = y + dy;
        int flipCount = 0;
        boolean canFlip = false;
        while (nx >= 0 && nx < board.length && ny >= 0 && ny < board[0].length()) {
            if (board[nx].charAt(ny) == '.') break;
            if (board[nx].charAt(ny) == 'X') {
                canFlip = true;
                break;
            }
            flipCount++;
            nx += dx;
            ny += dy;
        }
        return canFlip ? flipCount : 0;
    }
}