The Stream of Corning 2【可持久化线段树】

2018 ICPC Asia Nakhon Pathom Regional Contest K

题意上的重点：In the given inputs, the CURRENT_TIMESTAMPS will be strictly increasing between consecutive events.(给定的事件时间戳是严格递增的)

解题思路：
方法①：题目上是事件和查询都是一起给出的，不能直接 在线+差分+可持久化线段树做，但是我们可以离线，然后对时间进行离散化后，在按照时间戳建树+差分。
方法②：用一个优先队列来维护每一个事件，如果一个事件在这个事件开始时，就已经结束了，就可以将该价值给删除，然后再将该事件加入。

具体细节见代码：
方法①：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;

struct OP {
    int mark, l, r, x;
} op[maxn];
struct Edge {
    int e;
    int p;
} load[maxn * 2];
int head[maxn * 2], sign;
struct node {
    int ls, rs, cnt;
#define left(a, b) p[a].ls, p[b].ls, l, mid
#define right(a, b) p[a].rs, p[b].rs, mid + 1, r
} p[maxn * 60];
int root[maxn * 2], times;
int T_ranks[maxn * 2], num_ranks[maxn], sub_T, sub_n;
int q[maxn * 2];

void add_edge(int s, int e) {
    load[++sign] = Edge{e, head[s]};
    head[s] = sign;
}

void insert(int &now, int old, int l, int r, int x) {
    now = ++times;
    p[now] = p[old], p[now].cnt += (x > 0) ? 1 : -1;
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (abs(x) <= mid) insert(left(now, old), x);
    else insert(right(now, old), x);
}

int query(int now, int l, int r, int k) {
    if (l == r) return l;
    int mid = (l + r) >> 1;
    int x = p[p[now].ls].cnt;
    if (k <= x) return query(p[now].ls, l, mid, k);
    else return query(p[now].rs, mid + 1, r, k - x);
}

void init() {
    sign = sub_T = sub_n = times = 0;
    memset(q, 0, sizeof(q));
    memset(head, -1, sizeof(head));
}

int main() {
    int T, n, s, e, x;
    scanf("%d", &T);
    for (int cases = 1; cases <= T; cases++) {
        init();
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &op[i].mark);
            if (op[i].mark == 1) {
                scanf("%d %d %d", &op[i].l, &op[i].x, &op[i].r);
                T_ranks[++sub_T] = op[i].l;
                T_ranks[++sub_T] = op[i].r + 1;
                num_ranks[++sub_n] = op[i].x;
            } else {
                scanf("%d %d", &op[i].l, &op[i].x);
                T_ranks[++sub_T] = op[i].l;
            }
        }
        sort(T_ranks + 1, T_ranks + 1 + sub_T);
        sort(num_ranks + 1, num_ranks + 1 + sub_n);
        int d = unique(num_ranks + 1, num_ranks + 1 + sub_n) - (num_ranks + 1);
        int up = unique(T_ranks + 1, T_ranks + 1 + sub_T) - (T_ranks + 1);
        for (int i = 1; i <= n; i++) {
            if (op[i].mark == 2) { q[lower_bound(T_ranks + 1, T_ranks + 1 + up, op[i].l) - T_ranks] = op[i].x; }
            else {
                s = lower_bound(T_ranks + 1, T_ranks + 1 + up, op[i].l) - T_ranks;
                e = lower_bound(T_ranks + 1, T_ranks + 1 + up, op[i].r + 1) - T_ranks;
                x = lower_bound(num_ranks + 1, num_ranks + 1 + d, op[i].x) - num_ranks;
                add_edge(s, x), add_edge(e, -x);
            }
        }
        printf("Case %d:\n", cases);
        for (int i = 1; i <= up; i++) {
            root[i] = root[i - 1];
            for (int j = head[i]; ~j; j = load[j].p) {
                insert(root[i], root[i], 1, d, load[j].e);
            }
            if (q[i] != 0) {
                if (q[i] > p[root[i]].cnt) printf("-1\n");
                else printf("%d\n", num_ranks[query(root[i], 1, d, q[i])]);
            }
        }
    }
    return 0;
}

方法②：
 

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;

struct node {
    int ls, rs, cnt;
#define left(a, b) p[a].ls, p[b].ls, l, mid
#define right(a, b) p[a].rs, p[b].rs, mid + 1, r

    bool friend operator<(node a, node b) {
        return a.rs > b.rs;
    }
} p[maxn * 40];

int root[maxn], times;

void insert(int &now, int old, int l, int r, int pos, int x) {
    now = ++times;
    p[now] = p[old], p[now].cnt += x;
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (pos <= mid) insert(left(now, old), pos, x);
    else insert(right(now, old), pos, x);
}

int query(int now, int l, int r, int k) {
    if (l == r) return l;
    int mid = (l + r) >> 1;
    int x = p[p[now].ls].cnt;
    if (k <= x) return query(p[now].ls, l, mid, k);
    else return query(p[now].rs, mid + 1, r, k - x);
}

priority_queue<node> q;

void init() {
    times = 0;
    while (!q.empty()) q.pop();
}

int main() {
    int T, n, mark, l, r, x, k;
    scanf("%d", &T);
    for (int cases = 1; cases <= T; cases++) {
        printf("Case %d:\n", cases);
        init();
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &mark);
            root[i] = root[i - 1];
            if (mark == 1) {
                scanf("%d %d %d", &l, &x, &r);
                while (!q.empty() && q.top().rs < l) {
                    insert(root[i], root[i], 1, (int) 1e6, q.top().cnt, -1);
                    q.pop();
                }
                q.push(node{l, r, x});
                insert(root[i], root[i], 1, (int) 1e6, x, 1);
            } else {
                scanf("%d %d", &l, &k);
                while (!q.empty() && q.top().rs < l) {
                    insert(root[i], root[i], 1, (int) 1e6, q.top().cnt, -1);
                    q.pop();
                }
                if (p[root[i]].cnt < k) printf("-1\n");
                else printf("%d\n", query(root[i], 1, (int) 1e6, k));
            }
        }
    }
    return 0;
}