[bzoj3224]普通平衡树[Treap]

Treap 的各种操作，模板题，要再写几遍

 #include <iostream>
 #include <algorithm>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cmath>
 #include <ctime>

 using namespace std;

 class    Treap
 {
     private:
         struct Treap_Point
         {
             int    l,r,val,size,key,num;
             Treap_Point(){l=r=val=size=key=num=;}
         };
         Treap_Point    d[];
         int    root,cnt;
         pair<int,int>    tmp;

         void    update(const int t)
         {
             d[t].size=d[d[t].l].size+
                 d[d[t].r].size+d[t].num;
             return ;
         }

         void    turn_R(int & t)
         {
             int    temp=d[t].l;d[t].l=d[temp].r;d[temp].r=t;
             d[temp].size=d[t].size;update(t);t=temp;return ;
         }

         void    turn_L(int & t)
         {
             int    temp=d[t].r;d[t].r=d[temp].l;d[temp].l=t;
             d[temp].size=d[t].size;update(t);t=temp;return ;
         }

         void    insert(int & t,const int x)
         {
             if(!t)
             {
                 cnt++;t=cnt;d[t].size=d[t].num=;
                 d[t].val=x,d[t].key=rand();
                 return ;
             }
             d[t].size++;
             if(d[t].val==x)d[t].num++;
             else if(x<=d[t].val)
             {
                 insert(d[t].l,x);
                 if(d[d[t].l].key<d[t].key)turn_R(t);
             }
             else
             {
                 insert(d[t].r,x);
                 if(d[d[t].r].key<d[t].key)turn_L(t);
             }
             return ;
         }

         void    erase(int & t,const int x)
         {
             if(!t)return ;
             if(d[t].val==x)
             {
                 if(d[t].num>)
                 {
                     d[t].num--;d[t].size--;return ;
                 }
                 if(d[t].l*d[t].r==)t=d[t].l+d[t].r;
                 else if(d[d[t].l].key<d[d[t].r].key)
                     turn_R(t),erase(t,x);
                 else
                     turn_L(t),erase(t,x);
             }
             else if(x<=d[t].val)d[t].size--,erase(d[t].l,x);
             else    d[t].size--,erase(d[t].r,x);
             return ;
         }

         int    get(const int & t,const int x)
         {
             if(t==)return ;
             if(x<=d[d[t].l].size)return get(d[t].l,x);
             else if(x>d[d[t].l].size+d[t].num)
                 return get(d[t].r,x-d[d[t].l].size-d[t].num);
             return d[t].val;
         }

         int    upper_bound(const int & t,const int x,const int step)
         {
             if(t==)return ;
             if(x<d[t].val)tmp=min(tmp,make_pair(d[t].val,step));
             if(x>=d[t].val)upper_bound(d[t].r,x,step+d[d[d[t].r].l].size+d[t].num);
             else    upper_bound(d[t].l,x,step-d[d[d[t].l].r].size-d[d[t].l].num);
             return tmp.second;
         }

         int    lower_bound(const int & t,const int x,const int step)
         {
             if(t==)return ;
             if(x<=d[t].val)tmp=min(tmp,make_pair(d[t].val,step));
             if(x>d[t].val)lower_bound(d[t].r,x,step+d[d[d[t].r].l].size+d[t].num);
             else    lower_bound(d[t].l,x,step-d[d[d[t].l].r].size-d[d[t].l].num);
             return tmp.second;
         }

     public:
         void    insert(const int x)
         {
             insert(root,x);
         }
         void    erase(const int x)
         {
             erase(root,x);
         }
         int    get(const int x)
         {
             return get(root,x);
         }
         int    upper_bound(const int x)
         {
             tmp=make_pair(0x7fffffff,);
             return upper_bound(root,x,d[d[root].l].size+);
         }
         int    lower_bound(const int x)
         {
             tmp=make_pair(0x7fffffff,);
             return lower_bound(root,x,d[d[root].l].size+);
         }
 }S;

 int    n;

 int main()
 {
     int    i,op,x;

     scanf("%d",&n);

     S.insert(0x7ffffff0);
     for(i=;i<=n;++i)
     {
         scanf("%d%d",&op,&x);
         if(op==)S.insert(x);
         if(op==)S.erase(x);
         if(op==)printf("%d\n",S.lower_bound(x));
         if(op==)printf("%d\n",S.get(x));
         if(op==)printf("%d\n",S.get(S.lower_bound(x)-));
         if(op==)printf("%d\n",S.get(S.upper_bound(x)));
     }

     return ;
 }