HDU 4441 Queue Sequence（优先队列+Treap树）（2012 Asia Tianjin Regional Contest）

Problem Description

There's a queue obeying the first in first out rule. Each time you can either push a number into the queue (+i), or pop a number out from the queue (-i). After a series of operation, you get a sequence (e.g. +1 -1 +2 +4 -2 -4). We call this sequence a queue sequence.

Now you are given a queue sequence and asked to perform several operations:

1. insert p
First you should find the smallest positive number (e.g. i) that does not appear in the current queue sequence, then you are asked to insert the +i at position p (position starts from 0). For -i, insert it into the right most position that result in a valid queue sequence (i.e. when encountered with element -x, the front of the queue should be exactly x).
For example, (+1 -1 +3 +4 -3 -4) would become (+1 +2 -1 +3 +4 -2 -3 -4) after operation 'insert 1'.
2. remove i
Remove +i and -i from the sequence.
For example, (+1 +2 -1 +3 +4 -2 -3 -4) would become (+1 +2 -1 +4 -2 -4) after operation 'remove 3'.
3. query i
Output the sum of elements between +i and -i. For example, the result of query 1, query 2, query 4 in sequence (+1 +2 -1 +4 -2 -4) is 2, 3(obtained by -1 + 4), -2 correspond.

 

Input

There are less than 25 test cases. Each case begins with a number indicating the number of operations n (1 ≤ n ≤ 100000). The following n lines with be 'insert p', 'remove i' or 'query i'(0 ≤ p ≤ length (current sequence), 1 ≤ i, i is granted to be in the sequence).
In each case, the sequence is empty initially.
The input is terminated by EOF.

 

Output

Before each case, print a line "Case #d:" indicating the id of the test case.
After each operation, output the sum of elements between +i and -i.

 

题目大意：这题太难描述了不讲了，亏出题人能想出这么难讲的题……

思路：对于插入最小正数，有一个优先队列维护即可（咋这么多人喜欢用线段树……）

然后序列用一个平衡树维护，我选择了treap，每个结点的右儿子在序列的左边，右结点在序列的右边。

每个点存他的值（val）、这颗子树的负数的总数（neg）、这颗子树的结点的总数（size）、这颗子树的权和（sum）。

可以发现正数和负数的排列是一样的（FIFO），那么插入的正数前面有多少个正数，那么插入的负数前面就有多少个负数，把这个多少个正数算出来，然后插负数的时候尽量往右插即可。

删除操作，在插入的时候记录正数和负数在那个结点上，删除的时候直接旋转到底删掉。

查询操作，因为我们把结点位置记录起来了，那么对于区间[a,b]，在a所在的结点往上走，可以算出[a, ~)的权和，同理可以算出(~, b]的权和，然后这两个的和减去所有的数的和（容斥原理）就是这个查询的答案（由于总和一定是0，所以不用减了）。

 

代码（796MS）：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
typedef long long LL;

const int MAXN = 2 * 100010;
const int n = 100000;
int weight[MAXN], child[MAXN][2], size[MAXN], neg[MAXN], val[MAXN], pre[MAXN];
LL sum[MAXN];
int pos[MAXN];
int stk[MAXN], top, node_cnt;

int m, p, x, root;
char s[10];

priority_queue<int> Q;
int int_cnt;

void test(int x) {
    if(child[x][0]) test(child[x][0]);
    cout<<val[x]<<" "<<sum[x]<<" "<<x<<" "<<pre[x]<<" "<<(child[pre[x]][1] == x)<<endl;
    //cout<<val[x]<<endl;
    if(child[x][1]) test(child[x][1]);
}

void init() {
    while(!Q.empty()) Q.pop();
    int_cnt = top = node_cnt = 0;
}

int new_int() {
    if(!Q.empty()) {
        int ret = -Q.top(); Q.pop();
        return ret;
    }
    return ++int_cnt;
}

