动态规划 - 01背包问题

Reference：http://www.ahathinking.com/archives/95.html

问题：有个容量为V大小的背包，有很多不同重量weight[i](i=1..n)不同价值value[i](i=1..n)的物品，每种物品只有一个，想计算一下最多能放多少价值的货物。

DP的关键也是难点是找到最优子结构和重叠子问题，进而找到状态转移方程，编码就相对容易些。最优子结构保证每个状态是最优的，重叠子问题也即n状态的求法和n-1状态的求法是一样的；DP在实现上一般是根据状态转移方程自底向上的迭代求得最优解（也可以使用递归自顶向下求解）。

回到0-1背包，每个物体i，对应着两种状态：放入&不放入背包。背包的最优解是在面对每个物体时选择能够最大化背包价值的状态。0-1背包的状态转移方程为

f(i,v)表示前i个物体面对容量为v时背包的最大价值，c[i]代表物体i的cost(即重量)，w[i]代表物体i的价值；如果第i个物体不放入背包，则背包的最大价值等于前i-1个物体面对容量v的最大价值；如果第i个物体选择放入，则背包的最大价值等于前i-1个物体面对容量v-cost[i]的最大价值加上物体i的价值w[i]。

对于实现，一般采用一个二维数组（状态转移矩阵）dp[i][j]来记录各个子问题的最优状态，其中dp[i][j]表示前i个物体面对容量j背包的最大价值。

下面给出0-1背包的基本实现，时间复杂度为O(N*V)，空间复杂度也为O(N*V)，初始化的合法状态很重要，对于第一个物体即f[0][j]，如果容量j小于第一个物体（编号为0）的重量，则背包的最大价值为0，如果容量j大于第一个物体的重量，则背包最大价值便为该物体的价值。

#include <iostream>
using namespace std;

/* 0-1背包 版本1
* Time Complexity  O(N*V)
* Space Complexity O(N*V)
* 设 V <= 200 N <= 10
* 状态转移方程：f(i,v) = max{ f(i-1,v), f(i-1,v-c[i])+w[i] }
*/

int maxValue[11][201]; /* 前i个物体面对容量j的最大价值，即子问题最优解 */
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 = 0; j <= V; ++j) /* 容量为V 等号 */
{
if(i > 0)
{
maxValue[i][j] = maxValue[i-1][j];
if(j >= weight[i]) /* 等号 */
{
int tmp = maxValue[i-1][j-weight[i]] + value[i];
maxValue[i][j] = ( tmp > maxValue[i][j]) ? tmp : maxValue[i][j];
}
}else   /* 数组第0行赋值 */
{
if(j >= weight[0])
maxValue[0][j] = value[0];
}
}
}

printf("%d\n",maxValue[N-1][V]);

/* 重定向输出结果到文件 */
//freopen("C:\\dp.txt","w",stdout);

for(i = 0; i <= N; ++i)
{
for(j = 0; j <= V; ++j)
{
printf("%d   ",maxValue[i][j]);
}
printf("\n");
}

}

测试用例：

程序输出的状态转移矩阵如下图，第一行表示第1个物体对于容量0至V时的最优解，即背包最大价值。





0-1背包使用一维数组

使用滚动数组将空间优化到了2*V，在背包九讲中提到了使用一维数组也可以达到同样的效果，个人认为这也是滚动思想的一种，由于使用一维数组解01背包会被多次用到，完全背包的一种优化实现方式也是使用一维数组，所以我们有必要理解这种方法。

如果只使用一维数组f[0…v]，我们要达到的效果是：第i次循环结束后f[v]中所表示的就是使用二维数组时的f[i][v]，即前i个物体面对容量v时的最大价值。我们知道f[v]是由两个状态得来的，f[i-1][v]和f[i-1][v-c[i]]，使用一维数组时，当第i次循环之前时，f[v]实际上就是f[i-1][v]，那么怎么得到第二个子问题的值呢？事实上，如果在每次循环中我们以v=v…0的顺序推f[v]时，就能保证f[v-c[i]]存储的是f[i-1][v-c[i]]的状态。状态转移方程为：

我们可以与二维数组的状态转移方程对比一下

正如我们上面所说，f[v-c[i]]就相当于原来f[i-1][v-c[i]]的状态。如果将v的循环顺序由逆序改为顺序的话，就不是01背包了，就变成完全背包了，这个后面说。这里举一个例子理解为何顺序就不是01背包了

