hdu2475Box(splay树形转线性）

链接

推荐一篇帖子

http://blog.csdn.net/lyhypacm/article/details/6734748

这题暴力不可行主要是因为这颗树可能极度不平衡，不能用并查集是不能路径压缩，这样时间复杂度是很高的。

可以用伸展树主要是因为它的伸展性，每次操作后可以通过伸展使这棵树更好的保持平衡。

这题还是值得记录一下的，从早上做到了晚上，

第一次错误，定义了全局的n以及局部的n使得取得结果不正确，以后还是统一习惯，要么写在全局要么写在局部。

第二次错误，vector初始化没有初始到0导致后面的数据跑不动，以后初始化的操作都从0开始。

第三次错误，debug了n久，建树的时候误把根节点的父亲节点写成了根，应该是0，自以为不会出错的地方也要认真检查。

 #include <iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<stdlib.h>
 #include<vector>
 #include<cmath>
 #include<queue>
 #include<set>
 #include<stack>
 using namespace std;
 #define N 100010
 #define LL long long
 #define INF 0xfffffff
 const double eps = 1e-;
 const double pi = acos(-1.0);
 const double inf = ~0u>>;
 int n,po[N];
 vector<int>ed[N];
 vector<int>dd;

 struct splay_tree
 {
     int pre[N];
     int ch[N][];
     int root,tot,num;
     int key[N];
 //    void dfs(int x)
 //    {
 //        if(x)
 //        {
 //            dfs(ch[x][0]);
 //            printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size=%2d,key=%2d\n",
 //                   x,ch[x][0],ch[x][1],pre[x],size[x],key[x]);
 //            dfs(ch[x][1]);
 //        }
 //    }
 //    void debug()
 //    {
 //        printf("root:%d\n",root);
 //        dfs(root);
 //    }
 //以上用于debug*/
     void newnode(int &x,int v,int fa)//新建一结点
     {
         x = ++tot;
         ch[x][]=ch[x][] = ;
         pre[x] = fa;
         key[x] = v;
         po[v] = x;
     }
     void pushup(int w)//由儿子更新其父亲
     {
     }
     void rotate(int r,int kind)//旋转操作，根据kind进行左旋和右旋
     {
         int y = pre[r];
         ch[y][!kind] = ch[r][kind];
         pre[ch[r][kind]] = y;
         if(pre[y])
         {
             ch[pre[y]][ch[pre[y]][]==y] = r;
         }
         pre[r] = pre[y];
         ch[r][kind] = y;
         pre[y] = r;
         pushup(y);
         pushup(r);
     }
     void splay(int r,int goal)//将r结点旋至goal下
     {
         while(pre[r]!=goal)
         {
             if(pre[pre[r]]==goal)
             {
                 rotate(r,ch[pre[r]][]==r);
             }
             else
             {
                 int y = pre[r];
                 int kind = (ch[pre[y]][]==y);
                 if(ch[y][kind]==r)
                 {
                     rotate(r,!kind);
                     rotate(r,kind);
                 }
                 else
                 {
                     rotate(y,kind);
                     rotate(r,kind);
                 }
             }
         }
         pushup(r);
         if(goal==) root = r;
     }
     int get_min(int x)
     {
         while(ch[x][])
             x =  ch[x][];
         return x;
     }
     int get_max(int x)
     {
         while(ch[x][])
             x = ch[x][];
         return x;
     }
     void update(int x,int y) //更新区间信息
     {
         int l = po[x],r = po[x+n];
         splay(l,);
         splay(r,);
         int ll = ch[l][];
         int rr = ch[r][];
         pre[ll] = pre[rr] = ;
         ch[r][] = ch[l][] = ;

         int tll = get_max(ll);
         if(tll!=)
             ch[tll][] = rr;
         pre[rr] = tll;

         if(y==) return ;
         if(query(y)==x)
         {
             ch[r][] = rr;
             ch[l][] = ll;
             pre[ll] = l;
             pre[rr] = r;
             ch[tll][] = ;
             pre[] = ;
             return ;
         }

         if(rr!=) splay(rr,);
         int tt = po[y];
         splay(tt,);
         int tq = get_min(ch[tt][]);
         splay(tq,tt);
         ch[tq][] = r;
         pre[r] = tq;
     }
     int query(int x)//询问l,r区间，将第l-1个结点旋自根，第r+1个结点旋自根的有儿子，
     {
         splay(po[x],);
         int k = get_min(po[x]);
         return key[k];
     }
     void build(int &x,int l,int r,int fa)
     {
         int m = (l+r)>>;
         if(l>r) return ;
         newnode(x,dd[m],fa);
         build(ch[x][],l,m-,x);
         build(ch[x][],m+,r,x);
         pushup(x);
     }
     void init()
     {
         root = tot = ;
         memset(ch,,sizeof(ch));
         memset(pre,,sizeof(pre));
         memset(key,,sizeof(key));
         memset(po,,sizeof(po));
     }
 } SP;
 void dfs(int u)
 {
     int i;
     dd.push_back(u);
     for(i = ; i  < ed[u].size(); i++)
     {
         int v = ed[u][i];
         dfs(v);
     }
     dd.push_back(u+n);
 }
 int main()
 {
     int i;
     int q;
     int mark = false;
     while(scanf("%d",&n)!=EOF)
     {
         if(mark)
             puts("");
         else
             mark = true;
         SP.init();
         for(i = ; i <= n; i++)
         {
             ed[i].clear();
         }
         dd.clear();
         for(i = ; i <= n; i++)
         {
             int x;
             scanf("%d",&x);
             ed[x].push_back(i);
         }
         dfs();
         int o = ;
         scanf("%d",&q);
         stack<int>st;
         for(i =  ; i < dd.size()- ; i++)
         {
             int x = dd[i];
             if(x<=n) st.push(x);
             else st.pop();
             if(st.empty())
             {
                 SP.build(SP.root,o,i,);
                 o = i+;
             }
         }
         int stt = ;
         while(q--)
         {
             char sq[];
             int x,y;
             scanf("%s",sq);
             if(sq[]=='Q')
             {
                 scanf("%d",&x);
                 printf("%d\n",SP.query(x));
             }
             else
             {
                 scanf("%d%d",&x,&y);
                 SP.update(x,y);
             }
         }
     }
     return ;
 }