LeetCode 688. La probabilidad de un "caballo" en el tablero (DP)

Directorio de artículos

1. Título

Dado un NxNtablero de ajedrez, los números de fila y columna del tablero de ajedrez se basan en cero. Es decir, la esquina superior izquierda está marcada como (0, 0) y la esquina inferior derecha está marcada como (N-1, N-1).

Actualmente hay un "caballo" (también traducido como "caballero") ubicado (r, c)y tiene la intención de realizar K movimientos .

Como se muestra en la figura siguiente, el "caballo" del ajedrez se mueve 2 casillas en la dirección horizontal o vertical en cada paso, y luego se mueve 1 casilla en la dirección perpendicular a ella Hay un total de 8 posiciones opcionales.

Ahora el "caballo" selecciona aleatoriamente una de las posiciones opcionales (incluidas las que están fuera del tablero) para moverse en cada paso, hasta que se mueve K veces o salta fuera del tablero . (Nota de Blogger: no se puede retroceder desde afuera)

Encuentre la probabilidad de que el "caballo" permanezca en el tablero después del movimiento .

示例:
输入: 3, 2, 0, 0
输出: 0.0625
解释: 
输入的数据依次为 N, K, r, c
第 1 步时,有且只有 2 种走法令 “马” 
可以留在棋盘上(跳到(1,2)或(2,1))。
对于以上的两种情况,各自在第2步均有且只有2种走法令 “马” 仍然留在棋盘上。
所以 “马” 在结束后仍在棋盘上的概率为 0.0625。
 
注意:
N 的取值范围为 [1, 25]
K 的取值范围为 [0, 100]
开始时,“马” 总是位于棋盘上

Fuente: LeetCode (LeetCode)
Enlace: https://leetcode-cn.com/problems/knight-probability-in-chessboard Los
derechos de autor son propiedad de LeetCode . Para reimpresiones comerciales, comuníquese con la autorización oficial. Para reimpresiones no comerciales, indique la fuente.

2. Resolución de problemas

Temas similares: LeetCode 576. Número de rutas fuera de límites (programación dinámica)

  • dp[i][j][k]Representa la (i, j)probabilidad de permanecer cuando k supera oportunidades
class Solution {
    
    
public:
    double knightProbability(int N, int K, int r, int c) {
    
    
        vector<vector<vector<double>>> dp(N, vector<vector<double>>(N, vector<double>(K+1, 0.0)));
        dp[r][c][K] = 1.0;
        vector<vector<int>> dir = {
    
    {
    
    2,1},{
    
    1,2},{
    
    -2,1},{
    
    -1,2},{
    
    2,-1},{
    
    1,-2},{
    
    -1,-2},{
    
    -2,-1}};
        int i, j, k, x, y, d;
        for(k = K; k > 0; k--) 
        {
    
    
            for(i = 0; i < N; i++)
            {
    
    
                for(j = 0; j < N; j++)
                {
    
    
                    for(d = 0; d < 8; d++)
                    {
    
    
                        x = i + dir[d][0];
                        y = j + dir[d][1];
                        if(x>=0 && x<N && y>=0 && y<N)
                        {
    
    
                            dp[x][y][k-1] += dp[i][j][k]/8.0;
                        }
                    }
                }
            }
        }
        double ans = 0.0;
        for(i = 0; i < N; i++)
            for(j = 0; j < N; j++)
                ans += dp[i][j][0];
        return ans;
    }
};

28 ms 8 MB


Mi dirección de blog de CSDN https://michael.blog.csdn.net/

Mantenga presionado o escanee el código QR para seguir mi cuenta oficial (Michael Amin), ¡vengan juntos, aprendan y progresen juntos!
Michael Amin

Supongo que te gusta

Origin blog.csdn.net/qq_21201267/article/details/108913560
Recomendado
Clasificación