HDU 3436 Queue-jumpers Splay+离散化

有n个人从小到大排成一列，分别记为1，2...，m次询问，3种操作： 1.把x这个人放到队首。 2.求x这个人在哪个位置。 3.求x这个位置是那个人。 虽然最多有1亿个人，但是操作最多只有10w次，那就离散化，把连续一段没有出现过的数压缩成一个点，然后就是普通的Splay树了。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 200010;
int ch[maxn][2], pre[maxn], sz[maxn], val[maxn], sum[maxn], map[maxn]; 
int root, top, tol;
struct node
{
    int type, x;
}q[maxn];
int num[maxn], cnt;
int s[maxn], e[maxn];
void NewNode(int &x, int f, int c)
{
    x = ++top;
    ch[x][0] = ch[x][1] = 0;
    pre[x] = f;
    
    sz[x] = e[c]-s[c]+1;
    val[x] = c;
    sum[x] = e[c]-s[c]+1;
    map[c] = x;
}


void pushup(int x)
{
    sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + sum[x];    
}

void build(int &x, int l, int r, int f)
{
    if(l > r)
        return;
    int m = (l + r) >> 1;
    NewNode(x, f, m);
    build(ch[x][0], l, m-1, x);
    build(ch[x][1], m+1, r, x);
    pushup(x);
    
}
void init()
{
    ch[0][0] = ch[0][1] = sum[0] = pre[0] = val[0] = sz[0] = 0;
    root = top = 0;
    build(root, 1, tol, 0);
}
void rotate(int x, int d)
{
    int y = pre[x];
    ch[y][d^1] = ch[x][d];
    pre[ch[x][d]] = y;
    if(pre[y])
        ch[pre[y]][ch[pre[y]][1] == y] = x;
    pre[x] = pre[y];
    ch[x][d] = y;
    pre[y] = x;
    pushup(y);
    
}
void Splay(int x, int goal)
{
    while(pre[x] != goal)
    {
        if(pre[pre[x]] == goal)
        {
            rotate(x, ch[pre[x]][0] == x);
        }
        else
        {
            int y = pre[x], z = pre[y];
            int d = (ch[z][0] == y);
            if(ch[y][d] == x)
            {
                rotate(x, d^1);
                rotate(x, d);
            }
            else
            {
                rotate(y, d);
                rotate(x, d);
            }
        }
    }
    pushup(x);
    if(goal == 0)
        root = x;
}
int get_min(int x)  
{  
    if(!x)  
        return 0;  
    while(ch[x][0])  
    {  
        x = ch[x][0];  
    }  
    return x;  
}  
int get_max(int x)  
{  
    if(!x)  
        return 0;  
    while(ch[x][1])  
    {  
        x = ch[x][1];  
    }  
    return x;  
}
void insert(int& rt, int f, int k)
{
    if(rt == 0)
    {
        NewNode(rt, f, k);
        return;
    }
    insert(ch[rt][0], rt, k);
    pushup(rt);
}
int Bin(int x)
{
    int l = 1, r = tol;
    while(l <= r)
    {
        int mid = (l+r) >> 1;
        if(x >= s[mid] && x <= e[mid])
            return mid;
        if(x > e[mid])
            l = mid+1;
        else
            r = mid-1;
    }
}

void remove(int x)  
{  
    Splay(x, 0);
    if(!ch[root][0] && !ch[root][1])
    {
        root = 0;
        return;
    }
    if(!ch[root][0])  
    {  
        root = ch[root][1];  
        pre[root] = 0;
    }  
    else
    {  
        int m = get_max(ch[root][0]);  
        Splay(m, root);  
        ch[m][1] = ch[root][1];  
        pre[ch[root][1]] = m;  
        root = m;  
        pre[root] = 0;  
        pushup(root);
    }  
}  
void Top(int x)
{
    int k = Bin(x);
    int y = map[k];
    remove(y);
    insert(root, 0, k);
    Splay(top, 0);
}
int get_kth(int rt, int k)
{
    int t = sz[ch[rt][0]];
    if(k <= t)
        return get_kth(ch[rt][0], k);
    else if(k <= t+sum[rt])
        return s[val[rt]]+k-t-1;
    else
        return get_kth(ch[rt][1], k-t-sum[rt]);
}

int get_rank(int x)
{
    int k = Bin(x);
    
    int y = map[k];
    Splay(y, 0);
    //printf("+++++%d %d\n", sz[root], sz[ch[root][0]]);
    return sz[ch[root][0]]+1;
}




int main()
{
    int T, cas = 1;
    scanf("%d", &T);
    while(T--)
    {
        printf("Case %d:\n", cas++);
        int n, m;
        scanf("%d %d", &n, &m);
        cnt = 0;
        num[++cnt] = 0;
        for(int i = 0; i < m; i++)
        {
            char s[10];
            scanf("%s %d", s, &q[i].x);
            if(s[0] == 'T')
            {
                q[i].type = 1;
                num[++cnt] = q[i].x;
            }
            else if(s[0] == 'R')
                q[i].type = 2;
            else
            {
                q[i].type = 3;
                num[++cnt] = q[i].x;
            }
        }
        num[++cnt] = n;
        sort(num+1, num+cnt+1);
        tol = 0;
        for(int i = 2; i <= cnt; i++)
        {
            if(num[i] != num[i-1])
            {
                if(num[i] - num[i-1] > 1)
                {
                    tol++;
                    s[tol] = num[i-1]+1;
                    e[tol] = num[i]-1;
                }
                tol++;
                s[tol] = num[i];
                e[tol] = num[i];
            }
        }
        init();
        for(int i = 0; i < m; i++)
        {
            if(q[i].type == 1)
            {
                Top(q[i].x);
            }
            else if(q[i].type == 2)
            {   
                int x = get_kth(root, q[i].x);
                printf("%d\n", x);
            }
            else
            {
                int x = get_rank(q[i].x);
                printf("%d\n", x);
            }
        }
    }
    return 0;
}
/*
3
9 5
Rank 3
Top 7
Rank 6
Rank 8
Top 1
*/