Hdu3436-Queue-jumpers(伸展树)

Description

Ponyo and Garfield are waiting outside the box-office for their favorite movie. Because queuing is so boring, that they want to play a game to kill the time. The game is called “Queue-jumpers”. Suppose that there are N people numbered from 1 to N stand in a line initially. Each time you should simulate one of the following operations:  1.  Top x :Take person x to the front of the queue  2.  Query x: calculate the current position of person x  3.  Rank x: calculate the current person at position x  Where x is in [1, N].  Ponyo is so clever that she plays the game very well while Garfield has no idea. Garfield is now turning to you for help. 

Input

In the first line there is an integer T, indicates the number of test cases.(T<=50)  In each case, the first line contains two integers N(1<=N<=10^8), Q(1<=Q<=10^5). Then there are Q lines, each line contain an operation as said above. 

Output

For each test case, output “Case d:“ at first line where d is the case number counted from one, then for each “Query x” operation ,output the current position of person x at a line, for each “Rank x” operation, output the current person at position x at a line.

Sample Input

3
9 5
Top 1
Rank 3
Top 7
Rank 6
Rank 8
6 2
Top 4
Top 5
7 4
Top 5
Top 2
Query 1
Rank 6

Sample Output

Case 1:
3
5
8
Case 2:
Case 3:
3
6

题意：刚开始给出一个N,代表初始是1,2,3...N排成一行，有三种操作 Top x 将值x置于最前面 Query x 查询值x排在第几 Rank x 查询排在第x的位置是数值几

解析：这道题坑了我半天，一直超时，看了别人的博客，原来是自己 的Splay写low了，而且要加一个地方才能不超时，我代码中有注释。 数据达到10^8，显然不能建这么大一颗树，需要离散化，把Top和Query操作 的数保存下来离散化，然后处理出一段段区间 一开始按照区间段排在第几个的位置建树，要保存区间段v对应的是哪个节点的 编号，如果是Top操作，先二分找到x对应的区间k,将k对应的节点伸展到根，然后 删除这个节点，再插入最右边，如果是Query操作，也是二分找到x对应的区间k, 将k对应的节点伸展到根，即可得到他的排名。如果是Rank操作，从根开始找就行， 判断是否在某一段区间内。然后找到了就可以得到答案了。

