HDU 3436 Queue-jumpers （splay tree）

Queue-jumpers

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1821    Accepted Submission(s): 425

Problem 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

 

Author

wzc1989

 

Source

2010 ACM-ICPC Multi-University Training Contest（1）——Host by FZU

 

Recommend

zhouzeyong

 

离散化，

把Top的点提取出来，其余的缩点

 /* ***********************************************
 Author        :kuangbin
 Created Time  :2013/8/25 13:28:12
 File Name     :F:\2013ACM练习\专题学习\splay_tree_2\HDU3436.cpp
 ************************************************ */

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <set>
 #include <map>
 #include <string>
 #include <math.h>
 #include <stdlib.h>
 #include <time.h>
 using namespace std;

 #define Key_value ch[ch[root][1]][0]
 const int MAXN = ;
 int pre[MAXN],ch[MAXN][],size[MAXN];
 int num[MAXN];//r结点包含的数的个数
 int s[MAXN],e[MAXN];
 int cnt;//离散分段后的个数
 int root,tot1;

 //debug部分**********************************
 void Treavel(int x)
 {
     if(x)
     {
         Treavel(ch[x][]);
         printf("结点：%2d: 左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d  num = %2d s = %2d e = %2d\n",x,ch[x][],ch[x][],pre[x],size[x],num[x],s[x],e[x]);
         Treavel(ch[x][]);
     }
 }
 void debug()
 {
     printf("root:%d\n",root);
     Treavel(root);
 }
 //以上是debug部分**************************************

 void NewNode(int &r,int father,int k)
 {
     r = k;
     ch[r][] = ch[r][] = ;
     size[r] = e[k] - s[k] + ;
     num[r] = e[k] - s[k] + ;
     pre[r] = father;
 }
 void push_up(int r)
 {
     size[r] = size[ch[r][]] + size[ch[r][]] + num[r];
 }
 void push_down(int r)
 {

 }
 void Build(int &x,int l,int r,int father)
 {
     if(l > r)return;
     int mid = (l+r)/;
     NewNode(x,father,mid);
     Build(ch[x][],l,mid-,x);
     Build(ch[x][],mid+,r,x);
     push_up(x);
 }
 void Init()
 {
     root = tot1 = ;
     ch[root][] = ch[root][] = num[root] = size[root] = pre[root] = ;
     Build(root,,cnt,);
     push_up(root);
 }
 //旋转，0为左旋，1为右旋
 void Rotate(int x,int kind)
 {
     int y = pre[x];
     push_down(y);
     push_down(x);//先把y的标记下传，在把x的标记下传
     ch[y][!kind] = ch[x][kind];
     pre[ch[x][kind]] = y;
     if(pre[y])
         ch[pre[y]][ch[pre[y]][]==y] = x;
     pre[x] = pre[y];
     ch[x][kind] = y;
     pre[y] = x;
     push_up(y);
 }
 //Splay调整，将r结点调整到goal下面
 void Splay(int r,int goal)
 {
     push_down(r);
     while(pre[r] != goal)
     {
         if(pre[pre[r]] == goal)
             Rotate(r,ch[pre[r]][]==r);
         else
         {
             int y = pre[r];
             int kind = ch[pre[y]][]==y;
             if(ch[y][kind] == r)
             {
                 Rotate(r,!kind);
                 Rotate(r,kind);
             }
             else
             {
                 Rotate(y,kind);
                 Rotate(r,kind);
             }
         }
     }
     push_up(r);
     if(goal == ) root = r;
 }

 int Get_Min(int r)
 {
     push_down(r);
     while(ch[r][])
     {
         r = ch[r][];
         push_down(r);
     }
     return r;
 }
 int Get_Max(int r)
 {
     push_down(r);
     while(ch[r][])
     {
         r = ch[r][];
         push_down(r);
     }
     return r;
 }
 //删除根结点
 void Delete()
 {
     if(ch[root][] ==  || ch[root][] == )
     {
         root = ch[root][] + ch[root][];
         pre[root] = ;
         return;
     }
     int k = Get_Min(ch[root][]);
     Splay(k,root);
     Key_value = ch[root][];
     root = ch[root][];
     pre[ch[root][]] = root;
     pre[root] = ;
     push_up(root);
 }

 int Bin(int x)//二分查找x属于哪一段
 {
     int l = , r = cnt;
     while(l <= r)
     {
         int mid = (l+r)/;
         if(s[mid] <= x && x <= e[mid])return mid;
         if(x < s[mid])r = mid-;
         else l = mid+;
     }
     return -;
 }

 //将点x放到最前面
 void Top(int x)
 {
     int r = Bin(x);
     Splay(r,);
     Delete();
     Splay(Get_Min(root),);
     ch[r][] = ;
     ch[r][] = root;
     pre[root] = r;
     root = r;
     pre[root] = ;
     push_up(root);
 }
 int Query(int x)
 {
     int r = Bin(x);
     Splay(r,);
     return size[ch[root][]] + x - s[r] + ;
 }
 int Get_Rank(int r,int k)
 {
     int t  = size[ch[r][]];
     if(k <= t)return Get_Rank(ch[r][],k);
     else if(k <= t + num[r]) return s[r] + k - t - ;
     else return Get_Rank(ch[r][],k - t - num[r]);
 }
 char op[MAXN][];
 int qnum[MAXN];
 int p[MAXN];

 int main()
 {
     //freopen("in.txt","r",stdin);
     //freopen("out.txt","w",stdout);
      int N,Q;
     int T;
     scanf("%d",&T);
     int iCase = ;
     while(T--)
     {
         iCase++;
         scanf("%d%d",&N,&Q);
         int t = ;
         for(int i = ;i < Q;i++)
         {
             scanf("%s%d",&op[i],&qnum[i]);
             if(op[i][] == 'T')
                 p[t++] = qnum[i];
         }
         p[t++] = ;
         p[t++] = N;
         sort(p,p+t);
         t = unique(p,p+t) - p;
         cnt = ;
         for(int i = ;i < t;i++)
         {
             if(i >  && p[i] - p[i-] > )
             {
                 cnt++;
                 s[cnt] = p[i-] + ;
                 e[cnt] = p[i] - ;
             }
             cnt++;
             s[cnt] = p[i];
             e[cnt] = p[i];
         }
         Init();
     //    debug();
         //continue;
         printf("Case %d:\n",iCase);
         for(int i = ;i < Q;i++)
         {
             if(op[i][] == 'T')Top(qnum[i]);
             else if(op[i][] =='Q')printf("%d\n",Query(qnum[i]));
             else printf("%d\n",Get_Rank(root,qnum[i]));
             //debug();
         }
     }
     return ;
 }