背包问题

01背包问题

题目

有N件物品和一个容量为M的背包，每种物品只可以取一件。第i件物品的费用是c[i]，价值是v[i]。求解将哪些物品装入背包可使价值总和最大。

分析

这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。用子问题定义状态：即f[i][j]表示前i件物品恰放入一个容量为j的背包可以获得的最大价值。则其状态转移方程便是：

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

优化空间复杂度

即改用一维数组f[j]存储第i个物品时剩余空间为j时的背包的最大价值。

注意到j-c[i]<j这个关系，当j=0……M顺序推f[j]，则后面的到的f[j]将会使用到当前i状态下新生成的f[j-c[i]]，而不是我们所需的i-1状态时的f[j-c[i]]。

因此，在每次主循环中我们以j=M……0顺序推f[j]，这样才能保证推f[j]时f[j-c[i]]保存的是状态f[i-1][j-c[i]]的值。

参考代码

[cpp] view plaincopy

1. /* 
2.  * n：物品种类 每种只能选取一种 
3.  * capacity：背包容量 
4.  * c[i]：第i种物品的花费 cost 
5.  * v[i]：第i种物品的价值 value 
6.  * f[j]：i状态下容量为j时背包可获得的最大价值 
7.  */  
8. int getMaxValue(int n,int capacity){  
9.     for(int i=0;i<n;i++)  
10.         for(int j=capacity;j>=0;j--)  
11.             if(i==0){  
12.                 if(j>=c[i])f[j]=v[i];  
13.                 else f[j]=0;  
14.             }  
15.             else if(j>=c[i])f[j]=max(f[j],f[j-c[i]]+v[i]);  
16.     return f[capacity];  
17. }  

 

完全背包问题

题目

有N件物品和一个容量为M的背包，每种物品都有无限件可用。第i件物品的费用是c[i]，价值是v[i]。求解将哪些物品装入背包可使价值总和最大。

分析

类似01背包问题，但与它相关的策略已并非取或不取两种，而是有取0件、取1件、取2件……。如果仍然按照解01背包时的思路，令f[i][j]表示前i种物品恰放入一个容量为j的背包的最大权值。仍然可以按照每种物品不同的策略写出状态转移方程：

f[i][j]=max{ f[i-1][j-k*c[i]]+k*v[i] | 0<=k*c[i]<=M }

优化时间复杂度

若两件物品i、j满足c[i]<=c[j]且w[i]>=w[j]，则将物品j去掉，不用考虑。

将费用大于M的物品去掉，然后使用类似计数排序的做法，计算出费用相同的物品中价值最高的是哪个。

转化为01背包问题求解

最简单的想法是：考虑到第i种物品最多选M/c[i]件，于是可以把第i种物品转化为M/c[i]件费用及价值均不变的物品，然后求解这个01背包问题。这样完全没有改进基本思路的时间复杂度，但这毕竟给了我们将完全背包问题转化为01背包问题的思路：将一种物品拆成多件物品。

更高效的转化方法是：把第i种物品拆成费用为c[i]*2^k、价值为v[i]*2^k的若干件物品，其中k满足c[i]*2^k<=M。这是二进制的思想，因为不管最优策略选几件第i种物品，总可以表示成若干个2^k件物品的和。这样把每种物品拆成O(logM/c[i])件物品，是一个很大的改进。

最简O(MN)算法：首先想想为什么01背包问题中为何要按照j=M..0的逆序来循环。这是因为要保证第i次循环中的状态f[i][j]是由状态f[i-1][j-c[i]]递推而来。换句话说，这正是为了保证每件物品只选一次，保证在考虑“选入第i件物品”这件策略时，依据的是一个绝无已经选入第i件物品的子结果f[i-1][j-c[i]]。而现在完全背包的特点恰是每种物品可选无限件，所以在考虑“加选一件第i种物品”这种策略时，却正需要一个可能已选入第i种物品的子结果f[i][j-c[i]]，所以就可以并且必须采用j=0..M的顺序循环。

参考代码

[cpp] view plaincopy

1. /* 
2.  * n：物品种类 每种只能选取一种 
3.  * capacity：背包容量 
4.  * c[i]：第i种物品的花费 cost 
5.  * v[i]：第i种物品的价值 value 
6.  * f[j]：i状态下容量为j时背包可获得的最大价值 
7.  */  
8. int getMaxValue(int n,int capacity){  
9.     for(int i=0;i<n;i++)  
10.         for(int j=0;j<=capacity;j++)  
11.             if(i==0){  
12.                 if(j>=c[i])f[j]=v[i]*(j/c[i]);  
13.                 else f[j]=0;  
14.             }  
15.             else if(j>=c[i])f[j]=max(f[j],f[j-c[i]]+v[i]);  
16.     return f[capacity];  
17. }  

