Treap入门题

Treap可以说是最简单的平衡树了，核心是利用随机数，使得二叉排序树的各种操作复杂度平均为O(lgn)，写起来也是相当简单。

主要功能有：

Struct Tree{
　　int key, size, fa, son[2];
}

void Rotate(int x, int p); //0左旋 1右旋

void Insert(int x,int key) //插入key

void Remove(int x,int key) //删除值为key的节点 若有重点只删其中一个

int getKth(int x,int k) //获得第k大的节点

int getRank(int x,int key) //获得值<=key的节点个数 并将其转移到根处 若<key只需将<=换为<

int getPrev() //返回比根值小的最大值 若无返回0

int getSucc() //返回比根值大的最小值 若无返回0

int getMax(int r) //返回比最大值

int getMin(int r) //返回最小值

模板：

#include <cstdio>
#include <cstdlib>
/*************************Treap模板*****************************/
const int MAXN=1e6+9;
int cnt,rt; //节点编号从1开始
struct Treap {
int key, size, pri, son[2]; //保证父亲的pri大于儿子的pri

} T[MAXN];

int newNode(int key) { //新建结点
++cnt;
T[cnt].key=key;
T[cnt].pri=rand();
T[cnt].size=1;
T[cnt].son[0]=T[cnt].son[1]=0;
return cnt;
}
void Rotate(int &x,int p) { //0左旋 1右旋
int y=T[x].son[!p];
T[x].size=T[x].size-T[y].size+T[T[y].son[p]].size;
T[x].son[!p]=T[y].son[p];
T[y].size=T[y].size-T[T[y].son[p]].size+T[x].size;
T[y].son[p]=x;
x=y;
}

void Insert(int &x,int key) { //插入结点
if(x == 0)x=newNode(key);
else {
T[x].size++;
int p=key < T[x].key;
Insert(T[x].son[!p],key);
if(T[x].pri < T[T[x].son[!p]].pri)
Rotate(x,p);
}
}

void Remove(int &x,int key) { //删除值为key的节点
if(T[x].key == key) {
if(T[x].son[0] && T[x].son[1]) {
int p=T[T[x].son[0]].pri > T[T[x].son[1]].pri;
Rotate(x,p);
Remove(T[x].son[p],key);
} else {
if(!T[x].son[0])
x=T[x].son[1];
else
x=T[x].son[0];
}
} else {
T[x].size--;
int p=T[x].key > key;
Remove(T[x].son[!p],key);
}
}

int getKth(int &x,int p) { //找出第p小的节点的编号
if(p == T[T[x].son[0]].size+1)
return x;
if(p > T[T[x].son[0]].size+1)
return getKth(T[x].son[1],p-T[T[x].son[0]].size-1);
else
return getKth( T[x].son[0],p);
}

int getRank(int &x,int key) { //找出值小于等于key的节点个数
if(x == 0)
return 0;
if(T[x].key <= key)
return T[T[x].son[0]].size+1+getRank(T[x].son[1],key);
else
return getRank( T[x].son[0],key);
}

int getMax(int r) { //得到最大值
while(T[r].son[1])r=T[r].son[1];
return T[r].key;
}
int getMin(int r) { //得到最小值
while(T[r].son[0])r=T[r].son[0];
return T[r].key;
}
int getPrev() { //得到根结点的前驱
int x=T[rt].son[0];
if(!x)return 0;
while(T[x].son[1])x=T[x].son[1];
return x;
}
int getSucc() { //得到根结点的后继
int x=T[rt].son[1];
if(!x)return 0;
while(T[x].son[0])x=T[x].son[0];
return x;
}
/*****************************************************************/

几道简单的入门题：

poj 3481

题目：http://poj.org/problem?id=3481

题意：

主要维护一个优先队列，支持插入，删除，取最大值，取最小值。

分析：

很多解法可做，用Treap的话，支持上述四种操作即可。客户端的名称和优先级用一个map映射一下，然后插入的是优先级。

poj 1442

题目：http://poj.org/problem?id=1442

题意：

黑盒，每次可以ADD一个数，黑盒中数列有序，有一个GET操作，可以查找第k大元素，k从0递增（在每次GET操作后递增）

分析：

很多解法可做，用Treap的话，只有支持插入，查询第k大元素即可。

poj 2352

题目：http://poj.org/problem?id=2352

题意：

y从小到大，若y相同，x从小到大，这样给出一些坐标，求每个点覆盖的点个数，即每个点有左下方的点数。

分析：

相当经典的题目，许多数据结构的入门题。

按照输入顺序插入x，每遇到一个数只需计算小于等于当前元素的数有多少个即可，也就是求Rank。