【HDU3487】【splay分裂合并】Play with Chain

Problem Description

YaoYao is fond of playing his chains. He has a chain containing n diamonds on it. Diamonds are numbered from 1 to n.
At first, the diamonds on the chain is a sequence: 1, 2, 3, …, n.
He will perform two types of operations:
CUT a b c: He will first cut down the chain from the ath diamond to the bth diamond. And then insert it after the cth diamond on the remaining chain.
For example, if n=8, the chain is: 1 2 3 4 5 6 7 8; We perform “CUT 3 5 4”, Then we first cut down 3 4 5, and the remaining chain would be: 1 2 6 7 8. Then we insert “3 4 5” into the chain before 5th diamond, the chain turns out to be: 1 2 6 7 3 4 5 8.

FLIP a b: We first cut down the chain from the ath diamond to the bth diamond. Then reverse the chain and put them back to the original position.
For example, if we perform “FLIP 2 6” on the chain: 1 2 6 7 3 4 5 8. The chain will turn out to be: 1 4 3 7 6 2 5 8

He wants to know what the chain looks like after perform m operations. Could you help him?

 

Input

There will be multiple test cases in a test data. 
For each test case, the first line contains two numbers: n and m (1≤n, m≤3*100000), indicating the total number of diamonds on the chain and the number of operations respectively.
Then m lines follow, each line contains one operation. The command is like this:
CUT a b c // Means a CUT operation, 1 ≤ a ≤ b ≤ n, 0≤ c ≤ n-(b-a+1).
FLIP a b    // Means a FLIP operation, 1 ≤ a < b ≤ n.
The input ends up with two negative numbers, which should not be processed as a case.

 

Output

For each test case, you should print a line with n numbers. The ith number is the number of the ith diamond on the chain.

 

Sample Input

8 2
CUT 3 5 4
FLIP 2 6
-1 -1

 

Sample Output

1 4 3 7 6 2 5 8

 

Source

2010 ACM-ICPC Multi-University Training Contest（5）——Host by BJTU

【分析】

果断被指针引用坑.......

调了一个半小时，本来想复习一下昨天的内容，结果被虐了。。

感觉pushdown和update出现的地方有些奇怪.

还有就是rotate里面的写法引用和不引用是不一样的。