int new_node(int f, int v) {
    int x = (top ? stk[top--] : ++node_cnt);
    pre[x] = f;
    sum[x] = val[x] = v;
    if(v < 0) pos[n - v] = x;
    else pos[v] = x;
    size[x] = 1; neg[x] = (v < 0);
    weight[x] = rand();
    child[x][0] = child[x][1] = 0;
    return x;
}

void update(int x) {
    sum[x] = sum[child[x][0]] + sum[child[x][1]] + val[x];
    size[x] = size[child[x][0]] + size[child[x][1]] + 1;
    neg[x] = neg[child[x][0]] + neg[child[x][1]] + (val[x] < 0);
}

void rotate(int &x, int t) {
    int y = child[x][t];
    child[x][t] = child[y][t ^ 1];
    child[y][t ^ 1] = x;
    pre[y] = pre[x]; pre[x] = y;
    pre[child[x][t]] = x;
    update(x); update(y);
    x = y;
}

void insert1(int f, int &x, int k, int v) {
    if(x == 0) x = new_node(f, v);
    else {
        int t = (size[child[x][0]] + 1 <= k);
        insert1(x, child[x][t], k - t * (size[child[x][0]] + 1), v);
        if(weight[child[x][t]] < weight[x]) rotate(x, t);
    }
    update(x);
}

int cnt_pos(int x, int t) {
    if(!x) return 0;
    int ret = cnt_pos(pre[x], child[pre[x]][1] == x);
    if(t == 1) ret += size[child[x][0]] - neg[child[x][0]] + (val[x] > 0);
    return ret;
}

void insert2(int f, int &x, int k, int v) {
    if(x == 0) x = new_node(f, v);
    else {
        int t = (neg[child[x][0]] + (val[x] < 0) <= k);
        insert2(x, child[x][t], k - t * (neg[child[x][0]] + (val[x] < 0)), v);
        if(weight[child[x][t]] < weight[x]) rotate(x, t);
    }
    update(x);
}

void remove(int &x) {
    if(child[x][0] && child[x][1]) {
        int t = weight[child[x][0]] < weight[child[x][1]];
        rotate(x, t);
        remove(child[x][t ^ 1]);
    } else {
        stk[++top] = x;
        pre[child[x][0]] = pre[child[x][1]] = pre[x];
        x = child[x][0] + child[x][1];
    }
    if(x > 0) update(x);
}

LL query1(int x, int t) {
    if(!x) return 0;
    LL ret = query1(pre[x], child[pre[x]][1] == x);
    if(t == 0) ret += sum[child[x][1]] + val[x];
    return ret;
}

LL query2(int x, int t) {
    if(!x) return 0;
    LL ret = query2(pre[x], child[pre[x]][1] == x);
    if(t == 1) ret += sum[child[x][0]] + val[x];
    return ret;
}

LL query(int x, int a, int b) {
    LL ret = query1(pre[a], child[pre[a]][1] == a) + sum[child[a][1]];
    ret += query2(pre[b], child[pre[b]][1] == b) + sum[child[b][0]];
    return ret;
}

void update_parent(int t) {
    while(t) update(t), t = pre[t];
}

int main() {
    for(int t = 1; ; ++t) {
        if(scanf("%d", &m) == EOF) break;
        init();
        printf("Case #%d:\n", t);
        root = 0;
        while(m--) {
            scanf("%s%d", s, &x);
            if(*s == 'i') {
                int tmp = new_int();
                insert1(0, root, x, tmp);
                int k = cnt_pos(pos[tmp], 1) - 1;
                insert2(0, root, k, -tmp);
            }
            if(*s == 'r') {
                if(root == pos[x]) {
                    remove(root);
                }
                else {
                    int t = pos[x], p = pre[t];
                    remove(child[p][child[p][1] == t]);
                    update_parent(p);
                }
                int y = x + n;
                if(root == pos[y]) {
                    remove(root);
                }
                else {
                    int t = pos[y], p = pre[t];
                    remove(child[p][child[p][1] == t]);
                    update_parent(p);
                }
                Q.push(-x);
            }
            if(*s == 'q') {
                printf("%I64d\n", query(root, pos[x], pos[x + n]));
            }
                //test(root);
        }
    }
}