停在原地的方案数(动态规划)

停在原地的方案数 | 动态规划

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

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

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

由于答案可能会很大，请返回方案数 模 10^9 + 7 后的结果。
链接：https://leetcode-cn.com/problems/number-of-ways-to-stay-in-the-same-place-after-some-steps
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目分析：

对于计算方案数的题目，常用的方法是动态规划。

不妨定义数组 dp[ i ] [ j ] 存储记录第 i 步时，指针位于下标为 j 的方案数。

（其中 0 ≤ i ≤ steps，0 ≤ j ≤ arrLen - 1，而其中最多走 steps 步，故 j = min {arrLen - 1，steps}）

当没有进行任何操作时，指针一定位于下标 0，因此动态规划的边界条件是 dp[0] [0] = 1;

当 1 ≤ j ≤ arrLen - 1 的时候，dp[0] [ j ] = 0；

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

故可以得到动态转移方程：

dp[ i ] [ j ] = dp[ i - 1] [ j - 1] + dp[i - 1] [ j ] + dp[ i - 1] [ j + 1]

（注意：这里可能会存在疑问：为什么 dp[ i ] [ j ]的方案数不统计 dp[ i + 1] [ k ]能到达其的方案数。

***原因：由题目可知统计的是第 i 步时的方案数，如果加上 dp[ i + 1] [ k ]的方案数，实际上应该是 dp[ i + 2] [ k ]的方案数！***）

与此同时，还要注意数组的界限，不能超出数组的边界，因而需要添加判断条件，避免下标越界。

class Solution {
    public int numWays(int steps, int arrLen) {
        final int MODULO = 1000000007;
        int maxColumn = Math.min(arrLen - 1, steps);
        int[][] dp = new int[steps + 1][maxColumn + 1];
        dp[0][0] = 1;
        for (int i = 1; i <= steps; i++) {
            for (int j = 0; j <= maxColumn; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j - 1 >= 0) {
                    dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % MODULO;
                }
                if (j + 1 <= maxColumn) {
                    dp[i][j] = (dp[i][j] + dp[i - 1][j + 1]) % MODULO;
                }
            }
        }
        return dp[steps][0];
    }
}

---

代码改进

我们记录数据采用的是二维数组，造成了空间的浪费，例如：当 1 ≤ j ≤ arrLen - 1 的时候，dp[0] [ j ] = 0；

我们再分析题目结果可以看出，dp[ i ] [ j ] 的值仅与上一行有关，即：dp 的每一行只和上一行有关，故可以降低空间复杂度。

class Solution {
    public int numWays(int steps, int arrLen) {
        final int MODULO = 1000000007;
        int maxColumn = Math.min(arrLen - 1, steps);
        int[] dp = new int[maxColumn + 1];
        dp[0] = 1;
        for (int i = 1; i <= steps; i++) {
            int[] dpNext = new int[maxColumn + 1];
            for (int j = 0; j <= maxColumn; j++) {
                dpNext[j] = dp[j];
                if (j - 1 >= 0) {
                    dpNext[j] = (dpNext[j] + dp[j - 1]) % MODULO;
                }
                if (j + 1 <= maxColumn) {
                    dpNext[j] = (dpNext[j] + dp[j + 1]) % MODULO;
                }
            }
            dp = dpNext;
        }
        return dp[0];
    }
}