背包问题：多重背包的优化

在背包九讲里面将多重背包转化为01背包，并且进行时间优化，有利用到一个二进制分解的思想。

下面是在网上搜索之后得到的一个关于二进制分解思想的讲解和实现

多重背包二进制分解思想讲解

1. /**  
2.     在这之前，我空间好像转过一个背包九讲，现在我就只对  
3.     01背包和多重背包有点印象了  
4.   
5.     先说下 01 背包，有n 种不同的物品，每个物品有两个属性  
6.     size 体积，value 价值，现在给一个容量为 w 的背包，问  
7.     最多可带走多少价值的物品。  
8.   
9.     int f[w+1];   //f[x] 表示背包容量为x 时的最大价值  
10.     for (int i=0; i<n; i++)  
11.         for (int j=w; j>=size[i]; j++)  
12.             f[j] = max(f[j], f[j-size[i]]+value[i]);  
13.   
14.     如果物品不计件数，就是每个物品不只一件的话，稍微改下即可  
15.     for (int i=0; i<n; i++)  
16.         for (int j=size[i]; j<=w; j++)  
17.             f[j] = max(f[j], f[j-size[i]]+value[i]);  
18.   
19.     f[w] 即为所求  
20.   
21.     初始化分两种情况  
22.     1、如果背包要求正好装满则初始化 f[0] = 0, f[1~w] = -INF;  
23.     2、如果不需要正好装满 f[0~v] = 0;  
24.   
25.     多重背包问题要求很简单，就是每件物品给出确定的件数，求  
26.     可得到的最大价值  
27.   
28.     多重背包转换成 01 背包问题就是多了个初始化，把它的件数C 用  
29.     分解成若干个件数的集合，这里面数字可以组合成任意小于等于C  
30.     的件数，而且不会重复，之所以叫二进制分解，是因为这样分解可  
31.     以用数字的二进制形式来解释  
32.     比如：7的二进制 7 = 111 它可以分解成 001 010 100 这三个数可以  
33.     组合成任意小于等于7 的数，而且每种组合都会得到不同的数  
34.     15 = 1111 可分解成 0001  0010  0100  1000 四个数字  
35.     如果13 = 1101 则分解为 0001 0010 0100 0110 前三个数字可以组合成  
36.     7以内任意一个数，加上 0110 = 6 可以组合成任意一个大于6 小于13  
37.     的数，虽然有重复但总是能把 13 以内所有的数都考虑到了，基于这种  
38.     思想去把多件物品转换为，多种一件物品，就可用01 背包求解了。  
39.   
40.   
41.     看代码：  
42.     int n;  //输入有多少种物品  
43.     int c;  //每种物品有多少件  
44.     int v;  //每种物品的价值  
45.     int s;  //每种物品的尺寸  
46.     int count = 0; //分解后可得到多少种物品  
47.     int value[MAX]; //用来保存分解后的物品价值  
48.     int size[MAX];  //用来保存分解后物品体积  
49.   
50.     scanf("%d", &n);    //先输入有多少种物品，接下来对每种物品进行分解  
51.   
52.     while (n--) {   //接下来输入n中这个物品  
53.         scanf("%d%d%d", &c, &s, &v);  //输入每种物品的数目和价值  
54.         for (int k=1; k<=c; k<<=1) { //<<右移 相当于乘二  
55.             value[count] = k*v;  
56.             size[count++] = k*s;  
57.             c -= k;  
58.         }  
59.         if (c > 0) {  
60.             value[count] = c*v;  
61.             size[count++] = c*s;  
62.         }  
63.     }  
64.   
65.     现在用count 代替 n 就和01 背包问题完全一样了  

在背包九讲里面，他的实现方法和这个是不一样的，他是利用01背包和完全背包来配合实现的，下面是那个版本的实现

1. /* 
2. HDOJ 2191 
3. 多重背包用二进制转化的思想，进行优化 
4. */  
5.   
6. #include <iostream>  
7. using namespace std;  
8.   
9. int weight[110],Value[110],num[110];  
10. int f[1100];  
11. int limit;  
12.   
13. inline void ZeroOnePack(int w,int v)  
14. {  
15.     int j;  
16.     for(j=limit;j>=w;j--)  
17.     {  
18.         if(f[j-w]+v > f[j])  
19.             f[j]=f[j-w]+v;  
20.     }  
21. }  
22.   
23. inline void CompletePack(int w,int v)  
24. {  
25.     int j;  
26.     for(j=w;j<=limit;j++)  
27.     {  
28.         if(f[j-w]+v > f[j])  
29.             f[j]=f[j-w]+v;  
30.     }  
31. }  
32.   
33. inline void MultiplePack(int w,int v,int amount)  
34. {  
35.     if(amount * w >= limit)  
36.     {  
37.         CompletePack(w,v);  
38.         return ;  
39.     }  
40.     for(int k=1;k<amount;k<<=1)  
41.     {  
42.         ZeroOnePack(k*w,k*v);  
43.         amount -= k;  
44.     }  
45.     ZeroOnePack(amount*w,amount*v);  
46. }  
47.   
48. int main()  
49. {  
50.     int T,n;  
51.     cin>>T;  
52.     while(T--)  
53.     {  
54.         cin>>limit>>n;  
55.           
56.         for(int i=0;i<n;i++)  
57.             cin>>weight[i]>>Value[i]>>num[i];  
58.           
59.         memset(f,0,sizeof(f));  
60.           
61.         for(i=0;i<n;i++)  
62.             MultiplePack(weight[i],Value[i],num[i]);  
63.           
64.         cout<<f[limit]<<endl;  
65.     }  
66.     return 0;  
67. }