【算法基础】动态规划导论

本文为翻译文章
原文链接：https://cp-algorithms.com/dynamic_programming/intro-to-dp.html

动态规划导论

动态规划的关键是避免重复的计算。通常情况下，动态规划算法解决的问题可以用递归的方法解决。可以先尝试将问题写出最朴素的递归算法，再使用一个表来保存中间结果，这种属于自底向上的动态规划，或者叫做“记忆化搜索”。

一个最经典的例子就是求斐波那契数列。它的递归式是：当$n\ge 2$时，$f(n)=f(n-1)+f(n-2)$，$n=0$时$f(0)=0$，$n=1$时，$f(1)=1$。用C++来实现就是下面这样：

int f(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    return f(n - 1) + f(n - 2);
}

它的时间复杂度时$O(2^n)$，因为每一个$f(n)$的计算都要调用两次相似的规模的子问题（$f(n-1)$和$f(n-2)$）。

使用动态规划加速斐波那契数列（记忆化）

递归算法需要指数的时间来计算斐波那契数列。这意味着我们只能处理很小的一些输入。比如要计算$f(29)$需要超过一百万次函数调用。

为了加快计算速度，我们注意到子问题的规模仅仅是$O(n)$的。就是说，为了计算$f(n)$我们只需要知道$f(n-1),f(n-1),…,f(0) $。因此，相比于重复计算这些子问题，我们通过把这些问题的结果存在一个表中来避免重复的计算。已经计算过的子问题的调用可以通过这个表马上返回结果，避免了指数指数级别的调用次数。

每一次的调用都会先检查表中数据，这会花费$O(1)$的时间。如果我们之前已经计算过了，那就返回结果，否则，正常地计算。总共的时间复杂度是$O(n)$。相对于之前的算法来说是一个巨大的提升。

const int MAXN = 100;
bool found[MAXN];
int memo[MAXN];

int f(int n) {
    if (found[n]) return memo[n];
    if (n == 0) return 0;
    if (n == 1) return 1;

    found[n] = true;
    return memo[n] = f(n - 1) + f(n - 2);
}

使用记忆化搜索的方法，$f(29)$的计算只需要57次的调用。不过我们还要注意到这是结果的正确性还取决于我们使用的数据类型，在32位整数类型下，我们最多能计算第46位的斐波那契数。

通常情况下我们会在数组中保存着些数，因为在数组中查找的时间是$O(1)$。实际上我们可以使用任何我们喜欢的数据结构来保存这些数。比如maps或者unordered_maps。

比如：

unordered_map<int, int> memo;
int f(int n) {
    if (memo.count(n)) return memo[n];
    if (n == 0) return 0;
    if (n == 1) return 1;

    return memo[n] = f(n - 1) + f(n - 2);
}

或者类似的：

map<int, int> memo;
int f(int n) {
    if (memo.count(n)) return memo[n];
    if (n == 0) return 0;
    if (n == 1) return 1;

    return memo[n] = f(n - 1) + f(n - 2);
}

这两种保存数据的方式在通常情况下会比数组要慢，但是当状态是向量或者字符串时，这样保存还是很有用的。

最朴素的计算递归算法时间复杂度的方式是：
$$每一个子问题计算时间\ast 子问题个数$$
使用平衡二叉树（C++中的map）来保存状态信息的话，最终需要$O(nlogn)$的时间因为每次的插入和查找都会需要$O(logn)$的时间。而子问题的数量一共有$O(n)$个。

上面这种方式叫做自顶向下的，因为我们从询问的数开始计算，并且计算的过程是从上到下的，通过记忆化的方式保留中间的计算结果。

自底向上的动态规划

到目前位置我们只看到了记忆化搜索这种自顶向下的动态规划。其实我们也可以用自底向上的动态规划来解决问题。自底向上方式和自顶向下的方式完全相反，我们从最底层开始（递归的初始条件（base case）），然后扩展到更多的数。

为了实现自底向上的动态规划，我们需要在数组里初始化初始条件。然后在数组中应用递归式：

const int MAXN = 100;
int fib[MAXN];

int f(int n) {
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i <= n; i++) fib[i] = fib[i - 1] + fib[i - 2];

    return fib[n];
}

当然了，这种写法其实有些愚蠢。因为首先如果我们重复调用f(n)，会重复计算。其次我们只需要之前的两个数就可以计算当前的值。因此我们把空间复杂度从$O(n)$减少到$O(1)$。

代码：

const int MAX_SAVE = 3;
int fib[MAX_SAVE];

int f(int n) {
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i <= n; i++)
        fib[i % MAX_SAVE] = fib[(i - 1) % MAX_SAVE] + fib[(i - 2) % MAX_SAVE];

    return fib[n % MAX_SAVE];
}

注意到把MAXN变成了MAX_SAVE。这是因为我们需要访问的数其实只有3个。需要的空间和输入无关，根据定义，这就是$O(1)$的空间复杂度。并且在这段代码中还使用了一个常用的小技巧（使用模运算）来维护我们需要的数。

上面就是动态规划的基础：不要重复你之前的工作。

一个更好掌握动态规划的方式是学习一些经典的例子。

经典的动态规划问题

• 0-1 Knapsack
• Subset Sum
• Longest Increasing Subsequence
• Counting all possible paths from top left to bottom right corner of a matrix
• Longest Common Subsequence
• Longest Path in a Directed Acyclic Graph (DAG)
• Coin Change
• Longest Palindromic Subsequence
• Rod Cutting
• Edit Distance

• Bitmask Dynamic Programming
• Digit Dynamic Programming
• Dynamic Programming on Trees