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 = 0;
    char c = gc();
    bool f = 0;
    while(c < '0' || c > '9') {
        if(c == '-') f = 1;
        c = gc();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - 48;
        c = gc();
    }
    if(f) x = (~x) + 1;
    return;
}

typedef long long LL;
const int N = 100010;

struct Node {
    int val, d, id, cnt, flag;
    Node(int V = 0, int D = 0, int ID = 0, int C = 0, int F = 0) {
        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 = 100000;
    read(n); read(m); read(k);
    for(int i = 1; i <= lm; i++) {
        fa[i] = i;
        rest[i] = m;
    }
    for(int i = 1; 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] - 1) / x[i] + 1, lm);
        }
        Q.push(Node(a[i] + s[i], day, i, 1, 0));
        if((day - 1) * x[i] + 1 < c[i]) { /// the last day have rest
            Q.push(Node(a[i], day, i, c[i] - 1 - x[i] * (day - 1), 0));
        }
        if(day > 1 && x[i]) {
            Q.push(Node(a[i], day - 1, i, x[i] * (day - 1), 1));
        }
        //c[i]--;
    }

    //int Last = 0, Cnt = 0;

    int tot = 0;
    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 - 1), 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, 0, t.id, large));
            rest[now] -= large;
            t.cnt -= large;
            if(!rest[now]) {
                fa[now] = find(now - 1);
            }
            now = find(now - 1);
        }
    }


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

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

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

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

    return 0;
}