LOJ#2306 蔬菜

补充一个题意不太清楚的地方：蔬菜坏掉是假设蔬菜都有标号，那么特定标号的蔬菜就会在特定时间坏掉。如果你及时卖了它们，那么那一天就不会有新的蔬菜坏掉。

结论1：如果我们知道了k天的答案，那么我们直接扔掉若干个最小的蔬菜即可获得k - 1天的答案。

证：因为能在k天卖的一定能在k - 1天卖.....

推论1：只要求100000天卖哪些蔬菜即可。

结论2：最贵的菜越晚卖越好。

证：因为它最贵，所以是一定要卖的。我们要让别的菜尽量卖的多，晚卖有决策包容性。

推论2：按照从贵到廉考虑蔬菜，每个菜越晚卖越好。

结论3：可以把每个蔬菜按照变质天数分类，当天变质的蔬菜能够出售的时间是第一天到当天。

推论3：假如把每种菜按照变质天数分类，那么有额外奖励的蔬菜应该在最后一天。

证：因为额外奖励比正常蔬菜贵，所以一定会优先卖它。由结论2可知应放在最后。

然后算法就出来了。分类之后按顺序放蔬菜。每天维护从它开始向前，第一个空闲的地方。可以用并查集实现。

每天能放多少菜要特别注意，代码实现上我用总数 - 之前应该留下的菜数来限制。

 #include <bits/stdc++.h>

 inline char gc() {
     /*static char buf[1000000], *p1, *p2;
     if(p1 == p2) p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
     return (p1 == p2) ? EOF : *p1++;*/ return getchar();
 }

 template <class T> inline void read(T &x) {
     x = ;
     char c = gc();
     bool f = ;
     while(c < '' || c > '') {
         if(c == '-') f = ;
         c = gc();
     }
     while(c >= '' && c <= '') {
         x = x *  + c - ;
         c = gc();
     }
     if(f) x = (~x) + ;
     return;
 }

 typedef long long LL;
 const int N = ;

 struct Node {
     int val, d, id, cnt, flag;
     Node(int V = , int D = , int ID = , int C = , int F = ) {
         val = V;
         d = D;
         id = ID;
         cnt = C;
         flag = F;
     }
     inline bool operator <(const Node &w) const {
         if(val != w.val)
             return val < w.val;
         return d < w.d;
     }
 };

 std::priority_queue<Node> Q, Q2;
 int a[N], s[N], c[N], x[N], fa[N], rest[N];
 LL ans[N];

 int find(int x) {
     if(x == fa[x]) return x;
     return fa[x] = find(fa[x]);
 }

 inline void del(LL &a) {
     Node t = Q2.top();
     Q2.pop();
     a += t.val;
     t.cnt--;
     if(t.cnt) Q2.push(t);
     return;
 }

 int main() {

     int n, m, k, lm = ;
     read(n); read(m); read(k);
     for(int i = ; i <= lm; i++) {
         fa[i] = i;
         rest[i] = m;
     }
     for(int i = ; i <= n; i++) {
         read(a[i]); read(s[i]); read(c[i]); read(x[i]);
         LL day;
         if(!x[i]) {
             day = lm;
         }
         else {
             day = std::min((c[i] - ) / x[i] + , lm);
         }
         Q.push(Node(a[i] + s[i], day, i, , ));
         if((day - ) * x[i] +  < c[i]) { /// the last day have rest
             Q.push(Node(a[i], day, i, c[i] -  - x[i] * (day - ), ));
         }
         if(day >  && x[i]) {
             Q.push(Node(a[i], day - , i, x[i] * (day - ), ));
         }
         //c[i]--;
     }

     //int Last = 0, Cnt = 0;

     int tot = ;
     while(Q.size()) {
         Node t = Q.top();
         Q.pop();
         int now = find(t.d);
         while(now && t.cnt) {
             LL large;
             if(t.flag) large = std::min(t.cnt, std::min(t.cnt - x[t.id] * (now - ), rest[now]));
             else if(x[t.id]) large = std::min(t.cnt, std::min(x[t.id], rest[now]));
             else large = std::min(t.cnt, rest[now]);

             ans[lm] += t.val * large;
             tot += large;
             Q2.push(Node(-t.val, , t.id, large));
             rest[now] -= large;
             t.cnt -= large;
             if(!rest[now]) {
                 fa[now] = find(now - );
             }
             now = find(now - );
         }
     }

     int day = (tot - ) / m + ; /// need (day) to sell the vegetables

     for(int i = lm - ; i >= day; i--) {
         ans[i] = ans[lm];
     }
     ans[day - ] = ans[day];
     for(int T = ; T <= tot - m * (day - ); T++) {
         del(ans[day - ]);
     }

     for(int i = day - ; i >= ; i--) {
         ans[i] = ans[i + ];
         for(int T = ; T <= m; T++) {
             del(ans[i]);
         }
     }

     for(int i = ; i <= k; i++) {
         int t;
         read(t);
         printf("%lld\n", ans[t]);
     }

     return ;
 }

AC代码