poj2299 Ultra-QuickSort

求逆序对的个数。

http://acm.pku.edu.cn/JudgeOnline/problem?id=2299

方法有：

一、归并排序的思想

        如果比较任意两个数字，那么时间复杂度是O(n^2),对于较大的n是无法接受的，MegerSort的时间复杂度是O(nlogn).

合并的时候一个指针指i向左边的元素l，有个指针j指向右边的元素r，当r小于l的时候，左边i到mid中的元素则与r构成逆序对。只用将逆序数总数加上mid-i+1就可以了。

注意，由于本题逆序数很大，存放逆序数的sum要用 long long,输出用printf("%lld/n",num);

代码如下：

#include<iostream>
using namespace std;

int* vec = new int[ 500000];
int* array = new int[500000];

void mergeArray(int* vec,int l1,int r1,int l2,int r2,long long& num,int* array)
{
	int size = r1+r2-l1-l2+2;
	int ll1 = l1,ll2 = l2;
	int cnt = l1;
	while(l1 <= r1 && l2 <= r2)
	{
		if(vec[l1] > vec[l2]){
			num += (r1-l1+1);
			array[cnt++] = vec[l2++];
		}else{
			array[cnt++] = vec[l1++];
		}
	}
	if(l1 <= r1) {
		memcpy(&array[cnt],&vec[l1],(r1-l1+1)*sizeof(int));
	}
	else{
		memcpy(&array[cnt],&vec[l2],(r2-l2+1)*sizeof(int));
	}

	memcpy(&vec[ll1],&array[ll1],size*sizeof(int));
}

void mergeSort(int* vec,int l,int r,long long& num,int* array)
{
	if(l < r){
		int mid = l + (r-l)/2;
		mergeSort(vec,l,mid,num,array);
		mergeSort(vec,mid+1,r,num,array);

		mergeArray(vec,l,mid,mid+1,r,num,array);
	}
	
}



int main()
{
	int n ;

	while(scanf("%d",&n) && n != 0)
	{
		int tmp;
		for(int i = 0;i<n;i++)
		{
			scanf("%d",&tmp);
			vec[i] = tmp;
		}
		long long num = 0;
		mergeSort(vec,0,n-1,num,array);
		printf("%lld\n",num);
	}
	return 0;

	
}

407MS

思路二：树状数组求逆序数对。需要注意的是下标是从1开始算的。

代码如下：

#include<iostream>
#include<algorithm>
using namespace std;
	
int* array = new int[500000];

struct node{
	int value;
	int ori_index;
	int new_index;
	node(){
		value = 0;
		ori_index = 0;
		new_index = 0;
	}
}a[500000];

bool cmp(node& n1,node& n2)
{
	return n1.value < n2.value;
}

bool cmp2(node& n1,node& n2)
{
	return n1.ori_index < n2.ori_index;
}

class Solution2{
public:
	int N;
	//C array
	//a vec 
	Solution2(int x){
		N = x;
		memset(array,0,(N+2)*sizeof(int));
	}

	int lowBit(int t)
	{
		return t & ( t ^ ( t - 1 ) );   
	}

	void update(int i,int num)
	{
		while(i <= N){
			array[i] += num;
			if(lowBit(i) == 0) break;
			i += lowBit(i);	
		}
	}

	int getSum(int t)
	{
		int sum = 0;
		while(t > 0)
		{
			sum += array[t];
			t -= lowBit(t);
		}
		return sum;
	}

	void sol(node* a,long long& num)
	{
		for(int i = 1;i<= N;i++)
		{
			update(a[i].new_index,1);
			num += (getSum(N) - getSum(a[i].new_index));
		}
	}
};

int main()
{
	int n ;
	
	while(scanf("%d",&n) && n != 0)
	{
		for(int i = 1;i<=n;i++)
		{
			scanf("%d",&a[i].value);
			a[i].ori_index = i;
		}
		sort(a+1,a+n+1,cmp);
		for(int i = 1;i<=n;i++)
		{
			a[i].new_index = i;
		}
		sort(a+1,a+n+1,cmp2);

		long long num = 0;
		Solution2(n).sol(a,num);
		printf("%lld\n",num);
	}
	return 0;

	
}

时间和空间相比归并的方法都较大。

http://www.cnblogs.com/kuangbin/archive/2012/08/09/2630042.html

http://gzhu-101majia.iteye.com/blog/1142722

http://www.ahathinking.com/archives/135.html