谷歌面试官必问的动态规划，这回有答案了！

谷歌面试题：停在原地的方案数2

描述
有一个长度为 arrLen 的数组，开始有一个指针在索引 0 处。
每一步操作中，你可以将指针向左或向右移动 1 步，或者停在原地（指针不能被移动到数组范围外）。
给你两个整数 steps 和 arrLen ，请你计算并返回：在恰好执行 steps 次操作以后，指针仍然指向索引 0 处的方案数。
由于答案可能会很大，请返回方案数 模 109+7 后的结果。

• 1≤steps≤500
• 1≤arrLen≤106

在线评测地址

样例1

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

样例 2：

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

样例 3：

输入：
4
2
输出：
8

解题思路
相比于题目1835中，steps = 15的情况，这道题目的数据范围大得多，所以不好用深度优先搜索解决。
题目让我们计算走steps步后，留在0位置的方案数。我们可以将步数和所停留的位置，抽象成一种状态。当在这种状态时，能够走到的方案数是多少。而且如果已知走第i步的所有状态，我们就能通过状态转移方程，O(1)时间内，计算出第i + 1步的某个状态。第i + 1步的状态也不能影响第i步的状态。这满足了动态规划的无后效性。
如果计算所有步数和位置的话，那么复杂度规模将会达到O(steps * arrLen)。还是不够优秀。可以发现steps的最大值远小于arrLen的最大值，说明有很多位置是不会被访问到的，所以令furthestPos为最远能走到位置，极端情况下，复杂度规模将会是O(steps * steps)。

代码思路

1. 设dp(i, j)为走i步，且走到j位置的方案数。
2. 令furthestPos等于min(steps/2, arrLen - 1)，代表最远能走到的位置。令dp数组的size为steps * furthestPos。
3. dp(0, 0) 初始化为 1，代表走 0 步在 0 位置的方案数是 1
4. 状态转移
   -对于dp(i, j)，如果j > 0，加上dp(i - 1, j - 1)的值。
   -对于dp(i, j)，如果j < furthestPos，加上dp(i - 1, j + 1)的值。
   -dp(i, j)加上dp(i - 1, j)的值。
5. 返回dp(steps, 0)，代表走steps步到0位置的方案数。

复杂度分析
设能走的步数为N，数组的长度为L。
时间复杂度

• 状态空间的规模为N * min(N, L)，每个状态可以在O(1)时间内转移得到，时间复杂度为O(N * min(N, L))。
  空间复杂度
• 状态空间的规模为N * min(N, L)，空间复杂度为O(N * min(N, L))。
• 在这个基础上，通过题目性质可以看出，走第i步的状态只与第i - 1步有关，所以我们计算第i步的所有状态时，可以只保留第i - 1步时所有的状态；同样的，计算第i + 1步时，保留第i步的状态，并丢弃掉第i - 1步时的状态。所以可以将空间优化到O(min(N, L))的时间范围内。这称为滚动数组优化。

源代码

public class Solution {
    /**
     * @param steps: steps you can move
     * @param arrLen: the length of the array
     * @return: Number of Ways to Stay in the Same Place After Some Steps
     */
    public int numWays(int steps, int arrLen) {
        final int MOD = 1000000007;
        // 最远能走到的位置
        int furthestPos = Math.min(steps/2, arrLen - 1);
        
        int[][] dp = new int[steps + 1][furthestPos + 1];
        // 将 dp(0, 0) 初始化为 1，代表走 0 步在 0 位置的方案数是 1
        dp[0][0] = 1;
        
        for (int i = 1; i <= steps; i++) {
            for (int j = 0; j <= furthestPos; j++) {
                // 加上从第 i - 1 步向右走到 j 的方案数
                if (j > 0) {
                    dp[i][j] += dp[i - 1][j - 1];
                    dp[i][j] %= MOD;
                }
                // 加上从第 i - 1 步向左走到 j 的方案数
                if (j < furthestPos) {
                    dp[i][j] += dp[i - 1][j + 1];
                    dp[i][j] %= MOD;
                }
                // 加上站在原地的方案数
                dp[i][j] += dp[i - 1][j];
                dp[i][j] %= MOD;
            }
        }
        
        return dp[steps][0];
    }
}

更多题解参考