HDU 3487 Play with Chain（Splay）

题目大意

给一个数列，初始时为 1, 2, 3, ..., n，现在有两种共 m 个操作

　　操作1. CUT a b c 表示把数列中第 a 个到第 b 个从原数列中删除得到一个新数列，并将它添加到新数列中第 c 个数的后面

　　操作2. FLIP a b 表示把数列中第 a 个数到第 b 个数翻转

经过 m 个操作之后，输出这个数列

1≤n, m≤3*100000

做法分析

这题也不好用线段树做，用 Splay 很快就搞出来了

对于"操作1. CUT a b c" ，只需要将 a-1 旋转到根，b+1旋转成 a-1 的子树，那么 [a, b] 之间的树变成了 b+1 的左子树，将整个子树从原树中删去，并把 b+1 旋转到根。之后把 c 旋转到根，c+1 旋转成 c 的子树，再把刚才删掉的子树添加到 c+1 的左子树上（没添加之前，c+1 的左子树必然为空）

对于“操作2. FLIP a b”，只需要给树中每个节点一个 rev 标记表示是否需要翻转以该节点为根的子树中序遍历所得的数列，和线段树差不多的使用懒操作就行了

还是那些细节问题，在什么时候 pushDown，什么时候 pushUp，写代码的时候一定要想清楚

参考代码

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <queue>

 using namespace std;

 const int N=, INF=0x7fffffff;

 struct Splay_Tree {
     struct Node {
         int val, Size, son[];
         bool rev;
         inline void init(int _val) {
             val=_val, Size=;
             son[]=son[]=rev=;
         }
     } T[N];
     int fa[N], root;
     queue <int> ans;

     inline void pushUp(int x) {
         T[x].Size=;
         if(T[x].son[]) T[x].Size+=T[T[x].son[]].Size;
         if(T[x].son[]) T[x].Size+=T[T[x].son[]].Size;
     }

     inline void pushDown(int x) {
         if(!T[x].rev) return;
         if(T[x].son[]) T[T[x].son[]].rev^=;
         if(T[x].son[]) T[T[x].son[]].rev^=;
         swap(T[x].son[], T[x].son[]);
         T[x].rev=;
     }

     void Rotate(int x, int kind) {
         int y=fa[x], z=fa[y];
         pushDown(y), pushDown(x);
         T[y].son[!kind]=T[x].son[kind], fa[T[x].son[kind]]=y;
         T[x].son[kind]=y, fa[y]=x;
         T[z].son[T[z].son[]==y]=x, fa[x]=z;
         pushUp(y);
     }

     void Splay(int x, int goal) {
         if(x==goal) return;
         while(fa[x]!=goal) {
             int y=fa[x], z=fa[y];
             int rx=T[y].son[]==x, ry=T[z].son[]==y;
             if(z==goal) Rotate(x, rx);
             else {
                 if(rx==ry) Rotate(y, ry);
                 else Rotate(x, rx);
                 Rotate(x, ry);
             }
         }
         pushUp(x);
         if(goal==) root=x;
     }

     int Select(int pos, int goal) {
         int u=root;
         pushDown(u);
         while(T[T[u].son[]].Size!=pos) {
             if(T[T[u].son[]].Size>pos) u=T[u].son[];
             else {
                 pos-=T[T[u].son[]].Size+;
                 u=T[u].son[];
             }
             pushDown(u);
         }
         Splay(u, goal);
         return u;
     }

     void Cut(int L, int R, int pos) {
         int u=Select(L-, ), v=Select(R+, u);
         int x=T[v].son[];
         fa[x]=, T[v].son[]=;
         Splay(v, );
         u=Select(pos, ), v=Select(pos+, u);
         T[v].son[]=x, fa[x]=v;
         Splay(x, );
     }

     void Reverse(int L, int R) {
         int u=Select(L-, ), v=Select(R+, u);
         T[T[v].son[]].rev^=;
     }

     void DFS(int u) {
         pushDown(u);
         if(T[u].son[]) DFS(T[u].son[]);
         ans.push(T[u].val);
         if(T[u].son[]) DFS(T[u].son[]);
     }

     void Display(int n) {
         while(!ans.empty()) ans.pop();
         DFS(root);
         for(int cnt=, x; cnt<n; cnt++, ans.pop()) {
             for(x=ans.front(); x==-INF; ans.pop(), x=ans.front());
             printf("%d", x);
             if(cnt+==n) printf("\n");
             else printf(" ");
         }
     }

     int build(int L, int R) {
         if(L>R) return ;
         if(L==R) return L;
         int mid=(L+R)>>, sL, sR;
         T[mid].son[]=sL=build(L, mid-);
         T[mid].son[]=sR=build(mid+, R);
         fa[sL]=fa[sR]=mid;
         pushUp(mid);
         return mid;
     }

     void init(int n) {
         T[].init(-INF), T[].init(-INF), T[n+].init(-INF);
         for(int i=; i<=n+; i++) T[i].init(i-);
         root=build(, n+);
         T[].Size=, T[].son[]=root, fa[root]=, fa[]=;
     }
 } hehe;
 int n, m;
 char cmd[];

 int main() {
 //    freopen("in", "r", stdin);
     while(scanf("%d%d",&n, &m), n!=- || m!=-) {
         hehe.init(n);
         for(int i=, a, b, c; i<m; i++) {
             scanf("%s", cmd);
             if(cmd[]=='C') {
                 scanf("%d%d%d", &a, &b, &c);
                 hehe.Cut(a, b, c);
             }
             else {
                 scanf("%d%d", &a, &b);
                 hehe.Reverse(a, b);
             }
         }
         hehe.Display(n);
     }
     return ;
 }

HDU 3487

题目链接 & AC 通道

HDU 3487 Play with Chain