hdu 1890 Robotic Sort(splay 区间反转+删点)

题目链接：hdu 1890 Robotic Sort

题意：

给你n个数，每次找到第i小的数的位置，然后输出这个位置，然后将这个位置前面的数翻转一下，然后删除这个数，这样执行n次。

题解：

典型的splay区间翻转+删点。

我们把数据排序，然后记录一下每个数原来的位置，然后splay建树的时候用原来的位置来对应，这样val[i].second就直接是这个数在splay中的那个节点。

(当然你也可以普通建树，然后手动记录位置)。

然后我们把要找的那个数对应的节点旋转到根，然后根左边的size+i就是当前数的答案，然后翻转一下前面的数，再删除根。

#include<bits/stdc++.h>
#define F(i,a,b) for(int i=a;i<=b;++i)
using namespace std;

const int N=1e5+7;
int n,a[N],size[N],ch[N][2],f[N],tot,root;bool rev[N];
pair<int,int>val[N];

void rev1(int x){if(!x)return;swap(ch[x][0],ch[x][1]);rev[x]^=1;}

void pb(int x){
    if(rev[x]){
        rev1(ch[x][0]);
        rev1(ch[x][1]);
        rev[x]=0;
    }
}

void up(int x){
    size[x]=1;
    if(ch[x][0])size[x]+=size[ch[x][0]];
    if(ch[x][1])size[x]+=size[ch[x][1]];
}

void rotate(int x){
    int y=f[x],w=ch[y][1]==x;
    ch[y][w]=ch[x][w^1];
    if(ch[x][w^1])f[ch[x][w^1]]=y;
    if(f[y]){
        int z=f[y];
        if(ch[z][0]==y)ch[z][0]=x;
        if(ch[z][1]==y)ch[z][1]=x;
    }
    f[x]=f[y];ch[x][w^1]=y;f[y]=x;up(y);
}

void splay(int x,int w){
    int s=1,i=x,y;a[1]=x;
    while(f[i])a[++s]=i=f[i];
    while(s)pb(a[s--]);
    while(f[x]!=w){
        y=f[x];
        if(f[y]!=w){if((ch[f[y]][0]==y)^(ch[y][0]==x))rotate(x);else rotate(y);}
        rotate(x);
    }
    if(!w)root=x;
    up(x);
}

void newnode(int &r,int fa,int k)
{
    r=k,f[r]=fa,rev[r]=0,ch[r][0]=ch[r][1]=0;
}

void build(int &x,int l,int r,int fa){
    int mid=(l+r)>>1;
    newnode(x,fa,mid);
    if(l<mid)build(ch[x][0],l,mid-1,x);
    if(r>mid)build(ch[x][1],mid+1,r,x);
    up(x);
    return;
}

int getmax(int x)
{
    pb(x);
    while(ch[x][1])x=ch[x][1],pb(x);
    return x;
}

void delroot()
{
    if(ch[root][0])
    {
        int m=getmax(ch[root][0]);
        splay(m,root);
        ch[m][1]=ch[root][1];
        f[ch[root][1]]=m;
        root=m,f[m]=0,up(m);
    }else root=ch[root][1],f[root]=0;
}

int main(){
    while(scanf("%d",&n),n)
    {
        F(i,1,n)scanf("%d",&val[i].first),val[i].second=i;
        sort(val+1,val+1+n),build(root,1,n,0);
        F(i,1,n-1)
        {
            splay(val[i].second,0);
            rev1(ch[root][0]);
            printf("%d ",i+size[ch[root][0]]);
            delroot();
        }
        printf("%d
",n);    
    }
    return 0;
}