动态规划——初识
动态规划
初识
动态规划(dynamic programming)是一个重要的算法范式，它将一个问题分解为一系列更小的子问题，并通过存储子问题的解来避免重复计算，从而大幅提升时间效率。
本节中，我们从一个经典例题入手，先给出它的暴力回溯解法，观察其中包含的重叠子问题，再逐步导出更高效的动态规划解法。
爬楼梯 力扣 第70题
给定一个共有\(n\)阶的楼梯，你每步可以上1阶或2阶，请问有多少种方案可以爬到楼顶？
如图所示，对于一个3阶楼梯，共有3种方案可以爬到楼顶
本题的目标是求解方案数量，我们可以考虑使用回溯来穷举所有可能性。具体来说，将爬楼梯想象为一个多轮选择的过程，从地面触发，每轮选择上1阶或2阶，每当到达楼梯顶部时就将方案数量加1，越过楼梯顶部时就将其剪枝。
暴力回溯代码实现：
class Solution {
public:
int climbStairs(int n) {
int state = 0;
int count = 0;
backtrack(state, n, count);
return count;
}
void backtrack(int &state, int &n, int &count){
// 爬到第n阶时， 方案数量+1
if(state == n){
count ++;
return;
}
// 遍历所有选择
for(int i = 1; i <= 2; i++){
// 剪枝：不允许超过第n阶
if(state + i > n) continue;
state += i;
backtrack(state, n, count);
// 回溯
state -= i;
}
}
};
暴力搜索
回溯算法通常并不显式地对问题进行拆解，而是将求解问题看作一系列决策步骤，通过试探和剪枝，搜索所有可能的解。
我们可以尝试从问题分解的角度分析这道题。设爬到第\(i\)阶共有\(dp[i]\)种方案，那么\(dp[i]\)就是原问题，其子问题包括：
由于每轮只能上1阶或2阶，因此当我们站在第\(i\)阶楼梯上时，上一轮只可能站在第\(i-1\)阶或\(i-2\)阶上。换句话说，我们只能从第\(i-1\)阶或第\(i-2\)阶迈向地\(i\)阶
由此便可得出一个重要推论：爬到第\(i-1\)阶的方案数加上爬到第\(i-2\)阶的方案数就等于爬到第\(i\)阶的方案数。公式如下：
这意味着在爬楼梯问题中，各个子问题之间存在递推关系，原问题的解可以由子问题的解构建得到。
我们可以根据递推公式得到暴力搜索解法。以\(dp[n]\)为起点，递归地将一个较大问题拆解为两个较小问题的和，直至到达最小子问题\(dp[1]\)和\(dp[2]\)时返回。其中，最小子问题的解是已知的，即\(dp[1]=1、dp[2]=2\)，表示爬到第1、2阶分别有1、2中方案。
class Solution {
public:
int climbStairs(int n) {
return dfs(n);
}
int dfs(int i){
// 已知dp[1]和dp[2] 返回
if(i == 1) return 1;
if(i == 2) return 2;
// dp[i] = dp[i - 1] + dp[i - 2]
return dfs(i - 1) + dfs(i - 2);
}
};
对比标准的回溯代码，都属于深度优先搜索，但更加简洁
下图展示了暴力搜索形成的递归树。对于问题\(dp[n]\)，其递归深度为\(n\)，时间复杂度为\(O(2^n)\)。指数阶属于爆炸式增长，如果我们输入一个比较大的\(n\)，则会陷入漫长的等待中。
观察后容易看出，指数阶的时间复杂度是“重叠子问题”导致的。例如\(dp[9]\)被分解为\(dp[8]\)和\(dp[7]\)，\(dp[8]\)又被分解为\(dp[7]\)和\(dp[6]\)，两者都包含子问题\(dp[7]\)。
以此类推，子问题中包含更小的子问题，绝大部分计算资源都浪费在这些重叠的子问题上。
记忆化搜索
为了提升算法效率，我们希望所有的重叠子问题都只被计算一次。为此，我们需要声明一个数组mem来记录每个子问题的解，并在搜索过程中将重叠子问题剪枝。
- 当首次计算\(dp[i]\)时，我们将其记录至
mem[i]在，以便之后使用。 - 当再次需要计算\(dp[i]\)时，我们便可直接从
mem[i]中获取结果，从而避免重复计算该子问题。
代码实现：
class Solution {
public:
int climbStairs(int n) {
// mem[i] 记录爬到第 i 阶的方案总数， -1 代表无记录
vector<int> mem(n + 1, -1);
return dfs(n, mem);
}
int dfs(int i, vector<int> &mem){
// 已知dp[1]和dp[2] 返回
if(i == 1) return 1;
if(i == 2) return 2;
// 若存在记录dp[i]，则直接返回
if(mem[i] != -1) return mem[i];
// dp[i] = dp[i - 1] + dp[i - 2]
int dpi = dfs(i - 1, mem) + dfs(i - 2, mem);
// 记录dp[i]
mem[i] = dpi;
return dpi;
}
};
观察递归树发现，经过记忆化处理后，所有重叠子问题都只需要计算一次，时间复杂度优化至\(O(n)\)，这是一个巨大的飞跃。
动态规划
** 记忆化搜索是一种“从顶至底”的方法**：我们从原问题（根节点）开始，递归地将较大子问题分解为较小子问题，直至解已知的最小子问题（叶节点）。之后，通过回溯层收集子问题的解，构建出原问题的解。
与之相反，动态规划是一个“从底至顶”的方法：从最小子问题的解开始，迭代地构建更大子问题的解，直至得到原问题的解。
由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无需使用递归。在以下代码中，我们初始化一个数组dp来存储子问题的解，它起到了与记忆化搜索数组mem相同的记录作用：
class Solution {
public:
/* 爬楼梯：动态规划 */
int climbStairs(int n) {
if(n < 3) 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];
}
};
下图模拟了以上代码的执行过程
与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如爬楼梯问题的状态定义为当前所在楼梯阶数\(i\)。
根据以上内容，我们可以总结出动态规划的常用术语。
- 将数组
dp称为dp表，\(dp[i]\)表示状态\(i\)对应子问题的解。 - 将最小子问题对应的状态（第一阶和第二阶楼梯）称为初识状态。
- 将递推公式\(dp[i] = dp[i-1] + dp[i-2]\)称为状态转移方程。
空间优化
根据状态转移方程可以发现，\(dp[i]\)只与\(dp[i-1]\)和\(dp[i-2]\)有关，因此我们无需使用一个数组dp来存储所有的子问题的解，而只需要两个变量滚动前进即可。
class Solution {
public:
/* 爬楼梯：空间优化后的动态规划 */
int climbStairs(int n) {
if(n < 3) return n;
// 初始状态 a=dp[1] b=dp[2]
int a = 1, b = 2;
for(int i = 3; i <= n; ++i){
// 状态转移 dp[i] = dp[i - 1] + dp[i - 2]
int tmp = b;
b = a + b;
a = tmp;
}
return b;
}
};
由于省去了数组dp占用的空间，因此空间复杂度从\(O(n)\)降至\(O(1)\)。
在动态规划问题中，当前状态往往仅与前面有限个状态有关，这时我们可以只保留必要的状态，通过“降维”来节省内存空间。这种空间优化技巧被称为滚动变量或滚动数组。
浙公网安备 33010602011771号