题干：

NN people numbered from 1 to NN 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 ii-th person as hihi. The ii-th person remembers that there were kiki 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 kiki in a wrong direction. kiki could be either the number of taller people before or after the ii-th person.
Can you help them to determine the original order of the queue?

Input

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

Output

For each test case, output a single line consisting of “Case #X: S”. XX is the test case number starting from 1. SS 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

题目大意：

有 N 个人排队，每个人都忘记自己的位置。但是每个人都知道自己的Hi，Ki，Hi代表自己的身高，Ki代表自己前边或后边比自己高的人的个数。给你每个人的 Hi，Ki，求满足题意的一组解。输出每个位置上站着的人的身高，如果有多组解，输出字典序最小的那一组。如果没有满足的情况，则输出"impossible"。

解题报告：

首先按照身高从小到大排个序，依次决策位置，因为题目给出的是身高比当前人高的人的个数，所以这样可以保证此时之前的决策对我自己没啥影响，因为之前的决策都是身高比我矮的，关于这一点题干中并没有约束。

考虑线段树维护没有被占的位置。这样只需要在线段树中查询从前往后第K+1个不为0的位置，从后往前第K+1个不为0的位置，选最靠前的一个位置放上这个人即可。

这题按照身高从大到小排序也是可解的。思路类似，但是因为只知道相对位置不知道每个人的实际位置，所以需要平衡树维护。

AC代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<set>
#include<string>
#include<cmath>
#include<cstring>
#define FF first
#define SS second
#define ll long long
#define pb push_back
#define pm make_pair
using namespace std;
typedef pair<int,int> PII;
const int MAX = 1e5 + 5;
struct Node{int h,id,k;bool operator<(const Node & b) const {return h < b.h;} 
} R[MAX];
struct TREE {int l,r,sum;
} tr[MAX<<2];
void pushup(int cur) {tr[cur].sum = tr[cur*2].sum + tr[cur*2+1].sum;
}
void build(int l,int r,int cur) {tr[cur].l = l,tr[cur].r = r;if(l == r) {tr[cur].sum = 1;return;}int m = (l+r)>>1;build(l,m,cur*2);build(m+1,r,cur*2+1);pushup(cur);
}
int query(int k,int cur) {if(tr[cur].l == tr[cur].r) return tr[cur].l;if(tr[cur*2].sum >= k) return query(k,cur*2);else return query(k-tr[cur*2].sum,cur*2+1);		
}
void update(int tar,int cur) {if(tr[cur].l == tr[cur].r) {tr[cur].sum = 0;return;}if(tar <= tr[cur*2].r) update(tar,cur*2);else update(tar,cur*2+1);pushup(cur);
}
int ans[MAX],n;
int main()
{int T,iCase=0;cin>>T;while(T--) {scanf("%d",&n);for(int i = 1; i<=n; i++) {scanf("%d%d",&R[i].h,&R[i].k);R[i].id = i;}sort(R+1,R+n+1); build(1,n,1);int flag = 1;for(int i = 1; i<=n; i++) {int res = tr[1].sum;if(R[i].k >= res) {flag = 0;break;}int tar = min(query(R[i].k+1,1),query(res-R[i].k,1));ans[tar] = R[i].h;update(tar,1);}printf("Case #%d:",++iCase);if(flag == 0) printf(" impossible");else for(int i = 1; i<=n; i++) printf(" %d",ans[i]);printf("\n");}return 0 ;
}