题目大意

已知一个 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[i][j][k]表示位于位置(i,j)，走k步不出界的概率。
当能够走k+1步时，可以向8个方向分别走一步到达新位置，然后根据新位置上走k步不出界的结果，得到当前位置k+1步不出界的结果（求均值）。

class Solution {
private:
	vector<vector<int>> dirs = {{1, 2}, {-1, 2}, {1, -2}, {-1, -2}, {2, 1}, {-2, 1}, {2, -1}, {-2, -1}};
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)));

    	return step(N, r, c, dp, K);
    }

    double step(int N, int curX, int curY, vector<vector<vector<double>>> & dp, int curStep){
    	// 出界的话，概率为0
    	if(curX < 0 || curY < 0 || curX >= N || curY >= N)
    		return 0.;
		// 没出界，且走完了K步，则概率为1
    	if (curStep == 0)
    		return 1.;
		// 如果之前走过，则直接返回结果
    	if (dp[curX][curY][curStep] >= 1e-8)
    		return dp[curX][curY][curStep];
		// 遍历8个方向
    	for (auto dir : dirs){
    		dp[curX][curY][curStep] += step(N, curX + dir[0], curY + dir[1], dp, curStep - 1); 
    	}
    	dp[curX][curY][curStep] /= 8;
    	return dp[curX][curY][curStep];
    }
};

//改写成动态规划
class Solution {
private:
	vector<vector<int>> dirs = {{1, 2}, {-1, 2}, {1, -2}, {-1, -2}, {2, 1}, {-2, 1}, {2, -1}, {-2, -1}};

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步时，任何一个位置都不会出界，所以走0步时所有位置的概率都是1
    	for (int i = 0; i < N; ++i)
    		for(int j = 0; j < N; ++j)
    			dp[i][j][0] = 1.;
		// 遍历K步
    	for (int k = 1; k <=K; ++k){
    		// 遍历每一个位置
    		for (int i = 0; i < N; ++i){
    			for (int j = 0; j < N; ++j){
    				// 遍历8个方向
    				for (auto dir : dirs){
    					// 走出边界，概率为0
    					if (i + dir[0] < 0 || i + dir[0] >= N || j + dir[1] < 0 || j + dir[1] >= N)
    						dp[i][j][k] += 0;
    					else
    						dp[i][j][k] += dp[i + dir[0]][j + dir[1]][k - 1];
    				}
    				dp[i][j][k] /= 8;
					// 提前判断一下...... 有没有这个if（）都行
    				if (k == K && i == r && j == c)
    					return dp[i][j][k];
    			}
    		}
    	}
    	return dp[r][c][K];
    }
};