有一个长度为 arrLen 的数组，开始有一个指针在索引 0 处。

每一步操作中，你可以将指针向左或向右移动 1 步，或者停在原地（指针不能被移动到数组范围外）。

给你两个整数 steps 和 arrLen ，请你计算并返回：在恰好执行 steps 次操作以后，指针仍然指向索引 0 处的方案数。

由于答案可能会很大，请返回方案数 模 10^9 + 7 后的结果。

示例1：

  1. 输入：steps = 3, arrLen = 2
  2. 输出：4
  3. 解释：3 步后，总共有 4 种不同的方法可以停在索引 0 处。
  4. 向右，向左，不动
  5. 不动，向右，向左
  6. 向右，不动，向左
  7. 不动，不动，不动

示例2：

  1. 输入：steps = 2, arrLen = 4
  2. 输出：2
  3. 解释：2 步后，总共有 2 种不同的方法可以停在索引 0 处。
  4. 向右，向左
  5. 不动，不动

示例3：

  1. 输入：steps = 4, arrLen = 2
  2. 输出：8

提示：

  1. 1 <= steps <= 500
  2. 1 <= arrLen <= 10^6

定义：\(dp[i][j]\)表示走i步到达j处的方案数。

状态转移方程：\(dp[i][j]=dp[i-1][j-1]+dp[i-1][j]+dp[i-1][j+1]\)。

边界条件：\(dp[0][0]=1\)。

时间复杂度：\(O(steps*min(arrlen,steps//2))\)

  1. var numWays = function(steps, arrLen) {
  2.     const MODULO = 1000000007;
  3.     let maxColumn = Math.min(arrLen - 1, ~~(steps/2));
  4.     const dp = new Array(steps + 1).fill(0).map(() => new Array(maxColumn + 1).fill(0));
  5.     dp[0][0] = 1;
  6.     for (let i = 1; i <= steps; i++) {
  7.         let min = Math.min(i, maxColumn);
  8.         for (let j = 0; j <= min; j++) {
  9.             dp[i][j] = dp[i - 1][j];
  10.             if (j - 1 >= 0) {
  11.                 dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % MODULO;
  12.             }
  13.             if (j + 1 <= min) {
  14.                 dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % MODULO;
  15.             }
  16.         }
  17.     }
  18.     return dp[steps][0];
  19. };

版权声明：本文为krnl-dpr原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/krnl-dpr/p/14766246.html