代码

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
#define t tr[r]
#define y tr[fa]
const int maxn=;
int N,Q,A[maxn];//A数组用于保存离散化的数
char op[maxn][]; //操作字符串
int opx[maxn],seg[maxn][],Size;//操作值，区间左右端点，多少个区间
int BIS(int v) //二分找区间下标
{
    int x=,yy=Size,mid;
    while(x<=yy)
    {
        int mid=(x+yy)/;
        if(seg[mid][]<=v&&v<=seg[mid][]) return mid; //找到了
        if(seg[mid][]<v) x=mid+;
        else yy=mid;
    }
}
int bel[maxn]; //用于保存第几段区间现在的节点编号
struct treap
{
    int son[],fa; //左右儿子和父亲
    int s,v,num; //s是大小,v代表区间的下标,num代表这段区间的大小
    treap(){ s=v=num=; son[]=son[]=fa=; }
    int rk();//排名
    void pushup(); //更新
    int cmp(int k); //比较
}tr[maxn*];
int treap::rk(){ return tr[son[]].s+num; }
void treap::pushup(){ s=tr[son[]].s+tr[son[]].s+num; }
int treap::cmp(int k)
{
    if(tr[son[]].s<k&&k<=rk()) return -;//在区间内
    if(k<rk()) return ;
    else return ;
}
struct splaytree
{
    int id,root;
    void init(){ id=root=; tr[].s=tr[].num=; }//初始化
    void dfs(int r)
    {
        if(r==) return;
        dfs(t.son[]);
        printf("%d ",t.v);
        dfs(t.son[]);
    }
    void Visit(){ dfs(root); puts("");}
    int NewNode(int fa,int v) //得到新节点
    {
        bel[v]=++id; //保存v值对应的下标
        int r=id;
        t.fa=fa; t.v=v;
        t.s=t.num=seg[v][]-seg[v][]+;
        t.son[]=t.son[]=;
        return r;
    }
    void Build(int &r,int le,int ri,int fa)//建树
    {
        if(le>ri) return; //区间不存在
        int mid=(le+ri)/;
        r=NewNode(fa,mid); //得到新节点
        Build(t.son[],le,mid-,r); //左建树
        Build(t.son[],mid+,ri,r); //右建树
        t.pushup();
    }
    void Insert(int &r,int fa,int k) //插入到最左边
    {
        if(r==){ r=NewNode(fa,k); return; } //在最左边建立新节点
        Insert(t.son[],r,k);
        t.pushup();
    }
    int GetMin(int r) //得到这棵子树最左端的节点
    {
        while(t.son[]!=) r=t.son[];
        return r;
    }
    void Rotate(int r,int d) //翻转
    {
        int fa=t.fa;
        y.son[d^]=t.son[d];
        if(t.son[d]!=) tr[t.son[d]].fa=fa;
        if(y.fa==) t.fa=;
        else if(tr[y.fa].son[]==fa) { t.fa=y.fa; tr[t.fa].son[]=r; }
        else if(tr[y.fa].son[]==fa) { t.fa=y.fa; tr[t.fa].son[]=r; }
        t.son[d]=fa;
        y.fa=r;
        y.pushup();
        t.pushup();

    }
    void Splay(int r) //伸展
    {
        while(t.fa!=)
        {
            if(tr[t.fa].fa==) Rotate(r,tr[t.fa].son[]==r);
            else
            {
                int fa=t.fa;
                int d=(tr[y.fa].son[]==fa);
                if(y.son[d]==r)
                {
                    Rotate(r,d^);
                    Rotate(r,d);
                }
                else
                {
                    Rotate(fa,d);
                    Rotate(r,d);
                }
            }
        }
    }
    void Top(int &r,int k) //将k对应的区间置于最前面
    {
        r=bel[k];
        Splay(r);//伸展到根
        int rr=GetMin(t.son[]);//找到右子树最小的节点
        Splay(rr); //伸展到根
        treap& tt=tr[rr];
        tt.son[]=t.son[];  //将原来的左子树连到rr上去
        if(t.son[]!=) tr[t.son[]].fa=rr;
        tt.fa=;
        tt.pushup();
        r=rr;
        Insert(r,,k); //插入到最右边
        Splay(r=id); //不加这个会超时。。。
    }
    int Query(int &r,int k)
    {
        r=bel[k];
        Splay(r);
        return t.rk();
    }
    int Rank(int &r,int k)
    {
        int d=t.cmp(k);
        if(d==-) return seg[t.v][]+ k- tr[t.son[]].s - ;
        if(d==) return Rank(t.son[],k);
        else return Rank(t.son[],k- t.rk());
    }
}spt;
int main()
{
    int T,Case=;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&N,&Q);
        int k=;
        A[k++]=;
        for(int i=;i<Q;i++)
        {
            scanf("%s%d",op[i],&opx[i]);
            if(op[i][]=='T'||op[i][]=='Q') A[k++]=opx[i];
        }
        A[k++]=N+;
        sort(A,A+k);
        Size=;
        for(int i=;i<k;i++) //处理出每段区间
        {
            if(A[i]==A[i-]) continue;
            if(A[i]-A[i-]>){ seg[++Size][]=A[i-]+; seg[Size][]=A[i]-; }
            seg[++Size][]=A[i]; seg[Size][]=A[i];
        }
        spt.init();
        spt.Build(spt.root,,Size,);
        printf("Case %d:\n",++Case);
        for(int i=;i<Q;i++)
        {
           if(op[i][]=='T') spt.Top(spt.root,BIS(opx[i]));
           else if(op[i][]=='Q') printf("%d\n",spt.Query(spt.root,BIS(opx[i])));
           else printf("%d\n",spt.Rank(spt.root,opx[i]));
        }
    }
    return ;
}