动态规划入门

动态规划入门

参考资料:

Hello算法 动态规划
灵神 动态规划入门：从记忆化搜索到递推

「动态规划 dynamic programming」是一个重要的算法范式，它将一个问题分解为一系列更小的子问题，并通过存储子问题的解来避免重复计算，从而大幅提升时间效率。

启发思路: 选或不选 / 选哪个
把原问题变成一个和原问题相似的、规模更小的子问题

回溯三问?
当前操作: 枚举第 i 个选 / 不选
子问题: 从前 i 个获得结果
下一个子问题: dp方程

给定一个共有 \(n\) 阶的楼梯，你每步可以上 \(1\) 阶或者 \(2\) 阶，请问有多少种方案可以爬到楼顶？

通过回溯来穷举所有可能性

/* 标准回溯模板 */
void backtrack(vector<int> &choices, int state, int n, vector<int> &res) {
    // 当爬到第 n 阶时，方案数量加 1
    if (state == n)
        res[0]++;
    // 遍历所有选择
    for (auto &choice : choices) {
        // 剪枝：不允许越过第 n 阶
        if (state + choice > n)
            continue;
        // 尝试：做出选择，更新状态
        backtrack(choices, state + choice, n, res);
        // 回退
    }
}

/* 爬楼梯：回溯 */
int climbingStairsBacktrack(int n) {
    vector<int> choices = {1, 2}; // 可选择向上爬 1 阶或 2 阶
    int state = 0;                // 从第 0 阶开始爬
    vector<int> res = {0};        // 使用 res[0] 记录方案数量
    backtrack(choices, state, n, res);
    return res[0];
}	

暴力搜索

回溯算法通常并不显式地对问题进行拆解，而是将求解问题看作一系列决策步骤，通过试探和剪枝，搜索所有可能的解。

我们可以尝试从问题分解的角度分析这道题。各个子问题之间存在递推关系，原问题的解可以由子问题的解构建得来。

int dfs(int i) {
    // 已知 dp[1] 和 dp[2] ，返回之
    if (i == 1 || i == 2)
        return i;
    // dp[i] = dp[i-1] + dp[i-2]
    int count = dfs(i - 1) + dfs(i - 2);
    return count;
}

/* 爬楼梯：搜索 */
int climbingStairsDFS(int n) {
    return dfs(n);
}

据递推公式 \(dp[i] = dp[i - 1] + dp[i - 2]\) 得到暴力搜索解法。以 \(dp[n]\) 为起始点，递归地将一个较大问题拆解为两个较小问题的和，直至到达最小子问题 \(dp[1]\) 和 \(dp[2]\) 时返回。其中，最小子问题的解是已知的。

暴力搜索形成的递归树，对于问题 \(dp[n]\)，其递归的深度为 \(n\)，时间复杂度为 \(O(2^n)\)，而这个指数阶的时间复杂度是“重叠子问题”导致的。

记忆化搜索

为了提升算法效率，我们希望所有的重叠子问题都只被计算一次。我们声明一个数组 mem 来记录每个子问题的解，并在搜索过程中将重叠子问题剪枝。

1. 当首次计算 \(dp[i]\) 时，我们将其存储在 mem[i]，以便之后使用。
2. 当再次需要计算 \(dp[i]\) 时，我们可以直接从 mem[i] 中获取结果，从而避免重复计算该子问题。

/* 记忆化搜索 */
int dfs(int i, vector<int> &mem) {
    // 已知 dp[1] 和 dp[2] ，返回之
    if (i == 1 || i == 2)
        return i;
    // 若存在记录 dp[i] ，则直接返回之
    if (mem[i] != -1)
        return mem[i];
    // dp[i] = dp[i-1] + dp[i-2]
    int count = dfs(i - 1, mem) + dfs(i - 2, mem);
    // 记录 dp[i]
    mem[i] = count;
    return count;
}

/* 爬楼梯：记忆化搜索 */
int climbingStairsDFSMem(int n) {
    // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
    vector<int> mem(n + 1, -1);
    return dfs(n, mem);
}

经过记忆化处理后，所有重叠子问题都只需计算一次，时间复杂度优化至 \(O(n)\)

注意：mem 数组的初始值一定不能等于要记忆化的值！例如初始值设置为 0 ，并且要记忆化的 dfs(i) 也等于 0，那就没法判断 0 到底表示第一次遇到这个状态，还是表示之前遇到过了，从而导致记忆化失效。一般把初始值设置为 −1。

由于每个状态只会计算一次，动态规划的时间复杂度 = 状态个数 \(\times\) 单个状态的计算时间。

动态规划

记忆化搜索是一种“从顶至底”的方法：
我们从原问题（根节点）开始，递归地将较大子问题分解为较小子问题，直至解已知的最小子问题（叶节点）。之后，通过回溯逐层收集子问题的解，构建出原问题的解。

与之相反，动态规划是一种“从底至顶”的方法：
从最小子问题的解开始，迭代地构建更大子问题的解，直至得到原问题的解。

由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无须使用递归。
(去掉递归中的「递」，只保留「归」的部分，即自底向上计算)

/* 爬楼梯：动态规划 */
int climbingStairsDP(int n) {
    if (n == 1 || n == 2)
        return n;
    // 初始化 dp 表，用于存储子问题的解
    vector<int> dp(n + 1);
    // 初始状态：预设最小子问题的解
    dp[1] = 1;
    dp[2] = 2;
    // 状态转移：从较小子问题逐步求解较大子问题
    for (int i = 3; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
}

与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的特定阶段，每个状态都对应一个子问题以及相应的局部最优解。

注意在状态转移方程中有可能会出现下标为负的情形 \(dp[i] = dp[i - 1] + dp[i - 2]\) ，所以我们可以选择在dp数组前前面插两个空位，即下标加 2 即可规避边界问题

空间优化

由于 dp[i] 只与 dp[i - 1] 和 dp[i - 2] 有关，因此我们无需使用一个数组 dp 来存储所有子问题的解，而只需两个变量滚动前进即可。

/* 爬楼梯：空间优化后的动态规划 */
int climbingStairsDPComp(int n) {
    if (n == 1 || n == 2)
        return n;
    int a = 1, b = 2;
    for (int i = 3; i <= n; i++) {
        int tmp = b;
        b = a + b;
        a = tmp;
    }
    return b;
}

观察以上代码，由于省去了数组 dp 占用的空间，因此空间复杂度从 \(O(n)\) 降至 \(O(1)\)