LeetCodeDFS游戏-祖玛游戏&扫雷游戏

488. 祖玛游戏（回溯） 

你正在参与祖玛游戏的一个变种。

在这个祖玛游戏变体中，桌面上有 一排 彩球，每个球的颜色可能是：红色 'R'、黄色 'Y'、蓝色 'B'、绿色 'G' 或白色 'W' 。你的手中也有一些彩球。

你的目标是 清空 桌面上所有的球。每一回合：

从你手上的彩球中选出 任意一颗 ，然后将其插入桌面上那一排球中：两球之间或这一排球的任一端。
接着，如果有出现 三个或者三个以上 且 颜色相同 的球相连的话，就把它们移除掉。
如果这种移除操作同样导致出现三个或者三个以上且颜色相同的球相连，则可以继续移除这些球，直到不再满足移除条件。
如果桌面上所有球都被移除，则认为你赢得本场游戏。
重复这个过程，直到你赢了游戏或者手中没有更多的球。
给你一个字符串 board ，表示桌面上最开始的那排球。另给你一个字符串 hand ，表示手里的彩球。请你按上述操作步骤移除掉桌上所有球，计算并返回所需的 最少 球数。如果不能移除桌上所有的球，返回 -1 。

---

方法：没有什么好方法，只能暴力搜索，每一轮试着将手上任一球扔到图上任一位置，如果可以清空board，记录扔出球数，最后返回所有球数中的最小值

class Solution {
    int INF = 0x3f3f3f3f;
    String b;
    int m;
    Map<String, Integer> map = new HashMap<>();
    public int findMinStep(String a, String _b) {
        b = _b;
        m = b.length();
        int ans = dfs(a, 1 << m);
        return ans == INF ? -1 : ans;
    }
    int dfs(String a, int cur) {
        if (a.length() == 0) return 0;
        if (map.containsKey(a)) return map.get(a);
        int ans = INF;
        int n = a.length();
        for (int i = 0; i < m; i++) {
            if (((cur >> i) & 1) == 1) continue;
            int next = (1 << i) | cur;
            for (int j = 0; j <= n; j++) {
                boolean ok = false;
                if (j > 0 && j < n && a.charAt(j) == a.charAt(j - 1) && a.charAt(j - 1) != b.charAt(i)) ok = true;
                if (j < n && a.charAt(j) == b.charAt(i)) ok = true;
                if (!ok) continue;
                StringBuilder sb = new StringBuilder();
                sb.append(a.substring(0, j)).append(b.substring(i, i + 1));
                if (j != n) sb.append(a.substring(j));
                int k = j;
                while (0 <= k && k < sb.length()) {
                    char c = sb.charAt(k);
                    int l = k, r = k;
                    while (l >= 0 && sb.charAt(l) == c) l--;
                    while (r < sb.length() && sb.charAt(r) == c) r++;
                    if (r - l - 1 >= 3) {
                        sb.delete(l + 1, r);
                        k = l >= 0 ? l : r; 
                    } else {
                        break;
                    }
                }
                ans = Math.min(ans, dfs(sb.toString(), next) + 1);
            }
        }
        map.put(a, ans);
        return ans;
    }
}

---

529. 扫雷游戏（DFS）

让我们一起来玩扫雷游戏！

给你一个大小为 m x n 二维字符矩阵 board ，表示扫雷游戏的盘面，其中：

'M' 代表一个 未挖出的 地雷，
'E' 代表一个 未挖出的 空方块，
'B' 代表没有相邻（上，下，左，右，和所有4个对角线）地雷的 已挖出的 空白方块，
数字（'1' 到 '8'）表示有多少地雷与这块 已挖出的 方块相邻，
'X' 则表示一个 已挖出的 地雷。
给你一个整数数组 click ，其中 click = [clickr, clickc] 表示在所有 未挖出的 方块（'M' 或者 'E'）中的下一个点击位置（clickr 是行下标，clickc 是列下标）。

根据以下规则，返回相应位置被点击后对应的盘面：

如果一个地雷（'M'）被挖出，游戏就结束了- 把它改为 'X' 。
如果一个 没有相邻地雷 的空方块（'E'）被挖出，修改它为（'B'），并且所有和其相邻的 未挖出 方块都应该被递归地揭露。
如果一个 至少与一个地雷相邻 的空方块（'E'）被挖出，修改它为数字（'1' 到 '8' ），表示相邻地雷的数量。
如果在此次点击中，若无更多方块可被揭露，则返回盘面。

简单模拟，DFSBFS都可以，但我选择DFS

代码一：这段代码会爆栈，可以自己看看试试，找一找错误在哪里

class Solution {
    int[] dirX = {0, 1, 0, -1, 1, 1, -1, -1};
    int[] dirY = {1, 0, -1, 0, 1, -1, 1, -1};

    public char[][] updateBoard(char[][] board, int[] click) {
        int x = click[0], y = click[1];
        if (board[x][y] == 'M') {
            // 规则 1，点到雷改为X退出游戏
            board[x][y] = 'X';
        } else if (board[x][y] == 'E') {
            // 只有当点的是未被访问过的格子E才进入递归和判断
            dfs(board, x, y);
        }
        return board;
    }

    void dfs(char[][] board, int x, int y) {
        int cnt = 0;
        // 计算当前格子的八个方向里有几个雷
        for(int i=0;i<8;i++){
            int dx=x+dirX[i],dy=y+dirY[i];
        //考虑是否越界
            if(dx<0||dy<0||dx>=board.length||dy>=board[0].length)continue;
            if(board[dx][dy]=='M'){
                cnt++;
            }
        }
        //周边有雷，不能点开更多
        if(cnt!=0){
            board[x][y]=(char)('0'+cnt);
        }else{//中心位置无雷，遍历四周
            board[x][y]='B';
            for(int i=0;i<8;i++){
                int dx=x+dirX[i],dy=y+dirY[i];
                //是否越界(错误点)
                if(dx<0||dy<0||dx>=board.length||dy>=board[0].length)continue;
                dfs(board, dx, dy);
            }
        }
        return;
    }
}

错误的原因是dfs的时候，必须要考虑到目标点是否已经翻面，如果已经翻面就不再考虑，否则将会无限循环

 代码改成这样即可，只处理未翻面的区域

            board[x][y]='B';
            for(int i=0;i<8;i++){
                int dx=x+dirX[i],dy=y+dirY[i];
                if(dx<0||dy<0||dx>=board.length||dy>=board[0].length)continue;
                if(board[dx][dy]=='E')dfs(board, dx, dy);
            }