[ZJOI2006]书架——平衡树

题目描述

小T有一个很大的书柜。这个书柜的构造有些独特，即书柜里的书是从上至下堆放成一列。她用1到n的正整数给每本书都编了号。

小T在看书的时候，每次取出一本书，看完后放回书柜然后再拿下一本。由于这些书太有吸引力了，所以她看完后常常会忘记原来是放在书柜的什么位置。不过小T的记忆力是非常好的，所以每次放书的时候至少能够将那本书放在拿出来时的位置附近，比如说她拿的时候这本书上面有X本书，那么放回去时这本书上面就只可能有X-1、X或X+1本书。

当然也有特殊情况，比如在看书的时候突然电话响了或者有朋友来访。这时候粗心的小T会随手把书放在书柜里所有书的最上面或者最下面，然后转身离开。

久而久之，小T的书柜里的书的顺序就会越来越乱，找到特定的编号的书就变得越来越困难。于是她想请你帮她编写一个图书管理程序，处理她看书时的一些操作，以及回答她的两个提问：(1)编号为X的书在书柜的什么位置；(2)从上到下第i本书的编号是多少。

输入输出格式

输入格式：
第一行有两个数n，m，分别表示书的个数以及命令的条数；第二行为n个正整数：第i个数表示初始时从上至下第i个位置放置的书的编号；第三行到m+2行，每行一条命令。命令有5种形式：

1． Top S——表示把编号为S的书放在最上面。

2． Bottom S——表示把编号为S的书放在最下面。

3． Insert S T——T∈{-1，0，1}，若编号为S的书上面有X本书，则这条命令表示把这本书放回去后它的上面有X+T本书；

4． Ask S——询问编号为S的书的上面目前有多少本书。

5． Query S——询问从上面数起的第S本书的编号。

输出格式：
对于每一条Ask或Query语句你应该输出一行，一个数，代表询问的答案。

输入输出样例

输入样例#1： 复制
10 10
1 3 2 7 5 8 10 4 9 6
Query 3
Top 5
Ask 6
Bottom 3
Ask 3
Top 6
Insert 4 -1
Query 5
Query 2
Ask 2
输出样例#1： 复制
2
9
9
7
5
3
说明

100%的数据，n,m <= 80000

---

首先要提的一点是这道题我用splay写，当然也有大佬用FHQ Treap写，但是我不会。

这道题以序列里的位置作为splay的判断值，而编号只是一个附加值。

我们一一分析需要的操作：

1.TOP：找到编号为x的书的位置，将他splay到根，然后将它左儿子里最小的点（也就是一直往左边走的点）splay到son[root][0]（根的左儿子），然后将root的右子树合并到左子树上（前提是保证平衡树的性质），然后将root变为son[root][0]的左儿子，原来的son[root][0]变为新的root。

下面就是图示：

2.BOTTOM：这个操作类似于TOP，实际上打这个函数的时候就直接复制TOP，然后将函数里的son[k][0]和son[k][1]掉换一下即可。

因为这两个操作本质一样，只不过BOTTOM是将它旋到最后面的点。

给出BOTTOM的代码

void bottom(int x){
    splay(x,root);
    int rt=son[root][1];if(!rt)return;
    while(son[rt][1]) rt=son[rt][1];
    splay(rt,son[root][1]);
    int rtt=son[root][0];
    if(!rtt){  //这里要特判没有左儿子的情况，不然会出现一些奇奇怪怪的错误
        fa[rt]=0;son[root][1]=son[root][0]=0;
        fa[root]=rt;son[rt][1]=root;
        up(root);up(rt);root=rt;return;
    }
    else{
        int p=root;fa[rtt]=0;root=rtt;
        while(son[rtt][1]) rtt=son[rtt][1];
        fa[rt]=rtt;son[p][1]=son[p][0]=0;son[rt][1]=p;fa[p]=rt;
        son[rtt][1]=rt;up(p);up(rt);
        splay(p,root);
    }
}

3.INSERT：这个操作其实就是交换两个点的信息（编号），所以直接将它们的信息swap一下即可。

注意因为我们记录了id数组，id[x]表示编号为x的书在序列中的位置，而这个操作是要改变这个相对位置的，所以要将它们的id也swap一下。

void swaps(int x,int y){  //y表示1，0或-1
    if(!y) return;
    splay(id[x],root);
    int p=query(root,y==1?siz[son[id[x]][0]]+2:siz[son[id[x]][0]]); //用query找出上一个点的位置，这里的query其实就是
    //下面的query操作
    int x1=num[p],x2=id[x];
    swap(id[x],id[x1]);swap(num[x2],num[p]);
}

4.ASK：问多少本书在它上面，那么我们只要把x旋转splay到根，统计其左子树的size即可（因为我们维护平衡树的信息就是其在序列中的位置，所以左子树中的点在序列中的位置都小于它）

5.QUERY：这个操作就很基础了，是普通平衡树的操作，查询排名为k的数是哪个，这个操作可以去参考普通平衡树（BZOJ3224）的代码。这里就贴出代码以便没见过的同学理解（你们肯定会看得懂的）

