多重背包POJ1276不要求恰好装满 poj1014多重背包恰好装满

二进制压缩，看背包九讲啦，写的很详细了，不赘述````

先贴不要求恰好装满的情形

POJ 1276

二进制压缩：

#include <cstdio>
#include <cstring>
int f[100005];//容量为i时最多能装多少
int p[12000];//物品拆分
int main()
{
    int n,cash;
    while(~scanf("%d%d",&cash,&n))
    {
        int vi,num;//物品价值，数量
        int cur = 0;
        memset(f,0,sizeof(f));
        for(int i=0; i<n; i++)
        {
            scanf("%d%d",&num,&vi);
            int k = 1;
            //把物品拆分成num = 1 + 2 + 4 + 8 + 16 + 32 + ``` + 2^k + l(剩余的值)
            //假设某物品有10件，拆成7=1+2+4+3。。这样，10件这样的物品变成了4件物品，用这四种物品可组和出
            //0-10的每一种情形，原理在于二进制，每位取0或者1，但是能表示出很多数
            //多重背包转化成了0-1背包
            while(num-k > 0)
            {
                p[cur]= vi*k;
                num -= k;
                k *= 2;
                cur++;
            }
            p[cur] = vi*num;
            cur++;
        }
        for(int i=0; i< cur; i++)
        {
            for(int j = cash; j >= p[i]; j--)
            {
                if(f[j] < f[j-p[i]]+p[i])
                    f[j] = f[j-p[i]]+p[i];
            }
        }
        printf("%d\n",f[cash]);
    }
    return 0;
}

另一种算法，感觉挺好的。。。

#include <cstdio>
#include <cstring>
//#define debug
int count[100005];//被使用的次数
bool vis[100005]; //是否恰好能被零散货币表示
int main()
{
    int n,i,j,cash;
#ifdef debug
    freopen("in.cpp","r",stdin);
#endif
    while(~scanf("%d",&cash))
    {
        scanf("%d",&n);
        memset(vis,0,sizeof(vis));//vis用来表示是否恰好被装满
        vis[0] = 1;
        for(i=0; i<n; ++i)
        {
            int v,num;
            scanf("%d%d",&num,&v);
            memset(count,0,sizeof(count));//用来记录该物品被用过几次，每次都得重新赋值，麻烦的
            for(j=v; j<=cash; ++j)
            {
                int t = j-v;
                if(!vis[j] && vis[t] && count[t] < num)//用过的次数>=num。就不行了
                {
                    vis[j] = 1;
                    count[j] = count[t] + 1;
                }
            }
        }
        for(i=cash; i>=0; --i)
        {
            if(vis[i])
            {
                printf("%d\n",i);
                break;
            }
        }
    }
    return 0;
}

该算法复杂度为O（N*M），貌似和单调队列优化的复杂度差不多

再贴恰好要装满的情形

POJ 1014

#include <cstdio>
int f[500000];
int p[2000];
int main()
{
    int ser = 0;
    while(1)
    {
        int n[7];
        int sum =0;
        int cur =0;
        for(int i=1; i<= 6; i++)
        {
            scanf("%d",&n[i]);
            sum += i*n[i];
            int k = 1;
            while(n[i] - k > 0)
            {
                p[cur] = i*k;
                cur++;
                n[i] -= k;
                k *= 2;
            }
            p[cur] = n[i]*i;
            cur++;
        }
        if(sum == 0) break;
        if(sum%2 == 1)
        {
            printf("Collection #%d:\n",++ser);
            printf("Can't be divided.\n\n");
            continue;
        }
        sum = sum/2;
        for(int i=1 ; i <= sum; i++)
            f[i] = -1000;
        f[0] = 0;
        for(int i=0; i < cur && f[sum] < 0; i++)
        {
            for(int j= sum; j >0; j--)
            {
                if(j - p[i] < 0) continue;
                if(f[j-p[i]] >= 0 && f[j-p[i]]+p[i] > f[j])
                {
                    f[j] = f[j-p[i]]+p[i];
                    if(j == sum )  break;
                }
            }
        }
        printf("Collection #%d:\n",++ser);
        if(f[sum] == sum)
            printf("Can be divided.\n\n");
        else
            printf("Can't be divided.\n\n");
    }
    return 0;
}