[ZJOI 2006]书架

Description

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

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

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

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

Input

第一行有两个数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本书的编号。

Output

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

Sample Input

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

Sample Output

2
9
9
7
5
3

Hint

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

题解

其实除了$Splay$，则道题还可以用$Treap$做。

以$key$为关键词，表示其在书架中的位置，若插在两本书中间，直接取$mid$就可以。

$double$有误差，建议一开始就把书架位置的公差调大。

 #include<cmath>
 #include<ctime>
 #include<queue>
 #include<stack>
 #include<cstdio>
 #include<string>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 const int N=;
 const int X=0.00000001;

 struct node
 {
     double key;
     int lev,num,low;
     node *child[];
 } T[N+],*root,*pos;
 double key[N+],miner,maxer;
 int n,m,x,y;
 char c;

 void NewNode(node* &r,double key,int num);
 void Insert(node* &r,double key,int num);
 void Delete(node* &r,double key);
 int Query(node* r,int rank,int cnt);
 int Ask(node* r,double key);
 void Rotate(node* &r,bool t);
 int Count(node* r);
 double my_abs(double x) {return x< ? -x:x;}
 int Read();

 int main()
 {
     srand(time());
     root=NULL;
     pos=T;
     n=Read();
     m=Read();
     miner=;
     maxer=n;
     for (int i=;i<=n;i++)
     {
         x=Read();
         key[x]=i;
         Insert(root,key[x],x);
     }
     while(m--)
     {
         c=;
         while(c<'A'||c>'Z') c=getchar();
         if (c=='T')
         {
             x=Read();
             Delete(root,key[x]);
             key[x]=--miner;
             Insert(root,key[x],x);
         }
         else if (c=='B')
         {
             x=Read();
             Delete(root,key[x]);
             key[x]=++maxer;
             Insert(root,key[x],x);
         }
         else if (c=='I')
         {
             x=Read();
             y=Read();
             if (y==) continue;
             int a=Ask(root,key[x]);
             if (a==n-&&y==)
             {
                 Delete(root,key[x]);
                 key[x]=++maxer;
                 Insert(root,key[x],x);
                 continue;
             }
             if (a==&&y==-)
             {
                 Delete(root,key[x]);
                 key[x]=--miner;
                 Insert(root,key[x],x);
                 continue;
             }
             Delete(root,key[x]);
             if (y==) key[x]=(key[Query(root,a,)]+key[Query(root,a+y,)])/2.0;
             else key[x]=(key[Query(root,a+y,)]+key[Query(root,a+y*,)])/2.0;
             Insert(root,key[x],x);
         }
         else if (c=='A')
         {
             x=Read();
             printf("%d\n",Ask(root,key[x])-);
         }
         else if (c=='Q')
         {
             x=Read();
             printf("%d\n",Query(root,x,));
         }
         else break;
     }
     return ;
 }

 int Read()
 {
     int sum=;
     bool ok=;
     c=;
     while ((c<''||c>'')&&c!='-') c=getchar();
     if (c=='-')
     {
         ok=;
         c=getchar();
     }
     while (c>=''&&c<='')
     {
         sum=sum*+c-'';
         c=getchar();
     }
     return ok ? -sum:sum;
 }
 void NewNode(node* &r,double key,int num)
 {
     r=pos++;
     r->key=key;
     r->num=num;
     r->low=;
     r->lev=rand();
 }
 void Insert(node* &r,double key,int num)
 {
     if (!r)
     {
         NewNode(r,key,num);
         return;
     }
     bool t=key>r->key;
     if (!t) r->low++;
     Insert(r->child[t],key,num);
     if (r->child[t]->lev<r->lev)
     {
         Rotate(r,!t);
         r->low=+Count(r->child[]);
     }
 }
 void Delete(node* &r,double key)
 {
     if (my_abs(r->key-key)<=X)
     {
         if (r->child[]&&r->child[])
         {
             bool t=r->child[]->lev<r->child[]->lev;
             Rotate(r,t);
             r->low=+Count(r->child[]);
             if (!t) r->low--;
             Delete(r->child[t],key);
         }
         else
         {
             if (r->child[]) r=r->child[];
             else r=r->child[];
         }
     }
     else
     {
         bool t=key>r->key;
         if (!t) r->low--;
         Delete(r->child[t],key);
     }
 }
 void Rotate(node* &r,bool t)
 {
     node *y=r->child[!t],*R=r;
     r->child[!t]=y->child[t];
     y->child[t]=r;
     r=y;
     R->low=+Count(R->child[]);
 }
 int Query(node* r,int rank,int cnt)
 {
     //cout<<cnt<<" "<<rank<<" "<<r->low<<endl;
     if (r->low+cnt==rank) return r->num;
     if (r->low+cnt<rank) return Query(r->child[],rank,r->low+cnt);
     if (r->low+cnt>rank) return Query(r->child[],rank,cnt);
 }
 int Ask(node* r,double key)
 {
     if (my_abs(r->key-key)<=X) return r->low;
     if (r->key<key) return r->low+Ask(r->child[],key);
     if (r->key>key) return Ask(r->child[],key);
 }
 int Count(node* r)
 {
     if (!r) return ;
     return r->low+Count(r->child[]);
 }