揹包问题-01/完全/多重

揹包问题是典型的动态规划的问题

对于0/1揹包，东西有两种选择，

第一，weight大于揹包剩余体积，放弃之，

第二，weight小于揹包剩余体积，再有两种选择，第一，不划算，放弃不要。。。第二，要，放进揹包

于是就有

weight[i]<=C  dp[i][j]=max(放进去，不放进去);

对于递归的写法，不提倡，因为如同Fib的写法，效率很低，时间复杂度接近N^2

int knapSack(int C,int N, int weight[], int price[]){
    if(C==0 || N==0)
        return 0;
    if(weight[N]>C)
        return knapSack(C,N-1,weight,price);
    else
        return max(knapSack(C-weight[N],N-1,weight,price)+price[N],knapSack(C,N-1,weight,price));
}

对于递归没有把以前算的值存起来导致的效率低下，我们可以考虑用二维数组来存贮，这样就不要算N遍了。

改进版的应该是这样的，但是用的还是递归的思想。

#include <iostream>
#include <queue>
#include <string>
#include <memory>
#include <algorithm>
#include <map>
using namespace std;;
int price[501],weight[501];
int dp[10][501];
int N,C;//N is the num of stuff, C is the capacity of bag
int main(void){
    freopen("input.txt","r",stdin);
    memset(price,0,sizeof(price));
    memset(weight,0,sizeof(weight));
    memset(dp,0,sizeof(dp));
    cin>>N>>C;
    for(int i=1;i<=N;i++)
        cin>>price[i]>>weight[i];

    for(int i=1;i<=N;i++){
        for(int j=1;j<=C;j++){
            dp[i][j] = dp[i-1][j];
            if(weight[i]<=j)
                dp[i][j]=max(dp[i-1][j-weight[i]]+price[i],dp[i-1][j]);
        }
    }
    cout<<dp[N][C]<<endl;
    return 0;
}

时间复杂度为O(NC)，空间复杂度即二维数组复杂度，O(NC)，我们可以优化空间复杂度，即用一维数组代替二维。

但是0/1的一维数组代替是N正序，C倒序。。。。。

#include <iostream>
#include <queue>
#include <string>
#include <memory>
#include <algorithm>
#include <map>
using namespace std;;
int price[501],weight[501];
const int num_case = 1;
int dp[501];
int N,C;
int main(void){
    freopen("input.txt","r",stdin);
    //init data
    memset(price,0,sizeof(price));
    memset(weight,0,sizeof(weight));
    memset(dp,0,sizeof(dp));
    cin>>N>>C;
    for(int i=1;i<=N;i++)
        cin>>price[i]>>weight[i];

    for(int i=1;i<=N;i++){
        for(int j=C;j>=1;j--){
            if(weight[i]<=j)
                dp[j]=max(dp[j-weight[i]]+price[i],dp[j]);
        }
    }
    cout<<dp[C]<<endl;

    return 0;
}

如果N正序，C也正序的话，那是什么了？---------> 完全揹包的一维数组解决方案

思想摘录自博文：http://love-oriented.com/pack/P01.html

先考虑上面讲的基本思路如何实现，肯定是有一个主循环i=1..N，每次算出来二维数组f[i][0..V]的所有值。那么，如果只用一个数组f[0..V]，能不能保证第i次循环结束后f[v]中表示的就是我们定义的状态f[i][v]呢？f[i][v]是由f[i-1][v]和f[i-1][v-c[i]]两个子问题递推而来，能否保证在推f[i][v]时（也即在第i次主循环中推f[v]时）能够得到f[i-1][v]和f[i-1][v-c[i]]的值呢？事实上，这要求在每次主循环中我们以v=V..0的顺序推f[v]，这样才能保证推f[v]时f[v-c[i]]保存的是状态f[i-1][v-c[i]]的值。伪代码如下：

for i=1..N
    for v=V..0
        f[v]=max{f[v],f[v-c[i]]+w[i]};
其中的f[v]=max{f[v],f[v-c[i]]}一句恰就相当于我们的转移方程f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]}，因为现在的f[v-c[i]]就相当于原来的f[i-1][v-c[i]]。如果将v的循环顺序从上面的逆序改成顺序的话，那么则成了f[i][v]由f[i][v-c[i]]推知，与本题意不符，但它却是另一个重要的揹包问题P02最简捷的解决方案，故学习只用一维数组解01揹包问题是十分必要的。

完全揹包问题：

完全揹包，是N的数量不穷尽，不是拿完了就没了，所以我们从比较好理解的二维数组入手，它应该是这样的。

