【每日一题Day244】LCP 41. 黑白翻转棋 bfs dfs-Toy模板网

这篇具有很好参考价值的文章主要介绍了【每日一题Day244】LCP 41. 黑白翻转棋 bfs dfs。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

LCP 41. 黑白翻转棋

在 n*m 大小的棋盘中，有黑白两种棋子，黑棋记作字母 "X", 白棋记作字母 "O"，空余位置记作 "."。当落下的棋子与其他相同颜色的棋子在行、列或对角线完全包围（中间不存在空白位置）另一种颜色的棋子，则可以翻转这些棋子的颜色。

思路

枚举棋盘中每一个未下棋的位置，求出在该位置下黑子时，能够反转的白子数目，取最大值返回即可。对于每一个位置需要求出八个方向末尾是黑子的连续白子数目，并且如果将一个白子反转为黑子后，还需要搜索该位置延伸出去能够翻转的白子数目，故而可以使用bfs或者dfs实现

bfs

实现

将每个方向的可以反转的白子加入队列中

class Solution {
    String[] chessboard;
    int[][] dirs = {{0, 1},{0, -1}, {1, 0}, {-1, 0}, {1, -1}, {1, 1},{-1, 1}, {-1, -1}};
    int m, n;
    public int flipChess(String[] chessboard) {
        m = chessboard.length;
        n = chessboard[0].length();
        this.chessboard = chessboard;
        int res = 0;
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++){
                if (chessboard[i].charAt(j) == '.'){
                    res = Math.max(res, bfs(i, j));
                }
            }
        }
        return res;
    }
    // 使用bsf搜索在位置(x,y)下黑子时,能够反转的白子数目
    // 将白子放入队列中，搜索八个方向末尾是黑子的连续白子数目
    // 如果下一个位置是白子，那么继续放入队列
    // 如果下一个位置是黑子，那么记录连续白子数目
    // 如果下一个位置没有子，那么忽略不计
    public int bfs(int x, int y){
        char[][] chess = new char[m][n];       
        for (int i = 0; i < m; i++){
            chess[i] = chessboard[i].toCharArray();
        }
        int res = 0;
        Deque<int[]> queue = new LinkedList<>();
        queue.addLast(new int[]{x, y});
        chess[x][y] ='X';
        while (!queue.isEmpty()){
            int[] loc = queue.pollFirst();
            x = loc[0];
            y = loc[1];
            for (int k = 0; k < 8; k++){
                int i = x + dirs[k][0] , j = y + dirs[k][1];

                while (i >= 0 && i < m && j >= 0 && j < n && chess[i][j] == 'O'){
                 
                    i += dirs[k][0];
                    j += dirs[k][1];
                    
                }
                if (i >= 0 && i < m && j >= 0 && j < n && chess[i][j] == 'X'){
                
                    i -= dirs[k][0];
                    j -= dirs[k][1];
                    res += Math.max(Math.abs(x - i), Math.abs(y - j));
                    while (x != i || y != j){
                        chess[i][j] = 'X';
                        queue.addLast(new int[]{i, j});
                        i -= dirs[k][0];
                        j -= dirs[k][1];
                    }
                    
                }
                
            }
        }
        
        return res;
    }
}

dfs

实现

使用额外数组记录每个方向可以反转的白子位置，再进行dfs文章来源地址https://www.toymoban.com/news/detail-494190.html

class Solution {
        char[][] cb;
        int m,n;
        int ans = 0;
        int[] directions = new int[]{-1,-1,0,1,1,-1,1,0,-1};
        public int flipChess(String[] chessboard) {
            m = chessboard.length;
            n = chessboard[0].length();

            this.cb = new char[m][n];
            for(int i = 0; i < m; i++){
                for(int j = 0; j < n; j++){
                    if(chessboard[i].charAt(j)=='.'){
                        for(int t = 0; t < m; t++){
                            cb[t] = chessboard[t].toCharArray();
                        }
                        ans = Math.max(ans,dfs(i,j));
                    }
                }
            }
            return ans;
        }

        private int dfs(int i, int j){
            List<int[]> nexts = new ArrayList<>();
            for(int index = 0; index < 8; index++){
                int x = i+directions[index];
                int y = j+directions[index+1];
                List<int[]> tmp = new ArrayList<>();
                while(x>=0&&x<m&&y>=0&&y<n&&cb[x][y]=='O'){
                    tmp.add(new int[]{x,y});
                    x+=directions[index];
                    y+=directions[index+1];
                }

                if(x>=0&&x<m&&y>=0&&y<n&&cb[x][y]=='X'){
                    nexts.addAll(tmp);
                }
            }

            for(int[] next:nexts){
                cb[next[0]][next[1]] = 'X';
            }

            int ans = nexts.size();
            for(int[] next:nexts){
                ans += dfs(next[0],next[1]);
            }

            return ans;
        }
    }

作者：钰娘娘丿-曱-乀
链接：https://leetcode.cn/problems/fHi6rV/solutions/2315793/yu-niang-niang-lcp-41-hei-bai-fan-zhuan-yv1s6/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。