Treap模板

#include<bits/stdc++.h>

#define inf 0x3f3f3f3f

const int maxn=10000;

using namespace std;

struct node{
   node* left;
   node* right;
   int value,fix,s,cnt;
   node(int _value,int _fix,int _s,int _cnt):value(_value),fix(_fix),s(_s),cnt(_cnt){}
   int lsize(){
        if(left){
        return left->s;
        } else {
         return 0;
        }
   }
   int rsize(){
        if(right){
        return right->s;
        } else{
        return 0;
        }
   }
   void M(){
        s=cnt;
        s+=lsize()+rsize();
   }
};

void left_rotate(node* &a){
      node* b=a->right;
      a->right=b->left;
      b->left=a;
      a->M();
      b->M();
      a=b;
}

void right_rotate(node* &a){
      node* b=a->left;
      a->left=b->right;
      b->right=a;
      a->M();
      b->M();
      a=b;
}

void treap_insert(node* &P,int value){
     if(!P){
        P=new node(value,rand(),1,1);
     } else{
     if(P->value==value){
        P->cnt++;
     }
     if(P->value>value){
        treap_insert(P->left,value);
     } else {
        treap_insert(P->right,value);
     }
     if(P->fix>P->left->fix){
        right_rotate(P);
     } else if(P->fix>P->right->fix){
        left_rotate(P);
     }
     }
     P->M();
}

void treap_delete(node* &P,int value){
     if(P->value==value){
        if(P->cnt==1){
        if(!P->left||!P->right){
            node* t=P;
            if(P->left)
             P=P->left;
            else if(P->right){
             P=P->right;
            } else {
            P=NULL;
              }
             delete t;
        } else {
           if(P->left->fix<P->right->fix){
                right_rotate(P);
                treap_delete(P->right,value);
           } else {
                left_rotate(P);
                treap_delete(P->left,value);
           }
        }

      } else{
        P->cnt--;
       }
     } else {
        if(P->value>value){
        treap_delete(P->left,value);
     } else {
        treap_delete(P->right,value);
     }
     }
     if(P){
        P->M();
     }
}

int treap_find(node* P,int value){
     if(P->value==value){
        return 1;
     } else {
       if(P->value>value){
        if(P->left)
        treap_find(P->left,value);
       } else {
         if(P->right)
         treap_find(P->right,value);
       }
     }
     return 0;
}

int treap_kth(node* &P,int k){
     int Lsize=P->lsize();
     if(k<Lsize+1){
        return treap_kth(P->left,k);
     } else if(k>Lsize+P->cnt){
        return treap_kth(P->right,k-Lsize-P->cnt);
     } else {
        return P->value;
     }
}

int treap_rank(node* &P,int value,int cur){
    int Lsize=P->lsize();
    if(value==P->value){
        return cur+Lsize+1;
    } else if(value<P->value){
        return treap_rank(P->left,value,cur);
    } else {
        return treap_rank(P->right,value,cur+Lsize+P->cnt);
    }
}

node* tpred(node* &P,int value,node* &best){
     if(!P){
        return best;
     } else {
        if(P->value<value){
                return tpred(P->right,value,P);
        } else{
           return tpred(P->left,value,best);
        }
     }
}

node* tsuc(node* &P,int value,node* &best){
     if(!P){
        return best;
     } else {
       if(P->value>value){
        return tsuc(P->left,value,P);
       } else {
        return tsuc(P->right,value,best);
       }
     }
}

int main()
{
    srand(time(0));
    return 0;
}