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 =  * ;
 const int n = ;
 int weight[MAXN], child[MAXN][], 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[];

 priority_queue<int> Q;
 int int_cnt;

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

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

 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 < ) pos[n - v] = x;
     else pos[v] = x;
     size[x] = ; neg[x] = (v < );
     weight[x] = rand();
     child[x][] = child[x][] = ;
     return x;
 }

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

 void rotate(int &x, int t) {
     int y = child[x][t];
     child[x][t] = child[y][t ^ ];
     child[y][t ^ ] = 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 == ) x = new_node(f, v);
     else {
         int t = (size[child[x][]] +  <= k);
         insert1(x, child[x][t], k - t * (size[child[x][]] + ), v);
         if(weight[child[x][t]] < weight[x]) rotate(x, t);
     }
     update(x);
 }

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

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

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

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

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

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

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

 int main() {
     for(int t = ; ; ++t) {
         if(scanf("%d", &m) == EOF) break;
         init();
         printf("Case #%d:\n", t);
         root = ;
         while(m--) {
             scanf("%s%d", s, &x);
             if(*s == 'i') {
                 int tmp = new_int();
                 insert1(, root, x, tmp);
                 int k = cnt_pos(pos[tmp], ) - ;
                 insert2(, 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][] == 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][] == t]);
                     update_parent(p);
                 }
                 Q.push(-x);
             }
             if(*s == 'q') {
                 printf("%I64d\n", query(root, pos[x], pos[x + n]));
             }
                 //test(root);
         }
     }
 }