codevs1260 快餐问题

题意：

一个套餐需要a个A，b个B，c个C。

你生产一个A需要t1,一个B需要t2，一个C需要t3时间。

你有n台机器。每台每天工作timei时间。

一件物品只能在一个机器上生产。

求你一天最多能生产多少套餐。

每天ABC产量上限是100，n<=10

解：

这个DP的状态表示真是奇怪..

有一种做法是设f[i][j][k][l]表示前i台机器生产j个A，k个B，l个C的最大套餐数量。

被我的 1 1 1   2 2 2   3   3 2 1 卡掉了，输出1，答案是0

还有一种做法是设f[i][j][k][l]表示前i台机器生产j个A，k个B，l个C的所需最少时间。

这是zbtrs提供的。我还没思考。但是直觉上感觉很不对劲....

---

最后是我用的，f[i][j][k]表示前i台机器生产j个A，k个B时所能生产的最多C数量。

一开始预处理出最大套餐值和最大ABC值。

转移就是枚举这一台/之前的机器生产了多少A和B，然后计算出C来。

注意，一开始的时候可能会从f[0][x][y]之类的不存在的状态转移过来。

解决方案是赋值为-1，特判。初值是f[0][0][0] = 0

有几个剪枝：第一个是这条生产线不能生产更多的A和B了，这时要break

还有就是这个状态的C已经满了，此时不用继续枚举转移了，直接出转移(goto flag)。

然后就把很吓人的时间复杂度剪下去了。

 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #define say(a) printf(#a); printf(" = %d \n", a)
 const int N = ;

 int f[][N][N], time[N];
 int a, b, c;
 int t1, t2, t3;

 int main() {
     int n;
     scanf("%d%d%d", &a, &b, &c);
     scanf("%d%d%d", &t1, &t2, &t3);
     scanf("%d", &n);
     int sum = , ans = ;
     for(int i = ; i <= n; i++) {
         scanf("%d", &time[i]);
         sum += time[i];
     }
     int lm = sum / (a * t1 + b * t2 + c * t3);
     int maxA = std::min(lm * a, );
     int maxB = std::min(lm * b, );
     int maxC = std::min(lm * c, );

     memset(f, -, sizeof(f));
     f[][][] = ;
     for(int i = ; i <= n; i++) {
         f[i][][] = ;
     }
     for(int i = ; i <= n; i++) {
         for(int j = maxA; j >= ; j--) {
             for(int k = maxB; k >= ; k--) {
                 /// get f[i][j][k]
                 for(int jj = j; jj >= ; jj--) {
                     for(int kk = k; kk >= ; kk--) {
                         if(time[i] < (j - jj) * t1 + (k - kk) * t2) {
                             goto flag;
                         }
                         if(f[i - ][jj][kk] == -) {
                             continue;
                         }
                         f[i][j][k] = std::max(f[i][j][k],
                                               f[i - ][jj][kk] + (time[i] - (j - jj) * t1 - (k - kk) * t2) / t3);
                         if(f[i][j][k] >= maxC) {
                             goto flag;
                         }
                     }
                 }
                 flag:
                 int now = std::min(j / a, k / b);
                 now = std::min(now, f[i][j][k] / c);
                 ans = std::max(ans, now);
             }
         }
     }

     printf("%d", ans);
     return ;
 }

AC代码

codevs的数据很弱。强数据在洛谷上。