LeetCode第688题骑士在棋盘上的概率

题目

在一个 n x n 的国际象棋棋盘上，一个骑士从单元格 (row, column) 开始，并尝试进行 k 次移动。行和列是从 0 开始的，所以左上单元格是 (0,0) ，右下单元格是 (n - 1, n - 1) 。
象棋骑士有8种可能的走法，如下图所示。每次移动在基本方向上是两个单元格，然后在正交方向上是一个单元格。
每次骑士要移动时，它都会随机从8种可能的移动中选择一种(即使棋子会离开棋盘)，然后移动到那里。
骑士继续移动，直到它走了 k 步或离开了棋盘。
返回骑士在棋盘停止移动后仍留在棋盘上的概率。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/knight-probability-in-chessboard
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

答案

答案一（动态规划）

class Solution {
    /**
     * 主体逻辑:
     *  对整个棋盘进行遍历,遍历每次结果的概率
     * @param n
     * @param k
     * @param row
     * @param column
     * @return
     */
    public double knightProbability(int n, int k, int row, int column) {
        if(!inBoard(row, column, n)){
            return 0.0;
        }
        if(k==0){
            return 1.0;
        }
        // 记录每一步共有多少情况
        int[] xs = new int[]{-2,-1,1,2,2,1,-1,-2};
        int[] ys = new int[]{-1,-2,-2,-1,1,2,2,1};
		//用于存储走了多少步后的状态
        double[][] begin = new double[n][n];
        double[][] after = new double[n][n];

        for (int i = 0; i < begin.length; i++) {
            for (int j = 0; j < begin.length; j++) {
                begin[i][j] = 1.0;
            }
        }
        for (int i = 0; i < k; i++) {
            for (int j = 0; j < begin.length; j++) {
                for (int l = 0; l < begin[j].length; l++) {
                    double num = 0;
                    for (int q = 0; q < xs.length; q++) {
                        int xNum = j + xs[q];
                        int yNum = l + ys[q];
                        if(inBoard(xNum, yNum, n)){
                            num += begin[xNum][yNum];
                        }
                    }
                    after[j][l] = num / (double)xs.length;
                }
            }
            double[][] dou = after;
            after = begin;
            begin = dou;
        }
        return begin[row][column];
    }
    public boolean inBoard(int row, int column, int n){
        return row < n && row >= 0 && column < n && column >= 0;
    }

}

初始化变量i用于记录走了几步，创建二维数组，在走了i步后，当前位置仍然在棋盘内的可能性，并且每一次的概率都与上一步后每个位置的概率有关，例如，第i步时坐标为（x，y）的点的概率为第i-1步时可以达到（x，y）位置的点的合计概率除以8（即可能的个数）。

答案一（动态规划）(相比于答案二极小幅度优化）

class Solution {
    /**
     * 主体逻辑:
     *  对整个棋盘进行遍历,遍历每次结果的概率
     * @param n
     * @param k
     * @param row
     * @param column
     * @return
     */
    public double knightProbability(int n, int k, int row, int column) {
        if(!inBoard(row, column, n)){
            return 0.0;
        }
        if(k==0){
            return 1.0;
        }
        int[] xs = new int[]{-2,-1,1,2,2,1,-1,-2};
        int[] ys = new int[]{-1,-2,-2,-1,1,2,2,1};
        double[][] begin = new double[n][n];
        double[][] after = new double[n][n];
        for (int i = 0; i < begin.length; i++) {
            for (int j = 0; j < begin.length; j++) {
                begin[i][j] = 1.0;
            }
        }
        for (int i = 0; i < k - 1; i++) {
            for (int j = 0; j < begin.length; j++) {
                for (int l = 0; l < begin[j].length; l++) {
                    double num = 0;
                    for (int q = 0; q < xs.length; q++) {
                        int xNum = j + xs[q];
                        int yNum = l + ys[q];
                        if(inBoard(xNum, yNum, n)){
                            num += begin[xNum][yNum];
                        }
                    }
                    after[j][l] = num / (double)xs.length;
                }
            }
            double[][] dou = after;
            after = begin;
            begin = dou;
        }

        double result = 0.0;
        for (int i = 0; i < xs.length; i++) {
            int x = row + xs[i];
            int y = column + ys[i];
            if(inBoard(x, y, n)){
                result += begin[x][y];
            }
        }
        return result / xs.length;
    }
    public boolean inBoard(int row, int column, int n){
        return row < n && row >= 0 && column < n && column >= 0;
    }
}