SPOJ-227 ORDERS - Ordering the Soldiers (还原逆序对 二分 + 树状数组)

ORDERS - Ordering the Soldiers

#tree  #bitmasks

As you are probably well aware, in Byteland it is always the military officer's main worry to order his soldiers on parade correctly. In Bitland ordering soldiers is not really such a problem. If a platoon consists of n men, all of them have different rank (from 1 - lowest to n - highest) and on parade they should be lined up from left to right in increasing order of rank.

Sounds simple, doesn't it? Well, Msgt Johnny thought the same, until one day he was faced with a new command. He soon discovered that his elite commandos preferred to do the fighting, and leave the thinking to their superiors. So, when at the first rollcall the soldiers lined up in fairly random order it was not because of their lack of discipline, but simply because they couldn't work out how to form a line in correct order of ranks. Msgt Johnny was not at all amused, particularly as he soon found that none of the soldiers even remembered his own rank. Over the years of service every soldier had only learned which of the other soldiers were his superiors. But Msgt Johnny was not a man to give up easily when faced with a true military challenge. After a moment's thought a solution of brilliant simplicity struck him and he issued the following order: "men, starting from the left, one by one, do: (step forward; go left until there is no superior to the left of you; get back in line).". This did indeed get the men sorted in a few minutes. The problem was solved... for the time being.

The next day, the soldiers came in exactly the same order as the day before, and had to be rearranged using the same method. History repeated. After some weeks, Msgt Johnny managed to force each of his soldiers to remember how many men he passed when going left, and thus make the sorting process even faster.

If you know how many positions each man has to walk to the left, can you try to find out what order of ranks the soldiers initially line up in?

Input

The first line of input contains an integer t<=50, the number of test cases. It is followed by t test cases, each consisting of 2 lines. The first line contains a single integer n (1<=n<=200000). The second line contains n space separated integers wi, denoting how far the i-th soldier in line must walk to the left when applying Msgt Johnny's algorithm.

Output

For each test case, output a single line consisting of n space separated integers - the ranks of the soldiers, given from left to right in their initial arrangement.

Example

Input:
2
3
0 1 0
5
0 1 2 0 1

Output:
2 1 3
3 2 1 5 4

#include <stdio.h>  
#include <string.h>  
#include <algorithm>
using namespace std;
#define maxn 200005
int a[maxn], c[maxn], ans[maxn];
inline int lowbit(int x){ return x & (-x);}
int getsum(int x){
	int ans = 0;
	while(x){
		ans += c[x];
		x -= lowbit(x);
	}
	return ans;
}
void add(int x, int n, int v){
	while(x <= n){
		c[x] += v;
		x += lowbit(x);
	}
}
int main(){
	int T;
	scanf("%d", &T);
	while(T--){
		int n, l, r, mid;
		scanf("%d", &n);
		memset(c, 0, sizeof(c));
		for(int i = 1; i <= n; ++i){
			scanf("%d", &a[i]);
		}
		for(int i = n; i >= 1; --i){
			l = 1; r = n;
			while(r > l){
				mid = l + r >> 1;
				if(i - (mid - getsum(mid)) <= a[i]) r = mid;
				else l = mid + 1;
			}
			ans[i] = l;
			add(l, n, 1);
		}
		for(int i = 1; i <= n; ++i){
			printf("%d%s", ans[i], i == n ? "\n" : " ");
		}
	}
}

/*
题意：给出一个序列中每个数前面有多少个数比它大，还原这个序列。

思路：说实话我不知道题意对不对。。。因为我没读题。。。题目一入眼就不想做了，然后发现样例很和谐，
貌似就是这个意思，把以前的代码贴上去，改一下，过了。。。。那应该就是这个题意了。神经病，一个裸题写这么长的题面。
这题我们应该从后往前还原，因为最后一位容易推出来，即在还未用过的数字里找到满足a[i]大小关系的即可，
如果前面没有比它大的，那该位一定是剩下的数里最大的，如果前面有一个比它大的，那它就是次大的。数据范围2e5，我们可以
用树状数组统计数字的使用情况，然后二分答案，每次看答案前面有多少数字没有用过，少了或者多了，就根据情况
转移一下L或R。

这题也可以用平衡树做，思路感觉更清楚一点，可以看一下POJ-2182 Lost Cows,(http://blog.csdn.net/hmc0411/article/details/78202939)
*/