【算法】-动态规划之01背包和完全背包

由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。
由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值

所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

(2)dp数组初始化

首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。如图：

状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。

代码如下：

// 倒叙遍历
for j := bagWeight; j >= weight[0]; j-- {
    dp[0][j] = dp[0][j-weight[0]] + value[0] // 初始化 i 为 0 时候的情况
}

那么这个初始化为什么是倒叙的遍历的？正序遍历就不行么？

答案是不行，dp[0][j]表示容量为j的背包存放物品0时候的最大价值，物品0的价值就是15，因为题目中说了 每个物品只有一个！所以dp[0][j]如果不是初始值的话，就应该都是物品0的价值，也就是15。但如果一旦正序遍历了，那么物品0就会被重复加入多次！例如代码如下：

for j := weight[0]; j <= begweight; j++ {
    dp[0][j] = dp[0][j-weight[0]] +value[0]
}

例如dp[0][1] 是15，到了dp[0][2] = dp[0][2 - 1] + 15; 也就是dp[0][2] = 30 了，那么就是物品0被重复放入了。

所以一定要倒叙遍历，保证物品0只被放入一次！这一点对01背包很重要，后面在讲解滚动数组的时候，还会用到倒叙遍历来保证物品使用一次！此时dp数组初始化情况如图所示：

dp[0][j] 和 dp[i][0] 都已经初始化了，那么其他下标应该初始化多少呢？

dp[i][j]在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，因为0就是最小的了，不会影响取最大价值的结果。

如果题目给的价值有负数，那么非0下标就要初始化为负无穷了。例如：一个物品的价值是-2，但对应的位置依然初始化为0，那么取最大值的时候，就会取0而不是-2了，所以要初始化为负无穷。这样才能让dp数组在递归公式的过程中取最大的价值，而不是被初始值覆盖了。

最后初始化代码如下：

// 初始化 dp
dp := make([][]int, len(weight)+1)
for i := range dp {
    dp[i] = make([]int, bagWeight+1)
}

for j := bagWeight; j >= weight[0]; j-- {
    dp[0][j] = dp[0][j-weight[0]] + value[0]
}

(3)确定遍历顺序

在如下图中，可以看出，有两个遍历的维度：物品与背包重量

那么，先遍历物品还是先遍历背包重量呢？其实都可以，但是先遍历物品更好理解。那么我先给出先遍历物品，然后遍历背包重量的代码。

// weight 数组的大小就是物品个数
for i := 1; i < len(weight); i++ { // 遍历物品
    for j := 0; j <= bagWeight; j++ { // 遍历背包容量
        if j < weight[i] {
            dp[i][j] = dp[i-1][j] // 这个是为了展现 dp 数组里元素的变化
        } else {
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i])
        }
    }
}

先遍历背包，再遍历物品，也是可以的，例如这样：

// weight 数组的大小就是物品个数
for j := 0; j <= bagWeight; j++ { // 遍历背包容量
    for i := 1; i < len(weight); i++ { // 遍历物品
        if j < weight[i] {
            dp[i][j] = dp[i-1][j]
        } else {
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i])
        }
    }
}

为什么也是可以的呢？要理解递归的本质和递推的方向。

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的。

dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括正左和正上两个方向），那么先遍历物品，再遍历背包的过程如图所示：

再来看看先遍历背包，再遍历物品呢，如图：

大家可以看出，虽然两个for循环遍历的次序不同，但是dp[i][j]所需要的数据就是左上角，根本不影响dp[i][j]公式的推导！但先遍历物品再遍历背包这个顺序更好理解。

(4)推导得到dp数组

来看一下对应的dp数组的数值，如图：

最终结果就是dp[2][4]。完整代码如下：

package main

import "fmt"

func bag01_1() {
	weight := []int{1, 3, 4}
	value := []int{15, 20, 30}
	bagWeight := 4

	// 二维数组
	dp := make([][]int, len(weight)+1)
	for i := range dp {
		dp[i] = make([]int, bagWeight+1)
	}

	// 初始化
	for j := bagWeight; j >= weight[0]; j-- {
		dp[0][j] = dp[0][j-weight[0]] + value[0]
	}

	// weight 数组的大小就是物品个数
	for i := 1; i < len(weight); i++ { // 遍历物品
		for j := 0; j <= bagWeight; j++ { // 遍历背包容量
			if j < weight[i] {
				dp[i][j] = dp[i-1][j]
			} else {
				dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i])
			}
		}
	}

	fmt.Println(dp[len(weight)-1][bagWeight])
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	bag01_1()
}

以上遍历的过程也可以这么写：

// 遍历过程
for i := 1; i < len(weight); i++ { // 遍历物品
    for j := 0; j <= bagWeight; j++ { // 遍历背包容量
        if j-weight[i] >= 0 {
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i])
        }
    }
}

这么写打印出来的dp数据这就是入下图，空出来的0其实是用不上的。

小结

