POJ2299-Ultra-QuickSort (归并排序求逆序数)

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

根据这个题研究了一下归并排序。。。感觉不是很难，，就是先把一个数组一步步拆分成最小单元，然后再分两部分进行比较合并 。。。 主要就是递归的过程不好理解。。。

一个乱序序列的 逆序数 = 在只允许相邻两个元素交换的条件下,得到有序序列的交换次数。就是从第一个开始 看看后边有几个数比当前数小。。

归并排序好弄，但是逆序数。。。。当后者小于前者的时候需要计算交换的次数。。。。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
__int64 k = 0;
int a[500001];

void ME (int *s,int low,int m,int high)
{
    int i = low,j = m + 1,p = 0;
    int *ss;
    ss = (int *)malloc( sizeof (int ) * (high - low + 1));
    while ( i <= m && j <= high)
    {
        if ( s[i] < s[j])
            ss[p++] = s[i++];
        else
        {
            ss[p++] = s[j++];
            k += (m - i + 1);///？？？
        }

    }
    while ( i <= m)
        ss[p++] = s[i++];
    while ( j <= high)
        ss[p++] = s[j++];

    for ( p = 0 , i = low ; i <= high ; p++ ,i++)
    {
        s[i] = ss[p];
    }
    free (ss);
}

void MEDC(int *s,int low,int high)
{
    int mid;
    if ( low < high)
    {
        mid = (low + high)>>1;
        MEDC (s,low,mid);
        MEDC (s,mid + 1,high);
        ME (s,low,mid,high);
    }
}

int main ()
{
    int i,n;
    while (~scanf ("%d",&n) && n)
    {
        k = 0;
        for (i = 0 ; i < n ; i++)
            scanf ("%d",&a[i]);
        MEDC (a,0,n - 1);
//        for ( i = 0 ; i < n ; i++)
//            printf ("%d ",a[i]);
        printf ("%I64d\n",k);
    }
    return 0;
}