揹包問題

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] 即爲所求  
        初始化分兩種情況：
        1、如果揹包要求正好裝滿則初始化 f[0] = 0, f[1~w] = -INF;  

        2、如果不需要正好裝滿 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以內任意一個數，即1、2、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;
}