刚刚讲完了二维dp的01背包，其实可以发现最简单的是推导公式了，但难就难在如何初始化和遍历顺序上。接下来我们再来讲一维dp数组实现的01背包（滚动数组），分析一下和二维有什么区别，在初始化和遍历顺序上又有什么差异。

一维数组01背包（滚动数组）

再来说一说滚动数组，其实在前面的题目中我们已经用到过滚动数组了，就是把二维dp降为一维dp，接下来还是用如下这个例子来进行讲解

背包最大重量为4。

物品为：

                重量   价值
物品0         1 15
物品1        3 20
物品2         4 30
问背包能背的物品最大价值是多少？

对于背包问题其实状态都是可以压缩的。在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);

于其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）。

这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层。

(1)确定递推公式

dp[j]为容量为j的背包所背的最大价值，那么如何推导dp[j]呢？

dp[j]可以通过dp[j - weight[i]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最大价值。dp[j - weight[i]] + value[i] 表示容量为 j - 物品i重量的背包加上物品i的价值。（也就是容量为j的背包，放入物品i了之后的价值即：dp[j]）

此时dp[j]有两个选择，一个是取自己dp[j]，一个是取dp[j - weight[i]] + value[i]，指定是取最大的，毕竟是求最大价值，

所以递归公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]); 可以看出相对于二维dp数组的写法，就是把dp[i][j]中i的维度去掉了。

(2)dp数组初始化

dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]，那么dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0。

那么dp数组除了下标0的位置，初始为0，其他下标应该初始化多少呢？

看一下递归公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

dp数组在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。

(3)确定遍历顺序

for i := 0; i < len(weight); i++ { // 遍历物品
    for j := bagWeight; j >= weight[i]; j-- { // 遍历背包容量
        dp[j] = max(dp[j], dp[j-weight[i]]+value[i])
    }
}

这里大家发现和二维dp的写法中，遍历背包的顺序是不一样的！二维dp遍历的时候，背包容量是从小到大，而一维dp遍历的时候，背包是从大到小。这是为了确保物品值放入一次！

举一个例子：物品0的重量weight[0] = 1，价值value[0] = 15

如果正序遍历

dp[1] = dp[1 - weight[0]] + value[0] = 15

dp[2] = dp[2 - weight[0]] + value[0] = 30

此时dp[2]就已经是30了，意味着物品0，被放入了两次，所以不能正序遍历。为什么倒叙遍历，就可以保证物品只放入一次呢？倒叙就是先算dp[2]

dp[2] = dp[2 - weight[0]] + value[0] = 15 （dp数组已经都初始化为0）

dp[1] = dp[1 - weight[0]] + value[0] = 15

所以从后往前循环，每次取得状态不会和之前取得状态重合，这样每种物品就只取一次了。

那么问题又来了，为什么二维dp数组历的时候不用倒叙呢？因为对于二维dp，dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，而不像一维数组是状态的拷贝。

再来看看两个嵌套for循环的顺序，代码中是先遍历物品嵌套遍历背包容量，那可不可以先遍历背包容量嵌套遍历物品呢？答案是不可以！因为一维dp的写法，背包容量一定是要倒序遍历，如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。

(4)推导得到dp数组

一维dp，费用用物品0，物品1，物品2 来遍历背包，最终得到结果如下：

完整代码如下，可以看出，一维dp 的01背包，要比二维简洁的多，初始化和遍历顺序相对简单了。

package main

import "fmt"


func bag01_2() {
	weight := []int{1, 3, 4}
	value := []int{15, 20, 30}
	bagWeight := 4

	// 初始化
	dp := make([]int, bagWeight+1)
	for i := 0; i < len(weight); i++ { // 遍历物品
		for j := bagWeight; j >= weight[i]; j-- { // 遍历背包容量
			dp[j] = max(dp[j], dp[j-weight[i]]+value[i])
		}
	}
	fmt.Println(dp[bagWeight])
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	bag01_2()
}

完全背包

与01背包几乎相同，但是物品的数量是无限的。
解决完全背包问题，同01背包，首先定义一个二维数组dp[i][j]表示：在第0到i个物品中任取物品，放进容量为j的背包中，背包所能装的最大价值。

考虑dp[i][j]，相较于前一种情况，有不放第i个物品和放k件第i个物品两种情况（k≥1)，与01背包相似，完全背包的递归方程如下。

dp[i][j]= max (dp[i-1][j], max(dp[i-1][j-k*weight[i]] + k*value[i])) (1 ≤ k ≤ j/w[i])

那么，完全背包该怎么遍历呢？大家注意一维01背包中所说，我们不用正序遍历背包容量的原因是从前向后遍历时同样的物品会被放多次，这不正好契合完全背包的题意吗？

我们把01背包一维数组做法的背包容量正过来遍历，直接就得到了完全背包的代码：

for i := 1; i < len(weight); i++ {
	for j := 0; j <= bagWeight; j++ {
		dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i])
	}
}