hdu 5493 Queue 树状数组第K大或者二分

Queue

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 862    Accepted Submission(s): 449

Problem Description

N people numbered from 1 to N are waiting in a bank for service. They all stand in a queue, but the queue never moves. It is lunch time now, so they decide to go out and have lunch first. When they get back, they don’t remember the exact order of the queue. Fortunately, there are some clues that may help.
Every person has a unique height, and we denote the height of the i-th person as hi. The i-th person remembers that there were ki people who stand before him and are taller than him. Ideally, this is enough to determine the original order of the queue uniquely. However, as they were waiting for too long, some of them get dizzy and counted ki in a wrong direction. ki could be either the number of taller people before or after the i-th person.
Can you help them to determine the original order of the queue?

 

Input

The first line of input contains a number T indicating the number of test cases (T≤1000).
Each test case starts with a line containing an integer N indicating the number of people in the queue (1≤N≤100000). Each of the next N lines consists of two integers hi and ki as described above (1≤hi≤109,0≤ki≤N−1). Note that the order of the given hi and ki is randomly shuffled.
The sum of N over all test cases will not exceed 106

 

Output

For each test case, output a single line consisting of “Case #X: S”. X is the test case number starting from 1. S is people’s heights in the restored queue, separated by spaces. The solution may not be unique, so you only need to output the smallest one in lexicographical order. If it is impossible to restore the queue, you should output “impossible” instead.

 

Sample Input

3
3
10 1
20 1
30 0
3
10 0
20 1
30 0
3
10 0
20 0
30 1

 

Sample Output

Case #1: 20 10 30
Case #2: 10 20 30
Case #3: impossible

 

Source

2015 ACM/ICPC Asia Regional Hefei Online

题意：一个队列，把队列拆散，每个人知道自己前面或者后面比他高的人的数量；

　　　求原先的队列；

思路：刚刚开始看并没有什么思路，接着模拟一下就会发现思路，虽然复杂度高，接着只需要想如何优化； 

　　　因为要求字典序最小， 我们可以先按照身高从小到大排序，假设当前到了第i高的人， 他前面或者

　　　后面有k个人， 那么他前面的所有人都比他矮， 比他高的还有n-i个人，那么假设他前面还有p个空

　　　位， 他就是第p+1个空位上的人， 那么怎么求p呢？  因为要求字典序最小， 所以 p = min(k, n - i - k)。

　　　为什么这样是对的呢？每个人有两个可能位置啊，  因为他之前的都比他矮，  所以他无论在哪个位置都是可以的。

　　 那么为了让字典序最小， 就选择一个较小的位置。   当n - i - k < 0 时， 说明没有多余空格， 那么无解。

　　（取别人的博客http://doc.okbase.net/weizhuwyzc000/archive/197172.html）

　　一些小错误，运算符优先级(*/)>（+-）>(>>,<<) 所以记得上括号（wa N遍的感受）

#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<queue>
#include<algorithm>
#include<stack>
#include<cstring>
#include<vector>
#include<list>
#include<set>
#include<map>
using namespace std;
#define ll __int64
#define mod 1000000007
int scan()
{
    int res = 0 , ch ;
    while( !( ( ch = getchar() ) >= '0' && ch <= '9' ) )
    {
        if( ch == EOF )  return 1 << 30 ;
    }
    res = ch - '0' ;
    while( ( ch = getchar() ) >= '0' && ch <= '9' )
        res = res * 10 + ( ch - '0' ) ;
    return res ;
}
#define maxn (1<<18)
struct is
{
    int h,k;
}a[maxn];
int cmp(is x,is y)
{
    return x.h<y.h;
}
int tree[maxn],n;
int q[maxn];//原队列；
int lowbit(int x)
{
    return x&-x;
}
void update(int x,int change)
{
    while(x<=n)
    {
        tree[x]+=change;
        x+=lowbit(x);
    }
}
int k_thfind(int K)//树状数组求第K小
{
    int sum=0;
    for(int i=18;i>=0;i--)
    {
        if(sum+(1<<i)<=n&&tree[sum+(1<<i)]<K)
        {
            K-=tree[sum+(1<<i)];
            sum+=1<<i;
        }
    }
    return sum+1;
}
int main()
{
    int x,y,z,i,t;
    int gg=1;
    scanf("%d",&x);
    while(x--)
    {
        memset(tree,0,sizeof(tree));
        int flag=0;
        scanf("%d",&n);
        for(i=1;i<=n;i++)
        scanf("%d%d",&a[i].h,&a[i].k);
        sort(a+1,a+n+1,cmp);
        printf("Case #%d:",gg++);
        for(i=1;i<=n;i++)
        update(i,1);
        for(i=1;i<=n;i++)
        {
            if(n-i<a[i].k) flag=1;
            if(flag)break;
            int pos1=k_thfind(a[i].k+1);
            int pos2=k_thfind(n-a[i].k+1-i);
            //cout<<pos1<<"\t"<<pos2<<endl;
            if(pos1<pos2)
            {
                q[pos1]=a[i].h;
                update(pos1,-1);
            }
            else
            {
                q[pos2]=a[i].h;
                update(pos2,-1);
            }
        }
        if(flag)
        printf(" impossible\n");
        else
        {
            for(i=1;i<=n;i++)
            printf(" %d",q[i]);
            printf("\n");
        }
    }
    return 0;
}