HDU 1890 Robotic Sort（splay）

【题目链接】

http://acm.hdu.edu.cn/showproblem.php?pid=1890

【题意】

给定一个序列，每次将i..P[i]反转，然后输出P[i]，P[i]定义为当前数字i的所在位置。相等的两个数排序后相对位置不变。

【思路】

由于相对位置不变，所以可以根据数值与位置重编号。

依旧使用直接定位从上到下旋转至根的splay写法。每次将i结点旋转至根，则答案为左儿子大小+i，然后将i删掉合并左右儿子。

需要注意合并时判断左右儿子是否为空，以及各种pushdown下传标记。

【代码】

 #include<set>
 #include<cmath>
 #include<queue>
 #include<vector>
 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #define trav(u,i) for(int i=front[u];i;i=e[i].nxt)
 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)
 using namespace std;

 typedef long long ll;
 const int N = 5e5+; 

 ll read() {
     char c=getchar();
     ll f=,x=;
     while(!isdigit(c)) {
         if(c=='-') f=-; c=getchar();
     }
     while(isdigit(c))
         x=x*+c-'',c=getchar();
     return x*f;
 }

 struct Node *null;
 struct Node {
     int v,s,rev;
     Node *ch[],*fa;
     void init(int x) {
         v=x;
         s=rev=;
         ch[]=ch[]=fa=null;
     }
     void pushdown() {
         if(rev) {
             swap(ch[],ch[]);
             ch[]->rev^=; ch[]->rev^=;
             rev=;
         }
     }
     void maintain() {
         s=ch[]->s+ch[]->s+;
     }
 } nodepool[N],*node[N];

 void rot(Node* o,int d) {
     Node *k=o->ch[d],*tmp=null;
     o->ch[d]=k->ch[d^];
     if((tmp=k->ch[d^])!=null) tmp->fa=o;
     k->ch[d^]=o;
     if((tmp=o->fa)!=null) tmp->ch[tmp->ch[]==o]=k;
     o->fa=k; k->fa=tmp;
 }
 Node *st[N<<];
 void up_push(Node* u) {
     int top=;
     while(u!=null)
         st[++top]=u,u=u->fa;
     while(top)
         st[top--]->pushdown();
 }
 void splay(Node* o,Node* des=null) {
     up_push(o);
     Node *nf,*nff;
     while(o!=des && (nf=o->fa)!=des) {
         nff=nf->fa;
         if(nff==des) rot(nf,nf->ch[]==o),nf->maintain();
         else {
             int d1=nf->ch[]==o,d2=nff->ch[]==nf;
             if(d1==d2) rot(nff,d2),rot(nf,d1);
             else rot(nf,d1),rot(nff,d2);
             nff->maintain(),nf->maintain();
         }
     }
     o->maintain();
 }
 void reverse(Node* o) {
     swap(o->ch[],o->ch[]);
     o->ch[]->rev^=;
     o->ch[]->rev^=;
 }
 Node* getbound(Node* o,int d) {
     o->pushdown();
     if(o->ch[]==null&&o->ch[]==null) return o;
     if(o->ch[d]!=null) return getbound(o->ch[d],d);
     else return o;
 }
 void merge(Node* u,Node* v) {
     if(u->ch[]==null) u->ch[]=v;
     else {
         u=getbound(u,);
         splay(u);
         u->ch[]=v;
     }
     v->fa=u; u->maintain();
 }

 int n,a[N];

 Node* build(int l,int r,Node* fa) {
     if(l>r) return null;
     int mid=l+r>>;
     Node* o=node[a[mid]];
     o->fa=fa;
     o->v=a[mid];
     o->ch[]=build(l,mid-,o);
     o->ch[]=build(mid+,r,o);
     o->maintain();
     return o;
 }
 struct snode {
     int a,rank;
     bool operator < (const snode& rhs) const {
         return a<rhs.a||(a==rhs.a&&rank<rhs.rank);
     }
 } nodes[N];

 int main()
 {
     //freopen("in.in","r",stdin);
     //freopen("out.out","w",stdout);
     while(n=read(),n) {
         null=new Node();
         FOR(i,,n) {
             a[i]=read();
             nodes[i]=(snode){a[i],i};
             node[i]=&nodepool[i];
             nodepool[i].init();
         }
         sort(nodes+,nodes+n+);
         FOR(i,,n) a[nodes[i].rank]=i;
         build(,n,null);
         FOR(i,,n-) {
             Node* o=node[i];
             splay(o);
             printf("%d ",o->ch[]->s+i);
             Node *lc=o->ch[],*rc=o->ch[];
             o->ch[]=o->ch[]=null;
             lc->fa=rc->fa=null;
             if(lc!=null) {
                 lc->pushdown();
                 if(rc!=null) rc->pushdown();
                 reverse(lc);
                 merge(lc,rc);
             }
         }
         printf("%d\n",n);
     }
     return ;
 }

P.S.好久之前就想切掉这道题了，但一直苦于没有正确的姿势=-=