hdu 2475 BOX (splay)

版权声明：本文为博主原创文章，未经博主允许不得转载。

hdu 2475

Splay树是一种神奇的东西。。。

题意：

　　有一些箱子，要么放在地上，要么放在某个箱子里面 。

　　现在有两种操作：

　　　　（1） MOVE x y： 把 x 号箱子放到 y 号箱子里面，操作不合法就忽略这一次操作 。

　　　　（2） QUERY x :  查询 x 号箱子最外面的箱子是哪一个

解法：

　　首先对所有的树进行一遍DFS，得到一个DFS序，可以把它看成是一个括号序列，开始访问某个节点是左括号，结束访问时是右括号 。这样这题就转换成用Splay树来维护这个序列 。

　　对于MOVE操作：

　　　　将 x 对应那一段序列切下来，并将其放到 y 对应左括号的右边 。

　　对于QUERY操作：

　　　　直接查询以 x 为根的子树的最小值 。

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <queue>
 #include <set>
 #include <vector>
 #include <map>
 #define ll long long

 using namespace std;

 const int N=;

 //  前向星
 struct edge{
     int to,nex;
 }e[N];
 int cnt;
 int head[N];

 inline void addedge(int u,int v){
     e[cnt].to=v;
     e[cnt].nex=head[u];
     head[u]=cnt++;
 }

 int id[N*];   // DFS序
 int cou;

 int tot;
 struct tree{
     int key,fa,son[];
 }t[N*];
 int L[N],R[N];  // 第i个箱子所对应的左右括号在Splay树上的序号

 inline void pushup(int x){}
 inline void pushdown(int x){}

 inline void rotate(int x,int p){
     int y=t[x].fa;
     pushdown(y);
     pushdown(x);

     t[y].son[!p]=t[x].son[p];
     t[t[x].son[p]].fa=y;
     t[x].fa=t[y].fa;
     if (t[x].fa)
         t[t[x].fa].son[t[t[x].fa].son[]==y]=x;
     t[x].son[p]=y;
     t[y].fa=x;
     pushup(y);
     pushup(x);
 }

 inline void Splay(int x,int to){
     while (t[x].fa!=to){
         if (t[t[x].fa].fa==to)
             rotate(x,t[t[x].fa].son[]==x);
         else {
             int y=t[x].fa, z=t[y].fa;
             int p=(t[z].son[]==y);
             if (t[y].son[p]==x)
                 rotate(x,!p),rotate(x,p);
             else
                 rotate(y,p),rotate(x,p);
         }
     }
 }

 inline int newnode(int key,int fa){
     int x=tot++;
     t[x].key=key;
     t[x].fa=fa;
     t[x].son[]=t[x].son[]=;

     if (key>) L[key]=x;
     else R[-key]=x;

     return x;
 }

 inline int get_min(int x){
     while (t[x].son[]!=)
         x=t[x].son[];
     return x;
 }

 inline int get_max(int x){
     while (t[x].son[]!=)
         x=t[x].son[];
     return x;
 }

 inline int bulid(int l,int r,int fa){
     if (l>r) return ;
     int x,mid=(l+r)>>;
     x=newnode(id[mid],fa);
     t[x].son[]=bulid(l,mid-,x);
     t[x].son[]=bulid(mid+,r,x);
     pushup(x);
     return x;
 }

 inline void dfs(int u){
     id[cou++]=u;
     for (int i=head[u];~i;i=e[i].nex)
         dfs(e[i].to);
     id[cou++]=-u;
 }

 inline void init(){
     memset(head,-,sizeof(head));
     cnt=;
     cou=;
     tot=;
 }

 inline int query(int a){
     int x=L[a];
     Splay(x,);
     x=get_min(x);
     return t[x].key;
 }

 inline void move(int a,int b){
     if (a==b) return;

     int x=L[a],y=R[a];
     Splay(x,);
     Splay(y,x);

     int xx=t[x].son[],yy=t[y].son[],z=;
     z=get_max(xx);

     t[x].son[]=; t[y].son[]=;
     t[xx].fa=; t[yy].fa=;
     if (z!=) t[z].son[]=yy;
     t[yy].fa=z;

     if (b==) return;

     if (query(b)==a){
         t[x].son[]=xx; t[y].son[]=yy;
         t[xx].fa=x; t[yy].fa=y;
         t[z].son[]=;
         return;
     }

     int l=L[b],r;
     Splay(l,);
     r=get_min(t[l].son[]);
     Splay(r,l);
     t[r].son[]=x;
     t[x].fa=r;
 }

 int main(){
     int n,q;
     int x,y;
     char ch[];
     bool f=false;
     while (scanf("%d",&n)!=EOF){
         if (f) puts("");
         else f=true;

         init();

         for (int i=;i<=n;i++){
             scanf("%d",&x);
             addedge(x,i);
         }

         dfs();
         int k=,st=;
         for (int i=;i<=*n;i++){
             if (id[i]>) k++;
             else k--;
             if (k==) {
                 bulid(st,i,);
                 st=i+;
             }
         }

         scanf("%d",&q);
         while (q--){
             scanf("%s",ch);
             if (ch[]=='Q') {
                 scanf("%d",&x);
                 printf("%d\n",query(x));
             }
             else {
                 scanf("%d %d",&x,&y);
                 move(x,y);
             }
         }
     }

     return ;
 }