NYOJ 546 Divideing Jewels 多重背包

本文转载自：http://blog.csdn.net/hrdv676/article/details/7737269

题目：http://acm.nyist.net/JudgeOnline/problem.php?pid=546

[cpp] view plain copy print ?

1. #include<stdio.h>  
2. #include<iostream>  
3. #include<string.h>  
4. using namespace std;  
5. int dp[50010],v,j;  
6. void zeroonePack(int c,int w)//01背包  
7. {  
8.     for(j=v;j>=c;j--)  
9.        dp[j]=max(dp[j],dp[j-c]+w);  
10. }  
11. void complatePack(int c,int w)//完全背包  
12. {  
13.     for(j=c;j<=v;j++)  
14.         dp[j]=max(dp[j],dp[j-c]+w);  
15. }  
16. void multipiePack(int c,int w,int n)//多重背包  
17. {  
18.     if(c*n>=v)            //物品的总价值已经大于背包容量可以看做是完全背包  
19.        complatePack(c,w);  
20.     else  
21.     {  
22.     int k=1;  
23.     while(k<n) //转换为01背包，二进制思想优化（例：13可以分为 1（2^0）、2（2^1）、4(2^2)、6,因为1、2、4、6这四个数可以组合成1—13中的所有数字）  
24.     {  
25.             zeroonePack(c*k,w*k);  
26.             n-=k;  
27.             k*=2;  
28.         }  
29.         zeroonePack(c*n,w*n);  
30.     }  
31. }  
32. int main()  
33. {  
34.     int num[11];  
35.     int i,j,sum,count=0;  
36.     while(1)  
37.     {  
38.         sum=0;count++;  
39.         for(i=1;i<=10;i++)  
40.         {  
41.             scanf("%d",&num[i]);  
42.             sum+=i*num[i];  
43.         }  
44.         if(sum==0) break;  
45.         printf("#%d:",count);  
46.         if(sum%2!=0)     
47.         printf("Can't be divided.\n\n");  
48.         else  
49.         {  
50.             v=sum/2;  
51.             memset(dp,0,sizeof(dp));  
52.             for(i=1;i<=10;i++)  
53.               multipiePack(i,i,num[i]);  
54.             if(dp[v]==v)  
55.                 printf("Can be divided.\n\n");  
56.             else  
57.                 printf("Can't be divided.\n\n");      
58.         }  
59.     }  
60.     return 0;  
61. }  

基本方法是转化为01背包求解：把第i种物品换成n[i]件01背包中的物品，则得到了物品数为Σn[i]的01背包问题，直接求解，复杂度仍然是O(V*Σn[i])。

但是我们期望将它转化为01背包问题之后能够像完全背包一样降低复杂度。仍然考虑二进制的思想，我们考虑把第i种物品换成若干件物品，使得原问题中第i种物品可取的每种策略——取0..n[i]件——均能等价于取若干件代换以后的物品。另外，取超过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种物品。另外这种方法也能保证对于0..n[i]间的每一个整数，均可以用若干个系数的和表示，这个证明可以分0..2^k-1和2^k..n[i]两段来分别讨论得出，并不难，希望你自己思考尝试一下。

这样就将第i种物品分成了O(log n[i])种物品，将原问题转化为了复杂度为O(V*Σlog n[i])的01背包问题，是很大的改进。

下面给出O(log amount)时间处理一件多重背包中物品的过程，其中amount表示物品的数量：

procedure MultiplePack(cost,weight,amount)

    if cost*amount>=V

        CompletePack(cost,weight)

        return

    integer k=1

    while k<num

        ZeroOnePack(k*cost,k*weight)

        amount=amount-k

        k=k*2

    ZeroOnePack(amount*cost,amount*weight)

希望你仔细体会这个伪代码，如果不太理解的话再看一下源码，单步执行几次，或者头脑加纸笔模拟一下，也许就会慢慢理解了。