算法-动态规划2

    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）将应用这个思路来解决一个组合问题。