5年前写过一篇关于动态规划的博客。最近重新学习基本算法,对动态规划有了更深入的体会。
对于“背包问题”,现在可以按照自己的思路写出来代码了,虽然运行一下发现有问题,经过修改调试,最终可以完成。这样的过程,我认为比记住一些代码,然后一遍把代码写对,是要好很多了。
要把动态规划的代码写出来要经过几个步骤。
递归算法的思考方式是自顶向下的,而动态规划是自底向上的。
但是有了自顶向下的“记忆化搜索”解法之后,再来思考动态规划的解法,会好很多。
下面用代码来展示这个思路
0.问题描述
有n个物体,每个物体有自己的重量和价值。现在有一个容量为 C 的背包,要从n个物体中选一些来放到这个背包里,要使得这个背包里的物体价值最大。
例如有 3个 物体
编号为 0, 1, 2。
重量为 1, 2,3。
价值为 6, 10,12.
背包的容量为 5.
那么价值最大的解法为 背包里放入 编号为1,2的物体,总价值为 10+12=22
1. 递归解法
要能写出递归解法,就是考虑:大的问题,能不能通过规模小一点的子问题来解决,并且要有递归终止的条件,这就是自顶向下的思考方式。
对于这个问题,我们要从[0,…n-1]个物体中 选出能装入 容量为 C的背包里。
那么我们考虑 背包里是否需要 放入 第 n-1 个物体 来作为破题的入口。
(1)假设最终的解法里, 背包里不需要第n-1个物体,那么问题就变成了:
我们要从[0,…,n-2]个物体中 选出能装入 容量为 C的背包里。
(2)假设最终的解法里,背包里需要放入第n-1个物体,那么问题就转变为:
我们要从[0,…,n-2]个物体中 选出能装入 容量为:(C 减去 第n-1个物体的重量)的背包里。
比较(1)和(2)两种情况下,背包里物体的价值谁最大就是问题的解法。
其实函数的定义, 就是 所谓的 “状态定义”。函数定义里的参数,就是问题的约束条件。
递归函数的实现体,就是 所谓的 “状态转移方程”。
class Solution:
# get the max value in [0,...,n-1] items
def max_value(self, weight_list, value_list, n, capacity):
if n <= 0 or capacity <= 0:
return 0
# 第(1)种情况的解法
res1 = self.max_value(weight_list, value_list, n-1, capacity)
# 第(2)中情况的解法
res2 = 0
if capacity >= weight_list[n-1]:
res2 = value_list[n-1] + self.max_value(weight_list, value_list, n-1, capacity-weight_list[n-1])
# 比较(1)和(2)谁最优
res = max(res1, res2)
return res
def backpack(self, weight_list, value_list, capacity):
n = len(weight_list)
return self.max_value(weight_list, value_list, n, capacity)
# main
s = Solution()
weight = [1, 2, 3]
value = [6, 10, 12]
print(s.backpack(weight, value, 5))
2. 记忆化搜索
记忆化搜索,其实就是使用变量把中间结果暂存起来,避免重复计算。
class Solution:
def __init__(self):
self.memo = list()
# get the max value in [0,...,n-1] items
def max_value(self, weight_list, value_list, n, capacity):
if n <= 0 or capacity <= 0:
return 0
# 记忆化搜索新加代码
if self.memo[n][capacity] != 0:
return self.memo[n][capacity]
res1 = self.max_value(weight_list, value_list, n-1, capacity)
res2 = 0
if capacity >= weight_list[n-1]:
res2 = value_list[n-1] + self.max_value(weight_list, value_list, n-1, capacity-weight_list[n-1])
res = max(res1, res2)
# 记忆化搜索新加代码
self.memo[n][capacity] = res
return res
def backpack(self, weight_list, value_list, capacity):
n = len(weight_list)
self.memo = [[0 for j in range(capacity+1)] for i in range(n+1)]
return self.max_value(weight_list, value_list, n, capacity)
# main
s = Solution()
weight = [1, 2, 3]
value = [6, 10, 12]
print(s.backpack(weight, value, 5))
3. 动态规划解法
有了前面自顶向下的 记忆化搜索算法,反过来自底向上的思考动态规划的解法。
def backpack(weight_list, value_list, capacity):
n = len(weight_list)
memo = [[0 for j in range(capacity + 1)] for i in range(n+1)]
for j in range(capacity + 1):
memo[0][j] = value_list[0] if weight_list[0] <= j else 0
for i in range(1, n):
for c in range(0, capacity+1):
remain = 0
if c >= weight_list[i]:
remain = memo[i-1][c-weight_list[i]] if (c-weight_list[i]) >= 0 else 0
remain = value_list[i] + remain
memo[i][c] = max(memo[i-1][c], remain)
return memo[n-1][capacity]
# main
weight = [1, 2, 3]
value = [6, 10, 12]
print(backpack(weight, value, 5))
致谢
感谢慕课网上《玩转算法面试-- Leetcode真题分门别类讲解》这门课程的老师liuyubobobo,本文的思路就是从这门课里学到的。这门课不仅教会了我具体问题的解法,而且指出了思考的路径,做到了授人以渔。
应用
在下一篇文章(算法-动态规划3)将应用这个思路来解决一个组合问题。