详解线性 DP 解法，以及两个「可优化」的点

题目描述

这是 LeetCode 上的 1269. 停在原地的方案数 ，难度为困难。

Tag : 「线性 DP」

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

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

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

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

示例 1：

输入：steps = 3, arrLen = 2

输出：4

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

示例 2：

输入：steps = 2, arrLen = 4

输出：2

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

示例 3：

输入：steps = 4, arrLen = 2

输出：8

提示：

1 <= steps <= 500
1 <= arrLen <=

动态规划

这道题的可变维度分析不算复杂，因此这次就不从 DFS 开始给大家分析了。

定义代表当前剩余操作数为，所在位置为的所有方案数。

起始位置为，操作次数为，即有初始化条件，则是我们的最终答案。

不失一般性的考虑可以由哪些状态转移而来：

由「原地」操作到达当前状态，消耗一次操作，此时由状态转移而来
由「向左」操作到达当前状态，消耗一次操作，此时由状态转移而来
由「向右」操作到达当前状态，消耗一次操作，此时由状态转移而来

求的是方案数，即最终的为三者累加值。

同时我们发现依赖于，因此我们需要按照「从大到小」的顺序进行转移。

同时我们根据「最终回到下标位置」可以推断出，最远到达的位置为（再远就回不来了）。将最远到达位置与数组最大下标取即可确定维度的范围。

代码：

class Solution {
    int mod = (int)1e9+7;
    public int numWays(int steps, int len) {
        int max = Math.min(steps / 2, len - 1);
        int[][] f = new int[steps + 1][max + 1];
        f[steps][0] = 1;
        for (int i = steps - 1; i >= 0; i--) {
            for (int j = 0; j <= max; j++) {
                f[i][j] = (f[i][j] + f[i + 1][j]) % mod;
                if (j - 1 >= 0) f[i][j] = (f[i][j] + f[i + 1][j - 1]) % mod;
                if (j + 1 <= max) f[i][j] = (f[i][j] + f[i + 1][j + 1]) % mod;
            }
        }
        return f[0][0];
    }
}

时间复杂度：共有数量级为个的状态需要被转移。复杂度为
空间复杂度：

优化

1. 对时间复杂度进行「常数级别的优化」

并不依赖于操作次数同为的其他位置的状态，而只依赖于操作次数为的特定位置的状态。同理其他状态也是。

因此我们会发现随着「可操作次数」的减少，「可达到的最远位置」下标也会逐步缩小。从目标状态进行倒推的话，会发现「可达到的最远位置」等于「可操作次数」。

所以其实可以从两者取一个就能够有效减少「无效状态」的计算。数据量越大，这个性质带来的剪枝效果越好。

PS. 为了方便你看到优化前后的差别，我增加了打印注释，使用测试数据 (500, 100000) 并打开注释，可以看到少计算了多少「无效状态」。

详解线性 DP 解法，以及两个「可优化」的点｜Java_数组

代码：

class Solution {
    int mod = (int)1e9+7;
    public int numWays(int steps, int len) {
        int max = Math.min(steps / 2, len - 1);
        int[][] f = new int[steps + 1][max + 1];
        f[steps][0] = 1;
        for (int i = steps - 1; i >= 0; i--) {
            int edge = Math.min(i, max);
            // if (edge != max) System.out.println(edge + " " + max);
            for (int j = 0; j <= edge; j++) {
                f[i][j] = (f[i][j] + f[i + 1][j]) % mod;
                if (j - 1 >= 0) f[i][j] = (f[i][j] + f[i + 1][j - 1]) % mod;
                if (j + 1 <= max) f[i][j] = (f[i][j] + f[i + 1][j + 1]) % mod;
            }
        }
        return f[0][0];
    }
}

时间复杂度：共有数量级为个的状态需要被转移。复杂度为
空间复杂度：

2. 对空间复杂度进行「维度级别的优化」

这个优化思维难度就要低很多了，利用依赖于，使用「滚动数组」方式进行优化即可。

详解线性 DP 解法，以及两个「可优化」的点｜Java_时间复杂度_02

代码：

class Solution {
    int mod = (int)1e9+7;
    public int numWays(int steps, int len) {
        int max = Math.min(steps / 2, len - 1);
        int[][] f = new int[2][max + 1];
        f[steps&1][0] = 1;
        for (int i = steps - 1; i >= 0; i--) {
            int edge = Math.min(i, max);
            int a = i & 1, b = (i + 1) & 1;
            for (int j = 0; j <= edge; j++) {
                f[a][j] = 0;
                f[a][j] = (f[a][j] + f[b][j]) % mod;
                if (j - 1 >= 0) f[a][j] = (f[a][j] + f[b][j - 1]) % mod;
                if (j + 1 <= max) f[a][j] = (f[a][j] + f[b][j + 1]) % mod;
            }
        }
        return f[0][0];
    }
}