LCP 41. 黑白翻转棋 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
class Solution {
    private static final int[][] DIRECTIONS = new int[][]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {-1, -1}, {1, 1}, {-1, 1}, {1, -1}};

    public int flipChess(String[] chessboard) {
        int m = chessboard.length, n = chessboard[0].length();

        int maxCount = 0;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (chessboard[i].charAt(j) == '.') {
                    // 在空余位置落下一颗棋子，并以此为起点寻找另一个黑色棋子
                    maxCount = Math.max(maxCount, bfs(chessboard, i, j));
                }
            }
        }

        return maxCount;
    }

    private int bfs(String[] chessboard, int i, int j) {
        int m = chessboard.length, n = chessboard[0].length();

        char[][] board = new char[m][n];
        for (int k = 0; k < m; k++) {
            for (int l = 0; l < n; l++) {
                board[k][l] = chessboard[k].charAt(l);
            }
        }

        int count = 0;

        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{i, j});
        while (!queue.isEmpty()) {
            int[] point = queue.poll();
            for (int[] direction : DIRECTIONS) {
                int nextI = point[0] + direction[0], nextJ = point[1] + direction[1];
                if (canReachAnotherBlack(board, point, direction)) {
                    // 能够到达最近的黑色棋子，在这段距离中，可能存在白色棋子，也可能不存在
                    // 如果存在白色棋子，则翻转、统计并加入队列继续延伸
                    while (board[nextI][nextJ] == 'O') {
                        board[nextI][nextJ] = 'X';
                        queue.offer(new int[]{nextI, nextJ});
                        nextI += direction[0];
                        nextJ += direction[1];
                        count++;
                    }
                }
            }
        }

        return count;
    }

    private boolean canReachAnotherBlack(char[][] board, int[] point, int[] direction) {
        int m = board.length, n = board[0].length;

        int nextI = point[0] + direction[0], nextJ = point[1] + direction[1];
        while (nextI >= 0 && nextI < m && nextJ >= 0 && nextJ < n) {
            if (board[nextI][nextJ] == 'X') {
                return true;
            } else if (board[nextI][nextJ] == '.') {
                return false;
            }

            nextI += direction[0];
            nextJ += direction[1];
        }

        return false;
    }
}

References

LCP 41. 黑白翻转棋