POJ2299 Ultra-QuickSort 树状数组

题目：

POJ2299

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 59125		Accepted: 21882

Description

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

Source

Waterloo local 2005.02.05

题意：

给定一串序列，求将它按升序排列要交换几次。

思路；

题目就是要求该序列中有几个逆序对。

为了使数据更小更方便计算，计算前先将数据离散化。

关于离散化：

百科解释

在不需要用到数据的精确值而只用知道数据的相对大小时，可以这样处理。

如样例 9 1 0 5 4 可离散化成为 5 2 1 4 3。

//离散化部分代码
for(int i=1; i<=n; i++) {
	scanf("%d",&a[i].value);
	a[i].num=i;
}
sort(a+1,a+n+1);
for(int i=1; i<=n; i++) {
	b[a[i].num]=i;
}

要求该序列中有几个逆序对，可以求出每个数前面有几个数比自己大，再把每个数的值相加。要求每个数前面有几个数比自己大，可以先求出前面有几个数小于等于自己，在用自己的编号（该数在序列中的第几个编号就为几）减去这个值就是比自己大的数的个数。

树状数组c[x]中存的是小于等于数x的数的个数。

加入时把数x后的数+1。

查询时把查到的值顺次相加返回即可。

输出i-查询到的值。

//树状数组部分代码 
int lowbit(int x){
	return (x&(-x));
}

void add(int x) {
	while(x<=n){
		c[x]++;
		x+=lowbit(x);
	}
	return ;
}

int getsum(int x) {
	int s=0;
	while(x>=1){
		s+=c[x];
		x-=lowbit(x);
	}
	return s;
}

还要注意，因为输出值很大，要用long long型输出。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

int n;
struct A {
	int num;
	int value;
	bool operator < (const A& x) const {
		if(value<x.value) return true;
		if(value==x.value&&num<x.num) return true;
		return false;
	}
};

int c[500010]= {0};

int lowbit(int x){
	return (x&(-x));
}

void add(int x) {
	while(x<=n){
		c[x]++;
		x+=lowbit(x);
	}
	return ;
}

int getsum(int x) {
	int s=0;
	while(x>=1){
		s+=c[x];
		x-=lowbit(x);
	}
	return s;
}

A a[500010]= {0};
int b[500010]= {0};
int main() {

	while(true) {
		scanf("%d",&n);
		if(n==0) break;
		
		memset(b,0,sizeof(b));
		memset(c,0,sizeof(c));
		for(int i=1; i<=n; i++) {
			scanf("%d",&a[i].value);
			a[i].num=i;
		}
		sort(a+1,a+n+1);
		for(int i=1; i<=n; i++) {
			b[a[i].num]=i;
		}
		long long s=0;
		for(int i=1; i<=n; i++) {
			add(b[i]);
			s+=i-getsum(b[i]);
		}
		printf("%lld\n",s);
	}

	return 0;
}