HDU 1059 Dividing 多重背包

今天学了一下多重背包，这是我A的第一个题，刚开始用用比较暴力的，没优化的多重背包就TLE了。代码如下：

#include<stdio.h>
#include<stdlib.h>
int DP( int val[], int N )
{
    int f[100024]={0};
    for( int i=1;i<=6; i++ )//取不同的元素
    {
        for( int  j=1; j<=val[i]; j++ )//取元素的个数
        {
             for( int k=N; k>=0; k-- )
             {
                int t=j*i;
                if( t<=k&&f[ k-t ]+t>f[k] )
                {
                  f[k]=f[k-t]+t;
      //            printf( "t==%d f[%d]==%d\n",t,k,f[k] );
                  }
                if( f[N]==N )
                   return 1; 
             }  
        }     
    } 
    return  0;    
}
int main()
{
    int val[7],sum,flag,k=0;
    while( 1 )
    {
       k++;
       sum=flag=0;
       for( int i=1; i<=6; i++ )
        {
           scanf( "%d",&val[i] );
           if(val[i])
            sum+=val[i]*i;
            else flag++;    
        }
        if( flag==6 )
          break;
          printf( "Collection #%d:\n",k );
        if( sum&1 )
          printf( "Can't be divided.\n" );
        else if( DP ( val,sum/2 ) ) 
              printf( "Can be divided.\n" );
              else  printf( "Can't be divided.\n" );      
    }
    return 0;    
}

下面我们先来看一下二进制优化的多重背包代码实现，在诠释一下

#include<stdio.h>
#include<stdlib.h>
void ZoreOnePack( int f[], int n,int weight,int N )
{
     int t=n*weight;
    for( int k=N; k>=0;k-- )
    {
        if( k>=t && f[ k-t ]+t>f[k] )
        f[k]=f[k-t]+t;     
        if( f[N]==N )
        return ;
    }
         
}
void CompletePack( int f[],int weight,int N )
{
     for( int k=0;k<=N; k++ )
     {
        if( k>=weight&&f[ k- weight ]+weight>f[ k ] )
         f[ k ]=f[ k- weight ]+weight;
           if( f[N]==N )
              return ;
     }     
}
int  DP(int val[],int N)
{
     int f[100024]={0};
    for( int i=1; i<=6; i++ )
    {
          if( i*val[i]>=N )
          CompletePack( f, i, N ); 
          else 
          {
              int k=1,count=val[i];
              while( k<val[i] )
              {
                  ZoreOnePack(  f,  k, i, N );
                  count=count-k;
                  k=k<<1;      
              } 
              ZoreOnePack(  f,  count, i, N ) ;    
          }
         if( f[ N ]==N )
         return 1;  
                  
    }
    return 0;     
}
int main()
{
     int val[7],sum,flag,k=0;
    while( 1 )
    {
       k++;
       sum=flag=0;
       for( int i=1; i<=6; i++ )
        {
           scanf( "%d",&val[i] );
           if(val[i])
            sum+=val[i]*i;
            else flag++;    
        }
        if( flag==6 )
          break;
          printf( "Collection #%d:\n",k );
        if( sum&1 )
          printf( "Can't be divided.\n" );
        else if( DP ( val,sum/2 ) ) 
              printf( "Can be divided.\n" );
              else  printf( "Can't be divided.\n" );
              puts("");    
}
     return 0;
}

　　

基本方法是转化为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)

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