一天一道算法题——Treap树（树堆）

 Treap，由Tree和Heap各取一半组成的单词，也可意为树堆。

二叉查找树为每一个结点设置了一个键值，Treap树在上面又加了一个被称为优先级的权值。对键值来说，Treap树是排序二叉树；对优先级来说，Treap树是堆——在这棵树的任意子树上，根节点的优先级最大。

Treap的唯一性指：另每个节点的优先级互不相等，则该棵树的形态唯一，与元素的插入顺序无关。

 上图描述了Treap树的建树过程。

节点定义：

struct Node
{
    int size;
    int rank;
    int key;
    Node *son[2];
    bool operator < (const Node &a)const
    {
        return rank<a.rank;
    }
    int cmp(int x)const
    {
        if(x==key) return -1;
        return x<key?0:1;
    }
    void update()
    {
        size=1+son[0]->size+son[1]->size;
    }
};

首先我们来实现插入操作。

方法一：已知优先级，按照优先级由大到小排序，然后键值比根节点小的放左子树，大的放右子树。

方法二：按照BST的插入先将新结点插入到所在位置，然后为该节点分配一个随机的优先级，比较和根节点优先级的大小，如果比根节点大，那么就往上走。

void rotate(Node* &o,int d)
    {
        Node *k=o->son[d^1];
        o->son[d^1]=k->son[d];
        k->son[d]=o;
        o->update();
        k->update();
        o=k;
    }
    void build(Node* &o,int x)
    {
        if(o==null)
        {
            o=new Node();
            o->son[0]=o->son[1]=null;
            o->rank=rand();
            o->key=x;
            o->size=1;
        }
        else
        {
            int d=o->cmp(x);
            build(o->son[d],x);
            o->update();
            if(o<o->son[d])
                rotate(o,d^1);
        }
    }

因为我们需要修改o的值，所以在形参里用了*&

然后是找到x的在Treap树里的排名。所以我们只需要判断比它大的元素有几个就好了。

int kth(Node* o,int k)
    {
        if(o==null||k<=0||k>o->size) return -1;
        int s=o->son[1]==null?0:o->son[1]->size;
        if(k==s+1) return o->key;
        else if(k<=s) return kth(o->son[1],k);
        else return kth(o->son[0],k-s-1);
    }

接着是找到排名第x的元素。

int find(Node* o,int k)
    {
        if(o==null) return -1;
        int d=o->cmp(k);
        if(d==-1) return o->son[1]->size+1;
        else if(d==1) return find(o->son[d],k);
        else
        {
            int tmp=find(o->son[d],k);
            if(tmp==-1) return -1;
            else return tmp+1+o->son[1]->size;
        }
    }

然后是删除元素x

void erase(Node *&t, int x) {
        if (t == null)return;
        if (t->key == x) {
            if (t->son[0] == null || t->son[1] == null) {
                Node *p = t;
                if (t->son[0] == null)
                    t = t->son[1];
                else
                    t = t->son[0];
                delete p;
            }
            else {
                int d = t->son[0] > t->son[1] ? 1 : 0;
                rotate(t, d ^ 1);
                erase(t->son[d], x);
            }
        }
        else if (x < t->key)erase(t->son[0], x);
        else erase(t->son[1], x);
}

以下为例题。

HUD4585 Shaolin

Problem Description

Shaolin temple is very famous for its Kongfu monks.A lot of young men go to Shaolin temple every year, trying to be a monk there. The master of Shaolin evaluates a young man mainly by his talent on understanding the Buddism scripture, but fighting skill is also taken into account.
When a young man passes all the tests and is declared a new monk of Shaolin, there will be a fight , as a part of the welcome party. Every monk has an unique id and a unique fighting grade, which are all integers. The new monk must fight with a old monk whose fighting grade is closest to his fighting grade. If there are two old monks satisfying that condition, the new monk will take the one whose fighting grade is less than his.
The master is the first monk in Shaolin, his id is 1，and his fighting grade is 1,000,000,000.He just lost the fighting records. But he still remembers who joined Shaolin earlier, who joined later. Please recover the fighting records for him.

 

Input

There are several test cases.
In each test case:
The first line is a integer n (0 <n <=100,000),meaning the number of monks who joined Shaolin after the master did.(The master is not included).Then n lines follow. Each line has two integer k and g, meaning a monk's id and his fighting grade.( 0<= k ,g<=5,000,000)
The monks are listed by ascending order of jointing time.In other words, monks who joined Shaolin earlier come first.
The input ends with n = 0

Output

A fight can be described as two ids of the monks who make that fight. For each test case, output all fights by the ascending order of happening time. Each fight in a line. For each fight, print the new monk's id first ,then the old monk's id.

 

Sample Input

3 2 1 3 3 4 2 0

 

Sample Output

2 1 3 2 4 2

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>
using namespace std;
int vis[5000000+5];
struct Node
{
    int size;
    int rank;
    int key;
    Node *son[2];
    bool operator < (const Node &a)const
    {
        return rank<a.rank;
    }
    int cmp(int x)const
    {
        if(x==key) return -1;
        return x<key?0:1;
    }
    void update()
    {
        size=1+son[0]->size+son[1]->size;
    }
};
struct Treap
{
    Node *root;
    Node *null=new Node();
    void init()
    {
        srand(time(NULL));
        root=null;
    }
    void rotate(Node* &o,int d)
    {
        Node *k=o->son[d^1];
        o->son[d^1]=k->son[d];
        k->son[d]=o;
        o->update();
        k->update();
        o=k;
    }
    void build(Node* &o,int x)
    {
        if(o==null)
        {
            o=new Node();
            o->son[0]=o->son[1]=null;
            o->rank=rand();
            o->key=x;
            o->size=1;
        }
        else
        {
            int d=o->cmp(x);
            build(o->son[d],x);
            o->update();
            if(o<o->son[d])
                rotate(o,d^1);
        }
    }
    int kth(Node* o,int k)
    {
        if(o==null||k<=0||k>o->size) return -1;
        int s=o->son[1]==null?0:o->son[1]->size;
        if(k==s+1) return o->key;
        else if(k<=s) return kth(o->son[1],k);
        else return kth(o->son[0],k-s-1);
    }
    int find(Node* o,int k)
    {
        if(o==null) return -1;
        int d=o->cmp(k);
        if(d==-1) return o->son[1]->size+1;
        else if(d==1) return find(o->son[d],k);
        else
        {
            int tmp=find(o->son[d],k);
            if(tmp==-1) return -1;
            else return tmp+1+o->son[1]->size;
        }
    }
} treap;
int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        treap.init();
        int x,y;
        scanf("%d%d",&x,&y);
        treap.build(treap.root,y);
        vis[y]=x;
        printf("%d %d
",x,1);
        for(int i=2;i<=n;i++)
        {
            scanf("%d%d",&x,&y);
            vis[y]=x;
            treap.build(treap.root,y);
            int t=treap.find(treap.root,y);
            int ans1,ans2,ans;
            ans1=treap.kth(treap.root,t-1);
            ans2=treap.kth(treap.root,t+1);
            if(ans1!=-1&&ans2!=-1)
            {
                ans=ans1-y>=y-ans2?ans2:ans1;
            }
            else if(ans1==-1) ans=ans2;
            else ans=ans1;
            printf("%d %d
",x,vis[ans]);
        }
    }
    return 0;
}

之后会把hdu3726也加上来。