[路飞]_688. 骑士在棋盘上的概率688. 骑士在棋盘上的概率在一个 n x n 的国际象棋棋盘上，一个骑士从单元

「这是我参与2022首次更文挑战的第31天，活动详情查看：2022首次更文挑战」

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

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

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

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

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

示例1

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

示例2

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

提示

1 <= n <= 25
0 <= k <= 100
0 <= row, column <= n

题解

DFS （非正确思路）

第一次读题，这不是很简单， $DFS$ 计算骑士行走 $K$ 步后依然在棋盘上的骑士数。得到的数除以总数 $k ^ 8$ 答案不就出来了？

思路简单明确，代码很快就搞定了，如下代码所示。提交，运行。

var knightProbability = function (n, k, row, column) {
  const r = [1, 1, 2, 2, -1, -1, -2, -2];
  const c = [2, -2, 1, -1, 2, -2, 1, -1];
  let count = 0;
  dfs(row, column, 0);
  return count / Math.pow(8, k);
  function dfs(i, j, level) {
    if (level === k) {
      count++;
      return;
    }
    for (let k = 0; k < 8; k++) {
      const x = i + r[k];
      const y = j + c[k];
      if (x < n && x >= 0 && y >= 0 && y < n) {
        dfs(x, y, level + 1);
      }
    }
  }
};

超出时间限制,大写的尴尬。感觉思路没有问题啊？仔细一看时间复杂度: $O(8^k)$

这么看思路没问题，就是时间复杂度有点高。考虑降低一下时间复杂度 DFS 还能用

时间复杂度过高，向空间上考虑，空间换时间常见的优化时间复杂度方式

动态规划（DFS+额外空间+记忆化搜索）

起初准备用 $n * n$ 的二维数组记录骑士在棋盘上每个位置可能出现的次数,仔细考虑不行，如果是二维数组，无法记录具体哪一步走到了棋盘上的某个位置。毕竟骑士只能走 k 步；所以需要一个 $k * n * n$ 的三维数组
如果当前位置骑士到达过：状态转移方程：

$dp[k][i][j] = dp[k][i][j] + 1/8 * dfs[k-1][x][y]$

$x,y$ 表示当前骑士可以来的地方，可能从8个方向来。八个方向记录在数组 $r,c$ 中

  const r = [1, 1, 2, 2, -1, -1, -2, -2];
  const c = [2, -2, 1, -1, 2, -2, 1, -1];

根据动态规划思路，使用DFS+记忆化搜索编辑代码如下：

var knightProbability = function (n, k, row, column) {
  const r = [1, 1, 2, 2, -1, -1, -2, -2];
  const c = [2, -2, 1, -1, 2, -2, 1, -1];
  const dp = [];
  for (let i = 0; i <= k; i++) {
    dp[i] = [];
    for (let j = 0; j < n; j++) {
      dp[i][j] = [];
      for (let l = 0; l < n; l++) {
        dp[i][j][l] = 0;
      }
    }
  }
  return dfs(row, column, k);

  function dfs(i, j, level) {
      // 如果上一步是在棋盘外，返回0
    if (i >= n || i < 0 || j >= n || j < 0) return 0;
    
    // 骑士第一步，一定是在期盼内
    if (level === 0) return 1;
    
    // 骑士来过，直接返回。这不就是DFS的剪枝操作吗？
    if (dp[level][i][j]) return dp[level][i][j];
    
    
    for (let p = 0; p < 8; p++) {
      const x = i + r[p];
      const y = j + c[p];
      
      // 上下左右八个方向搜索骑士的来历和概率
      dp[level][i][j] += dfs(x, y, level - 1) * 0.125;
    }
    
    // 返回骑士存在棋盘的概率
    return dp[level][i][j];
  }
};