#include <iostream>
#include <queue>
#include <string>
#include <memory>
#include <algorithm>
#include <map>
using namespace std;;
int price[501],weight[501];
const int num_case = 1;
int dp[51][501];
int N,C;
int main(void){
    freopen("input.txt","r",stdin);
    //init data
    memset(price,0,sizeof(price));
    memset(weight,0,sizeof(weight));
    memset(dp,0,sizeof(dp));
    cin>>N>>C;
    for(int i=1;i<=N;i++)
        cin>>price[i]>>weight[i];

    for(int i=1;i<=N;i++){
        for(int j=1;j<=C;j++){
            dp[i][j] = dp[i-1][j];
            if(weight[i]<=j)
                dp[i][j]=max(dp[i][j-weight[i]]+price[i],dp[i-1][j]);
        }
    }
    cout<<dp[N][C]<<endl;

    return 0;
}

对于二维数组dp[i][j], 计算第N行的dp[i][] 都是将dp[i-1][] 先行拷贝下来，如果放进去的数值大于它，则更新。

如果是这样的话，每行的DP操作，都不会涉及到上一行之前的数据，所以可以用一维数组来代替

#include <iostream>
#include <queue>
#include <string>
#include <memory>
#include <algorithm>
#include <map>
using namespace std;;
int price[501],weight[501];
const int num_case = 1;
int dp[501];
int N,C;
int main(void){
    freopen("input.txt","r",stdin);
    //init data
    memset(price,0,sizeof(price));
    memset(weight,0,sizeof(weight));
    memset(dp,0,sizeof(dp));
    cin>>N>>C;
    for(int i=1;i<=N;i++)
        cin>>price[i]>>weight[i];

    for(int i=1;i<=N;i++){
        for(int j=1;j<=C;j++){
            if(weight[i]<=j)
                dp[j]=max(dp[j-weight[i]]+price[i],dp[j]);
        }
    }
    cout<<dp[C]<<endl;

    return 0;
}

注意：在一维数组的0/1揹包中，C是倒序。一维数组的完全揹包中，C是正序，这是他们唯一的区别

多重揹包问题

说到多重揹包，就只得去看揹包九讲的内容了。不再阐述。

但是下面的代码，确实用一维数组做出来的最全面的集合体了。

zeroOnePack ==== 0/1

multiPack =======多重

completePack =====完全

它是将N的枚举作为main中，因为他们几个的N枚举都是正序。

Weight的枚举，0/1是逆序，complete是正序

多重是先试试complete，如果不行就用0/1暴力破解。

但是中间加入了logN的K=K*2这种处理做出了部分优化，下面的代码希望能够理解。

#include <iostream>
#include <queue>
#include <string>
#include <memory>
#include <algorithm>
#include <map>
using namespace std;
const int M=501;
int num[M],price[M],weight[M];
//num=object's number...price=object's price...weight=object's weight.
//weight should be less than C
//price stored in dp[], the more the better.
int dp[M];
int N,C;
extern int zeroOnePack(int p, int w);//p and w is int, not int[]
extern int multiPack(int p, int w, int n);
extern int completePack(int p, int w);
int main(void){
    freopen("input.txt","r",stdin);
    //init data
    memset(num,0,sizeof(num));
    memset(price,0,sizeof(price));
    memset(weight,0,sizeof(weight));
    memset(dp,0,sizeof(dp));
    cin>>N>>C;
    for(int i=1;i<=N;i++){
        cin>>num[i]>>price[i]>>weight[i];
        //cin>>price[i]>>weight[i];
    }
    for(int i=1;i<=N;i++){
        //zeroOnePack(price[i],weight[i]);
        //completePack(price[i],weight[i]);
        multiPack(price[i],weight[i],num[i]);
    }
    cout<<dp[C]<<endl;
    return 0;
}
int zeroOnePack(int p, int w){
    for(int j=C;j>=w;j--){
        dp[j]=max(dp[j-w]+p,dp[j]);
    }
    return 0;
}
int completePack(int p, int w){
    for(int j=w;j<=C;j++){
        dp[j]=max(dp[j-w]+p,dp[j]);
    }
    return 0;
}
int multiPack(int p, int w, int n){
    if(w*n>=C){
        completePack(p,w);
        return 0;
    }
    int k=1;
    while(k<n){
        zeroOnePack(p*k,w*k);
        n=n-k;
        k=2*k;
    }
    zeroOnePack(p*n,w*n);
    return 0;
}

写在最后

如果感觉对这几种揹包都熟悉了，就可以找以下链接去练习一下。

http://blog.csdn.net/liuqiyao_01/article/details/8477725

网路上还有个 ” 揹包九讲“ 研究的很是深刻，可自行搜索。