平衡树（第K大）

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 1000005

typedef struct sbtnod
{
    int key,left,right,size;
}sbtnode;
int sbttail,sbt;

sbtnode tree[maxn];

void rrotate(int &t)
{
    int k=tree[t].left;
    if(!k)
    {
        return ;
    }
    tree[t].left=tree[k].right;
    tree[k].right=t;
    tree[k].size=tree[t].size;
    tree[t].size=tree[tree[t].left].size+tree[tree[t].right].size+1;
    t=k;
}

void lrotate(int &t)
{
    int k=tree[t].right;
    if(!k)return;
    tree[t].right=tree[k].left;
    tree[k].left=t;
    tree[k].size=tree[t].size;
    tree[t].size=tree[tree[t].left].size+tree[tree[t].right].size+1;
    t=k;
}

void maintain(int &t,bool flag)
{
    if(!t)return;
    if(!flag)
    {
        if(tree[tree[tree[t].left].left].size>tree[tree[t].right].size)
        {
            rrotate(t);
        }
        else if(tree[tree[tree[t].left].right].size>tree[tree[t].right].size)
        {
            lrotate(tree[t].left);
            rrotate(t);
        }
        else return ;
    }
    else
    {
        if(tree[tree[tree[t].right].right].size>tree[tree[t].left].size)
        {
            lrotate(t);
        }
        else if(tree[tree[tree[t].right].left].size>tree[tree[t].left].size)
        {
            rrotate(tree[t].right);
            lrotate(t);
        }
        else return ;
    }
    maintain(tree[t].left,false);
    maintain(tree[t].right,true);
    maintain(t,false);
    maintain(t,true);
}

void insert(int &t,int v)
{
    if(!t)
    {
        sbttail++;
        tree[sbttail].key=v;
        tree[sbttail].size=1;
        t=sbttail;
    }
    else
    {
        tree[t].size++;
        if(v<tree[t].key)
        {
            insert(tree[t].left,v);
        }
        else
        {
            insert(tree[t].right,v);
        }
        maintain(t,v>=tree[t].key);
    }
}

int del(int &t,int v)
{
    int ret;
    tree[t].size--;
    if(v==tree[t].key||(v<tree[t].key&&tree[t].left==0)||(v>tree[t].key&&tree[t].right==0))
    {
        ret=tree[t].key;
        if(tree[t].left==0||tree[t].right==0)
        {
            t=tree[t].left+tree[t].right;
        }
        else
        {
            tree[t].key=del(tree[t].left,tree[t].key+1);
        }
    }
    else
    {
            if(v<tree[t].key)
            {
                ret=del(tree[t].left,v);
            }
            else
            {
                ret=del(tree[t].right,v);
            }
    }
    return ret;
}

int select(int t,int k)
{
    if(k==tree[tree[t].left].size+1)
    {
        return t;
    }
    if(k<=tree[tree[t].left].size)
    {
        return select(tree[t].left,k);
    }
    else return select(tree[t].right,k-1-tree[tree[t].left].size);
}

int main()
{
    int n,k;
    while(~scanf("%d%d",&n,&k))
    {
        memset(tree,0,sizeof(tree));
        sbttail=0;
        sbt=0;

        char c;
        for(int i=1;i<=n;i++)
        {
            c=getchar();
            while(c!='I'&&c!='Q')
            {
                c=getchar();
            }
            int now;
            if(c=='I')
            {
                scanf("%d",&now);
                insert(sbt,now);
            }
            else
            {
                now=select(sbt,sbttail-k+1);
                printf("%d\n",tree[now].key);
            }
        }
    }
    return 0;
}