经典背包问题 01背包+彻底背包+多重背包

转自http://blog.csdn.net/lyhvoyage/article/details/8545852

01 背包

有n 种不一样的物品，每一个物品有两个属性，size 体积，value 价值，如今给一个容量为 w 的背包，问最多可带走多少价值的物品。  

 int f[w+1];   //f[x] 表示背包容量为x 时的最大价值
 for (int i=0; i<n; i++)
     for (int j=w; j>=size[i]; j--)
         f[j] = max(f[j], f[j-size[i]]+value[i]);

彻底背包 

若是物品不计件数，就是每一个物品不仅一件的话，稍微改下便可  

 for (int i=0; i<n; i++)
     for (int j=size[i]; j<=w; j++)
         f[j] = max(f[j], f[j-size[i]]+value[i]);

         f[w] 即为所求  
        初始化分两种状况：
        一、若是背包要求正好装满则初始化 f[0] = 0, f[1~w] = -INF;  

        二、若是不须要正好装满 f[0~v] = 0;  

        举例：

01背包

V=10，N=3，c[]={3,4,5}, w={4,5,6}

（1）背包不必定装满

      计算顺序是：从右往左，自上而下：由于每一个物品只能放一次，前面的体积小的会影响体积大的

（2）背包恰好装满    

      计算顺序是：从右往左，自上而下。注意初始值，其中-inf表示负无穷

彻底背包 ：

V=10，N=3，c[]={3,4,5}, w={4,5,6}

（1）背包不必定装满

计算顺序是：从左往右，自上而下：  每一个物品能够放屡次，前面的会影响后面的

（2）背包恰好装满

计算顺序是：从左往右，自上而下。注意初始值，其中-inf表示负无穷

多重背包 ：  
         多重背包问题要求很简单，就是每件物品给出肯定的件数，求 可获得的最大价值  
         多重背包转换成 01 背包问题就是多了个初始化，把它的件数C 用二进制 分解成若干个件数的集合，这里面数字能够组合成任意小于等于C 的件数，并且不会重复，之因此叫二进制分解，是由于这样分解可 以用数字的二进制形式来解释  
       好比：7的二进制 7 = 111 它能够分解成 001 010 100 这三个数能够 组合成任意小于等于7 的数，并且每种组合都会获得不一样的数  
       15 = 1111 可分解成 0001  0010  0100  1000 四个数字  
        若是13 = 1101 则分解为 0001 0010 0100 0110 前三个数字能够组合成   7之内任意一个数，即一、二、4能够组合为1——7内全部的数，加上 0110 = 6 能够组合成任意一个大于6 小于等于13 的数，好比12，可让前面贡献6且后面也贡献6就好了。虽然有重复但老是能把 13 之内全部的数都考虑到了，基于这种 思想去把多件物品转换为，多种一件物品，就可用01 背包求解了。  
       看代码：  
      

 int n;  //输入有多少种物品
 int c;  //每种物品有多少件
 int v;  //每种物品的价值
 int s;  //每种物品的尺寸
 int count = 0; //分解后可获得多少种物品
 int value[MAX]; //用来保存分解后的物品价值
 int size[MAX];  //用来保存分解后物品体积

 scanf("%d", &n);    //先输入有多少种物品，接下来对每种物品进行分解

 while (n--)     //接下来输入n中这个物品
 {
     scanf("%d%d%d", &c, &s, &v);  //输入每种物品的数目和价值
     for (int k=1; k<=c; k<<=1)   //<<右移 至关于乘二
     {
         value[count] = k*v;
         size[count++] = k*s;
         c -= k;
     }
     if (c > 0)
     {
         value[count] = c*v;
         size[count++] = c*s;
     }
 }

定理：一个正整数n能够被分解成1,2,4,…,2^(k-1),n-2^k+1（k是知足n-2^k+1>0的最大整数）的形式，且1～n以内的全部整数都可以惟一表示成1,2,4,…,2^(k-1),n-2^k+1中某几个数的和的形式。

证实以下：

（1） 数列1,2,4,…,2^(k-1),n-2^k+1中全部元素的和为n，因此若干元素的和的范围为：[1, n]；

（2）若是正整数t<= 2^k – 1,则t必定能用1,2,4,…,2^(k-1)中某几个数的和表示，这个很容易证实：咱们把t的二进制表示写出来，很明显，t能够表示成n=a0*2^0+a1*2^1+…+ak*2^（k-1），其中ak=0或者1，表示t的第ak位二进制数为0或者1.

