归并法求逆序数之“Ultra-QuickSort”

题目大意：

　　给你一个上限为（5e5）的整数 n 。

　　在给出 n 个非负整数，这些数上限是 999 999 999 。

　　求出其中有多少个逆序数对。

　　解释下逆序数对：

　　　　比如在数列 1 ，2 ，5 ，4 ，3 中，

　　　　1 的逆序数就是后面所有比它小的数字个数，即为 0 。

　　　　2 同理 ，即为 0 。

　　　　5 后面有 3 和 4 ，即为 2 。

　　　　4 后面有一个 3 ，即为 1 。

　　　　3 后面没有数字，即为 0 。

　　　　所以在上述数列中，逆序数对有  0 + 0 + 2 + 1 + 0 == 3  个。

解题思路：

　　在归并的过程中检测单向移动距离之和（所谓单向  就是要么都计算往前移动的距离，要么相反，计算往后移动的距离）。

　　比如 3  ，2 ，4 ，1 。（检查数字向前移动的距离和）

　　第一步：3 和 2 调换 ，检查 3 向前移动了 1 个单位，数列变成：　　2  3  4  1　　

　　第二步：4 和 1 调换 ，检查 4 向前移动了 1 个单位 ，数列变成：　　2  3  1  4

　　第三步：归并两个子数列 ，发现只有 1 向前移动了两个单位，而后再也不出现向前移动的数字，数列也变成最终的有序数列。

　　如果计算向后移动的距离和也是同理：

　　　　3 移动 1 个单位 ， 4 移动 1 个单位 ， 2 移动 1 个单位 ， 3 又移动 1 个单位。

　　　　加起来也是正好 4 个单位。

　　所以这个数列的逆序数对就是 4 ，输出换行即可。

AC代码：

import java.util.*;

public class Main{

    static long ans = 0L;
    static int num[] = new int[500005];
    static int temp[] = new int[500005];

    static void merge(int low,int mid,int high){
        int i = low; int j = mid + 1; int k = low;
        while(i <= mid && j <= high){  
            if (num[i] <= num[j]){  
                temp[k ++] = num[i ++];  
            }  
            else{  
                ans = ans + j - k ;
                 temp[k ++] = num[j ++];  
            }  
        }  
        while (i <= mid) {temp[k ++] = num[i ++];}  
        while (j <= high){temp[k ++] = num[j ++];}  
            for(i = low; i <= high; ++i){  
                num[i] = temp[i];  
            }  
    }
    
    static void sort(int a,int b){
        if(a < b){
            int mid = (a + b) / 2;  
            sort(a, mid);  
            sort(mid + 1, b);  
            merge(a, mid, b);    
        }
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            if(n == 0){break;}
            for(int i = 0;i < n;i ++){
                num[i] = sc.nextInt();
            }
            sort(0,n - 1);
            System.out.println(ans); 
            ans = 0L;
        }
    }
}

　　此处再给出一个超时的代码，不过这个程序可以查看计算过程和排序过程，具体超时原因应该是出现了无用遍历。

超时代码：

import java.util.*;

public class Main{
    
    static int ans = 0;
    
    static void print(int x[]){  
        for(int i = 0; i < x.length; i++){  
                    System.out.print(x[i] + "  ");  
               }System.out.println();  
        }

    static void mergeSort(int x[]){  
        sort(x,0,x.length - 1);  
    }


    static void sort(int arr[], int left, int right){  
        if (left >= right){return; } 
            int mid = (left + right) / 2;   
               sort(arr, left, mid);  
            sort(arr, mid + 1, right);   
            merge(arr, left, mid, right);  
            //print(data); 
        }  

    static void merge(int Array[], int index_L, int index_C, int index_R){  
            int Array_t[] = new int[Array.length];   
            int mid = index_C + 1;   
            int index_t = index_L;    
            int _t = index_L;  
            while (index_L <= index_C && mid <= index_R){    
                    if (Array[index_L] <= Array[mid]){  
                        Array_t[index_t ++] = Array[index_L ++];  
                    } 
            else{  
                //System.out.println(mid - index_t);
                    ans = ans + mid - index_t;
                //System.out.println("ans " + ans);
                           Array_t[index_t ++] = Array[mid ++];  
                    }  
            }  
            while (mid <= index_R) {  
                    Array_t[index_t ++] = Array[mid ++];  
            }  
            while (index_L <= index_C) {  
                    Array_t[index_t ++] = Array[index_L ++];  
            }    
            while (_t <= index_R) {  
                    Array[_t] = Array_t[_t ++];  
            }  
    }  

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            if(n == 0){break;}
            int in[] = new int[n];
            for(int i = 0;i < n;i ++){
                in[i] = sc.nextInt();
            }
            //print(in);
            mergeSort(in);
            //print(in);
            System.out.println(ans); 
            ans = 0;
        }
    }
}