数组中的逆序对

题目描述

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

输入描述:

题目保证输入的数组中没有的相同的数字

数据范围：

对于%50的数据,size<=10^4

对于%75的数据,size<=10^5

对于%100的数据,size<=2*10^5

　　思路：暴力法时间复杂度为O(n^2)，基于归并排序的解法时间复杂度为O(nlogn)

　　ps：一直纳闷为什么要输出P%1000000007而不是直接输出P，直到写完提交以后，通过率为50%，原因是我的答案竟然出现了负数，才发现int装不下，改用long，然而函数返回值又要求是int，恍然大悟P%1000000007！！！！！　　嗯，一切又解释得通了，世界又变得美好了。。。

class Solution {
public:
    long Merge(int *tmp, vector<int> &data, int left, int mid, int right)
    {
        long count=0;
        int i, j, k;
        for(i=mid, j=right, k=right; i>=left && j>=mid+1; --k)
        {
            if(tmp[i]>tmp[j])
            {
                count=count+j-mid;
                data[k]=tmp[i--];
            }else{
                data[k]=tmp[j--];
            }
        }
        while(i>=left)data[k--]=tmp[i--];
        while(j>=mid+1)data[k--]=tmp[j--];
        for(int idx=left; idx<=right; ++idx)tmp[idx]=data[idx];
        return count;
    }
    long MergeSort(vector<int> &data, int *tmp, int left, int right)
    {
        if(left==right)
        {
            tmp[left]=data[left];
            return 0;
        }else{
            int mid=(left+right)/2;
            long val1=MergeSort(data, tmp, left, mid);
            long val2=MergeSort(data, tmp, mid+1, right);
            long val3=Merge(tmp, data, left, mid, right);
            return val1+val2+val3;
        }
    }
    int InversePairs(vector<int> data) {
        if(data.size()<=1)return 0;
        int *tmp=new int[data.size()];//辅助数组
        long res=MergeSort(data, tmp, 0, data.size()-1);//归并排序
        delete []tmp;
        return res%1000000007;
    }
};

 　　更规范的写法是：

void Merge(vector<int> &data, int begin, int mid, int end, long long &result)
{
    int *arr=new int[end-begin+1];
    int i, j, k;
    for(i=begin, j=mid+1, k=0; i<=mid && j<=end; ++k)
    {
        if(data[i]>data[j])
        {
            arr[k]=data[j++];
            result=result+mid-i+1;//注意和上面不同之处
        }else arr[k]=data[i++];
    }
    while(i<=mid)arr[k++]=data[i++];
    while(j<=end)arr[k++]=data[j++];
    for(int idx=begin; idx<=end; ++idx)data[idx]=arr[idx-begin];
    delete []arr;
}
void MergeSort(vector<int> &data, int begin, int end, long long &result)
{
    if(begin>=end)return;
    int mid=(begin+end)/2;
    MergeSort(data, begin, mid, result);
    MergeSort(data, mid+1, end, result);
    Merge(data, begin, mid, end, result);
}
int InversePairs(vector<int> data)
{
    long long result=0;
    if(data.size()==0)return result;
    MergeSort(data, 0, data.size()-1, result);
    return result%1000000007;
}