hdu 4585 shaolin 平衡树

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

32 13 34 20 

Sample Output

2 13 24 2 

 

平衡树入门题，可以用STL做。

先上STL代码，注意迭代器的使用方法。STL好多类都支持lower_bound()和upper_bound()函数：

升序排列：
iterator lower_bound( const key_type &key ): 返回一个迭代器，指向键值>= key的第一个元素。
iterator upper_bound( const key_type &key ):返回一个迭代器，指向键值> key的第一个元素。
降序排列：
iterator lower_bound( const key_type &key ): 返回一个迭代器，指向键值<= key的第一个元素。
iterator upper_bound( const key_type &key ):返回一个迭代器，指向键值< key的第一个元素。

//296 ms

#include <vector>#include<cstdio>#include<cstring>#include<algorithm>#include<map>using namespace std;int main(){    int n,x,y;    while(scanf("%d",&n)!=EOF&&n)    {        map<int,int> sc_id;        sc_id[1000000000] = 1;        sc_id[-1000000000]=1;        while(n--)        {            scanf("%d%d",&x,&y);            map<int,int>::iterator itr,itl,tmp = sc_id.lower_bound(y);            itr = tmp--;            itl = tmp;            if(itr->first-y < y-itl->first) itl=itr;            printf("%d %d\n",x,itl->second);            sc_id[y]=x;            sc_id[-y]=x;        }    }    return 0;}

 

再看用模板过了的代码（splay)，速度很快，与map相当：

其中id是结点里我加的附加信息，把它去掉就是模板了。

//296 ms

#include <vector>#include<cstdio>#include<cstring>#include<algorithm>#include<map>using namespace std;#define MAXN 100010struct Node {    int key, sz, cnt ,id;    Node *ch[2], *pnt;//左右儿子和父亲    Node(){}    Node(int x, int y, int z){    key = x, sz = y, cnt = z;    }    void rs() {        sz = ch[0]->sz + ch[1]->sz + cnt;    }}nil(0, 0, 0), *NIL = &nil;struct Splay{//伸展树结构体类型    Node *root;    int ncnt;//计算key值不同的结点数，注意已经去重了    Node nod[MAXN];    void init(){// 首先要初始化        root = NIL;        ncnt = 0;    }    void rotate(Node *x, bool d){//旋转操作，d为true表示右旋        Node *y = x->pnt;        y->ch[!d] = x->ch[d];        if (x->ch[d] != NIL)            x->ch[d]->pnt = y;        x->pnt = y->pnt;        if (y->pnt != NIL){            if (y == y->pnt->ch[d])                y->pnt->ch[d] = x;            else                y->pnt->ch[!d] = x;        }        x->ch[d] = y;        y->pnt = x;        y->rs();        x->rs();    }    void splay(Node *x, Node *target){//将x伸展到target的儿子位置处        Node *y;        while (x->pnt != target){            y = x->pnt;            if (x == y->ch[0]){                if (y->pnt != target && y == y->pnt->ch[0])                    rotate(y, true);                    rotate(x, true);            }            else{                if (y->pnt != target && y == y->pnt->ch[1])                    rotate(y, false);                    rotate(x, false);            }        }        if (target == NIL)            root = x;    }    /************************以上一般不用修改************************/    void insert(int key,int id) {//插入一个值        if (root == NIL){            ncnt = 0;            root = &nod[++ncnt];            root->ch[0] = root->ch[1] = root->pnt = NIL;            root->key = key;            root->id = id;            root->sz = root->cnt = 1;            return;        }        Node *x = root, *y;        while (1){            x->sz++;            if (key == x->key){                x->cnt++;                x->rs();                y = x;                break;            }            else if (key < x->key){                    if (x->ch[0] != NIL)                        x = x->ch[0];                    else{                        x->ch[0] = &nod[++ncnt];                        y = x->ch[0];                        y->key = key;                        y->id = id;                        y->sz = y->cnt = 1;                        y->ch[0] = y->ch[1] = NIL;                        y->pnt = x;                        break;                    }            }            else{                if (x->ch[1] != NIL)                    x = x->ch[1];                else{                    x->ch[1] = &nod[++ncnt];                    y = x->ch[1];                    y->key = key;                    y->id = id;                    y->sz = y->cnt = 1;                    y->ch[0] = y->ch[1] = NIL;                    y->pnt = x;                    break;                }            }        }        splay(y, NIL);    }    Node* search(int key){ //查找一个值，返回指针        if (root == NIL)            return NIL;        Node *x = root, *y = NIL;        while (1){            if (key == x->key){                y = x;                break;            }            else if (key > x->key){                if (x->ch[1] != NIL)                x = x->ch[1];                else                    break;            }            else{                if (x->ch[0] != NIL)                    x = x->ch[0];                else                    break;            }        }        splay(x, NIL);        return y;    }    Node* searchmin(Node *x){//查找最小值，返回指针        Node *y = x->pnt;        while (x->ch[0] != NIL){//遍历到最左的儿子就是最小值            x = x->ch[0];        }            splay(x, y);            return x;    }    void del(int key){//删除一个值        if (root == NIL)            return;        Node *x = search(key), *y;        if (x == NIL)            return;        if (x->cnt > 1){            x->cnt--;            x->rs();            return;        }        else if (x->ch[0] == NIL && x->ch[1] == NIL){            init();            return;        }        else if (x->ch[0] == NIL){            root = x->ch[1];            x->ch[1]->pnt = NIL;            return;        }        else if (x->ch[1] == NIL){            root = x->ch[0];            x->ch[0]->pnt = NIL;            return;        }        y = searchmin(x->ch[1]);        y->pnt = NIL;        y->ch[0] = x->ch[0];        x->ch[0]->pnt = y;        y->rs();        root = y;    }    int rank(int key) { //求结点高度        Node *x = search(key);        if (x == NIL)            return 0;        return x->ch[0]->sz + 1/* or x->cnt*/;    }    Node* findk(int kth){//查找第k小的值        if (root == NIL || kth > root->sz)            return NIL;        Node *x = root;        while (1){            if (x->ch[0]->sz +1 <= kth && kth <= x->ch[0]->sz + x->cnt)                break;            else if (kth <= x->ch[0]->sz)                x = x->ch[0];            else{                kth -= x->ch[0]->sz + x->cnt;                x = x->ch[1];            }        }        splay(x, NIL);        return x;    }}sp;int main(){    int n,x,y;    while(scanf("%d",&n)!=EOF&&n)    {        sp.init();        sp.insert(1000000000,1);        while(n--)        {            scanf("%d%d",&x,&y);            sp.insert(y,x);            int th = sp.rank(y);            Node* r = sp.findk(th+1);            Node* l = th>1 ? sp.findk(th-1) : r;            if( y-l->key > r->key-y ) l = r;            printf("%d %d\n",x,l->id);        }    }    return 0;}

 

