经典背包问题 01背包+完全背包+多重背包

01 背包

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

[cpp]view plaincopyprint?

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]);  

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]);

 

 

完全背包 

如果物品不计件数，就是每个物品不只一件的话，稍微改下即可  

[cpp]view plaincopyprint?

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]);  

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 背包求解了。  
       看代码：  
      

[cpp]view plaincopyprint?

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;  

    }  

}  

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和完全背包：

[cpp]view plaincopyprint?

#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;  

}  

#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背包，用二进制优化：

[cpp]view plaincopyprint?

#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>

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;

}

 

未优化的：

[cpp]view plaincopyprint?

#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;  

}  

#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;

}