DP(正解完全背包+容斥)

DP

Time Limit:10000MS     Memory Limit:165888KB     64bit IO Format:%lld & %llu

Submit Status

Description

　　硬币购物一共有4种硬币。面值分别为c1,c2,c3,c4。某人去商店买东西，去了tot次。每次带di枚ci硬币，买s
i的价值的东西。请问每次有多少种付款方法。

Input

　　第一行 c1,c2,c3,c4,tot 下面tot行 d1,d2,d3,d4,s,其中di,s<=100000,tot<=1000

Output

　　每次的方法数

Sample Input

1 2 5 10 2
3 2 3 1 10
1000 2 2 2 900

Sample Output

4
27

//背包问题，容斥原理
//不得不说这是个好题，背包问题应该都会，主要是这个容斥原理，要理解，举个例子说明下日常中经常遇到的这个定理

一次考试，某班有15人数学得满分，有12人语文得满分，并且有4人语、数都是满分，那么这个班至少有一门得满分的同学有多少人？
答案：15+12-4=23

思路是，首先不限制4种钱币的个数，看组成某个价格的方案数共有多少
然后借助容斥定理减去4种钱币超过个数限制的情况，就不多不少的求出答案

dp[i]表示了|不限制| 硬币数目的最多付款方法，怎么转移应该都会
 那么只需将
 dp[res]
 -d1超过的限制数 - d2超过的... - d3... - d4...
 + (d1与d2) + ... + (d3与d4)
 - (d1,d2,d3)
 + (d1+d2+d3+d4)
 就行了

如果还不理解再继续看
这题的运用容斥定理，看了篇博客，例子写的很好，不然我真不太好理解，尤其是 d[i]++ 是为什么
我们来理解 x = dp[s]-dp[s-(d1+1)*c1] 的含义：
x 表示 c1 硬币的数量不超过 d1 个而其他三种硬币的数量不限制拼成 s 的方案数。
我们举着例子来说明，假设现在有两种硬币，面值分别为1和2，
那么我们求出 dp: dp[0]=1 , dp[1]=1 , dp[2]=2 , dp[3]=2 , dp[4]=3 , dp[5]=3 , dp[6]=4 。
其中dp[3]的两种分别为 3 = 1+1+1 = 1+2 ,dp[6]的四种为: 6 = 1+1+1+1+1+1 = 1+1+1+1+2 = 1+1+2+2 = 2+2+2 
假如我们现在求第一种硬币最多使用两个，第二种硬币无限制的方案数，按照我们说的 x = dp[6]-dp[6--(2+1)*1]=dp[6]-dp[3]=2。
也就是 6 = 1+1+2+2 = 2+2+2 两种。发现删除了 1+1+1+1+1+1 和 1+1+1+1+2 两种情况，
为什么能够通过减去 dp[3] 删掉这两种？我们来看 dp[3]， 3 = 1+1+1 = 1+2 ，
d1+1 就是相当于用掉了 di 个硬币,所以 dp[3] 的情况要从答案中剔除

先来易懂的用for容斥的代码

 #include <iostream>
 #include <stdio.h>
 using namespace std;

 typedef long long LL;
 #define MAX 100005

 LL c[],d[];
 LL dp[MAX];
 LL ans;

 int main()
 {
     for (int i=;i<=;i++)
     scanf("%lld",&c[i]);
     int tot;
     scanf("%lld",&tot);
     dp[]=;
     for (int i=;i<=;i++)
         for (int j=c[i];j<=;j++)
             dp[j]+=dp[j-c[i]];
     while (tot--)
     {
         LL res;
         for (int i=;i<=;i++)
         {
             scanf("%lld",&d[i]);
             d[i]++;
         }

         scanf("%lld",&res);
         ans=dp[res];

         int i,j,k;
         for (i=;i<=;i++)
             if (res>=c[i]*d[i])
             ans-=dp[res-c[i]*d[i]];

         for (i=;i<=;i++)
             for (j=i+;j<=;j++)
             if (res>=c[i]*d[i]+c[j]*d[j])
             ans+=dp[res-c[i]*d[i]-c[j]*d[j]];
         for (i=;i<=;i++)
             for (j=i+;j<=;j++)
                 for (k=j+;k<=;k++)
                 if (res>=c[i]*d[i]+c[j]*d[j]+c[k]*d[k])
                 ans-=dp[res-c[i]*d[i]-c[j]*d[j]-c[k]*d[k]];
         if (res>=c[]*d[]+c[]*d[]+c[]*d[]+c[]*d[])
             ans+=dp[res-c[]*d[]-c[]*d[]-c[]*d[]-c[]*d[]];

         printf("%lld\n",ans);

     }
     return ;
 }

这个是DFS去处理容斥，简洁明了，时间是一样的

 #include <iostream>
 #include <stdio.h>
 using namespace std;

 typedef long long LL;
 #define MAX 100005

 LL c[],d[];
 LL dp[MAX];
 LL ans;

 void dfs(int x,int k,LL s)
 {
     if (s<)return;
     if (x==)
     {
         if (k%)ans-=dp[s];
         else ans+=dp[s];
         return;
     }
     dfs(x+,k+,s-(d[x]+)*c[x]);
     dfs(x+,k,s);
 }
 int main()
 {
     for (int i=;i<=;i++)
     scanf("%lld",&c[i]);
     int tot;
     scanf("%lld",&tot);
     dp[]=;
     for (int i=;i<=;i++)
         for (int j=c[i];j<=;j++)
             dp[j]+=dp[j-c[i]];

     while (tot--)
     {
         LL res;
         for (int i=;i<=;i++)
             scanf("%lld",&d[i]);

         scanf("%lld",&res);
         ans= ;
         dfs(,,res);
         printf("%lld\n",ans);
     }
     return ;
 }