35数组中的逆序对

 

题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007

输入描述:

题目保证输入的数组中没有的相同的数字
数据范围：
    对于%50的数据,size<=10^4
    对于%75的数据,size<=10^5
    对于%100的数据,size<=2*10^5

示例1

输

1,2,3,4,5,6,7,0

输出

7

思路：
类似于megersort

先统计子数组内部的逆序对的数目，然后再统计2个相邻子数组之间的逆序对的数目，在统计的过程中，还需要对数组排序，
排序可以避免重复统计。

public class Solution {
    public int InversePairs(int [] a) {  
        int[] aux = new int[a.length];
        for(int i = 0;i<a.length;i++)
            aux[i] = a[i];
        
        return fun(a,aux,0,a.length-1);
    }
    private int fun(int[] a,int[] aux,int lo,int hi){
        if(lo==hi) return 0;
        int mid = (hi-lo)/2+lo;
        int left = fun(a,aux,lo,mid)%1000000007;
        int right = fun(a,aux,mid+1,hi)%1000000007;
        
        int i = mid;
        int j = hi;
        int ai = hi;//aux_index
        int  count = 0;
        while(i>=lo&&j>=mid+1){
            if(a[i]>a[j]){
                aux[ai--] = a[i--];
                count+=j-mid;
                if(count>=1000000007)//数值过大求余
                    count%=1000000007;       
            }
            else
                aux[ai--]=a[j--];
        }
        
        while(i>=lo)
            aux[ai--]=a[i--];
        while(j>=mid+1)
            aux[ai--] =a[j--];    
        
        //更新数组
        for(int k = lo;k<=hi;k++)
            a[k] = aux[k];
        
        return (left+right+count)%1000000007;
    }
}

c++ 20180725

class Solution {
public:
    int InversePairs(vector<int> data) {
        int length = data.size();
        if(length<=0) return 0;
        std::vector<int> copy(data);
        long long cnt = InversePairsCore(data,copy,0,length-1);
        return cnt;
    }
    long long InversePairsCore(std::vector<int> &data,std::vector<int> &copy,int lo,int hi){
        if(lo==hi) return 0;
        int mid = lo+(hi-lo)/2;
        long long left = InversePairsCore(data,copy,lo,mid);
        long long right  =InversePairsCore(data,copy,mid+1,hi);

        int i = mid;
        int j = hi;
        int k = hi;
        int cnt = 0;
        while(i>=lo&&j>=mid+1){
            if(data[i]>data[j]){
                copy[k--]=data[i--];
                cnt+=j-mid;
                if(cnt>=1000000007)
                cnt%=1000000007;
            }
            else{
                copy[k--]=data[j--];
            }
        }
        while(i>=lo)
            copy[k--] = data[i--];
        while(j>=mid+1)
            copy[k--] = data[j--];
        for(int m = lo;m<=hi;m++)
            data[m]  =copy[m];
        return (left+right+cnt)%1000000007;
    }
};