多重背包问题

题目

有N件物品和一个容量为M的背包，第i种物品最多有n[i]件可用。第i件物品的费用是c[i]，价值是v[i]。求解将哪些物品装入背包可使价值总和最大。

分析

这题目和完全背包问题很类似。基本的方程只需将完全背包问题的方程略微一改即可，因为对于第i种物品有n[i]+1种策略：取0件，取1件……取n[i]件。令f[i][v]表示前i种物品恰放入一个容量为v的背包的最大权值，则有状态转移方程：
 f[i][j]=max{ f[i-1][j-k*c[i]]+k*v[i] | 0<=k<=n[i] }

优化时间复杂度

将第i种物品分成若干件物品，其中每件物品有一个系数，这件物品的费用和价值均是原来的费用和价值乘以这个系数。使这些系数分别为1,2,4,...,2^(k-1),n[i]-2^k+1，且k是满足n[i]-2^k+1>0的最大整数。例如，如果n[i]为13，就将这种物品分成系数分别为1,2,4,6的四件物品。
分成的这几件物品的系数和为n[i]，表明不可能取多于n[i]件的第i种物品。

参考代码

[cpp] view plaincopy

1. /** 
2.  * 多重背包决策：遍历到第i种物品(i状态)时的决策 
3.  * cost：i状态时的花费c[i] 
4.  * weight：i状态时的价值v[i] 
5.  * amount：i状态时物品的最大数量n[i] 
6.  * CompletePack：多重背包决策 
7.  * ZeroOnePack：01背包决策 
8.  */  
9. void MultiplePack(cost,weight,amount){  
10.     if(cost*amount>=capacity){  
11.         CompletePack(cost,weight);return;  
12.     }  
13.     int k=1;  
14.     while(k<amount){   
15.         ZeroOnePack(k*cost,k*weight);  
16.         amount=amount-k;  
17.         k=k*2;  
18.     }  
19.     ZeroOnePack(amount*cost,amount*weight);  
20. }  

题目推荐：

ZOJ Problem Set - 1149 Dividing

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=149

题意：

给出序号为1、2、3、4、5、6的6种弹珠（好像是弹珠吧⊙﹏⊙b汗），其价值等于其编号，给出每种弹珠的数目，求能否将弹珠分两堆，使两堆的价值和相等。

分析：

多重背包问题，只是所谓的花费cost等于价值，且背包容量为总和的一半。

代码：

[cpp] view plaincopy

1. #include <iostream>  
2. #define MAX 210002  
3. #define max(a,b) (a)>(b)?(a):(b)  
4. using namespace std;  
5. long nums[6],total,f[MAX];  
6.   
7. int input(){  
8.     for(int i=total=0;i<6;i++){  
9.         cin>>nums[i];  
10.         total+=nums[i]*(i+1);  
11.     }  
12.     if(total)return 1;  
13.     return 0;  
14. }  
15.   
16. void zeroOnePack(int cost,int value,long capacity){  
17.     for(int j=capacity;j>-1;j--)  
18.         if(j>=cost)f[j]=max(f[j],f[j-cost]+value);  
19. }  
20. void completePack(int cost,int value,long capacity){  
21.     for(int j=0;j<=capacity;j++)  
22.         if(j>=cost)f[j]=max(f[j],f[j-cost]+value);  
23. }  
24. void multiplePack(int cost,int value,int count,long capacity){  
25.     if(cost*count>=capacity){  
26.         completePack(cost,value,capacity);  
27.         return;  
28.     }  
29.     int k=1;  
30.     while(k<count){  
31.         zeroOnePack(cost*k,value*k,capacity);  
32.         count-=k;  
33.         k*=2;  
34.     }  
35.     zeroOnePack(cost*count,value*count,capacity);  
36. }  
37.   
38. int judge(long capacity){  
39.     for(int i=0;i<6;i++){  
40.         if(i==0){  
41.             for(int j=0;j<=capacity;j++)  
42.                 if(j<i+1)f[j]=0;  
43.                 else{  
44.                     int amount=j/(i+1);  
45.                     f[j]=(nums[i]>=amount ? (i+1)*amount : nums[i]*(i+1));  
46.                 }  
47.         }  
48.         else multiplePack(i+1,i+1,nums[i],capacity);  
49.     }  
50.     if(f[capacity]==capacity)return 1;  
51.     return 0;  
52. }  
53.   
54. int main()  
55. {  
56.     int T=1;  
57.     while(input()){  
58.         printf("Collection #%d:\n",T++);  
59.         if(total&1)cout<<"Can't be divided."<<endl<<endl;  
60.         else if(judge(total/2))cout<<"Can be divided."<<endl<<endl;  
61.         else cout<<"Can't be divided."<<endl<<endl;  
62.     }  
63.     return 0;  
64. }