poj 2299 树状数组+离散化

POJ2299 Ultra-QuickSort

题意：给定n个数组成的序列，要求求出将该序列重排成升序所需最小步数（每次只能交换相邻两个数的位置）

数据范围： n < 500，000      每个元素0 <= a[i] <= 99,999,999

解析：      本题就是求该序列的逆序数，但数据范围较大，普通方法时间代价较高，选用数状数组实现，同时注意到a[i]的范围远大于n，采用离散化优化

代码：

//  原本采用qsort函数排序，但不知道为什么就是WA，如果有人知道请麻烦指教一下

#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdio.h>
using namespace std;

#define MAXN 500050

typedef struct NODE{
	int data;
	int pos;
}CNODE;

CNODE a[MAXN];    //原序列
int hash[MAXN];   //离散化后的数列
int C[MAXN];      //树状数组，C[i]表示当前出现的比i小的数的个数

int n;
long long  ans;
/*
int cmp(const void *a,const void *b){
	return ((CNODE *)a)->data > ((CNODE *)b)->data;
}
*/

bool cmp(CNODE a,CNODE b){
	return a.data < b.data;
}

void Init(){
	int i;
	ans = 0;
	memset(hash,0,sizeof(hash));
	memset(a,0,sizeof(a));
	memset(C,0,sizeof(C));

	for(i = 1;i <= n;i ++){
		scanf("%d",&a[i].data);
		a[i].pos = i;
	}

        //离散化过程 
//	qsort(a + 1,n,sizeof(a[0]),cmp);  //采用qsort排序会WA掉，虽然这不科学
	sort(a + 1,a + n + 1,cmp);        //改用sort就能A掉

	for(i = 1;i <= n;i ++){
		hash[a[i].pos] = i;
	}
}

//更新过程
void UpDate(int pos,int v){
	while(pos <= n){
		C[pos] += v;
		pos += pos&(-pos);
	}
}

//求和过程，即求比pos小的数的个数的过程
long long GetSum(int pos){
	long long sum = 0;
	while(pos > 0){
		sum += C[pos];
		pos -= pos&(-pos);
	}
	return sum;
}

int main(){
	int i;
	while(scanf("%d",&n) != EOF){
		if(n == 0)	break;

		Init();

                //倒序处理，比较方便
		for(i = n;i > 0;i --){
			ans += GetSum(hash[i]);
			UpDate(hash[i],1);
		}

		printf("%lld\n",ans);
	}
	return 0;
}