当然这里只返回了位置，所以最后输出时要输num[query(root,x)]

int query(int k,int x){
    if(siz[son[k][0]]>=x) return query(son[k][0],x);
    x-=siz[son[k][0]];
    if(x==1) return k;x-=1;
    return query(son[k][1],x);
}

完整CODE：

#include<bits/stdc++.h>
#define MAXN 80005
using namespace std;
int read(){
    char c;int x=0,y=1;while(c=getchar(),(c<'0'||c>'9')&&c!='-');
    if(c=='-') y=-1;else x=c-'0';while(c=getchar(),c>='0'&&c<='9')
    x=x*10+c-'0';return x*y;
}
void print(int x){
    if(x/10) print(x/10);
    putchar(x%10+'0');
}
int n,m,root;
char c;
int fa[MAXN],son[MAXN][2],p[MAXN],num[MAXN],siz[MAXN],id[MAXN];
void up(int k){
    siz[k]=siz[son[k][0]]+siz[son[k][1]]+1;
    id[num[son[k][0]]]=son[k][0],id[num[son[k][1]]]=son[k][1]; //up每次更新id的位置
}
int get(int k){
    return son[fa[k]][1]==k;
}
void build(int l,int r,int f){
    if(l>r) return;
    int mid=(l+r)>>1;fa[mid]=f;
    if(f) son[f][mid>f]=mid;siz[mid]=1;
    build(l,mid-1,mid);
    build(mid+1,r,mid);
    up(mid);
}
void rotate(int x,int &k){ 
    int f=fa[x],gran=fa[f],opt=get(x); 
    if(f==k) k=x;else son[gran][get(f)]=x; 
    son[f][opt]=son[x][opt^1];fa[son[f][opt]]=f; 
    son[x][opt^1]=f;fa[f]=x;fa[x]=gran;
    up(f);up(x); 
} 
void splay(int x,int &k){ 
    while(x!=k){ 
        int f=fa[x],gran=fa[f]; 
        if(f!=k) rotate(get(x)^get(f)?x:f,k); 
        rotate(x,k); 
    }
    id[num[x]]=x;
}
void top(int x){
    splay(x,root);
    int rt=son[root][0];if(!rt)return;
    while(son[rt][0]) rt=son[rt][0];
    splay(rt,son[root][0]);
    int rtt=son[root][1];
    if(!rtt){
        fa[rt]=0;son[root][0]=son[root][1]=0;
        fa[root]=rt;son[rt][0]=root;
        up(root);up(rt);root=rt;return;
    }
    else{
        int p=root;fa[rtt]=0;root=rtt;
        while(son[rtt][0]) rtt=son[rtt][0];
        fa[rt]=rtt;son[p][0]=son[p][1]=0;son[rt][0]=p;fa[p]=rt;
        son[rtt][0]=rt;up(p);up(rt);
        splay(p,root);
    }
}
void bottom(int x){
    splay(x,root);
    int rt=son[root][1];if(!rt)return;
    while(son[rt][1]) rt=son[rt][1];
    splay(rt,son[root][1]);
    int rtt=son[root][0];
    if(!rtt){
        fa[rt]=0;son[root][1]=son[root][0]=0;
        fa[root]=rt;son[rt][1]=root;
        up(root);up(rt);root=rt;return;
    }
    else{
        int p=root;fa[rtt]=0;root=rtt;
        while(son[rtt][1]) rtt=son[rtt][1];
        fa[rt]=rtt;son[p][1]=son[p][0]=0;son[rt][1]=p;fa[p]=rt;
        son[rtt][1]=rt;up(p);up(rt);
        splay(p,root);
    }
}
int ask(int x){
    splay(x,root);
    return siz[son[x][0]];
}
int query(int k,int x){
    if(siz[son[k][0]]>=x) return query(son[k][0],x);
    x-=siz[son[k][0]];
    if(x==1) return k;x-=1;
    return query(son[k][1],x);
}
void swaps(int x,int y){
    if(!y) return;
    splay(id[x],root);
    int p=query(root,y==1?siz[son[id[x]][0]]+2:siz[son[id[x]][0]]);
    int x1=num[p],x2=id[x];
    swap(id[x],id[x1]);swap(num[x2],num[p]);
}
int main()
{
    n=read();m=read();root=(n+1)>>1;
    for(int i=1;i<=n;i++)num[i]=read(),id[num[i]]=i;
    build(1,n,0);
    for(int i=1;i<=m;i++){
        while(c=getchar(),c<'A'||c>'Z');char s;
        while(s=getchar(),s>='a'&&s<='z');
        if(c=='Q'){
            int x=read();
            print(num[query(root,x)]);puts("");
        }
        else if(c=='T'){
            int x=read();
            top(id[x]);
        }
        else if(c=='B'){
            int x=read();
            bottom(id[x]);
        }
        else if(c=='I'){
            int x=read(),op=read();
            swaps(x,op);
        }
        else if(c=='A'){
            int x=read();
            print(ask(id[x]));puts("");
        }
    }
    return 0;
}