UVA 11922 Permutation Transformer （Splay树）

题意：

　　给一个序列，是从1~n共n个的自然数，接下来又m个区间，对于每个区间[a,b]，从第a个到第b个从序列中分离出来，翻转后接到尾部。输出最后的序列。

思路：

　　这次添加了Split和Merge两个基本操作，还有个比较困难的翻转操作。翻转操作只需要将需要翻转的序列独立成树，给根加上翻转标记之后再直接插到另外由前后两棵树组成的树上。但是在做一些操作的时候可能会遇到已经标记了翻转的子树，比如splay时，如果不顾flip标记，直接带flip标记的点伸展到根，会就会跟其他没有标记的节点混合了，而一个点如果带flip标记，其实标记的是它的两个孩子是需要翻转，此时如果来个无标记的孩子替换了某个孩子，就会造成错误。所以必须在splay之前完成翻转。

 #include <bits/stdc++.h>
 #define pii pair<int,int>
 #define INF 0x3f7f7f7f
 #define LL long long
 using namespace std;
 const int N=;
 const int mod=;

 struct node
 {
     int key, pre, flip, ch[], son[];
 }nod[N];
 int  n, m, a, b, node_cnt, root;

 int create_node(int v,int far)
 {
     nod[node_cnt].key=v;
     nod[node_cnt].pre=far;
     nod[node_cnt].flip=;
     nod[node_cnt].ch[]=;
     nod[node_cnt].ch[]=;
     nod[node_cnt].son[]=;
     nod[node_cnt].son[]=;
     return node_cnt++;
 }

 void push_down(int t)
 {
     if(nod[t].flip)
     {
         swap(nod[t].ch[],  nod[t].ch[]);
         swap(nod[t].son[], nod[t].son[]);
         nod[t].flip=;
         int L=nod[t].ch[], R=nod[t].ch[];
         if(L)   nod[L].flip=!nod[L].flip;
         if(R)   nod[R].flip=!nod[R].flip;
     }
 }

 void Rotate(int t,int d)
 {
     int son=nod[t].ch[d];
     int far=nod[t].pre;
     int gra=nod[far].pre;

     nod[son].pre=far;
     nod[far].pre=t;
     nod[t].pre=gra;

     nod[t].ch[d]=far;
     nod[far].ch[d^]=son;
     nod[gra].ch[ nod[gra].ch[]==far ]=t;

     nod[far].son[d^]=nod[t].son[d];
     nod[t].son[d]+=nod[far].son[d]+;
 }

 int Insert(int t,int v)
 {
     if(t==)    return root=create_node(v, );
     if( v<nod[t].key )
     {
         if(nod[t].ch[])    return Insert(nod[t].ch[], v);
         else                return nod[t].ch[]=create_node(v, t);
     }
     else
     {
         if(nod[t].ch[])    return Insert(nod[t].ch[], v);
         else                return nod[t].ch[]=create_node(v, t);
     }
 }

 void Splay(int t,int goal)
 {
     while(nod[t].pre!=goal)
     {
         int f=nod[t].pre, g=nod[f].pre;
         if(g==goal)    Rotate(t, nod[f].ch[]==t);
         else
         {
             int d1=nod[f].ch[]==t, d2=nod[g].ch[]==f;
             if(d1==d2)  Rotate(f, d1),Rotate(t, d1);
             else        Rotate(t, d1),Rotate(t, d2);
         }
     }
     if(!goal)   root=t;
 }

 int Find(int t,int k)   //找第k个元素，必须能找到。这里不处理出错。
 {
     push_down(t);               //找的时候顺便往下推。
     if( nod[t].son[]+==k )    return t;
     if( k<nod[t].son[]+ )     return Find(nod[t].ch[], k);
     else    return Find(nod[t].ch[], k-nod[t].son[]-);
 }

 void Split(int t, int k, int &L, int &R)    //在以t为根的树中将[1,k]分离出来，变成两棵树L和R。
 {
     Splay( Find(t, k), );   //查找第k个元素，并伸展到根
     L=root;
     R=nod[L].ch[];
     nod[L].son[]=;
     nod[L].ch[]=;
     nod[R].pre=;
 }

 int Merge(int L,int R)
 {
     int k=nod[L].son[]+nod[L].son[]+;
     Splay( Find(L, k),  );         //在用Splay时，必须先往下推。
     L=root;
     nod[L].ch[]=R;
     nod[R].pre=L;
     nod[L].son[]=nod[R].son[]++nod[R].son[];
     return L;
 }

 void cal(int a,int b)   //从树中取出[a,b]然后旋转，插到尾部
 {
     int left=, mid=, right=;
     if(a!= && b!=n)    //三段
     {
         Split(root,  a-, left, right);
         Split(right, b-a+, mid, right );
         nod[mid].flip^=;
         root=Merge(Merge( left, right ) , mid );
     }
     else if(a==)       //中后段
     {
         Split(root, b, mid, right );
         nod[mid].flip^=;
         root=Merge( right, mid );
     }
     else if(b==n)       //前中段
     {
         Split(root, a-, left, mid);
         nod[mid].flip^=;
         root=Merge(left, mid );
     }
 }

 void print(int t)    //深搜输出
 {
     push_down(t);   //要往下推
     if(nod[t].ch[])    print(nod[t].ch[]);
     printf("%d\n", nod[t].key);
     if(nod[t].ch[])    print(nod[t].ch[]);
 }

 int main()
 {
     //freopen("input.txt", "r", stdin);
     node_cnt=;root=;
     cin>>n>>m;
     for(int i=; i<=n; i++)    Splay(Insert(root, i), );

     for(int i=; i<m; i++)
     {
         scanf("%d%d",&a,&b);
         if(a== && b==n)  nod[root].flip^=;    //整个区间都翻转
         cal(a,b);
     }
     print(root);
     return ;
 }

AC代码