treap树模板，其中id是我加的附加信息，去掉后就是treap模板，实测该模板速度比上面代码稍逊：

//421 ms

#include <vector>#include<cstdio>#include<cstring>#include<algorithm>#include<map>#include<time.h>using namespace std;const int MAXN = 100005;int cnt=1,rt=0; //节点编号从1开始struct Tree{    int key, size, pri, son[2]; //保证父亲的pri大于儿子的pri    int id;    void set(int x, int Id,int y, int z)    {        id = Id;        key=x;        pri=y;        size=z;        son[0]=son[1]=0;    }}T[MAXN];void rotate(int p, int &x){    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 ins(int key, int &x ,int id){    if(x == 0)        T[x = cnt++].set(key, id , rand(), 1);    else    {        T[x].size++;        int p=key < T[x].key;        ins(key, T[x].son[!p] ,id );        if(T[x].pri < T[T[x].son[!p]].pri)            rotate(p, x);    }}void del(int key, int &x) //删除值为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(p, x);            del(key, T[x].son[p]);        }        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;        del(key, T[x].son[!p]);    }}int find(int p, int &x) //找出第p小的节点的编号{    if(p == T[T[x].son[0]].size+1)        return x;    if(p > T[T[x].son[0]].size+1)        find(p-T[T[x].son[0]].size-1, T[x].son[1]);    else        find(p, T[x].son[0]);}int find_NoLarger(int key, int &x) //找出值小于等于key的节点个数{    if(x == 0)        return 0;    if(T[x].key <= key)        return T[T[x].son[0]].size+1+find_NoLarger(key, T[x].son[1]);    else        return find_NoLarger(key, T[x].son[0]);}int main(){    int n,x,y;    srand(time(NULL));    while(scanf("%d",&n)!=EOF&&n)    {        cnt = 1; rt=0;//初始化        ins(1000000000,rt,1);        while(n--)        {            scanf("%d%d",&x,&y);            ins(y,rt,x);            int th = find_NoLarger(y,rt);            int r = find(th+1,rt);            int l = th>=2 ? find(th-1,rt) : r ;            if( y-T[l].key > T[r].key-y ) l = r;            printf("%d %d\n",x,T[l].id);        }    }    return 0;}