hdu 2159FATE(完全背包)

传送门

https://www.cnblogs.com/violet-acmer/p/9852294.html

题解：

　　思路一：完全背包转“01”背包

　　　　考虑到第ki个怪最多杀min(m/b[ki],s)个，于是可以把第ki个怪转化为min(m/b[ki],s)个忍耐度及经验值均不变的怪，然后求解这个01背包问题。

　　　　(1):不用滚动数组优化

　　　　　　本题有三个限制条件①怪物种类②忍耐度③杀怪数。

　　　　　　如果不使用滚动数组优化空间，则需要开个三维数组dp[ maxMaster ][ max_m ][ max_s ]。

　　　　　　dp[ tot ][ i ][ j ]的含义是杀第tot个怪时，耗费 i 个忍耐度和 j 个杀怪数所获得的最大经验值。　　

 void Solve()
 {
     int tot=;//把所有的 ki 怪转化为min(s,m/b[ki])个忍耐度及经验值均不变的物品时的总个数
     for(int kind=;kind <= k;++kind)
     {
         int x=min(s,m/b[kind]);//第 ki 个怪最多可转化成 x 个
         while(x--)//将这 x 依次加入到背包中
         {
             for(int i=;i <= m;++i)//当前耗费的忍耐度
                 for(int j=;j <= s;++j)//当前杀怪数
                     if(i >= b[kind])
                         dp[tot][i][j]=max(dp[tot-][i][j],dp[tot-][i-b[kind]][j-]+a[kind]);
                     else
                         dp[tot][i][j]=dp[tot-][i][j];
             tot++;
         }
     }
 }

　　　　　　思路完全正解，提交试试，返回的结果竟然是MLE...............

　　　　(2):使用滚动数组优化

　　　　　　既然MLE，那我用滚动数组优化一下总行了吧

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 #define mem(a,b) memset(a,b,sizeof(a))
 const int maxn=+;

 int n,m,k,s;
 int a[maxn],b[maxn];
 int dp[maxn][maxn];

 int Solve()
 {
     mem(dp,);
     bool index=;
     for(int kind=;kind <= k;++kind)
     {
         int x=min(m/b[kind],s);
         while(x--)//x 个 ki 怪物
         {
             for(int i=m;i >= b[kind];--i)
                 for(int j=;j <= s;++j)
                     dp[i][j]=max(dp[i][j],dp[i-b[kind]][j-]+a[kind]);
         }
     }
     int res=m+;
     for(int i=;i <= m;++i)
         for(int j=;j <= s;++j)
             if(dp[i][j] >= n)
                 res=(res > i ? i:res);//找到经验值达到n以上的最小的忍耐度
     return m-res;
 }

 int main()
 {
     while(~scanf("%d%d%d%d",&n,&m,&k,&s))
     {
         for(int i=;i <= k;++i)
             scanf("%d%d",a+i,b+i);
         printf("%d\n",Solve());
     }
 }

　　　　　　bingo，正解，不过，来分析一下此种做法的时间复杂度。

　　　　　　对于最坏的情况，m=100,k=100,s=100，且对于所有的 i 有 a[i] = b[i] =1，其时间复杂度高达O(n^4)，要不是此题范围小，指定超时。

　　　　　　那么，还有比这更有的算法吗？

　　　　　　有个稍加优化的方法，可以将最坏的时间复杂度变为O(n^3log(n))。

　　　　　　把第ki个怪拆成忍耐度为b[ki]*(2^x)、经验值为a[ki]*(2^x)的若干个怪，其中 x 满足 b[ki]*(2^x) < m && (2^x) < s 。

　　　　　　这是二进制的思想，因为不管最优策略杀几头第 ki 个物品，总可以表示成若干个 2^x 个怪物的和。

　　　　　　这样把每头怪拆成O( log(min(m/b[kind],s)) )头怪，是一个很大的改进。　　

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 using namespace std;
 #define mem(a,b) memset(a,b,sizeof(a))
 const int maxn=+;

 int n,m,k,s;
 int a[maxn],b[maxn];
 int dp[maxn][maxn];

 int Solve()
 {
     mem(dp,);
     bool index=;
     for(int kind=;kind <= k;++kind)
     {
         int x=log(min(m/b[kind],s))/log();
         for(int tot=;tot <= x;++tot)
         {
             for(int i=m;i >= (<<tot)*b[kind];--i)
                 for(int j=(<<tot);j <= s;++j)
                     dp[i][j]=max(dp[i][j],dp[i-(<<tot)*b[kind]][j-(<<tot)]+(<<tot)*a[kind]);
         }
     }
     int res=m+;
     for(int i=;i <= m;++i)
         for(int j=;j <= s;++j)
             if(dp[i][j] >= n)
                 res=(res > i ? i:res);//找到经验值达到n以上的最小的忍耐度
     return m-res;
 }

 int main()
 {
     while(~scanf("%d%d%d%d",&n,&m,&k,&s))
     {
         for(int i=;i <= k;++i)
             scanf("%d%d",a+i,b+i);
         printf("%d\n",Solve());
     }
 }

　　思路二：完全背包+滚动数组优化空间

　　　　设dp[i][j]表示消耗 i 个忍耐度，杀 j 头怪所获得的最大经验值。

　　　　状态转移方程：

　　　　　　dp[i][j]=max(dp[i][j],dp[i-b[k1]][j-1]+a[k1])

　　　　　　dp[i-b[k1]][j-1]+a[k1] : 杀k1怪所获得最大经验值

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 #define mem(a,b) memset(a,b,sizeof(a))
 const int maxn=+;

 int n,m,k,s;
 int a[maxn],b[maxn];
 int dp[maxn][maxn];//dp[i][j] : 所需耐力值为i杀怪数为j时所获得的最大经验值

 int Solve()
 {
     mem(dp,);
     for(int k1=;k1 <= k;++k1)
         for(int i=b[k1];i <= m;++i)
             for(int j=;j <= s;++j)
                 dp[i][j]=max(dp[i][j],dp[i-b[k1]][j-]+a[k1]);
     for(int i=;i <= m;++i)
         for(int j=;j <= s;++j)
             if(dp[i][j] >= n)
                 return m-i;
     return -;
 }
 int main()
 {
     while(scanf("%d%d%d%d",&n,&m,&k,&s) != EOF)
     {
         for(int i=;i <= k;++i)
             scanf("%d%d",a+i,b+i);
         printf("%d\n",Solve());
     }
     return ;
 }

　　总结：

　　　　这种题设dp变量很重要，要设成几维的以及含义。

　　　　设成几维的？

　　　　　　有多少个限制条件，就设置成几维的，例如此题有三个限制条件①怪物种类②忍耐度③杀怪数

　　　　　　如果不适用滚动数组，则需要设置成三维数组。

　　　　　　如果使用滚动数组优化空间，则把第一个限制条件开辟的空间省去了，但第一个限制条件要在最外层循环处