背包问题详解

01背包

　　一个背包中容量为V，现在有N个物品，每个物品的第i个 物品体积为weight[i]，价值为value[i]，现在往背包里面装东西，怎么装能使背包的内物品价值最大？这是01背包的最基础最根本的问题。01代表的意思是该物品取或者不取。顺便提一下各种背包之间的区别，完全背包每种物品的数目是无限种，多重背包的每种物品数目是有限中。

　　用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：

　　　　　　　　f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}

　　把这个过程理解为当取第i件物品是，价值为f[i-1][v-c[i]]+w[i]；

　　当不取第i件物品时，价值为f[i-1][v];

作图便是如下：内层循环为v从1到V，外层循环是n从1到N；





　　测试代码：

#include<iostream>
using namespace std;
#define  V 1500
unsigned int f[10][V];//全局变量，自动初始化为0
unsigned int weight[10];
unsigned int value[10];
#define  max(x,y)    (x)>(y)?(x):(y)
int main()
{

int N,M;
cin>>N;//物品个数
cin>>M;//背包容量
for (int i=1;i<=N; i++)
{
cin>>weight[i]>>value[i];
}
for (int i=1; i<=N; i++)
for (int j=1; j<=M; j++)
{
if (weight[i]<=j)
{
f[i][j]=max(f[i-1][j],f[i-1][j-weight[i]]+value[i]);
}
else
f[i][j]=f[i-1][j];
}

cout<<f
[M]<<endl;//输出最优解

}

　　01背包内存优化：可将状态转移方程中二维数组转化为一维数组，状态方程为：

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　f[j]=max{f[j],f[j-v[i]]+val[i]}

　　此时需要保证f[j-v[i]]是上一层状态的，即假如左边的f[j]是前i件物品，那么需要保证f[j-v[i]]是前i-1件物品。那么内层循环必须是逆序，举个例子，加入是顺序遍历的话：

　　

物品号 重量(c) 价值(w)
i=1 4 5

i=2 7 9

i=3 5 6

f[v]=max{ f[v],f[v-c[i]]+w[i] }

如果v是顺序递增 i=1时，v=4~10 （因为v要至少大于等于c[i]嘛 不然减出个负数没意义）
原先的: f[0]=0 f[1]=0 f[2]=0 f[3]=0 f[4]=0 f[5]=0 f[6]=0 f[7]=0 f[8]=0 f[9]=0 f[10]=0
--------------------------- i=1 -------------------------------- 后来的： f[0]=0 f[1]=0 f[2]=0 f[3]=0 f[4]=5 f[5]=5 f[6]=5 f[7]=5 f[8]=0 f[9]=0 f[10]=0
v=4:
f[4]=max{f[4],f[0]+5} max{0,5}=5 f[4]=5

v=5:
f[5]=max{f[5],f[1]+5} max{0,5}=5 f[5]=5

v=6:
f[6]=max{f[6],f[2]+5} max{0,5}=5 f[6]=5

v=7:
f[7]=max{f[7],f[3]+5} max{0,5}=5 f[7]=5

v=8:
f[8]=max{f[8],f[4]+5} max{0,10}=10 f[8]=10 (这里显然不对,这时i=1，只能放一件物品,然而没有一个物品的价值为10的 )

v=9:
f[9]=max{f[9],f[5]+5} max(0,10}=10 f[9]=10

v=10:
f[10]=max{f[10],f[6]+5} max{0,10}=10 f[10]=10

所以必须是逆序：　　　　

for(i=1;i<=n;i++)
for(j=v;j>=v[i];j--)
{
f[j]=max{f[j],f[j-v[i]]+val[i]};
}

注：此处没有对j<v[i]做分类讨论是因为当j<v[i]时默认了f[j]等于上一层的f[j]，即保持不变。

多重背包

　　已知一个容量为v的背包和N件物品，第i件物品最多有num[i]件，没见物品的重量是weight[i],收益是cost[i];

　　物品个数N = 3，背包容量为V = 8，则背包可以装下的最大价值为64.

　　　　　　　　　　　　　　　　　　　　　　　　　　


　　基本思路：直接扩展01背包

　　状态转移方程：

