POJ 2299 Ultra-QuickSort(归排并序)

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

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。值得注意的是归并排序是一种稳定的排序方法
归并过程为：比较f[i]和f[j]的大小，若f[i]≤f[j]，则将第一个有序表中的元素f[i]复制到r[k]中，并令i和k分别加上1，如此循环下去，知道其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。

#include<iostream>
using namespace std;
#define ll __int64
ll f[500000],r[500000];
ll ans;
void Sort(int x,int y)
{
	if(x==y) return;
	int i,j,k,mid=(x+y)/2;
	Sort(x,mid);
	Sort(mid+1,y);
	i=x;j=mid+1;k=0;
	while(i<=mid&&j<=y)
	{
		if(f[i]>f[j]) {
			ans+=mid-i+1;
			r[k]=f[j];j++;
		}
		else r[k]=f[i],i++;
		k++;
	}
	for(;i<=mid;i++,k++)
		r[k]=f[i];
	for(;j<=y;j++,k++)
		r[k]=f[j];
	for(i=x,k=0;i<=y;i++,k++)
		f[i]=r[k];
}
int main()
{
	int n;
	while(scanf("%d",&n)&&n)
	{
		for(int i=1;i<=n;i++)
			scanf("%I64d",&f[i]);
		ans=0;
		Sort(1,n);
		printf("%I64d\n",ans);
	}
	return 0;
}