假设有物体z容量2，价值vz很大，背包容量为5，如果v的循环顺序不是逆序，那么外层循环跑到物体z时，内循环在v=2时，物体z被放入背包，当v=4时，寻求最大价值，物体z放入背包，f[4]=max{f[4],f[2]+vz}，这里毫无疑问后者最大，那么此时f[2]+vz中的f[2]已经装入了一次物体z，这样一来该物体被装入背包两次了就，不符合要求，如果逆序循环v，这一问题便解决了。

代码如下，为了加深理解，可以在内循环结束输出每一个状态的情况到文本中，会发现与使用二维数组时的状态转移矩阵都是一样一样的。

#include <iostream>
using namespace std;

/* 0-1背包 版本3
* Time Complexity  O(N*V)
* Space Complexity O(V)
* 设 V <= 200 N <= 10
* 状态转移方程：v = V...0; 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]);
}

/*
* 对于第i轮循环
* 求出了前i个物品中面对容量为v的最大价值
*/
for(i = 0; i < N; ++i)
{
/*
* 内循环实际上讲maxV[0...v]滚动覆盖前一轮的maxV[0...V]
* 可输出对照使用二维数组时的情况
* j从V至0逆序是防止有的物品放入背包多次
*/
for(j = V; j >= weight[i]; --j)   /* weight > j 的物品不会影响状态f[0,weight[i-1]]  */
{
int tmp = maxV[j-weight[i]]+value[i];
maxV[j] = (maxV[j] > tmp) ? maxV[j] : tmp;
}
}
printf("%d\n",maxV[V]);

for(i = 0; i <= V; ++i)
{
printf("%d   ",maxV[i]);
}
printf("\n");
}

0-1背包恰好背满

在01背包中，有时问到“恰好装满背包”时的最大价值，与不要求装满背包的区别就是在初始化的时候，其实对于没有要求必须装满背包的情况下，初始化最大价值都为0，是不存在非法状态的，所有的都是合法状态，因为可以什么都不装，这个解就是0，但是如果要求恰好装满，则必须区别初始化，除了f[0]=0,其他的f[1…v]均设为-∞或者一个比较大的负数来表示该状态是非法的。

这样的初始化能够保证，如果子问题的状态是合法的（恰好装满），那么才能得到合法的状态；如果子问题状态是非法的，则当前问题的状态依然非法，即不存在恰好装满的情况。

#include <iostream>
using namespace std;

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 = 1; i <= V; ++i)  /* 初始化非法状态 */
{
maxV[i] = -100;
}

for(i = 0; i < N; ++i)
{
for(j = V; j >= weight[i]; --j)
{
int tmp = maxV[j-weight[i]]+value[i];
maxV[j] = (maxV[j] > tmp) ? maxV[j] : tmp;
}
}

printf("%d\n",maxV[V]);

for(i = 0; i <= V; ++i)
{
printf("%d   ",maxV[i]);
}
printf("\n");
}

01背包问题 - 完全背包问题

在01背包的一维数组解法时，考虑j是从后向前，为了就是避免多次选取同一个物品。

完全背包问题，每个物品有多件，可以重复选择，故可以使用一维数组顺序解决。

#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\n",maxV[V]);

for(i = 0; i <= V; ++i)
{
printf("%d   ",maxV[i]);
}
printf("\n");
}

对于该问题的一般解法也说一说，以便加深理解。

问题：有个容量为V大小的背包，有很多不同重量weight[i](i=1..n)不同价值value[i](i=1..n)的货物，每种物品有无限件可用，想计算一下最多能放多少价值的货物。

与01背包不同的是，完全背包每件物体可以放入无限件（只要能放的下），故对于每件物品i，相当于拆分成了v/c[i]件相同的物品，拆分之后物品i就不是放入或不放入的两种情况了，而是放入0件、放入1件、放入2件…等情况了，对于该件物品i，最大价值取放入k件的最大值，故状态转移方程为：

第i个物品要么不放：f（i,v） = f（i-1，v）；要么放k个：f（i，v） = f（i-1，v-k*c[i]）+k*w[i]

#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\n",maxV[N-1][V]);

for(i = 0; i <= N; ++i)
{
for(j = 0; j <= V; ++j)
{
printf("%d   ",maxV[i][j]);
}
printf("\n");
}
}