Codeforces GoodBye2015 New Year and Three Musketeers Codeforces 611E（贪心）

这道题在比赛的时候一直在想二分答案+贪心判定，结果一直在WA on pretest10……第二天起来一想，发现是有问题的……因为在判定的时候，我是把每一次操作隔离开来看的，但他要求是同时干某件事，所以不能直接给每个人分配k次出手机会。
比如说，现在的分配情况是：
a——b——c
&——_——&
_——&——&
a、c和b、c各一次，如果用之前的策略的话，就还可以用一次a、b，但是，a、b的可用时间是不一样的，所以这是行不通的。

我们现在考虑，一个时间，一个时间地模拟，那么，我们可以模糊地想象出一个贪心的策略。

贪心部分代码：

我们假设a<b<c
注：work(t)是指干掉≤t的最大的一个。
if(mx <= a)    //当最大的<a那么所有的怪都可以被任何一个musketeers消灭
{
    cnt --;
    cnt += (n+2)/3;
    break;
}
else if(mx <= b)//当a < mx <= b时，a先干掉a能干的，b、c干掉最大的两个。
{
    sbt.work(a);
    sbt.work(b);
    sbt.work(c);
}
else if(mx <= c)//当b <　mx <= c 时，若a和b都可以干掉一个，那么就分别干掉一个，如果a和b只能干掉一个或更少，那么就用a+b去干掉能干掉的最大的，显然更优。c干掉最大的。
{
    bool flag = true;
    int tmp = sbt.Prev(sbt.root, a);
    if(tmp != -1)
    {
        int s1 = tmp;
        sbt.erase(sbt.root, tmp);
        tmp = sbt.Prev(sbt.root, b);
        if(tmp != -1)
        {
            sbt.erase(sbt.root, tmp);
            n -= 2;
            sbt.work(c);
        }
        else
        {
            sbt.insert(sbt.root, s1);
            flag = 0;
        }
    }
    else flag = 0;
    if(!flag)
    {
        int aa = a+b, bb = c;
        if(aa > bb) swap(aa, bb);
        sbt.work(aa);
        sbt.work(bb);
    }
}
// 考虑多个人一起打怪
else if(mx <= a + b) // c < mx <= a+b
{
    int aa = c, bb = a + b;
    sbt.work(aa);
    sbt.work(bb);
}
else if(mx <= a + c) // c, a+b < mx <= a + c
{
    int aa = b, bb = a + c;
    sbt.work(aa);
    sbt.work(bb);
}
else if(mx <= c + b) // c, a+b, < a+c < mx <= b + c
{
    int aa = a, bb = c + b;
    sbt.work(aa);
    sbt.work(bb);
}
else
{
    sbt.work(a+b+c);
}

代码

#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXN 200005
#define INF 0x3f3f3f3f
int n, m, a, b, c, C[3], sd = 2333, sz;
int t[MAXN];
char ch, f;
inline void GET(int &n) {
    n = 0; f = 1;
    do {ch = getchar(); if(ch == '-') f = -1;} while(ch > '9' || ch < '0');
    while(ch >= '0' && ch <= '9') {n=n*10+ch-'0';ch=getchar();}
    n *= f;
}
struct Treap {
    struct Node {
        int v, s[2], cnt, rnd;
    } t[MAXN];
    int root;
    const inline int Rand() { return sd = sd * sd % 1000007; }
    inline void Rot(int &k, bool f) {
        int p = t[k].s[f]; t[k].s[f] = t[p].s[f^1];
        t[p].s[f^1] = k; k = p;
    }
    void insert(int &k, int v) {
        if(!k) { k = ++ sz; t[k].v = v; t[k].rnd = Rand(); t[k].cnt = 1; return; }
        if(t[k].v == v) { ++ t[k].cnt; return; }
        bool f = v > t[k].v;
        insert(t[k].s[f], v);
        if(t[t[k].s[f]].rnd > t[k].rnd) Rot(k, f);
    }
    void erase(int &k, int v) {
        if(!k) return;
        if(t[k].v == v) {
            if(t[k].cnt > 1) -- t[k].cnt;
            else if(t[k].s[0] * t[k].s[1] == 0) k = t[k].s[0] + t[k].s[1];
            else {
                bool f = t[t[k].s[1]].rnd > t[t[k].s[0]].rnd;
                Rot(k, f); erase(k, v);
            }
            return;
        }
        bool f = v > t[k].v;
        erase(t[k].s[f], v);
    }
    const int Prev(int k, int v, int p = 200003) {
        if(!k) return t[p].v;
        else if(t[k].v == v) return v;
        else if(t[k].v < v) return Prev(t[k].s[1], v, k);
        else return Prev(t[k].s[0], v, p);
    }
    const bool size() { return root; }
    const int Max() {
        int tmp = root;
        while(t[tmp].s[1]) tmp = t[tmp].s[1];
        return t[tmp].v;
    }
    void work(int val) {
        if(!root) return;
        int tmp = Prev(root, val);
        if(tmp == -1) return;
        n --;
        erase(root, tmp);
    }
} sbt;
int main() {
    scanf("%d", &n); sbt.root = 0; sbt.t[200003].v = -1;
    scanf("%d%d%d", &a, &b, &c);
    if(a > b) swap(a, b);
    if(a > c) swap(a, c);
    if(b > c) swap(b, c);
    for(int i = 1; i <= n; ++ i) {
        GET(t[i]);
        sbt.insert(sbt.root, t[i]);
    }
    if(sbt.Max() > a + b + c) { puts("-1"); return 0; }
    int cnt = 0;
    for(;sbt.size() && n;) {
        ++ cnt;
        C[0] = C[1] = C[2] = 0;
        int mx = sbt.Max();
        if(mx <= a) {
            cnt --;
            cnt += (n+2)/3;
            break;
        }
        else if(mx <= b) {
            sbt.work(a);
            sbt.work(b);
            sbt.work(c);
        }
        else if(mx <= c) {
            bool flag = true;
            int tmp = sbt.Prev(sbt.root, a);
            if(tmp != -1) {
                int s1 = tmp;
                sbt.erase(sbt.root, tmp);
                tmp = sbt.Prev(sbt.root, b);
                if(tmp != -1) {
                    sbt.erase(sbt.root, tmp);
                    n -= 2;
                    sbt.work(c);
                } else {
                    sbt.insert(sbt.root, s1);
                    flag = 0;
                }
            } else flag = 0;
            if(!flag) {
                int aa = a+b, bb = c;
                if(aa > bb) swap(aa, bb);
                sbt.work(aa);
                sbt.work(bb);
            }
        }
        else if(mx <= a + b) {
            int aa = c, bb = a + b;
            sbt.work(aa);
            sbt.work(bb);
        }
        else if(mx <= a + c) {
            int aa = b, bb = a + c;
            sbt.work(aa);
            sbt.work(bb);
        }
        else if(mx <= c + b) {
            int aa = a, bb = c + b;
            sbt.work(aa);
            sbt.work(bb);
        }
        else {
            sbt.work(a+b+c);
        }
    }
    printf("%d\n", cnt);
    return 0;
}