完全背包问题思路及GO语言实现

本文链接：https://blog.csdn.net/doreen211/article/details/125584171

0.前言

完全背包问题具体描述如下：

在M类物品取出若干件放在空间为W的背包里，每件物品的体积为W1_{Wn，与之相对应的价值为P1}Pn，求出能获得的最大价值，每件物品都有无限个（也就是可以放入背包多次**。

完全背包是01背包的升级版，将01背包中每个物品的个数从1个扩充到了无数个，如果对01背包不太熟悉的可以看看这篇文章：

01背包问题思路及GO语言实现_雨雨不怕雨的博客-CSDN博客

本文中，给出简单简单思路及GO语言解答实现。

1.实现

完全背包的最优化版本很难直接理解，接下来会首先给出最简单的思路，并一步步优化，分别如下。

1.1 使用二维dp数组+3重循环

此种方法便于理解，但是时间、空间复杂度更大。

dp[i][j]的含义为当物品为0~i、容量为k时，此时能获得的最大的价值。

根据每次选取n个第i个物品，可推出递推式：

dp[i][j] = max(dp[i-1][j-n*weight[i]]+n*value[i])

在上式中，如果不选取，则dp[i][j]的值会与dp[i-1][j]相同，如果选取n个，则值为dp[i-1][j-n*weight[i]]+n*value[i]，取其中的最大值，代码如下：

package main

import "fmt"

func main() {
	n:=0
	cap:=0
	fmt.Println("enter the number of objects:")
	fmt.Scan(&n)

	value :=make([]int,n)
	weight:=make([]int,n)

	fmt.Println("enter the value:")
	for i := 0; i < n; i++ {
		fmt.Scan(&value[i])
	}
	fmt.Println("enter the weight:")
	for i := 0; i < n; i++ {
		fmt.Scan(&weight[i])
	}
	fmt.Println("enter the capacity of bag:")
	fmt.Scan(&cap)
	fmt.Println("the answer is ",bag(weight,value,cap))

}

func bag(weight, value []int, cap int) int {
	dp := make([][]int, len(weight))
	for i := 0; i < len(weight); i++ {
		dp[i] = make([]int, cap+1)
	}
	//初始化dp数组
	for i := weight[0]; i <= cap; i++ {
		dp[0][i] = value[0]
	}

	//遍历填充dp数组
	for i := 1; i < len(dp); i++ {
		for j := 1; j <= cap; j++ {
			for n:=0;n*weight[i] <= j;n++{
					dp[i][j]=max(dp[i][j],dp[i-1][j-n*weight[i]]+n*value[i])
			}
		}
	}
	fmt.Println("the dp array is",dp)
	return dp[len(weight)-1][cap]

}

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

1.2 递归式优化

以上需要三重循环，复杂度很高，实际上，我们将递推式展开：

dp[i,j] = max ( dp[i-1][j], dp[i-1][j-weight[i]]+value[i],dp[i-1][j-2*weight[i]]+2*value[i],…dp[i-1][j-n*weight[i]]+n*value[i])

而对于选择前i个物品，体积为j-weight[i]的背包：，
dp[i,j-weight[i]]= max ( dp[i-1][j-weight[i]]， dp[i-1][j-2*weight[i]]+2*value[i]… …dp[i-1][j-n*weight[i]]+(n-1)*value[i] )

比较这两个式子，发现只有一个value[i]的差距！将底下的式子加上一个value[i]，即可得到：

dp[i,j-weight[i]]+value[i]= max ( dp[i-1][j-weight[i]]+value[i],dp[i-1][j-2*weight[i]]+3*value[i]… …dp[i-1][j-n*weight[i]]+n*value[i])

可以看出：这个式子与dp[i,j]的后半截是完全相等的，等量替换，即可得到：

dp[i,j]= max ( dp[i-1][j],dp[i,j-weight[i]]+value[i] )

对比简单01背包的状态转移方程：

dp[i,j]= max ( dp[i-1][j],dp[i-1,j-weight[i]]+value[i] )

可以发现，只是下标有一个改变了，即从i-1变成了i，意味着i是可以重复选举的，代码如下：

package main
import "fmt"

func main() {
	n:=0
	cap:=0

	fmt.Println("enter the number of objects:")
	fmt.Scan(&n)

	value :=make([]int,n)
	weight:=make([]int,n)

	fmt.Println("enter the value:")
	for i := 0; i < n; i++ {
		fmt.Scan(&value[i])
	}
	fmt.Println("enter the weight:")
	for i := 0; i < n; i++ {
		fmt.Scan(&weight[i])
	}
	fmt.Println("enter the capacity of bag:")
	fmt.Scan(&cap)
	fmt.Println("the answer is ",bag(weight,value,cap))

}

func bag(weight, value []int, cap int) int {
	dp := make([][]int, len(weight))
	for i := 0; i < len(weight); i++ {
		dp[i] = make([]int, cap+1)
	}
	//初始化dp数组
	for i := weight[0]; i <= cap; i++ {
		dp[0][i] = value[0]
	}

	//遍历填充dp数组
	for i := 1; i < len(dp); i++ {
		for k := 1; k <= cap; k++ {
			if k-weight[i] < 0 {
				dp[i][k] = dp[i-1][k]
			} else {
				dp[i][k] = max(dp[i-1][k], dp[i][k-weight[i]]+value[i])
			}
		}
	}
	fmt.Println("the dp array is",dp)
	return dp[len(weight)-1][cap]

}

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

1.3 优化成一维数组

在使用二维数组时，i的存在不是必要的。因为物品已经给定，并不需要记录0~i的各个物品选取情况。

dp[j]的含义为容量为j时，此时能获得的最大价值。

递推式与上述方法的核心是一样的，也是根据是否选取第i个物品来更新dp数组：

dp[j]=max(dp[j],dp[j-weight[i]]+value[i])

在编写代码时，思路也是一样，遍历每个物品，尝试将物品放入，如果放入后能获得更大价值，则更新dp数组的值。

注意：

此时遍历顺序不同于01背包，01背包中，遍历顺序为倒序遍历，这里需要用正序遍历，因为每次往下递推的时候，用的是第i层的数据，而不是01背包中的i-1的数据。

代码如下：

package main

import "fmt"

func main() {
	n:=0
	cap:=0

	fmt.Println("enter the number of objects:")
	fmt.Scan(&n)

	value :=make([]int,n)
	weight:=make([]int,n)

	fmt.Println("enter the value:")
	for i := 0; i < n; i++ {
		fmt.Scan(&value[i])
	}
	fmt.Println("enter the weight:")
	for i := 0; i < n; i++ {
		fmt.Scan(&weight[i])
	}
	fmt.Println("enter the capacity of bag:")
	fmt.Scan(&cap)
	fmt.Println("the answer is ",bag(weight,value,cap))

}

func bag(weight, value []int, cap int) int {
	dp:=make([]int,cap+1)
	for i:=0;i<len(weight);i++{
		for j:=weight[i];j<=cap;j++{
			dp[j]=max(dp[j],dp[j-weight[i]]+value[i])
		}
	}
	fmt.Println("the dp array is",dp)
	return dp[cap]


}

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