文章作者：Yx.Ac 文章来源：勇幸|Thinking (http://www.ahathinking.com) 转载请注明，谢谢合作。
---
前面回顾了01背包，在此基础上本节回顾完全背包的几种实现形式，主要有以下几方面内容：
==完全背包问题定义 & 基本实现
==完全背包二进制拆分思想
==完全背包使用滚动数组（略）
==完全背包中的逆向思维
==完全背包使用一维数组
========================================
完全背包问题定义 & 基本实现
问题：有个容量为V大小的背包，有很多不同重量weight[i](i=1..n)不同价值value[i](i=1..n)的货物，每种物品有无限件可用，想计算一下最多能放多少价值的货物。
与01背包不同的是，完全背包每件物体可以放入无限件（只要能放的下），故对于每件物品i，相当于拆分成了v/c[i]件相同的物品，拆分之后物品i就不是放入或不放入的两种情况了，而是放入0件、放入1件、放入2件…等情况了，对于该件物品i，最大价值取放入k件的最大值，故状态转移方程为：
1
|
f(i,v) = max{ f(i-1,v-k*c[i]) + k*w[i] | 0<=k<=v/c[i] }
|
各状态的意义不再赘述，上代码，关于复杂度以及每种物品的状态数见代码注释：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
#include <iostream>
using namespace std;
/* 完全背包 版本1
* Time Complexity 大于O(N*V)
* Space Complexity O(N*V)
* 设 V <= 200 N <= 10
* 状态转移方程：f(i,v) = max{ f(i-1,v-k*c[i]) + k*w[i] | 0<=k<=v/c[i] }
* 每件物品有v/c[i]种状态
*/
int maxV[11][201]; /* 记录子问题最优解，物品可重复 */
int weight[11];
int value[11];
int V, N;
void main()
{
int i, j, k;
scanf("%d %d",&V, &N);
for(i = 0; i < N; ++i)
{
scanf("%d %d",&weight[i],&value[i]);
}
for(i = 0; i < N; ++i)
{
for(j = 0; j <= V; ++j)
{
if(i > 0)
{
maxV[i][j] = maxV[i-1][j];
if(j/weight[i] >= 1)
{
int max_tmp = 0;
for(k = 1; k <= j/weight[i]; ++k)
{
if(maxV[i-1][j-k*weight[i]] + k*value[i] > max_tmp)
{
max_tmp = maxV[i-1][j-k*weight[i]] + k*value[i];
}
}
maxV[i][j] = maxV[i][j] > max_tmp ? maxV[i][j] : max_tmp;
}
}else
{
if(j/weight[0] >= 1)
{
maxV[0][j] = j/weight[0] * value[0];
}
}
}
}
printf("%d",maxV[N-1][V]);
}
|
========================================
完全背包二进制拆分思想
这种实现方式是对完全背包的基本实现做了一个优化，叫“二进制拆分”。所谓“拆分物体”就是将一种无限件物品拆分成有效的几件物品，拆分物体的目的是通过减少物品个数来降低复杂度。
在完全背包中，每种物品i对于容量v来讲实际上相当于有v/c[i]件，故在上述的基本实现中，k就要循环测试v/c[i]次。
这里的拆分是利用了一种二进制思想：即任何数字都可以表示成若干个2^k数字的和，例如7可以用1+2+2^2表示；这很好理解，因为任何正数都可以转成二进制，二进制就是若干个“1”（2的幂数）之和。
所以不管最优策略选择几件物品i，我们都可以将物品i拆成费用为c[i]*2^k，价值为w[i]*2^k的若干件物品。这样物品的状态数就降为了log(v/c[i])，是很大的改进。
在代码实现上，与基本实现的差别很小，区别如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
/* 完全背包 版本2
* Time Complexity 大于O(N*V)
* Space Complexity O(N*V)
* 设 V <= 200 N <= 10
* 状态转移方程：f(i,v) = max{ f(i-1,v-2^k*c[i]) + 2^k*w[i] | 0<=k<=log v/c[i] }
* 每件物品降低为 log(v/c[i]) 种状态
*/
for(k = 1; k <= j/weight[i]; k <<= 1)
{
if(maxV[i-1][j-k*weight[i]] + k*value[i] > max_tmp)
{
max_tmp = maxV[i-1][j-k*weight[i]] + k*value[i];
}
}
|
对于使用滚动数组的实现，这里就不写了，跟01背包是一样的。
========================================
完全背包中的逆向思维
我们知道，在01背包和完全背包的实现中，都是针对每种物品进行讨论，即外循环都是for i=0…n，然后每种物品对于容量v的变化而求得最大价值；
在完全背包中，由于物品的件数无限，所以我们可以倒过来想，我们针对每个容量讨论，外循环为容量，对于每个容量j，我们求j对于所有物品能装载的最大价值，这样一来我们就能将时间复杂度降为O(N*V)了。代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
#include <iostream>
using namespace std;
/* 完全背包 版本3
* Time Complexity O(N*V)
* Space Complexity O(N*V)
* 设 V <= 200 N <= 10
*/
int maxValue[201][11]; /* 记录子问题的各状态 */
int weight[11];
int value[11];
int maxV[201]; /* 记录子问题的最优解 */
int V, N;
void main()
{
int i, j;
scanf("%d %d",&V, &N);
for(i = 0; i < N; ++i)
{
scanf("%d %d",&weight[i],&value[i]);
}
for(i = 1; i <= V; ++i)
{
int i_maxV = 0; /* 记录子问题i的最优解 */
/* 每个容量求面对所有物体能装载的最大价值 */
for(j = 0; j < N; ++j)
{
if(i >= weight[j])
{
int tmp = maxV[i-weight[j]] + value[j];
maxValue[i][j] = maxV[i-1] > tmp ? maxV[i-1] : tmp;
}else
{
maxValue[i][j] = maxV[i-1];
}
if(maxValue[i][j] > i_maxV)
{
i_maxV = maxValue[i][j];
}
}
maxV[i] = i_maxV;
}
printf("%d",maxV[V]);
/* 重定向输出结果到文件 */
freopen("C:\\dp.txt","w",stdout);
for(i = 0; i <= V; ++i)
{
for(j = 0; j < N; ++j)
{
printf("%d ",maxValue[i][j]);
}
printf(" %d\n",maxV[i]);
}
}
|
同样，可以将状态转移矩阵重定向输出到文件进行对比，一看就明白了，这里就不贴图片了。
========================================
完全背包使用一维数组
对于01背包和完全背包，无论是空间复杂度还是时间复杂度，最优的方法还是使用一维数组进行实现。
基于01背包的分析，由于不必考虑物品的重复放入，故v的循环采用顺序即可。代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
#include <iostream>
using namespace std;
/* 完全背包 版本4
* Time Complexity O(N*V)
* Space Complexity O(V)
* 设 V <= 200 N <= 10
* 状态转移方程：v =0...V; f(v) = max{ f(v), f(v-c[i])+w[i] }
*/
int maxV[201]; /* 记录前i个物品中容量v时的最大价值, 物品可重复 */
int weight[11];
int value[11];
int V, N;
void main()
{
int i, j;
scanf("%d %d",&V, &N);
for(i = 0; i < N; ++i)
{
scanf("%d %d",&weight[i],&value[i]);
}
for(i = 0; i < N; ++i)
{
for(j = weight[i]; j <= V; ++j) /* j<weight[i]的对前面的状态不会有影响 */
{
int tmp = maxV[j-weight[i]]+value[i];
maxV[j] = (maxV[j] > tmp) ? maxV[j] : tmp;
}
}
printf("%d",maxV[V]);
}
|
========================================
PS：值得一提的是，在01背包和完全背包中，我们用到了两种思想，个人认为还是很有用的，其他地方也会用到很多，我们有必要在此留心：
记得有一回看到的面试题就用到了二进制拆分的思想，具体是啥忘了，以后碰到再说吧，就这样。
本文相关代码可以到这里下载。
（全文完）
参考资料：背包问题九讲 http://love-oriented.com/pack/
时间： 2025-01-06 00:27:39
