第3章 动态规划（1）
本章要求及学习目标
- 动态规划对数学思维要求高，需要抽象思维、计算能力、逻辑推理能力
- 基础题规律性强，易找套路
- 本章要求：只需要掌握例题（包括课堂、实验、作业），一定要会填表
考点：动态规划三大特性
- 最优子结构
- 重叠子问题
- 备忘录方法
动态规划-例题
动态规划问题特点
- 求一个问题的最优解（典型的如最多/最少），通常不关心最优解的方案，只关心答案
- 用直观的贪心法无法得到正确的答案
- 用穷举法会超时
- 难点：问题建模（建立子问题，以及问题与子问题之间的递推关系）
- 易点：
- 一旦算法描述完成，代码实现相对简单
- 时间复杂度/空间复杂度较容易计算
- 技巧：通过估算时间复杂度判断问题是否适用动态规划求解
动态规划解题步骤
- 确认问题和子问题，求解递推关系
- 创建备忘录（数组），用于记录已计算出的结果
- 通过查表+填表的方式，递推求解问题
说明：为了更简单直观地理解，我们统一用“备忘录”描述动态规划中保存的子问题结果，而不是像书本里那样只有记忆化回溯才叫备忘录
例题1：力扣70. 爬楼梯
解题步骤
- 手写计算，推导出规律（这个步骤很重要，务必要多练习锻炼思维能力）
- 得出规律：爬上i级楼梯的方案数=爬上i-1级总数+爬上i-2级总数
- 定义子问题：令dp[i]=爬上i级楼梯的总方案数
- 定义推导公式：dp[i] = dp[i - 1] + dp[i - 2]
- 创建备忘录：dp[n + 1]，dp[0] = 1, dp[1] = 1
- 依次填写 dp[2…n]，完成填表
代码实现
Java实现
public class ClimbStairsSolution {
// 爬楼梯，给定整数n表示总共n级楼梯
// 每次爬1或2级，求不同方案的总数
public int climbStairs(int n) {
// 创建备忘录数组
// dp[x]表示爬x级台阶的总数
// 即数组中每个数值即为一个子问题的解
int[] dp = new int[n + 1];
// 初始化
dp[0] = dp[1] = 1;
// 逐步求解所有的子问题
for (int i = 2; i <= n; i++)
// 递推公式：跳到当前台阶i的方案数等于
// 跳到i-1与i-2级台阶的方案数之和
dp[i] = dp[i - 1] + dp[i - 2];
// 备忘录最后一个值即为原问题的解
return dp[n];
}
public static void main(String[] args) {
int n = 30;
int ans = new ClimbStairsSolution().climbStairs(n);
System.out.println("跳上30级台阶的方案总数为: " + ans);
}
}
Python 实现
# 爬楼梯，给定整数n表示总共n级楼梯
# 每次爬1或2级，求不同方案的总数
def climbStairs(n: int) -> int:
# 创建备忘录数组
# dp[x]表示爬x级台阶的总数
# 即数组中每个数值即为一个子问题的解
dp = [0] * (n + 1)
# 初始化
dp[0] = dp[1] = 1
# 逐步求解所有的子问题
for i in range(2, n + 1):
# 递推公式：跳到当前台阶i的方案数等于
# 跳到i-1与i-2级台阶的方案数之和
dp[i] = dp[i - 1] + dp[i - 2]
# 备忘录最后一个值即为原问题的解
return dp[n]
# main
n = 30
ans = climbStairs(n)
print('跳上30级台阶的方案总数为:', ans)
代码优化
留意dp[i] 只跟 dp[i - 1] 和 dp[i - 2]有关，再前面的用不到了，所以考虑滚动变量节省空间
Java实现（优化后）
public int climbStairs(int n) {
// 用两个变量滚动计算，d1表示dp[i]，d2表示dp[i-1]
int d1 = 1, d2 = 1;
// 依然逐步求解所有的子问题
for (int i = 2; i <= n; i++) {
// 临时变量防数据丢失
int temp = d1;
// 递推公式：跳到当前台阶i的方案数等于
// 跳到i-1与i-2级台阶的方案数之和
d1 = d1 + d2;
// 传递上一步的d1到这一步的d2
d2 = temp;
}
// d1保存的是最后一次计算的结果，即问题答案
return d1;
}
Python实现（优化后）
def climbStairs(n: int) -> int:
d1, d2 = 1, 1
for _ in range(2, n + 1):
d1, d2 = d1 + d2, d1
return d1
例题2: 力扣198. 打家劫舍
解题思路
- 首先你可以会想到能否用贪心法求解，优先偷最值钱的，或者只偷序号为奇数或偶数的
- 手动计算一下便会发现以上算法结果不正确，一个反例是 [ 7 9 7 1 6 8 3 4 ]
- 如果用暴力穷举，对于长度为n的输入，时间复杂度为O(2n)，明显不符合要求
- 所以我们考虑用动态规划求解，解题步骤和上一题一样
- 令dp[i] = 在 houses[0…i] (即前i+1个房屋)中偷取的最大金额，那对于求解dp[i]，我们分为两种情况：
- (1) 不偷取houses[i]，那总金额跟前面一样，为dp[i - 1]
- (2) 偷取并获得houses[i]，根据规则不得偷取i-1，但再之前的收益可以加进去，即 houses[i] + dp[i - 2]
- (3) 综上所述，dp[i] = max(dp[i - 1], houses[i] + dp[i - 2])
- 最后我们跟上一题一样，创建备忘录并依次填表求解即可
代码实现
Java代码实现
public class RobSolution {
public int rob(int[] houses) {
int n = houses.length;
// dp[i]表示从houses[0..i]中取得的最大收益
int[] dp = new int[n];
for (int i = 0; i < n; ++i) {
// 分支1：不偷取，所以收益为0，总收益跟之前一样
if (i > 0) // 代码细节：不加这个判断下一句有可能数组越界
dp[i] = dp[i - 1];
// 分支2：偷取，总收益加上dp[i-2]
int money = houses[i];
if (i >= 2)
money += dp[i - 2];
if (money > dp[i])
dp[i] = money;
}
// 备忘录的最后一个值为答案
return dp[n - 1];
}
public static void main(String[] args) {
int[] houses = { 7, 9, 7, 1, 6, 8, 3, 4 };
int result = new RobSolution().rob(houses);
System.out.println("最大收益: " + result);
}
}
Python代码实现
def rob(houses: list[int]) -> int:
# dp[i]表示从houses[0..i]中取得的最大收益
n = len(houses)
dp = [0] * n
for i in range(n):
# 分支1：不偷取，所以收益为0，总收益跟之前一样
if (i > 0): # 代码细节：不加这个判断下一句有可能数组越界
dp[i] = dp[i - 1]
# 分支2：偷取并获得houses[i], 总收益加上dp[i-2]
money = houses[i]
if (i >= 2):
money += dp[i - 2]
if (money > dp[i]):
dp[i] = money
# 备忘录的最后一个值为答案
return dp[-1]
# main
houses = [ 7, 9, 7, 1, 6, 8, 3, 4 ]
result = rob(houses)
print('最大收益:', result)
代码优化
代码优化逻辑和上一题一样，采用滚动变量，节省空间使用
Java代码（优化后）
public int rob(int[] houses) {
// dp1表示到i为止的最大收益
// dp2表示到i-1为止的最大收益
int dp1 = 0, dp2 = 0;
for (int x: houses) {
// 缓存滚动后的i-1数据
int temp = dp1;
// 计算当前数据，计算方式和之前一样
dp1 = Math.max(dp1, x + dp2);
// 还原缓存的数据到dp2
dp2 = temp;
}
// 计算到最后的dp1为最终答案
return dp1;
}
Python代码（优化后）
def rob(houses: list[int]) -> int:
dp1, dp2 = 0, 0
for x in houses:
dp1, dp2 = max(dp1, x + dp2), dp1
return dp1
例题3 力扣120. 数塔问题之最短路径和
本题依然遵循前面所讲的动态规划方法论求解，要点如下：
- 本题的备忘录并不是线性数组，而是与题目给出一样的数塔形状
- 自上而下感觉有困难，但不妨尝试自下而上思考，就会发现每个节点的子问题解来自下一行邻接的两个子问题
- 自下而上填表时会发现，同样可以采用滚动更新的方式，最后只需要一维数组即可
Java示例代码：
注：代码当中有多处+1或者-1，非常容易出错，可以像示例代码那样添加print语句输出关键信息进行调试
class Solution {
public int minimumTotal(List<List<Integer>> triangle) {
int n = triangle.size();
int[] dp = new int[n];
for (int i = 0; i < n; i++)
dp[i] = triangle.get(n - 1).get(i);
// 自底向上
for (int i = n - 2; i >= 0; i--) {
//System.out.print("[" + triangle.get(i).get(0) + "] ");
for (int j = 0; j <= i; j++) {
dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
//System.out.print(" " + dp[j]);
}
//System.out.println();
}
return dp[0];
}
}
Python3示例代码：
class Solution:
def minimumTotal(self, triangle: List[List[int]]) -> int:
dp = [x for x in triangle[-1]]
for i in range(len(triangle) - 1, 0, -1):
dp[:i] = ((t + min(a, b)) for (t, (a, b)) in zip(triangle[i - 1], pairwise(dp[:i + 1])))
return dp[0]
扫一扫
1006
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
