数组中的逆序对

题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数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

刚开始的算法，运算结果正确。但是由于递归涉及到大量重复计算的问题，使得运行超时

class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size()==0) return 0;
        int len = data.size();
        int * array = new int[len];
        //memset(array, 0, data.size()*sizeof(array));
        for(int i=0;i<len;i++){
            array[i] = 0;
        }
        divideInversePairs(data,0,data.size()-1,array);

        int sum = 0;
        for(int i = 0;i<len;i++){
            sum += array[i];
        }

        return sum%1000000007;
    }
    void CombineInversePairs(vector<int> data,int low,int mid,
                           int high,int array[]){
        for(int i = low;i<=mid;i++){//数左右两部分的拟序对数目
            for(int j=mid+1;j<=high;j++){
                if(data[i]>data[j])
                    array[i]++;
            }
        }
    }

 void divideInversePairs(vector<int> data,int low,
                           int high,int array[]){
        if(low<high){
            int mid = low + (high - low)/2;
            
            divideInversePairs(data, low, mid, array); //分别计算左右两部分的拟序对数，将其存储在array数组中
            divideInversePairs(data, mid+1, high, array);
            CombineInversePairs(data,low,mid,high,array);
        }
    }
};

 查看了剑指offer上的算法思路，意识到自己的算法存在重复计算的问题

使用分治加归并排序的思路，在每次比较完之后将其排序，使得下一次计算不必重复计算，时间复杂度o(nlog(n)),空间复杂度0（n）

class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size()<=0) return 0;
        int len = data.size();
        int * array = new int[len];
        //memset(array, 0, data.size()*sizeof(array));
        vector<int> copy;
        for(int i=0;i<len;i++){
//             copy.push_back(data[i]);
            array[i] = data[i];
        }
        int count = divideInversePairs(data,0,len-1,array);

        free(array);
        return count%1000000007;
    }
   
 int divideInversePairs(vector<int> &data,int low,
                           int high,int copy[]){
         if(low == high){
             copy[low] = data[low];
             return 0;
         }
             
         int mid = (low+high)>>1;
         int leftcount = divideInversePairs(data,low,mid,copy)%1000000007;
         int rightcount = divideInversePairs(data, mid+1,high,copy)%1000000007;
     int count = 0;
     int i = mid;
     int j = high;
     int index = high;
         while(i>=low&&j>mid){
             if(data[i]>data[j]){//是逆序
                 count += j - mid;
                 copy[index--] = data[i--];
                if(count>=1000000007)//数值过大求余
                {
                    count%=1000000007;
                }
             }else{
                 copy[index--] = data[j--];
             }
         }
     while(i>=low){copy[index--] = data[i--];}
     while(j>mid){copy[index--] = data[j--];}
     for(int s=low;s<=high;s++)
        {
            data[s] = copy[s];
        }
     return (count + leftcount + rightcount)%1000000007;
    }
};

算法要注意的是：

1.vector<int> &data，这里需要使用引用传递，刚开始以为vector<int>和数组一样传递的是地址

2.数较大，每次计算都要取模，或者使用long long 存储。