【HDOJ】3487 Play with Chain

Splay入门题目，区间翻转，区间分割。

 /*  */
 #include <iostream>
 #include <string>
 #include <map>
 #include <queue>
 #include <set>
 #include <stack>
 #include <vector>
 #include <deque>
 #include <algorithm>
 #include <cstdio>
 #include <cmath>
 #include <ctime>
 #include <cstring>
 #include <climits>
 #include <cctype>
 #include <cassert>
 #include <functional>
 #include <iterator>
 #include <iomanip>
 using namespace std;
 //#pragma comment(linker,"/STACK:102400000,1024000")

 #define sti                set<int>
 #define stpii            set<pair<int, int> >
 #define mpii            map<int,int>
 #define vi                vector<int>
 #define pii                pair<int,int>
 #define vpii            vector<pair<int,int> >
 #define rep(i, a, n)     for (int i=a;i<n;++i)
 #define per(i, a, n)     for (int i=n-1;i>=a;--i)
 #define clr                clear
 #define pb                 push_back
 #define mp                 make_pair
 #define fir                first
 #define sec                second
 #define all(x)             (x).begin(),(x).end()
 #define SZ(x)             ((int)(x).size())
 #define lson            l, mid, rt<<1
 #define rson            mid+1, r, rt<<1|1
 #define grandlson        ch[ch[root][1]][0]

 const int maxn = 3e5+;
 int pre[maxn], ch[maxn][], root, tot;
 int key[maxn], s[maxn], rev[maxn];
 int stk[maxn], top;
 int n, m, cnt;

 void newNode(int& r, int fa, int k) {
     if (top)
         r = stk[top--];
     else
         r = ++tot;
     key[r] = k;
     pre[r] = fa;
     rev[r] = ;
     ch[r][] = ch[r][] = ;
     s[r] = ;
 }

 void PushUp(int r) {
     s[r] = s[ch[r][]] + s[ch[r][]] + ;
 }

 void UpdateRev(int rt) {
     if (rt == )    return ;
     swap(ch[rt][], ch[rt][]);
     rev[rt] ^= ;
 }

 void PushDown(int rt) {
     if (rev[rt]) {
         UpdateRev(ch[rt][]);
         UpdateRev(ch[rt][]);
         rev[rt] = ;
     }
 }

 void Build(int& rt, int l, int r, int fa) {
     if (l > r)    return ;

     int mid = (l + r) >> ;

     newNode(rt, fa, mid);
     Build(ch[rt][], l, mid-, rt);
     Build(ch[rt][], mid+, r, rt);
     PushUp(rt);
 }

 void inorder(int rt) {
     if (rt == )    return ;
     inorder(ch[rt][]);
     printf("s = %d, key = %d\n", s[rt], key[rt]);
     inorder(ch[rt][]);
 }

 void init() {
     root = tot = top = ;
     ch[][] = ch[][] = s[] = key[] = pre[] = rev[] = ;
     newNode(root, , -);
     newNode(ch[root][], root, -);
     Build(grandlson, , n, ch[root][]);
     PushUp(ch[root][]);
     PushUp(root);
     #ifndef ONLINE_JUDGE
         inorder(root);
     #endif
 }

 void Rotate(int x, int d) {
     int y = pre[x];

     PushDown(y);
     PushDown(x);
     ch[y][d^] = ch[x][d];
     pre[ch[x][d]] = y;
     if (pre[y])
         ch[pre[y]][ch[pre[y]][]==y] = x;
     pre[x] = pre[y];
     pre[y] = x;
     ch[x][d] = y;
     PushUp(y);
 }

 void Splay(int r, int goal) {
     PushDown(r);
     while (pre[r] != goal) {
         if (pre[pre[r]] == goal) {
             PushDown(pre[r]);
             PushDown(r);
             Rotate(r, ch[pre[r]][]==r);
         } else {
             PushDown(pre[pre[r]]);
             PushDown(pre[r]);
             PushDown(r);
             int y = pre[r];
             int d = ch[pre[y]][]==y;
             if (ch[y][d] == r) {
                 Rotate(r, d^);
                 Rotate(r, d);
             } else {
                 Rotate(y, d);
                 Rotate(r, d);
             }
         }
     }
     PushUp(r);
     if (goal == )
         root = r;
 }

 int kth(int r, int k) {
     PushDown(r);
     int t = s[ch[r][]] + ;

     if (t == k)
         return r;
     else if (k < t)
         return kth(ch[r][], k);
     else
         return kth(ch[r][], k-t);
 }

 void cut(int l, int r, int c) {
     Splay(kth(root, l), );
     Splay(kth(root, r+), root);
     int tmp = grandlson;
     grandlson = ;
     PushUp(ch[root][]);
     PushUp(root);
     Splay(kth(root, c+), );
     Splay(kth(root, c+), root);
     grandlson = tmp;
     pre[tmp] = ch[root][];
     PushUp(ch[root][]);
     PushUp(root);
 }

 void flip(int l, int r) {
     Splay(kth(root, l), );
     Splay(kth(root, r+), root);
     UpdateRev(grandlson);
     PushUp(ch[root][]);
     PushUp(root);
 }

 void print(int rt) {
     if (!rt)    return ;

     PushDown(rt);
     print(ch[rt][]);
     if (cnt>= && cnt<=n) {
         if (cnt < n)
             printf("%d ", key[rt]);
         else
             printf("%d\n", key[rt]);
     }
     ++cnt;
     print(ch[rt][]);
 }

 int main() {
     ios::sync_with_stdio(false);
     #ifndef ONLINE_JUDGE
         freopen("data.in", "r", stdin);
         freopen("data.out", "w", stdout);
     #endif

     char cmd[];
     int a, b, c;

     while (scanf("%d %d", &n, &m) != EOF) {
         if (n< && m<)
             break;
         init();
         while (m--) {
             scanf("%s %d %d", cmd, &a, &b);
             if (cmd[] == 'C') {
                 scanf("%d", &c);
                 cut(a, b, c);
             } else {
                 flip(a, b);
             }
         }
         cnt = ;
         print(root);
     }

     #ifndef ONLINE_JUDGE
         printf("time = %d.\n", (int)clock());
     #endif

     return ;
 }