leetcode---- 688.骑士在棋盘上的概率（记忆化dfs和动态规划两种解法）

688.骑士在棋盘上的概率

问题：在一个 n x n 的国际象棋棋盘上，一个骑士从单元格 (row, column) 开始，并尝试进行 k 次移动。行和列是 从 0 开始 的，所以左上单元格是 (0,0) ，右下单元格是 (n - 1, n - 1) 。

象棋骑士有8种可能的走法，如下图所示。每次移动在基本方向上是两个单元格，然后在正交方向上是一个单元格。

每次骑士要移动时，它都会随机从8种可能的移动中选择一种(即使棋子会离开棋盘)，然后移动到那里。

骑士继续移动，直到它走了 k 步或离开了棋盘。

返回 骑士在棋盘停止移动后仍留在棋盘上的概率 。

示例：

输入: n = 3, k = 2, row = 0, column = 0
输出: 0.0625
解释: 有两步(到(1,2)，(2,1))可以让骑士留在棋盘上。
在每一个位置上，也有两种移动可以让骑士留在棋盘上。
骑士留在棋盘上的总概率是0.0625。

输入: n = 1, k = 0, row = 0, column = 0
输出: 1.00000

思路：

• 记忆化dfs

这种方法是最容易想到的，比较容易理解，就是模拟计算所给位置节点走k步留在棋盘上的概率，使用额外的数组来减少重复计算。代码如下：

class Solution {
    private Double[][][] memo;
    public double knightProbability(int n, int k, int row, int column) {
        memo = new Double[n][n][k + 1];
        return dfs(n , k, row, column);
    }
	
    //八个方向
    private int[][] dirs = new int[][]{{-2, -1}, {-1, -2}, {1, -2}, {2, -1}, {2, 1}, {1, 2}, {-1, 2}, {-2, 1}};
    private double dfs(int n, int k, int r, int c){
        //base case 出界，停留在棋盘上的概率为0
        if(r < 0 || r >= n || c < 0 || c >= n){
            return 0.0;
        }
        //base case 移动次数用完还在棋盘的情况
        if(k == 0){
            return 1.0;
        }
		
        //该节点已经计算过了
        if(memo[r][c][k] != null){
            return memo[r][c][k];
        }
        
        double p = 0.0;
        //计算当前节点移动 k步，还留在棋盘上的概率
        for(int[] dir : dirs){
            p += dfs(n, k - 1, r + dir[0], c + dir[1]);
        }
		
        //因为当前节点走向8个方向的概率是等概率的 
        p /= 8;
        memo[r][c][k] = p;
        return p;
    }
}

• 动态规划 当前状态的计算依赖于前面状态的计算

定义dp数组含义：dp[i][j][p]，表示从(i, j)位置走p步留在棋盘上的概率。是一种自底向上的计算方法。计算dp[i][j][p]时，走p-1步的八个方位的状态都已经计算出来了。

class Solution {
    public double knightProbability(int n, int k, int row, int column) {
        double[][][] dp = new double[n][n][k + 1];
		
        //边界，当前位置一步也不走留在棋盘上的概率为1
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                dp[i][j][0] = 1.0;

        int[][] dirs = new int[][]{{-2, -1}, {-1, -2}, {1, -2}, {2, -1}, {2, 1}, {1, 2}, {-1, 2}, {-2, 1}};

        for(int p = 1; p <= k; p++){
            for(int i = 0; i < n; i++){
                for(int j = 0; j < n; j++){
                    //状态转移
                    for(int[] dir: dirs){
                        int nr = i + dir[0];
                        int nc = j + dir[1];
                        if(nr < 0 || nr >= n || nc < 0 || nc >= n) continue;
                        dp[i][j][p] += dp[nr][nc][p - 1] / 8;
                    }
                }
            }
        }

        return dp[row][column][k];
    }
}

通过代码我们可以看到，当前状态只依赖于上一个状态，还可以采用二维数组进一步优化空间复杂度。

整理思路，记录博客，以便复习。若有误，望指正~