完全背包详解（最优方法）

4、O(VN)的算法

伪代码

[cpp] view plain copy

1. for (int i = 1;i <= N;i++)  
2. {  
3.     for (int v = weight[i];v <= V;v++)  
4.     {  
5.         f[v] = max(f[v],f[v - weight[i]] + Value[i]);  
6.     }  
7. }  

分析：这和01背包的伪代码很相似，在01背包的代码中，v变化的区间是逆序循环的，即[V,Weight[i]]。而这里，v变化的区间是顺序循环的，即为[Weight[i],V]。

原因：

再次给出定义：

f[i][v]表示把前i件物品放入容量为v的背包时的最大代价。

f[i-1][v-c[i]]表示把前i - 1件物品放入容量为v的背包时的最大代价.

在01背包中，v变化的区间是逆序循环的原因：要保证由状态f[i-1][v-c[i]]递推状态f[i][v]时，f[i-1][v-c[i]]没有放入第i件物品。之后，在第i循环时，放入一件第i件物品。

01背包的方程：

[cpp] view plain copy

1. f[i][v] = max(f[i - 1][v],f[i - 1][v - weight[i]] + Value[i])    

在完全背包中，v变化的区间是顺序循环的原因：完全背包的特点是每种物品可选无限件，在求解加选第i种物品带来的收益f[i][v]时，在状态f[i][v-c[i]]中已经尽可能多的放入物品i了，此时在f[i][v-c[i]]的基础上，我们可以再次放入一件物品i，此时也是在不超过背包容量的基础下，尽可能多的放入物品i。

完全背包的方程：

[cpp] view plain copy

1. f[i][v] = max(f[i - 1][v],f[i][v - weight[i]] + Value[i]);  

举例：

物品个数N = 3，背包总容量为V = 5。

物品信息：

完全背包：

分析：

i = 2，表示正在处理第2件物品。在求解f[2][4]时，如果要计算把第2件物品放入背包后的代价时，我们需要知道f[2][2],此时f[2][2]中已经尽全力放入第2件物品了（已经放入一件）。此时此刻还可以在放入一件第2件物品，在背包容量为4时，最多可以放入两件第二件物品。

总结下，f[i][v]:表示在背包容量为v时，尽全力的放入第i件物品的代价。f[i][v - weight[i]]:表示在背包容量为v - weight[i]时，尽全力的放入第i件物品的代价。因此由f[i][v - weight[i]]转换为f[i][v]时，也是在f[i][v - weight[i]]的基础上有加入了一件物品i。

为了节省保存状态的空间，可以直接使用一维数组保存状态。

代码：迭代方程：f[i][v] = max(f[i - 1][v],f[i][v - weight[i]] + Value[i]);

[cpp] view plain copy

1. #include <iostream>  
2. #include <vector>  
3. #include <assert.h>  
4. using namespace std;  
5. const int N = 3;  
6. const int V = 5;//5  
7. int weight[N + 1] = {0,3,2,2};  
8. int Value[N + 1] = {0,5,10,20};  
9.   
10. int f[N + 1][V + 1] = {0};  
11.   
12. int Completeknapsack()  
13. {  
14.     //初始化  
15.     for (int i = 0;i <= N;i++)  
16.     {  
17.         f[i][0] = 0;  
18.     }  
19.     for (int v = 0;v <= V;v++)  
20.     {  
21.         f[0][v] = 0;  
22.     }  
23.     for (int i = 1;i <= N;i++)  
24.     {  
25.         for (int v = weight[i];v <= V;v++)  
26.         {  
27.             f[i][v] = max(f[i - 1][v],f[i][v - weight[i]] + Value[i]);  
28.         }  
29.     }  
30.     return f[N][V];  
31. }  
32.   
33. int main()  
34. {  
35.     cout<<Completeknapsack()<<endl;  
36.     system("pause");  
37.     return 1;  
38. }  

代码：迭代方程： f[v] = max(f[v],f[v - weight[i]] + Value[i]);

[cpp] view plain copy

1. #include <iostream>  
2. using namespace std;  
3. const int N = 3;  
4. const int V = 5;//5  
5. int weight[N + 1] = {0,3,2,2};  
6. int Value[N + 1] = {0,5,10,20};  
7.   
8. int f[V + 1] = {0};  
9.   
10. int Completeknapsack()  
11. {  
12.     f[0] = 0;  
13.     for (int i = 1;i <= N;i++)  
14.     {  
15.         for (int v = weight[i];v <= V;v++)  
16.         {  
17.             f[v] = max(f[v],f[v - weight[i]] + Value[i]);  
18.         }  
19.     }  
20.     return f[V];  
21. }  
22. int main()  
23. {  
24.     cout<<Completeknapsack()<<endl;  
25.     system("pause");  
26.     return 1;  
27. }