@codeforces - 702F@ T-Shirts

Posted 2020-11-16 tiw-air-oao

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

有 n 件 T-shirt，第 i 件 T-shirt 有一个 ci 和 qi，分别表示费用与质量。
同时有 k 个顾客，第 j 个顾客准备了 bj 的金钱去购买 T-shirt。

每个顾客的购买策略是相同的：
他会买他的资金范围内 q 值最大的一件，如果有多个选 c 最小的一件，每种 T-shirt 只买1 次。
重复购买，直到所有的 T-shirt 他都买不起或者他都买过了。

求每位顾客最终可以购买的 T-shirt 数量。

Input
第一行一个整数 n (1?≤?n?≤?2·10^5)，表示 T-shirt 的种类数。
接下来 n 行，每行两个整数 ci 与 qi (1?≤?ci,?qi?≤?10^9)，含义如上。
接下来一行一个正整数 k (1?≤?k?≤?2·10^5) ，表示顾客数。
接下来 k 个正整数 b1,?b2,?...,?bk (1?≤?bj?≤?10^9)。

Output
输出一行 k 个整数，表示第 i 个人买的 T-shirt。

Examples
Input
3
7 5
3 5
4 3
2
13 14
Output
2 3

Input
2
100 500
50 499
4
50 200 150 100
Output
1 2 2 1

@solution@

假如我们把人当作询问，T-shirt 当作元素，则至少我是想不出什么办法快速维护求出询问的。

但是反过来——我们按照 T-shirt 的优先级从大到小排序，把每个 T-shirt 当作一次修改，然后对人进行统一地修改，就很有戏了。
假如一个 T-shirt 的价格是 c，则我们的修改步骤就是先找出 >= c 的人，将这些人所拥有的钱减去 c，将这些人所拥有的 T-shirt 数量加上 1。

貌似可以用平衡树来 merge 和 split。但是注意，我们只能 merge 两个值域没有交集的平衡树，而减去 c 过后可能就产生了交集。
我们将 >= c 的人分为两类。第一类是 >= 2*c 的，这一部分减去 c 依然可以直接 merge；第二类是 < 2*c 的，这一类减去 c 过后只能一个个暴力插入。

因为第二类的人一定满足 c <= x < 2*c，每一次 x 至少折半，这样每个人只会被暴力插入 O(log)
于是就 O(nlog^2n) 的总复杂度。因为是 codeforces 所以能过。

@accepted code@

#include<cstdlib>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN = 200000;
struct treap{
    struct node{
        node *ch[2];
        int key, tg1;
        int sum, tg2;
        unsigned int pri;
    }pl[MAXN + 5], *ncnt, *NIL;
    #define mp make_pair
    #define fi first
    #define se second
    typedef pair<node*, node*> Droot;
    unsigned int get_rand() {return (rand() << 16) | rand();}
    treap() {
        NIL = ncnt = &pl[0];
        NIL->ch[0] = NIL->ch[1] = NIL;
        NIL->key = NIL->tg1 = NIL->sum = NIL->tg2 = 0;
        NIL->pri = -1;
    }
    node *newnode(int k) {
        node *p = (++ncnt);
        p->ch[0] = p->ch[1] = NIL;
        p->key = k, p->tg1 = p->sum = p->tg2 = 0;
        p->pri = get_rand();
        return p;
    }
    void maintain1(node *x, int k) {if( x != NIL ) x->key += k, x->tg1 += k;}
    void maintain2(node *x, int k) {if( x != NIL ) x->sum += k, x->tg2 += k;}
    void pushdown(node *rt) {
        if( rt->tg1 ) {
            maintain1(rt->ch[0], rt->tg1), maintain1(rt->ch[1], rt->tg1);
            rt->tg1 = 0;
        }
        if( rt->tg2 ) {
            maintain2(rt->ch[0], rt->tg2), maintain2(rt->ch[1], rt->tg2);
            rt->tg2 = 0;
        }
    }
    node *merge(node *x, node *y) {
        if( x == NIL ) return y;
        if( y == NIL ) return x;
        pushdown(x), pushdown(y);
        if( x->pri < y->pri ) {
            x->ch[1] = merge(x->ch[1], y);
            return x;
        }
        else {
            y->ch[0] = merge(x, y->ch[0]);
            return y;
        }
    }
    Droot split(node *rt, int k) {
        if( rt == NIL ) return mp(NIL, NIL);
        pushdown(rt);
        if( rt->key < k ) {
            Droot p = split(rt->ch[1], k);
            rt->ch[1] = p.fi; return mp(rt, p.se);
        }
        else {
            Droot p = split(rt->ch[0], k);
            rt->ch[0] = p.se; return mp(p.fi, rt);
        }
    }// < k, >= k
    node *insert(node *rt, node *x) {
        Droot p = split(rt, x->key);
        return merge(p.fi, merge(x, p.se));
    }
    void push(node *&rt, node *x) {
        if( x == NIL ) return ;
        pushdown(x);
        push(rt, x->ch[0]), push(rt, x->ch[1]);
        x->ch[0] = x->ch[1] = NIL;
        rt = insert(rt, x);
    }
    node *update(node *rt, int k) {
        Droot p = split(rt, k);
        if( p.se == NIL ) return merge(p.fi, p.se);
        p.se->key -= k, p.se->tg1 -= k;
        p.se->sum += 1, p.se->tg2 += 1;
        Droot q = split(p.se, k);
        if( q.fi != NIL ) push(p.fi, q.fi);
        return merge(p.fi, q.se);
    }
    void dfs(node *x) {
        if( x == NIL ) return ;
        pushdown(x);
        dfs(x->ch[0]), dfs(x->ch[1]);
    }
}T;
treap::node *nd[MAXN + 5], *rt;
struct Tshirt{
    int c, q;
    Tshirt(int _c=0, int _q=0):c(_c), q(_q) {}
    friend bool operator < (Tshirt a, Tshirt b) {
        return (a.q == b.q) ? a.c < b.c : a.q > b.q;
    }
}t[MAXN + 5];
int ans[MAXN + 5];
int read() {
    int x = 0; char ch = getchar();
    while( ch > '9' || ch < '0' ) ch = getchar();
    while( '0' <= ch && ch <= '9' ) x = 10*x + ch - '0', ch = getchar();
    return x;
}
int main() {
    int n = read(), k;
    srand(n ^ 0307);
    for(int i=1;i<=n;i++)
        t[i].c = read(), t[i].q = read();
    sort(t + 1, t + n + 1);
    k = read(), rt = T.NIL;
    for(int i=1;i<=k;i++)
        rt = T.insert(rt, nd[i] = T.newnode(read()));
    for(int i=1;i<=n;i++)
        rt = T.update(rt, t[i].c);
    T.dfs(rt);
    for(int i=1;i<=k;i++)
        printf("%d ", nd[i]->sum);
}

@details@

思路本身还是很巧妙的。
而且也印证了非旋 treap 是一种非常优美的数据结构，因为基本上没有什么实现难度。