POJ2299 ZOJ2386 UVA10810 Ultra-QuickSort【逆序偶+归并排序】

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 67664		Accepted: 25336

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

问题链接：POJ2299 ZOJ2386 UVA10810 Ultra-QuickSort

问题简述：（略）

问题分析：

  可以定义逆序对，一个序列中存在a[i]>a[j]且i<j，则a[i]与a[j]构成一对逆序对。

  一个序列的逆序对的总数，就是这个序列的逆序数。

  相邻元素进行交换，那么每次交换序列逆序数必然改变1，而一个递增的序列逆序数为0。因此，最少交换次数即为逆序数，而每次按照逆序对减少的方式交换就得到递增序列。

  这个程序必须采用基于分治法的排序算法程序，以便保证时间复杂度为O(nlogn)。

程序说明：

  使用暴力程序则出现TLE。这样采用分治法，使用归并排序的思想来实现，可以AC。

  程序使用标准的归并排序程序修改而成，只是增加了第19行。

题记：（略）

参考链接：归并排序（分治法）

AC的C语言程序如下：

/* POJ2299 ZOJ2386 UVA10810 Ultra-QuickSort */

#include <iostream>
#include <stdio.h>

using namespace std;

const int N = 500000;
long long a[N], temp[N], cnt;

void merge(int low, int middle, int high)
{
    int i = low, j=middle+1, k = low;
    while(i <= middle && j <= high)
    {
        if(a[i] < a[j])
            temp[k++] = a[i++];
        else {
            cnt += j - k;
            temp[k++] = a[j++];
        }
    }
    while(i <= middle)
        temp[k++] = a[i++];
    while(j <= high)
        temp[k++] = a[j++];
    for(i=low; i<=high; i++)
         a[i] = temp[i];
}

void mergesort(int low, int high)
{
    if(low < high)
    {
        int middle = (low + high) / 2;
        mergesort(low, middle);
        mergesort(middle+1, high);
        merge(low, middle, high);
    }
}

int main()
{
    int n;
    while(~scanf("%d", &n) && n) {
        for(int i = 0; i < n; i++)
            scanf("%lld", &a[i]);

        cnt = 0;
        mergesort(0, n - 1);

        printf("%lld\n", cnt);
    }

    return 0;
}

TLE的C语言程序（暴力法）如下：

/* POJ2299 ZOJ2386 UVA10810 Ultra-QuickSort */

#include <iostream>
#include <stdio.h>

using namespace std;

const int N = 500000;
int a[N];

int main()
{
    int n;
    while(~scanf("%d", &n) && n) {
        for(int i = 0; i < n; i++)
            scanf("%d", &a[i]);

        int cnt = 0;
        for(int i = 0; i < n; i++)
            for(int j = 0; j < i; j++)
                cnt += (a[j] > a[i]);

        printf("%d\n", cnt);
    }

    return 0;
}