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+10;
const int INF = 0x3f3f3f3f;

int pre[maxn],ch[maxn][2],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][0]);
        printf("结点:%2d: 左儿子 %2d 右儿子 %2d 父结点 %2d size= %2d val=%2d
",x,ch[x][0],ch[x][1],pre[x],size[x],key[x]);
        Treavel(ch[x][1]);
    }
}

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

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

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