BZOJ_3224_普通平衡树_(Treap)

描述

---

http://www.lydsy.com/JudgeOnline/problem.php?id=3224

Treap模板题.支持如下几种操作:

1.插入;

2.删除;

3.rank(x);

4.kth(k);

5.pre(x);

6.suc(x);

3224: Tyvj 1728 普通平衡树

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 7395  Solved: 3124
[Submit][Status][Discuss]

Description

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：
1. 插入x数
2. 删除x数(若有多个相同的数，因只删除一个)
3. 查询x数的排名(若有多个相同的数，因输出最小的排名)
4. 查询排名为x的数
5. 求x的前驱(前驱定义为小于x，且最大的数)
6. 求x的后继(后继定义为大于x，且最小的数)

Input

第一行为n，表示操作的个数,下面n行每行有两个数opt和x，opt表示操作的序号(1<=opt<=6)

Output

对于操作3,4,5,6每行输出一个数，表示对应答案

Sample Input

10
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

Sample Output

106465
84185
492737

HINT

1.n的数据范围：n<=100000

2.每个数的数据范围：[-1e7,1e7]

数据如下http://pan.baidu.com/s/1jHMJwO2

Source

平衡树

分析

---

写多了就熟了...昨天看了书,今天调试的时候敲了好多遍,感觉满脑子是tree+heap.

p.s.

1.rank,kth,pre,suc函数都可以写成非递归的形式.

2.remove函数有两种写法:

(1).LRJ白书上的方法:

　　如果待删除节点只有一个子树,则用该子树代替待删除节点,删除待删除节点即可.如果有两个子树,则将优先值小的(小根堆)子树旋转上去,再在另一　　个子树中递归删除待删除节点,每次这样的旋转操作都会减小子树,最终会达到第一种情况.

(2).在题解里看来的方法:

　　如果待删除节点没有子树,那么可以直接删除.如果有子树,则不管有两个还是一个,将优先值小的子树旋转上去(这里注意可以将null的优先值设为　　　INF),然后再在另一个子树中递归删除节点,每次这样的旋转操作都会减小子树,最终会达到第一种情况.

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

 const int oo=~0u<<;

 struct Treap{
     struct node{
         node* ch[];
         int v,s,r,c;
         node(int v,node *t):v(v){ ch[]=ch[]=t; r=rand(); s=c=; }
         bool operator < (const node &rhs) const { return r<rhs.r; }
         void push_up(){ s=ch[]->s+ch[]->s+c; }
     }*root,*null;
     Treap(){
         null=new node(,);
         null->s=null->c=;
         null->r=oo;
         root=null;
     }
     void rotate(node* &o,bool d){
         node* k=o->ch[!d]; o->ch[!d]=k->ch[d]; k->ch[d]=o;
         o->push_up(); k->push_up(); o=k;
     }
     void insert(node* &o,int x){
         if(o==null) o=new node(x,null);
         else{
             if(o->v==x){
                 o->c++; o->s++;
             }
             else{
                 bool d=x>o->v;
                 insert(o->ch[d],x);
                 if(o->ch[d]<o) rotate(o,!d);
                 o->push_up();
             }
         }
     }
     void remove(node* &o,int x){
         if(o->v==x){
             if(o->c>) o->c--;
             else{
                 if(o->ch[]!=null&&o->ch[]!=null){
                     bool d=o->ch[]<o->ch[];
                     rotate(o,d); remove(o->ch[d],x);
                 }
                 else{
                     node* u=o;
                     if(o->ch[]==null) o=o->ch[];
                     else o=o->ch[];
                     delete u;
                 }
             }
         }
         else{
             bool d=x>o->v;
             remove(o->ch[d],x);
         }
         if(o!=null) o->push_up();
     }
     int kth(node* o,int k){
         int s=o->ch[]->s+o->c;
         if(k>o->ch[]->s&&k<=s) return o->v;
         if(k<=o->ch[]->s) return kth(o->ch[],k);
         else return kth(o->ch[],k-s);
     }
     int rank(node *o,int x){
         int s=o->ch[]->s+o->c;
         if(x==o->v) return o->ch[]->s+;
         if(x<o->v) return rank(o->ch[],x);
         else return s+rank(o->ch[],x);
     }
     int pre(int x){
         node* t=root;
         int ret=;
         while(t!=null){
             if(t->v<x){
                 ret=t->v;
                 t=t->ch[];
             }
             else t=t->ch[];
         }
         return ret;
     }
     int suc(int x){
         node *t=root;
         int ret=;
         while(t!=null){
             if(t->v>x){
                 ret=t->v;
                 t=t->ch[];
             }
             else t=t->ch[];
         }
         return ret;
     }
 }tree;

 int main()
 {
     int n,a,b;
     scanf("%d",&n);
     while(n--){
         scanf("%d%d",&a,&b);
         switch(a){
             case():tree.insert(tree.root,b);break;
             case():tree.remove(tree.root,b);break;
             case():printf("%d\n",tree.rank(tree.root,b));break;
             case():printf("%d\n",tree.kth(tree.root,b));break;
             case():printf("%d\n",tree.pre(b));break;
             case():printf("%d\n",tree.suc(b));break;
         }
     }
     return ;
 }