leetcode 688. “马”在棋盘上的概率（dp & 记忆化搜索DFS）

已知一个 NxN 的国际象棋棋盘，棋盘的行号和列号都是从 0 开始。即最左上角的格子记为 (0, 0)，最右下角的记为 (N-1, N-1)。 

现有一个 “马”（也译作 “骑士”）位于 (r, c) ，并打算进行 K 次移动。 

如下图所示，国际象棋的 “马” 每一步先沿水平或垂直方向移动 2 个格子，然后向与之相垂直的方向再移动 1 个格子，共有 8 个可选的位置。

 

 

现在 “马” 每一步都从可选的位置（包括棋盘外部的）中独立随机地选择一个进行移动，直到移动了 K 次或跳到了棋盘外面。

求移动结束后，“马” 仍留在棋盘上的概率。

 

示例：

输入: 3, 2, 0, 0
输出: 0.0625
解释: 
输入的数据依次为 N, K, r, c
第 1 步时，有且只有 2 种走法令 “马” 可以留在棋盘上（跳到（1,2）或（2,1））。对于以上的两种情况，各自在第2步均有且只有2种走法令 “马” 仍然留在棋盘上。
所以 “马” 在结束后仍在棋盘上的概率为 0.0625。

解题思路：首先确定几维状态，棋盘是二维的 ，还有 步数也是一维（并且 在本题中 八个方向 很明显的状态方程，所以一定要有体现 ），所以我们至少 三维 来定义 状态

   状态 dp[x][y][k] : 处于位置 [x,y] ,步数为 k 处于 棋盘上的概率

 状态转换 dp[x][y][k] = sum(dp[x+dir[d][0]][y+dir[d][0]][k]) /8 ;  0<=d<8

初始化  dp[x][y][0] =1 : （因为 棋盘上的点都在棋盘上）

class Solution {
public:
    int dir[8][2] = {{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2},{1,-2},{2,-1}};
    bool Judge(int x,int y,int N){
        if(x>=0&&x<N&&y>=0&&y<N)
            return true;
        return false;
    }
    double knightProbability(int N, int K, int r, int c) {
        if(K<=0) return 1.0;
        if(N<0 || r<0 || r>=N || c<0 || c>=N)
             return 0.0;
        double dp[26][26][102];
        for(int i=0;i<N;i++)
            for(int j=0;j<N;j++)
                dp[i][j][0] = 1.0;
        for(int k=1;k<=K;k++)  // 一定要从k =1 开始遍历 因为初始情况 dp[i][j][0] 是已知的                    
              for(int i=0;i<N;i++)
                for(int j=0;j<N;j++){
                    double tmp = 0;
                    for(int d=0;d<8;d++){
                        int tmpx = i + dir[d][0];
                        int tmpy = j + dir[d][1];
                        if(Judge(tmpx,tmpy,N)){
                            tmp += dp[tmpx][tmpy][k-1];
                        }
                    }
                    dp[i][j][k] = tmp / 8.0;
                }
        return dp[r][c][K];
    }
};

 

 

思路二 记忆化DFS 思路同上 就是 实现不一向

class Solution {
public:
    int dir[8][2] = {{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2},{1,-2},{2,-1}};
    bool Judge(int x,int y,int N){
        if(x>=0&&x<N&&y>=0&&y<N)
            return true;
        return false;
    }
    double DFS(vector<vector<vector<double>>> &dp,int N,int k,int r,int c){
        if(!Judge(r,c,N)) return 0;  //出边界了 返回0
        if(k==0) //走完了 发现还在 棋盘里面 返回 1
            return 1;
        
        if(dp[r][c][k]!=-1)//已经计算过
            return dp[r][c][k];
        else{
            double tmp = 0;
            for(int i=0;i<8;i++){
            // if(dp[r+dir[i][0]][c+dir[i][1]][k-1]!= -1)  
                // tmp += dp[r+dir[i][0]][c+dir[i][1]][k-1];
            // else
                tmp +=DFS(dp,N,k-1,r+dir[i][0],c+dir[i][1]);
            }
            dp[r][c][k] = tmp / 8.0;
        }
        
        
        return dp[r][c][k];

    }
    double knightProbability(int N, int K, int r, int c) {
        if(K<=0) return 1.0;
        if(N<0 || r<0 || r>=N || c<0 || c>=N)
             return 0.0;
        vector<vector<vector<double>>> dp(N, vector<vector<double>>(N, vector<double>(K+1, -1)));
        
        return DFS(dp,N,K,r,c);
    }
};