昨天我两个都试了一下，今天就搞混了。。。。

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #include <utility>
 #include <iomanip>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <assert.h>
 #include <map>
 #include <ctime>
 #include <cstdlib>
 #define LOCAL
 const int MAXN =  + ;
 const int INF = ;
 const int SIZE = ;
 const int maxnode =  0x7fffffff + ;
 using namespace std;
 int M;
 struct SPLAY{
        struct Node{
               int val, size;
               bool turn;
               Node *ch[], *parent;

               /*Node(){//暂时不要构造函数,节约时间
                      val = 0;
                      size = 0;
                      turn = 0;
                      parent = ch[0] = ch[1] = NULL;
               }*/
               int cmp(){
                   if (parent->ch[] == this) return ;
                   else return ;
               }
               //更新
        }*root, *nil, _nil, mem[MAXN];
        int tot;

        void pushdown(Node *&t){
             if (t == nil) return;
             if (t->turn){
                Node *p;
                p = t->ch[];
                t->ch[] = t->ch[];
                t->ch[] = p;

                if (t->ch[] != nil) t->ch[]->turn ^= ;
                if (t->ch[] != nil) t->ch[]->turn ^= ;
                t->turn = ;
             }
        }
        void update(Node *&t){
             t->size = ;
             t->size += t->ch[]->size + t->ch[]->size;
        }
        Node* NEW(int val){
              Node *p = &mem[tot++];
              p->val = val;
              p->size = ;
              p->turn = ;
              p->parent = p->ch[] = p->ch[] = nil;
              return p;
        }
        void init(){
             //哨兵初始化
             nil = &_nil;
             _nil.val = _nil.size = _nil.turn = ;
             _nil.parent = _nil.ch[] = _nil.ch[] = nil;

             tot = ;
             root = NEW(INF);
             root->ch[] = NEW(INF);
             root->ch[]->parent  = root;
        }
        //1为右旋
        /*void Rotate(Node *&t, int d){
             Node *p = t->parent;
             pushdown(p);
             pushdown(t);
             pushdown(t->ch[d]);
             //t = p->ch[d ^ 1];这句话是废话,真正的一句一处
             p->ch[d ^ 1] = t->ch[d];
             if (t->ch[d] != nil) t->ch[d]->parent = p;
             t->parent = p->parent;
             if (p->parent != nil) p->ch[p->cmp()] = t;
             t->ch[d] = p;
             p->parent = t;
             update(p);//注意这里为什么只要updatep是因为旋转是在伸展中使用的，因此t的更新在splay中
             if (root == p) root = t;//换根
        }*/
        void Rotate(Node *t, int d){
             Node *p = t->parent;//t的右旋对于p来说也是右旋
             t = p->ch[d ^ ];
             p->ch[d ^ ] = t->ch[d];
             t->ch[d]->parent = p;
             t->ch[d] = p;
             t->parent = p->parent;
             //注意，这里要更新的原因在于t并不是引用
             if (t->parent != nil){
                if (t->parent->ch[] == p) t->parent->ch[] = t;
                else if (t->parent->ch[] == p)  t->parent->ch[] = t;
             }
             p->parent = t;
             if (t->parent == nil) root = t;
             //不用换回去了...
             update(p);
             update(t);
             //t->update();
        }
        void splay(Node *x, Node *y){
             pushdown(x);
             while (x->parent != y){
                   if (x->parent->parent == y){
                      Rotate(x, x->cmp() ^ );
                      break;
                   }else{
                      Rotate(x->parent, x->parent->cmp() ^ );
                      Rotate(x, x->cmp() ^ );
                   }
                   update(x);
             }
             update(x);//最后退出的update不要忘了
             if (nil == y) root = x;
        }
        //找到第k小的数并将其伸展到y
        void find(Node *y, int k){
             Node *x = root;
             while (){
                   //if (x == nil) break;//注意我已经在init中插入了两个数
                   pushdown(x);
                   int tmp = (x->ch[]->size);
                   if ((tmp + ) == k) break;
                   if (k <= tmp) x = x->ch[];
                   else k -= tmp + , x = x->ch[];
             }
             pushdown(x);
             splay(x, y);
        }
        //在pos位置后面插入一个数val
        void Insert(int pos, int val){
             find(nil, pos + );
             find(root, pos + );//时刻注意已经插入了两个INF
             pushdown(root);
             pushdown(root->ch[]);
             Node *p = NEW(val), *t = root->ch[];
             //一定要拆开！！不能放在ch[1]->[0]
             p->ch[] = t;
             t->parent = p;
             root->ch[] = p;
             p->parent = root;
             splay(p, nil);
        }
        //剪掉a,b位置的数并接到c位置后面
        void Cut(int a, int b, int c){
             find(nil, a);
             find(root, b + );
             pushdown(root);
             pushdown(root->ch[]);

             Node *p = root->ch[]->ch[];
             root->ch[]->ch[] = nil;//剪掉
             update(root->ch[]);///不要忘了更新
             update(root);

             find(nil, c + );
             find(root, c + );
             pushdown(root);
             pushdown(root->ch[]);

             root->ch[]->ch[] = p;
             p->parent = root->ch[];
             update(root->ch[]);
             update(root);
             splay(p, nil);
        }
        void Reverse(int l, int r){
             find(nil, l);
             find(root, r + );
             //print(root);
             root->ch[]->ch[]->turn ^= ;
             Node *p = root->ch[]->ch[];
             splay(p, nil);
        }
        void print(Node *t){
             if (t == nil) return;
             pushdown(t);
             print(t->ch[]);
             if (t->val != INF){
                if (M != ) {printf("%d ", t->val);M--;}
                else printf("%d", t->val);
             }
             print(t->ch[]);
        }
 }A;
 int n, m;

 void init(){
      A.init();
      //scanf("%d%d", &n, &m);
      for (int i = ; i < n; i++){
          A.Insert(i, i + );
      }
      //A.print(A.root);
 }
 void work(){
      for (int i = ; i <= m; i++){
          char str[];
          scanf("%s", str);
          if (str[] == 'C'){
             int a, b, c;
             scanf("%d%d%d", &a, &b, &c);
             A.Cut(a, b, c);
          }else{
             int l, r;
             scanf("%d%d", &l, &r);
             A.Reverse(l, r);
          }
          //A.print(A.root);
      }
      M = n;
      A.print(A.root);
 }

 int main(){

     while (scanf("%d%d", &n, &m)){
           if (n == - && m == -) break;
           init();
           //A.find(A.nil, 3);
           //printf("%d", A.root->size);
           work();
           printf("\n");
     }
     return ;
 }