[题解]CF609F Frogs and mosquitoes

思路

发现 $x$ 对题目的限制较大，因此考虑先将 $x$ 排序并离散化后再来考虑。

不难用线段树维护 $\max_{i = l}^{r}\{x_i + len_i\}$，这样我们就可以利用类似线段树上二分的技巧得出是哪一只青蛙吃掉的蚊子。

但是有可能有一只蚊子无法吃掉，我们先把它丢进一个集合里面。

每有一次青蛙能吃掉新蚊子，意味着有一个青蛙舌头的长度会增加，便有了能吃掉原本无法吃掉的蚊子的可能，在此时将那些蚊子单独拎出来判断即可。

考虑到对于每一只蚊子最多进集合一次，出集合一次，所以复杂度是正确的。

Code

#include <bits/stdc++.h>
#define fst first
#define snd second
#define re register

using namespace std;

typedef pair<int,int> pii;
const int N = 2e5 + 10;
int n,m;
int x[N],nx[N],len[N],id[N],vis[N];
pii tmp[N];
multiset<pii> st;

inline int read(){
    int r = 0,w = 1;
    char c = getchar();
    while (c < '0' || c > '9'){
        if (c == '-') w = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9'){
        r = (r << 3) + (r << 1) + (c ^ 48);
        c = getchar();
    }
    return r * w;
}

struct seg{
    #define ls(u) (u << 1)
    #define rs(u) (u << 1 | 1)

    struct node{
        int l,r,Max;
    }tr[N << 2];

    inline void pushup(int u){
        tr[u].Max = max(tr[ls(u)].Max,tr[rs(u)].Max);
    }

    inline void build(int u,int l,int r){
        tr[u] = {l,r};
        if (l == r) return tr[u].Max = x[id[l]] + len[id[l]],void();
        int mid = l + r >> 1;
        build(ls(u),l,mid),build(rs(u),mid + 1,r);
        pushup(u);
    }

    inline void modify(int u,int x,int k){
        if (tr[u].l == x && tr[u].r == x){
            vis[id[x]]++,len[id[x]] += k,tr[u].Max += k;
            return;
        }
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(ls(u),x,k);
        else modify(rs(u),x,k);
        pushup(u);
    }

    inline int query(int u,int k){
        if (tr[u].l == tr[u].r){
            int t = id[tr[u].l];
            if (x[t] <= k && x[t] + len[t] >= k) return t;
            else return -1;
        }
        if (tr[ls(u)].Max >= k) return query(ls(u),k);
        else return query(rs(u),k);
    }

    #undef ls
    #undef rs
}T;

int main(){
    n = read(),m = read();
    for (re int i = 1;i <= n;i++){
        x[i] = read(),len[i] = read();
        tmp[i] = {x[i],i};
    }
    sort(tmp + 1,tmp + n + 1);
    for (re int i = 1;i <= n;i++){
        id[i] = tmp[i].snd;
        nx[tmp[i].snd] = i;
    }
    T.build(1,1,n);
    while (m--){
        int p,del;
        p = read(),del = read();
        int t = T.query(1,p);
        if (!~t) st.insert({p,del});
        else{
            T.modify(1,nx[t],del);
            auto it = st.lower_bound(make_pair(x[t],-1));
            while (it != st.end() && x[t] + len[t] >= (*it).fst){
                T.modify(1,nx[t],(*it).snd);
                st.erase(it),it = st.lower_bound(make_pair(x[t],-1));
            }
        }
    }
    for (re int i = 1;i <= n;i++) printf("%d %d\n",vis[i],len[i]);
    return 0;
}