HDU1890-Robotic Sort-Splay

 #include <cstdio>
 #include <algorithm>
 #include <cstring>

 using namespace std;

 #define Key_value (ch[ch[root][1] ][0])

 const int maxn = 2e5+;
 const int INF = 0x3f3f3f3f;

 int pre[maxn],ch[maxn][],key[maxn],size[maxn];
 int root,tot1;
 int rev[maxn];
 int s[maxn],tot2;
 int N;

 struct Node{
     int num,id;
     bool operator < (const Node &rhs) const
     {
         if(num == rhs.num) return id < rhs.id;
         else return num < rhs.num;
     }
 }node[maxn];

 void Treavel(int x)
 {
     if(x)
     {
         Treavel(ch[x][]);
         printf("结点:%2d: 左儿子 %2d 右儿子 %2d 父结点 %2d size= %2d val=%2d\n",x,ch[x][],ch[x][],pre[x],size[x],key[x]);
         Treavel(ch[x][]);
     }
 }

 void debug()
 {
     printf("root:%d\n",root);
     Treavel(root);
 }

 void NewNode(int &o,int father,int k)
 {
     o = k;
     pre[o] = father;
     ch[o][] = ch[o][] = ;
     rev[o] = ;
     size[o] = ;
 }
 void update_rev(int o)
 {
     if(!o) return ;
     swap(ch[o][],ch[o][]);
     rev[o] ^= ;
 }
 void push_up(int o)
 {
     int lson = ch[o][],rson = ch[o][];
     size[o] = size[lson]+size[rson] + ;
 }
 void push_down(int o)
 {
     if(rev[o])
     {
         update_rev(ch[o][]);
         update_rev(ch[o][]);
         rev[o] = ;
     }
 }
 void Build(int &x,int l,int r,int father)
 {
     if(l > r) return ;
     int mid = (l+r)>>;
     NewNode(x,father,mid);
     Build(ch[x][],l,mid-,x);
     Build(ch[x][],mid+,r,x);
     push_up(x);
 }
 void Init()
 {
     root = tot1 = tot2 = ;
     ch[root][] = ch[root][] = size[root] = pre[root] = ;
     rev[root] = ;
     NewNode(root,,N+);
     NewNode(ch[root][],root,N+);

     Build(Key_value,,N,ch[root][]);
     push_up(ch[root][]);
     push_up(root);
 }
 void Rotate(int x,int kind)
 {
     int y = pre[x];
     push_down(y);
     push_down(x);
     ch[y][!kind] = ch[x][kind];
     pre[ch[x][kind] ] = y;
     if(pre[y])
         ch[pre[y] ][ch[pre[y]][]==y ] = x;
     pre[x] = pre[y];
     ch[x][kind] = y;
     pre[y] = x;
     push_up(y);
 }
 void Splay(int x,int goal)
 {
     push_down(x);
     while(pre[x] != goal)
     {
         if(pre[pre[x] ] == goal)
         {
             push_down(pre[x]);
             push_down(x);
             Rotate(x,ch[pre[x]][]==x);
         }
         else
         {
             push_down(pre[pre[x] ]);
             push_down(pre[x]);
             push_down(x);
             int y = pre[x];
             int kind = ch[pre[y] ][] == y;
             if(ch[y][kind] == x)
             {
                 Rotate(x,!kind);
                 Rotate(x,kind);
             }
             else
             {
                 Rotate(y,kind);
                 Rotate(x,kind);
             }
         }
     }
     push_up(x);
     if(goal == ) root = x;
 }
 int Get_kth(int x,int k)
 {
     push_down(x);
     int t = size[ch[x][]] + ;
     if(t==k) return x;
     if(t > k) return Get_kth(ch[x][],k);
     else return Get_kth(ch[x][],k-t);
 }
 int Get_next(int x)
 {
     push_down(x);
     if(ch[x][] == ) return -;
     x = ch[x][];
     while(ch[x][])
     {
         x = ch[x][];
         push_down(x);
     }
     return x;
 }
 int main()
 {
     while(scanf("%d",&N) && N)
     {
         for(int i=;i<=N;i++)
         {
             scanf("%d",&node[i].num);
             node[i].id = i;
         }
         sort(node+,node+N+);
         Init();
         for(int i=;i<=N;i++)
         {
             Splay(node[i].id,);
             printf("%d%s",size[ch[root][]],i==N?"":" ");
             Splay(Get_kth(root,i),);
             Splay(Get_next(node[i].id),root);
             update_rev(Key_value);
         }
         printf("\n");
     }
 }