子树大小平衡树（SizeBalancedTree,SBT）——模板

植树节，种一棵SBT玩玩，跑得不是很快…………不过还好吧…………

求各路神牛轻虐…………………

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

const int INF=0x7fffffff;
const int MAXN=1000010;

struct _Node
{
    int key,size;
    _Node *s[2];
    _Node() {}
    _Node(int key,int size,_Node *v):key(key),size(size) {s[0]=s[1]=v;}
}pool[MAXN],null(0,0,&null);

int idx;

class SizeBalancedTree
{
    private:

    _Node *root;

    void _update(_Node* now)
    {
        now->size=now->s[0]->size+now->s[1]->size+1;
    }
    void _rot(_Node *&now,bool d)
    {
        _Node *s=now->s[d];
        now->s[d]=s->s[!d];
        s->s[!d]=now;
        _update(now),_update(s);
        now=s;
    }
    void _maintain(_Node *&now,bool d)
    {
        if (now==&null) return;
        _Node *&p=now->s[d];

        if (p->s[d]->size>now->s[!d]->size)
            _rot(now,d);
        else if (p->s[!d]->size>now->s[!d]->size)
        {
            _rot(p,!d);
            _rot(now,d);
        }
        else return;
        _maintain(now->s[0],0);
        _maintain(now->s[1],1);
        _maintain(now,0);
        _maintain(now,1);
    }
    void _ins(_Node *&now,int key)
    {
        if (now==&null)
        {
            now=pool+(idx++);
            *now=_Node(key,1,&null);
            return;
        }
        bool d=key>now->key;
        _ins(now->s[d],key);
        _maintain(now,d);
        _update(now);
    }
    bool _del(_Node *&now,int key)
    {
        if (now==&null) return false;
        bool d,succ;
        if (now->key==key)
        {
            if (now->s[1]==&null)
            {
                now=now->s[0];
                return true;
            }
            else if (now->s[0]==&null)
            { 
                now=now->s[1];
                return true;
            }
            _Node *p=now->s[1];
            while (p->s[0]!=&null) p=p->s[0];
            now->key=p->key;
            succ=_del(now->s[1],p->key),d=1;
        }
        else
        {
            d=key>now->key;
            succ=_del(now->s[d],key);
        }
        //_maintain(now,!d);
        _update(now);
        return succ;
    }
    void _print(_Node *now,int d)
    {
        for (int i=1;i<d;++i) printf("    ");
        if (d) printf("|___");
        if (now==&null) printf("null\n");
        else
        {
            printf("[%d %d]\n",now->key,now->size);
            _print(now->s[0],d+1);
            _print(now->s[1],d+1);
        }
    }
    public:

    SizeBalancedTree() { root=&null; }
    void insert(int k) { _ins(root,k); }
    bool del(int k) { return _del(root,k); }
    void print() { _print(root,0); }

    int select(int k)
    {
        if (k>root->size) return -1;
        int z=k-1;
        _Node *now=root;
        while (now->s[0]->size!=z)
        {
            if (now->s[0]->size<z) now=now->s[1],z-=now->s[0]->size+1;
            else now=now->s[0];
        }
        return now->key;
    }
    int get_rank(int k)
    {
        _Node *now=root;int ans=0;
        while (now!=&null)
        {
            if (now->key<k) ans+=now->s[0]->size+1;
            now=now->s[now->key<k];
        }
        return ans+1;
    }
    int get_pre(int k)
    {
        _Node *now=root;int ans=-INF;
        while (now!=&null)
        {
            if (now->key<k) ans=max(ans,now->key);
            if (now->key==k) return k;
            now=now->s[now->key<k];
        }
        return ans==-INF?-1:ans;
    }
    int get_succ(int k)
    {
        _Node *now=root;int ans=INF;
        while (now!=&null)
        {
            if (now->key>k) ans=min(ans,now->key);
            if (now->key==k) return k;
            now=now->s[now->key<k];
        }
        return ans==INF?-1:ans;
    }
}sbt;

int main()
{
    char opt[2];
    int n,x;
    freopen("test1.in","r",stdin);
    freopen("test1_1.out","w",stdout);
    scanf("%d",&n);
    while (n--)
    {
        scanf("%s%d",opt,&x);
        switch (opt[0])
        {
            case 'I':
                sbt.insert(x);
                break;
            case 'D':
                if (!sbt.del(x)) puts("-1");
                break;
            case 'P':
                printf("%d\n",sbt.get_pre(x));
                break;
            case 'S':
                printf("%d\n",sbt.get_succ(x));
                break;
            case 'R':
                printf("%d\n",sbt.get_rank(x));
                break;
            case 'C':
                printf("%d\n",sbt.select(x));
                break;
        }
    }
    return 0;
}