　　　　　　　　f[i][j]=max{f[i][j],f[i-1][j-k*weight[i]+k*cost[i]};其中0<=k&&k<=j/weight[i],这是与01背包不同之处，边界条件。

注：此处为f[i][v]而不是f[i-1][v]，f[i][v]就相当于第i种物品中(m1,m2,m3,m4...)的上一层，上次没注意然后就wa了。

　　直接抄了网上的代码，如下：

#include <iostream>
using namespace std;
const int N = 3;//物品个数
const int V = 8;//背包容量
int Weight[N + 1] = {0,1,2,2};
int Value[N + 1] = {0,6,10,20};
int Num[N + 1] = {0,10,5,2};
int f[N + 1][V + 1] = {0};
/*
f[i][v]:表示把前i件物品放入容量为v的背包中获得的最大收益。
f[i][v] = max(f[i - 1][v],f[i - 1][v - k * Weight[i]] + K * Value[i]);其中1 <= k <= min(Num[i],V/Weight[i])
//初始化
f[i][0] = 0;
f[0][v] = 0;
*/
int MultiKnapsack()
{
int nCount = 0;
//初始化
for (int i = 0;i <= N;i++)
{
f[i][0] = 0;
}
for (int v = 0;v <= V;v++)
{
f[0][v] = 0;
}
//递推
for (int i = 1;i <= N;i++)
{
for (int v = Weight[i];v <= V;v++)
{
f[i][v] = 0;
nCount = min(Num[i],v/Weight[i]);//是当前背包容量v，而不是背包的总容量
for (int k = 0;k <= nCount;k++)
{
f[i][v] = max(f[i][v],f[i - 1][v - k * Weight[i]] + k * Value[i]);
}
}
}
return f
[V];
}
int main()
{
cout<<MultiKnapsack()<<endl;
system("pause");
return 1;
}

一维多重背包(选择01背包思想)，将相同的物品看作不同的来处理，然后选择取或者不取，但复杂度比较高

for(i=1;i<=n;i++)
{
for(j=0;j<=b[i];j++)
{
for(m=k;m>=a[i]*j;m--)
{
if(f[m]<(f[m-j*w[i]]+j*val[i]))
f[m]=f[m-j*w[i]]+j*val[i];
}
}
}

多重背包二进制优化模板：(思考在这里)

for(i=1;i<=n;i++)
{
p=0;
g=0;
while(b[i]>g)
{
for(j=k;j>=a[i]*g;j--)
{
f[j]=max(f[j],f[j-w[i]*g]+val[i]*g);
}
b[i]-=g;
g=pow(2,p);
p++;
}
for(j=k;j>=w[i]*b[i];--j)
{
f[j]=max(f[j],f[j-w[i]*b[i]]+val[i]*b[i]);
}
}

完全背包

　　完全背包只是每种物品的数量被放到了无限大，此时相对与多重背包变化的只是范围。

　 有一个容量为V的背包和N件物品，第i件物品的重量是weight[i]，收益是cost[i]。每种物品都有无限件，能放多少就放多少。在不超过背包容量的情况下，最多能获得多少价值或收益？

　 1.基本思路：直接扩展01背包

　　状态转移方程：

　　　　　　　　f[i][v] = max(f[i ][v],f[i][v - K * weight[i]] + K * Value[i]); 其中 0<= K * weight[i] <= j,(v指此时背包容量，不是总容量)

#include <iostream>
#include <assert.h>
using namespace std;
/*
f[i][v]:前i件物品放入背包容量为v的背包获得的最大收益

f[i][v] = max(f[i - 1][v],f[i - 1][v - k * Wi] + k * Vi,其中 1<=k<= v/Wi)

边界条件
f[0][v] = 0;
f[i][0] = 0;
*/

const int N = 3;
const int V = 5;
int weight[N + 1] = {0,3,2,2};
int Value[N + 1] = {0,5,10,20};

int f[N + 1][V + 1] = {0};

int Completeknapsack()
{
//边界条件
for (int i = 0;i <= N;i++)
{
f[i][0] = 0;
}
for (int v = 0;v <= V;v++)
{
f[0][v] = 0;
}
//递推
for (int i = 1;i <= N;i++)
{
for (int v = 1;v <= V;v++)
{
f[i][v] = 0;
int nCount = v / weight[i];
for (int k = 0;k <= nCount;k++)
{
f[i][v] = max(f[i][v],f[i - 1][v - k * weight[i]] + k * Value[i]);
}
}
}
return f
[V];
}

int main()
{
cout<<Completeknapsack()<<endl;     return 1;
}

　　内存压缩：可以接着01背包内存压缩的为什么内层循环方向分析，一维01背包内层循环反向max中的f[j]，f[j-w[i]]+val[i]是上一层的，而在完全背包中内层循环是从w[i]到v正向，刷新的是当前层的状态，看不懂可以再次分析上面的例子

for(i=1;i<=n;i++)
{
for(j=w[i];j<=v;j++)
{
f[j]=max(f[j],f[j-w[i]]+val[i]);
}
}

　

　2.直接利用多重背包

　　完全背包的物品可以取无限件，根据背包的总容量V和第i件物品的总重量Weight[i],可知，背包中最多装入V/Weight[i](向下取整)件该物品。因此可以直接改变第i件物品的总个数，使之达到V/Weight[i](向下取整)件，之后直接利用01背包的思路进行操作即可。

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

　　拆分之前的物品序列：

　　　　　　　　　　


　　拆分之后的物品序列：

　　　　　　　　　　　　　　　　　


根据上述思想：在背包的最大容量（5）中，最多可以装入1件物品一，因此不用扩展物品一。最多可以装入2件物品二，因此可以扩展一件物品二。同理，可以扩展一件物品三。

背包问题九讲：http://love-oriented.com/pack/Index.html

背包之01背包、完全背包、多重背包详解 ：http://www.wutianqi.com/?p=539

背包问题九讲笔记_01背包：/article/2021457.html

背包问题九讲笔记_完全背包：/article/2021333.html

背包问题九讲笔记_多重背包：/article/2021329.html

01背包、完全背包、多重背包：/article/1644220.html