zoukankan      html  css  js  c++  java
  • 平衡二叉树---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

    3 2 1 3 3 4 2 0
     

    Sample Output

    2 1 3 2 4 2
     
    题意:有n个新加入的和尚和一个开始的大和尚,大和尚编号为1,攻击力1000,000,000  其它n个和尚编号和攻击力各不一样,输入流中按时间顺序给出了加入的和尚的编号和攻击力,每个新加入的和尚会找一个和他攻击力最接近的已加入的和尚比试,若有两个和尚和这个新和尚的差值相同,攻击力小的和他比试,输出新和尚的编号和与他比试的和尚的编号。
     
    思路:使用平衡二叉树的算法,方便查找x值的前驱与后继。
     
    代码如下:
    #include <iostream>
    #include <algorithm>
    #include <cstdio>
    #include <cstring>
    using namespace std;
    struct data
    {
        int l,r,v,vo;
        int rnd;
    }tr[110000];
    int size,root,ans1,ans2;///定义全局整型变量默认初值为0;
    
    void rturn(int &k)
    {
        int t=tr[k].l;
        tr[k].l=tr[t].r;
        tr[t].r=k;
        k=t;
    }
    
    void lturn(int &k)
    {
        int t=tr[k].r;
        tr[k].r=tr[t].l;
        tr[t].l=k;
        k=t;
    }
    
    void insert(int &k,int x,int xo)
    {
        if(k==0)
        {
            size++;///记录已经使用的结构体数目;
            k=size;
            tr[k].v=x;
            tr[k].vo=xo;
            tr[k].rnd=rand();
            return;
        }
        if(x>tr[k].v)
        {
            insert(tr[k].r,x,xo);
            if(tr[tr[k].r].rnd<tr[k].rnd)
                lturn(k);
        }
        else
        {
            insert(tr[k].l,x,xo);
            if(tr[tr[k].l].rnd<tr[k].rnd)
                rturn(k);
        }
    }
    
    void query_pro(int k,int x)///求x的前驱(前驱定义为小于x,且最大的数);
    {
        if(k==0)return;
        if(tr[k].v<x)
        {
            ans1=k;
            query_pro(tr[k].r,x);
        }
        else query_pro(tr[k].l,x);
    }
    
    void query_sub(int k,int x)///求x的后继(后继定义为大于x,且最小的数);
    {
        if(k==0)return;
        if(tr[k].v>x)
        {
            ans2=k;
            query_sub(tr[k].l,x);
        }
        else query_sub(tr[k].r,x);
    }
    
    int main()
    {
        int n,xo,x;
        while(scanf("%d",&n)!=EOF&&n)
        {
            root=0;
            size=0;
            for(int i=0;i<110000;i++)
            {
                tr[i].l=0;
                tr[i].r=0;
                tr[i].v=0;
                tr[i].vo=0;
                tr[i].rnd=0;
            }
            insert(root,1000000000,1);
            while(n--)
            {
                scanf("%d %d",&xo,&x);
                insert(root,x,xo);
                ans1=0;
                ans2=0;
                query_pro(root,x);
                query_sub(root,x);
                if(ans1==0) printf("%d %d
    ",xo,tr[ans2].vo);
                else
                {
                    if(x-tr[ans1].v<=tr[ans2].v-x)
                        printf("%d %d
    ",xo,tr[ans1].vo);
                    else  printf("%d %d
    ",xo,tr[ans2].vo);
                }
            }
        }
        return 0;
    }
  • 相关阅读:
    字符串哈希之Rabin-Karp,poj1200
    字符串哈希之ELFHash,poj2503
    dfs之n的全排列
    几大排序算法(选择,插入)
    dfs之地图染色
    单纯的dfs
    dfs之记忆化搜索(字符串匹配,位置相对变)
    STL之map的一种用法
    JAVA之大数处理,有简单方法不用是sb
    ACM之素数环(DFS)
  • 原文地址:https://www.cnblogs.com/chen9510/p/5365099.html
Copyright © 2011-2022 走看看