[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=160000;
const int X=0.00000001;

struct node
{
    double key;
    int lev,num,low;
    node *child[2];
} T[N+5],*root,*pos;
double key[N+5],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<0 ? -x:x;}
int Read();

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

int Read()
{
    int sum=0;
    bool ok=0;
    c=0;
    while ((c<'0'||c>'9')&&c!='-') c=getchar();
    if (c=='-')
    {
        ok=1;
        c=getchar();
    }
    while (c>='0'&&c<='9')
    {
        sum=sum*10+c-'0';
        c=getchar();
    }
    return ok ? -sum:sum;
}
void NewNode(node* &r,double key,int num)
{
    r=pos++;
    r->key=key;
    r->num=num;
    r->low=1;
    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=1+Count(r->child[0]);
    }
}
void Delete(node* &r,double key)
{
    if (my_abs(r->key-key)<=X)
    {
        if (r->child[0]&&r->child[1])
        {
            bool t=r->child[0]->lev<r->child[1]->lev;
            Rotate(r,t);
            r->low=1+Count(r->child[0]);
            if (!t) r->low--;
            Delete(r->child[t],key);
        }
        else
        {
            if (r->child[0]) r=r->child[0];
            else r=r->child[1];
        }
    }
    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=1+Count(R->child[0]);
}
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[1],rank,r->low+cnt);
    if (r->low+cnt>rank) return Query(r->child[0],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[1],key);
    if (r->key>key) return Ask(r->child[0],key);
}
int Count(node* r)
{
    if (!r) return 0;
    return r->low+Count(r->child[1]);
}