LeetCode #688 - Knight Probability in Chessboard

最新推荐文章于 2024-02-01 16:25:02 发布

LawFile

最新推荐文章于 2024-02-01 16:25:02 发布

阅读量162

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/LawFile/article/details/86685020

版权

LeetCode 专栏收录该内容

625 篇文章 1 订阅

订阅专栏

题目描述：

On an NxN chessboard, a knight starts at the r-th row and c-th column and attempts to make exactly K moves. The rows and columns are 0 indexed, so the top-left square is (0, 0), and the bottom-right square is (N-1, N-1).

A chess knight has 8 possible moves it can make, as illustrated below. Each move is two squares in a cardinal direction, then one square in an orthogonal direction.

Each time the knight is to move, it chooses one of eight possible moves uniformly at random (even if the piece would go off the chessboard) and moves there.

The knight continues moving until it has made exactly K moves or has moved off the chessboard. Return the probability that the knight remains on the board after it has stopped moving.

Example:

Input: 3, 2, 0, 0

Output: 0.0625

Explanation: There are two moves (to (1,2), (2,1)) that will keep the knight on the board.

From each of those positions, there are also two moves that will keep the knight on the board.

The total probability the knight stays on the board is 0.0625.

Note:

• N will be between 1 and 25.

• K will be between 0 and 100.

• The knight always initially starts on the board.

最直接的方法就是从给定坐标开始递归，往8个方向搜索，经过k层递归，时间复杂度是O(8^K)。更好的方法是迭代k次，每一次对于每一个坐标都产生8个新坐标，最终计算从棋牌上的棋子开始移动k次，共有多少种可能最终落在给定坐标上，时间复杂度是O(K*N^2)。

class Solution {
public:
       double knightProbability(int N, int K, int r, int c) {
        if(K==0) return 1;
        vector<vector<double>> dp(N,vector<double>(N,1)); // dp[i][j]表示整个棋盘的所有棋子经过移动之后，共有多少种可能落在(i,j)坐标上，因此需要迭代k次，每一次对于每一个坐标都有8种移动方法，初始化dp矩阵每个元素都是1。
        vector<vector<int>> moves={{2,1},{2,-1},{-1,2},{-1,-2},{1,-2},{1,2},{-2,1},{-2,-1}};
        for(int k=0;k<K;k++)
        {
            vector<vector<double>> temp(N,vector<double>(N,0)); // 必须要定义一个temp矩阵，在遍历完全部节点之后才能更新dp矩阵
            for(int i=0;i<N;i++)
            {
                for(int j=0;j<N;j++)
                {
                    for(auto move: moves)
                    {
                        int x=i+move[0];
                        int y=j+move[1];
                        if(x<0||x>=N||y<0||y>=N) continue;
                        else temp[x][y]+=dp[i][j];
                    }
                }
            }
            dp=temp;
        }
        double result=dp[r][c]/pow(8,K);
        return result;
    }
};