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 = 300;

typedef class SegTreeNode {
    public:
        int val;
        SegTreeNode *l, *r;
        
        SegTreeNode():val(0) {        }
}SegTreeNode;

SegTreeNode pool[6000000];
SegTreeNode *top = pool;

SegTreeNode* newnode() {
    return top++;
}

typedef class SegTree {
    public:
        SegTreeNode** rts;
        
        SegTree():rts(NULL) {        }
        SegTree(int n) {
            rts = new SegTreeNode*[(n + 1)];
            build(rts[0], 1, n);
        }
        
        void build(SegTreeNode*& node, int l, int r) {
            node = newnode();
            if(l == r)    return;
            int mid = (l + r) >> 1;
            build(node->l, l, mid);
            build(node->r, mid + 1, 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) >> 1;
            if(idx <= mid)    update(newv->l, oldv->l, l, mid, idx, val);
            else    update(newv->r, oldv->r, mid + 1, r, idx, val);
        }
        
        int query(SegTreeNode*& node, int l, int r, int idx) {
            if(l == r)    return node->val;
            int mid = (l + r) >> 1;
            if(idx <= mid)    return query(node->l, l, mid, idx);
            return query(node->r, mid + 1, r, idx);
        }
        
        SegTreeNode*& operator [] (int pos) {
            return rts[pos];
        }
}SegTree;

int n;
int length[100005];
SegTree st;
char s[10];

inline void solve() {
    scanf("%d", &n);
    st = SegTree(n);
    length[0] = 0;
    for(int opt = 1, v = 1, x; opt <= n; opt++) {
        scanf("%s%d", s, &x);
        switch(s[0]) {
            case 'A':
                length[v] = length[v - 1] + 1;
                st.update(st[v], st[v - 1], 1, n, length[v], x), v++;
                break;
            case 'Q':
                printf("%d
", st.query(st[v - 1], 1, n, x));
                break;
            case 'U':
                length[v] = length[v - x - 1];
                st[v] = st[v - x - 1], v++;
                break;
        }
    }
}

int main() {
    solve();
    return 0;
}