POJ 2299 (求逆序对)-Ultra-QuickSort （树状数组）

题目：

In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence 

9 1 0 5 4 ,

Ultra-QuickSort produces the output 

0 1 4 5 9 .

Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.

Input

The input contains several test cases. Every test case begins with a line that contains a single integer n < 500,000 -- the length of the input sequence. Each of the the following n lines contains a single integer 0 ≤ a[i] ≤ 999,999,999, the i-th input sequence element. Input is terminated by a sequence of length n = 0. This sequence must not be processed.

Output

For every input sequence, your program prints a single line containing an integer number op, the minimum number of swap operations necessary to sort the given input sequence.

Sample Input

5
9
1
0
5
4
3
1
2
3
0

Sample Output

6
0

题意：很显然求逆序对数。可用树状数组来解决这个问题。

思路：因为这个题的数值比较大，所以需要进行离散化。

总的逆序对是这样算的 这个数读入的位置减去在他之前（包括他自己）不大于他本身的数的个数。

 

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<vector>
#define Max 0x7fffffff
#define ll long long
using namespace std;
const int INF=5e5+4;
int n;
struct Node{
	int id;
	ll d;
}a[INF];
int b[INF],g[INF];
bool cmp(Node p,Node q)
{
	return p.d <q.d ;
}
int lowbit(int x)
{
	return x&(-x);
}
void update(int x)
{
	while(x<=n)
	{
		g[x]++;
		x=x+lowbit(x);
	}
}
int find(int x)
{
	int sum=0;
	while(x>0)
	{
		sum=sum+g[x];
		x=x-lowbit(x);
	}
	return sum;
}
int main()
{
	while(1)
	{
		scanf("%d",&n);
		if(n==0)break;
		fill(g,g+n+1,0);
		int i,j,val;
		for(i=1;i<=n;i++)
		{
			scanf("%d",&a[i].d );
			a[i].id =i;
		}
		sort(a+1,a+n+1,cmp);
		for(i=1;i<=n;i++)
		    b[a[i].id]=i ;//离散化， i代表a[i].d的相对大小。 
		ll ans=0;
		for(i=1;i<=n;i++)//边更新边操作
		{
			update(b[i]);//按照输入的顺序来更新 
//这样从头读到尾读入b数组中的元素，保持了原来的大小关系 
			ans=ans+i-find(b[i]);//用读入时的标号（i）减去已读入的小于等于的这个值的个数 
		}
		printf("%lld\n",ans);
	}
	return 0;
}