POJ - 1742 Coins（多重背包—二进制优化，背包可行性，单调队列优化）

多重背包习题POJ - 1742

题目大意：有n种不同价值的硬币，每种硬币对应一个数量，求它们能在价值为m的背包内拼凑出不同价值数量（1~m）。

这道题背包体积<=100000，最大的背包价值和数量(1<=Ai<=100000,1<=Ci<=1000)

dp[i]背包容量为i时的最大价值
v[i]硬币的价值等同于体积
w[i]硬币的数量

1. 不优化的多重背包(TLE)

for(i=1;i<=n;i++)
      for(j=m;j>=0;j--)
           for(k=0;k<=w[i];k++) 
           {
                if(j-k*v[i]<0)   break;
                dp[j]=max(dp[j],dp[j-k*v[i]]+k*v[i]);
          }

超时

2. 二进制优化的多重背包(TLE)

原理：1到n以内的数字，能够通过 n 内的进制数组合得

方法：统一做二进制拆分然后做01背包处理

下面是拆分的过程：
9 - 1 = 8； 8 - 2 = 6； 6 - 4 = 2 ； 2 - 8 < 0；
所以1,2,4,2能组成9以内包括9的所有整数

int ans=1;
for(int i=1;i<=n;i++)
       {
           scanf("%d",&w[i]);
           for(int j=1;j<=w[i];j<<2)
           {
               w2[ans++]=v[i]*j;
               w[i]-=j;
           }
           if(w[i]>0)
           {
               w2[ans++]=v[i]*w[i];
           }
       }

我们将每种硬币的数量进行二进制优化，将从(0,w[i])的遍历,优化到了(1,ans-1)的遍历,然后将w2[]按01背包进行处理

int sum=0;
       for(int i=1;i<=ans-1;i++)
       {
           for(int j=m;j>=w2[i];j--)
           {
               dp[j]=max(dp[j],dp[j-w2[i]]+w2[i]);
               if(dp[j]==j&&visit[j]==0)
               {
                   visit[j]=1;
                   sum++;
               }
           }
       }
       printf("%d\n",sum);

约O（nmlog2(cnt)）还是超时

3. 二级制优化后再优化的多重背包(TLE)

方法：硬币的数量*硬币的价值的总和大于规定的 V 的时候，可以直接把他当做完全背包处理（如果用完全背包的话，一个物品不用拆分就能完成这个硬币的dp操作）

for(int i=1;i<=n;i++)
       {
           if(v[i]*w[i]>=m)
         {
             for(int j=v[i];j<=m;j++)
             {
                 dp[j]=max(dp[j],dp[j-v[i]]+v[i]);
             }
         }
           else
         {
             for(int j=1;j<=w[i];j*=2)
             {
                 for(int k=m;k>=v[i]*j;k--)
                 {
                     dp[k]=max(dp[k],dp[k-v[i]*j]+v[i]*j);
                 }
                 w[i]-=j;
             }
             if(w[i]>0)
             {
                 for(int j=m;j>=v[i]*w[i];j--)
                     dp[j]=max(dp[j],dp[j-v[i]*w[i]]+v[i]*w[i]);
             }
         }
       }

不幸的是还是TLE
二进制优化模板

#include<iostream>
#include<algorithm>
using namespace std;
int bag;
int dp[100001];
int v[101];
int w[101];
void zeroonepack(int weight,int value)//01背包
{
    for(int i=bag;i>=weight;i--)
    {
       dp[i]=max(dp[i],dp[i-weight]+value);
    }
}
void completepack(int weight,int value)//完全背包
{
    for(int i=weight;i<=bag;i++)
    {
        dp[i]=max(dp[i],dp[i-weight]+value);
    }
}

void multiplepack(int weight,int value,int number)//多重背包
{
    if(bag<=weight*number)//如果总容量不大于这个物品的总容量，相当于这个物品可以单独填满背包，相当于完全背包
    {
        completepack(weight,value);
    }
    else//否则就转化为01背包
    {
        int k=1;
        while(k<=number)
        {
            zeroonepack(k*weight,k*value);
            number-=k;
            k*=2;
        }
        zeroonepack(number*weight,number*value);//number二进制拆分后多余的数
    }
}
int main()
{
    int n;
    while(~scanf("%d%d",&n,&bag))
    {
        memset(dp,0,sizeof(dp));
        if(n==0&&bag==0)
        {
            break;
        }
        for(int i=0;i<n;i++)
        scanf("%d",&v[i]);
        for(int i=0;i<n;i++)
        scanf("%d",&w[i]);
        for(int i=0;i<n;i++)
        {
            multiplepack(v[i],v[i],w[i]);
        }
        int ans=0;
        for(int i=1;i<=bag;i++)
        {
            if(i==dp[i])//dp[i]表示的是背包容量为i时的最大价值，该题可视为容量与价值相等
            {
                ans++;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

4. 多重背包的可行性（AC）

方法：每种硬币*它的数量所能达到的每一种价值都用标记数组进行记录，标记过的点不再访问，标记过的点看该处的硬币价值是否满足dp[j-w[i]]被访问过（能被凑成），硬币数量足够

dp[0]=1;
       int ans=0;
       for(int i=1;i<=n;i++)
       {
           memset(visit,0,sizeof(visit));
           for(int j=v[i];j<=m;j++)
           {
               if(dp[j]==0&&dp[j-v[i]]==1&&visit[j-v[i]]+1<=w[i])
               {
                   dp[j]=1;
                   visit[j]=visit[j-v[i]]+1;
                   ans++;
               }
           }
       }

5. 普通单调队列优化多重背包（TLE）

（啃完这个一天就这么过去了╮(╯▽╰)╭）

//本题v[i]=w[i]
#include<iostream>
#include<algorithm>
using namespace std;
int v[105];
int w[105];
int num[100001];
int q[100001];
int dp[100001];
int l,r,n,bag;
int main()
{
    while(~scanf("%d%d",&n,&bag))
    {
        if(n==0&&bag==0)
        break;
        for(int i=0;i<=bag;i++)
        {
            dp[i]=0;
        }
        for(int i=0;i<n;i++)
           scanf("%d",&v[i]);
        for(int i=0;i<n;i++)
           scanf("%d",&w[i]);
        for(int i=0;i<n;i++)
        {
            if(w[i]>(bag/v[i]))//缩小滑动区间的范围
                w[i]=bag/v[i];
            for(int b=0;b<v[i];b++)//余数b的范围
            {
                 l=r=1;
                 for(int t=0;t<=(bag-b)/v[i];t++)//t最大取x,最小取0
                 {
                     int temp=dp[t*v[i]+b]-t*v[i];
                     while(l<r&&q[r-1]<=temp)
                        r--;
                     q[r]=temp;
                     num[r++]=t;
                     while(l<r&&t-num[l]>w[i])//滑动区间超过该硬币的数量
                        l++;//队首出列，因为维护的是单调递减的队列，所以队首为最大值，再加上t*w[i]
                     dp[t*v[i]+b]=max(dp[t*v[i]+b],q[l]+t*v[i]);
                 }
            }
        }
        int ans=0;
        for(int i=1;i<=bag;i++)
        {
            if(dp[i]==i)
            {
                ans++;
            }
        }
        printf("%d\n",ans);
    }
   return 0;
}

憨龟众多优化都失败告终，下面给出大牛们以队列优化和二进制优化AC

传送门1二进制优化
传送门2队列优化

总结一下，虽然TLE了很多次，但也学到了解决问题的许多种办法，以及不断优化时间复杂度的思想。