OpenJudge cdqz/Data Structure Challenge 2 (Problem 5822) - 可持久化线段树

描述

给一个空数列，有M次操作，每次操作是以下三种之一：

（1）在数列后加一个数

（2）求数列中某位置的值

（3）撤销掉最后进行的若干次操作（1和3）

输入

第一行一个正整数M。 接下来M行，每行开头是一个字符，若该字符为'A'，则表示一个加数操作，接下来一个整数x，表示在数列后加一个整数x；若该字符为'Q'，则表示一个询问操作，接下来一个整数x，表示求x位置的值；若该字符为'U'，则表示一个撤销操作，接下来一个整数x，表示撤销掉最后进行的若干次操作。

输出

对每一个询问操作单独输出一行，表示答案。

样例输入

9
A 1
A 2
A 3
Q 3
U 1
A 4
Q 3
U 2
Q 3

样例输出

3
4
3

提示

1<=M<=10^5，输入保证合法，且所有整数可用带符号32位整型存储。

---

　　可持久化线段树不解释。

Code

 /**
  * OpenJudge
  * Problem#5822
  * Accepted
  * Time: 846ms
  * Memory: 144000k
  */
 #include <iostream>
 #include <fstream>
 #include <sstream>
 #include <cstdio>
 #include <cstring>
 #include <cctype>
 #include <cstdlib>
 #include <ctime>
 #include <algorithm>
 #include <map>
 #include <set>
 #include <stack>
 #include <vector>
 #include <queue>
 using namespace std;
 
 const int segsize = ;
 
 typedef class SegTreeNode {
     public:
         int val;
         SegTreeNode *l, *r;
 
         SegTreeNode():val() {        }
 }SegTreeNode;
 
 SegTreeNode pool[];
 SegTreeNode *top = pool;
 
 SegTreeNode* newnode() {
     return top++;
 }
 
 typedef class SegTree {
     public:
         SegTreeNode** rts;
 
         SegTree():rts(NULL) {        }
         SegTree(int n) {
             rts = new SegTreeNode*[(n + )];
             build(rts[], , n);
         }
 
         void build(SegTreeNode*& node, int l, int r) {
             node = newnode();
             if(l == r)    return;
             int mid = (l + r) >> ;
             build(node->l, l, mid);
             build(node->r, mid + , r);
         }
 
         void update(SegTreeNode*& newv, SegTreeNode*& oldv, int l, int r, int idx, int val) {
             newv = newnode();
             *newv = *oldv;
             if(l == r) {
                 newv->val = val;
                 return;
             }
             int mid = (l + r) >> ;
             if(idx <= mid)    update(newv->l, oldv->l, l, mid, idx, val);
             else    update(newv->r, oldv->r, mid + , r, idx, val);
         }
 
         int query(SegTreeNode*& node, int l, int r, int idx) {
             if(l == r)    return node->val;
             int mid = (l + r) >> ;
             if(idx <= mid)    return query(node->l, l, mid, idx);
             return query(node->r, mid + , r, idx);
         }
 
         SegTreeNode*& operator [] (int pos) {
             return rts[pos];
         }
 }SegTree;
 
 int n;
 int length[];
 SegTree st;
 char s[];
 
 inline void solve() {
     scanf("%d", &n);
     st = SegTree(n);
     length[] = ;
     for(int opt = , v = , x; opt <= n; opt++) {
         scanf("%s%d", s, &x);
         switch(s[]) {
             case 'A':
                 length[v] = length[v - ] + ;
                 st.update(st[v], st[v - ], , n, length[v], x), v++;
                 break;
             case 'Q':
                 printf("%d\n", st.query(st[v - ], , n, x));
                 break;
             case 'U':
                 length[v] = length[v - x - ];
                 st[v] = st[v - x - ], v++;
                 break;
         }
     }
 }
 
 int main() {
     solve();
     return ;
 }