数组中的逆序对(归并排序)

题目描述

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

输入描述:

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

输入例子:

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

输出例子:

7

用python提交的时候超时，所以用的C++来实现的

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string>
#include <cstring>
#include <vector>
using namespace std;

class Solution
{
public:
    int InversePairs(vector<int> &data)
    {
        int len = data.size();
        if(len == 0)return 0;
        int res = 0;
        mergeSort(data,0,len - 1,res);
        return res;
    }
    // 分解
    void mergeSort(vector<int> &a,int begin,int end,int &res)
    {
        if(begin < end)
        {
            int mid = (begin + end) / 2;
            mergeSort(a,begin,mid,res);
            mergeSort(a,mid + 1,end,res);
            merge(a,begin,mid,end,res);
        }
    }
    // 合并
    void merge(vector<int> &a, int begin, int mid, int end,int &res)
    {
        int len1 = mid - begin + 1;
        int len2 = end - mid;
        int left[len1],right[len2];
        for(int i = 0; i < len1; ++i)left[i] = a[begin + i];
        for(int i = 0; i < len2; ++i)right[i] = a[mid + 1 + i];
        int i = len1 - 1, j = len2 - 1;
        int k;
        // 先取大的数，再取小的数
        for(k = end; k >= begin; --k)
        {
            if(left[i] > right[j])
            {
                res = (res + j + 1) % 1000000007;
                a[k] = left[i--];
                if(i < 0)break;
            }
            else
            {
                a[k] = right[j--];
                if(j < 0)break;
            }
        }
        // 证明left已经遍历完，遍历right
        if(i < 0)
        {
            for(--k; k >= begin; --k)a[k] = right[j--];
        }
        else if(j < 0)
        {
            for(--k; k >= begin; --k)a[k] = left[i--];
        }
    }
};

int main()
{
    vector<int> v;
    for(int i = 10; i >= 0; i --)
        v.push_back(i);
    Solution s;

    // 输出逆序对的对数
    cout << s.InversePairs(v) << endl;
    // 输出排好序的序列
    for(int i = 0;i < v.size(); i ++)
        cout << v[i] << " ";
    cout << endl;
    return 0;
}

下面是python的代码，提交超时

#coding: utf-8
class Solution:
    global count
    count = 0
 
    def InversePairs(self, data):
        print self.MergeSort(data)
        return count % 1000000007
    def MergeSort(self, lists):
        global count
        if len(lists) <= 1:
            return lists
        num = int( len(lists) / 2)
        left = self.MergeSort(lists[0:num])
        right = self.MergeSort(lists[num:])
        return self.Merge(left, right)
    def Merge(self, left, right):
        global count
        r = len(right) - 1
        l = len(left) - 1
        result=[]
        while l >= 0 and r >= 0:
            if left[l] > right[r]:
                result.insert(0, left[l])
                l -= 1
                count += r + 1
            else:
                result.insert(0, right[r])
                r -= 1
         
        if l >= 0:
            left = left[0 : l + 1]
            result = left + result
 
        if r >= 0:
            right = right[0 : r + 1]
            result = right + result
        return result

if __name__ == "__main__":
    a = Solution()
    print a.InversePairs([1, 2, 3, 4, 5, 6, 7, 0])