[H Game Theory] lc1728. Cat and Mouse II (Teoría de juegos + Búsqueda de memoria + Competición semanal 224_4)

1. Fuente del tema

Enlace: 1728. Gato y ratón II

2. Análisis de temas

La mayoría de los problemas de la teoría de los juegos de mesa se optimizan mediante la búsqueda de memoria . El espacio de estado efectivo no tanto, la mayoría de ellos breako returnafuera.

Ideas:

• Entender tanto al gato como al ratón bajo la estrategia óptima para ganar estado y el estado perdiendo sentido.
• Aquí kno puede ingresar al título hasta el límite máximo de 1000, de lo contrario, debido a las horas extraordinarias, calcule la cantidad de 100 millones ... Como resultado de esta búsqueda de memoria y adivine, el ciclo de la muerte debe ocurrir en aproximadamente 200 pasos, por lo que puedes conseguir 200 puntos de experiencia.
• En el proceso de transición del estado ganador del mouse, si el siguiente estado ocurre de modo que el mouse y el gato están en la misma posición, el estado actual del mouse debería ser anulado, pero este estado no es válido porque la transferencia actual es la ganadora. estado. El ratón no es un ratón tonto y no arrojará la red. Solo cuando no se puedan transferir todos los estados ganadores, el estado actual se juzgará como el estado de falla. Por lo tanto, si el siguiente estado no puede alcanzar el estado de falla, el estado actual se definirá directamente como el estado de falla. ¡Solo se necesita una transferencia del estado ganador! ¡Es importante entender esto!
• Al enumerar la dirección y la longitud del paso de la transición de estado, debe prestar atención a la multiplicación de la matriz de dirección descendente y el número de pasos.

La teoría de juegos es un problema de conocimiento realmente difícil, un lado un poco menos popular, desde la temporada de campo de la semana en el puesto 224 también se puede ver, la audiencia solo AKlos 22 chicos, por lo que la cuarta pregunta de una teoría de juegos fue bastante notable. Especialmente para problemas de teoría de juegos de tablero de ajedrez, ¡la búsqueda casi memorizada se ha convertido en una característica estándar!

Esta pregunta también es un problema de teoría de juegos muy clásico, ¡una buena pregunta!

---

• Complejidad del tiempo : $O(4n\times {norte}^{4}k)$。
• Complejidad espacial : $O\left(n^{4}k\right)$

Código:

int f[8][8][8][8][200];

class Solution {
    
    
public:
    int n, m, cj, mj;
    vector<string> g;
    int dx[4] = {
    
    -1, 0, 1, 0}, dy[4] = {
    
    0, 1, 0, -1};

    int dp(int cx, int cy, int mx, int my, int k) {
    
    
        if (k >= 200) return 0;
        auto& v = f[cx][cy][mx][my][k];

        if (v != -1) return v;  // 如果之前搜过 v 则直接返回
        if (k & 1) {
    
                // 奇数猫走，偶数老鼠走，题目要求老鼠先走
            for (int i = 0; i < 4; i ++ ) {
    
    
                for (int j = 0; j <= cj; j ++ ) {
    
    
                    int x = cx + dx[i] * j, y = cy + dy[i] * j;         // 下一个状态进行转移
                    if (x < 0 || x >= n || y < 0 || y >= m || g[x][y] == '#') break;  // 越界或撞墙均为无效转移
                    if (x == mx && y == my) return v = 0;       // 抓到老鼠，猫必胜
                    if (g[x][y] == 'F') return v = 0;           // 找到食物，猫必胜
                    if (!dp(x, y, mx, my, k + 1)) return v = 0; // 转移状态如果为猫必胜，则当前即为猫必胜
                }
            }
            return v = 1;      // 否则猫必败
        } else {
    
    
            for (int i = 0; i < 4; i ++ ) {
    
    
                for (int j = 0; j <= mj; j ++ ) {
    
    
                    int x = mx + dx[i] * j, y = my + dy[i] * j;
                    if (x < 0 || x >= n || y < 0 || y >= m || g[x][y] == '#') break;
                    if (x == cx && y == cy) continue;    // 如果老鼠走到猫的位置，这个状态不要转移，最优策略下为无效状态
                    if (g[x][y] == 'F') return v = 1;
                    if (dp(cx, cy, x, y, k + 1)) return v = 1; // 转移状态如果为老鼠必胜，则当前即为老鼠必胜
                }
            }
            return v = 0;
        }
    }

    bool canMouseWin(vector<string>& grid, int catJump, int mouseJump) {
    
    
        g = grid;
        n = g.size(), m = grid[0].size(), cj = catJump, mj = mouseJump;

        int cx, cy, mx, my;
        for (int i = 0; i < n; i ++ ) 
            for (int j = 0; j < m; j ++ )
                if (g[i][j] == 'C') cx = i, cy = j;
                else if (g[i][j] == 'M') mx = i, my = j;
        memset(f, -1, sizeof f);
        return dp(cx, cy, mx, my, 0);
    }
};