（3）若是t>=2^k,设s=n-2^k+1，则t-s<=2^k-1，于是t-s能够表示成1,2,4,…,2^(k-1)中某几个数的和的形式，进而t能够表示成1,2,4,…,2^(k-1)，s中某几个数的和（加数中必定含有s）的形式。

（证毕！）

      

        如今用count 代替 n 就和01 背包问题彻底同样了  

杭电2191题解：

此为多重背包用01和彻底背包：

 #include<stdio.h>
 #include<string.h>
 int dp[102];
 int p[102],h[102],c[102];
 int n,m;
 void comback(int v,int w)//经费，重量。彻底背包；
 {
     for(int i=v; i<=n; i++)
         if(dp[i]<dp[i-v]+w)
             dp[i]=dp[i-v]+w;
 }
 void oneback(int v,int w)//经费，重量；01背包；
 {
     for(int i=n; i>=v; i--)
         if(dp[i]<dp[i-v]+w)
             dp[i]=dp[i-v]+w;
 }
 int main()
 {
     int ncase,i,j,k;
     scanf("%d",&ncase);
     while(ncase--)
     {
         memset(dp,0,sizeof(dp));
         scanf("%d%d",&n,&m);//经费，种类；
         for(i=1; i<=m; i++)
         {
             scanf("%d%d%d",&p[i],&h[i],&c[i]);//价值，重量，数量;
             if(p[i]*c[i]>=n) comback(p[i],h[i]);
             else
             {
                 for(j=1; j<c[i]; j<<1)
                 {
                     oneback(j*p[i],j*h[i]);
                     c[i]=c[i]-j;
                 }
                 oneback(p[i]*c[i],h[i]*c[i]);
             }
         }
         printf("%d\n",dp[n]);
     }
     return 0;
 }

只是用01背包，用二进制优化：

 #include <iostream>
 using namespace std;
 int main()
 {
     int nCase,Limit,nKind,i,j,k,  v[111],w[111],c[111],dp[111];
     //v[]存价值，w[]存尺寸，c[]存件数
     //在本题中，价值是米的重量，尺寸是米的价格
     int count,Value[1111],size[1111];
     //count存储分解完后的物品总数
     //Value存储分解完后每件物品的价值
     //size存储分解完后每件物品的尺寸
     cin>>nCase;
     while(nCase--)
     {
         count=0;
         cin>>Limit>>nKind;
         for(i=0; i<nKind; i++)
         {
             cin>>w[i]>>v[i]>>c[i];
             //对该种类的c[i]件物品进行二进制分解
             for(j=1; j<=c[i]; j<<=1)
             {
                 //<<右移1位，至关于乘2
                 Value[count]=j*v[i];
                 size[count++]=j*w[i];
                 c[i]-=j;
             }
             if(c[i]>0)
             {
                 Value[count]=c[i]*v[i];
                 size[count++]=c[i]*w[i];
             }
         }
         //通过上面对每一种物品的分解，
         //如今Value[]存的就是分解后的物品价值
         //size[]存的就是分解后的物品尺寸
         //count就至关于原来的n
         //下面就直接用01背包算法来解
         memset(dp,0,sizeof(dp));
         for(i=0; i<count; i++)
             for(j=Limit; j>=size[i]; j--)
                 if(dp[j]<dp[j-size[i]]+Value[i])
                     dp[j]=dp[j-size[i]]+Value[i];

         cout<<dp[Limit]<<endl;
     }
     return 0;
 }

未优化的：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;

 int Value[105];
 int Cost[105];
 int Bag[105];
 int dp[105];

 int main()
 {
     int C,m,n;
     scanf("%d",&C);
     while(C--)
     {
         scanf("%d%d",&n,&m);
         for(int i = 1; i <= m; i++)
             scanf("%d%d%d",&Cost[i],&Value[i],&Bag[i]);
         memset(dp,0,sizeof(dp));
         for(int i=1; i<= m; i++)
             for(int j=1; j<=Bag[i]; j++)
                 for(int k=n; k>=Cost[i]; k--)
                     dp[k]=max(dp[k], dp[k-Cost[i]]+Value[i]);
         printf("%d\n",dp[n]);
     }
     return 0;
 }