JZ35 剑指offer 数组中的逆序对

第35题 数组中的逆序对

题目描述

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

class Solution {
public:
    const int kmod = 1000000007;
    int InversePairs(vector<int> data) {
        int ret=0;
        vector<int> tmp(data.size());
        sort(data,tmp,0,data.size()-1,ret);
        return ret;
    }
    void sort(vector<int> &data,vector<int>& tmp,int l,int r,int &ret){
        if(l>=r) return;
        int mid = l+((r-l)>>1);
        sort(data,tmp,l,mid,ret);
        sort(data,tmp,mid+1,r,ret);
        merge(data,tmp,l,mid,r,ret);
    }
    void merge(vector<int> &data,vector<int>& tmp,int l,int mid,int r,int& ret){
        int i = l,j = mid+1,k = l;
        while(i<=mid && j<=r){
            if(data[i]>data[j]){
                tmp[k++] = data[j++];
                ret += (mid-i+1);
                ret %= kmod;
            }else{
                tmp[k++] = data[i++];
            }
        }
        while(i<=mid){
            tmp[k++] = data[i++];
        }
        while(j<=r){
            tmp[k++] = data[j++];
        }
        k = l,i = l;
        while(k<=r){
            data[i++] = tmp[k++];
        }
    }
};

class Solution:
    def reversePairs(self, nums: List[int]) -> int:
        self.ret = 0
        tmp = nums.copy()
        def merge(nums,tmp,l,m,r):
            i, j = l, m + 1
            tmp[l: r+1] = nums[l: r+1]
            for k in range(l,r+1):
                if i == m + 1:
                    nums[k] = tmp[j]
                    j += 1
                elif j == r + 1 or tmp[i] <= tmp[j]:
                    nums[k] = tmp[i]
                    i += 1
                else:
                    nums[k] = tmp[j]
                    self.ret += m - i + 1
                    j += 1
        def sort(nums,tmp,l,r):
            if l >= r:
                return
            mid = (l + r) // 2
            sort(nums,tmp,l,mid)
            sort(nums,tmp,mid+1,r)
            merge(nums,tmp,l,mid,r)
        sort(nums,tmp,0,len(nums)-1)
        return self.ret

class Solution:
    def reversePairs(self, nums: List[int]) -> int:
        def merge_sort(l, r):
            # 终止条件
            if l >= r: return 0
            # 递归划分
            m = (l + r) // 2
            res = merge_sort(l, m) + merge_sort(m + 1, r)
            # 合并阶段
            i, j = l, m + 1
            tmp[l:r + 1] = nums[l:r + 1]
            for k in range(l, r + 1):
                if i == m + 1:
                    nums[k] = tmp[j]
                    j += 1
                elif j == r + 1 or tmp[i] <= tmp[j]:
                    nums[k] = tmp[i]
                    i += 1
                else:
                    nums[k] = tmp[j]
                    j += 1
                    res += m - i + 1 # 统计逆序对
            return res
        
        tmp = [0] * len(nums)
        return merge_sort(0, len(nums) - 1)

思路：
使用归并排序思想，归并排序，就是先将区间二分，然后有序的进行合并。开辟tmp数组来进行合并操作，首先我们根据左右指针，进行二分后，对左、右区间递归进行sort，最后再合并然后退回。
合并操作中我们对两个区间值作比较有序放入位置（因为归并操作递归进行，每个操作前的两区间区间内有序，所以依次进行判断再放入tmp，最后结束后再更改原数组）

对于本题，我们要寻找逆序对，借助归并排序时我们会判断不同区间两个数之间的大小关系
比如如果两个区间为[4, 3] 和[1, 2]
那么逆序数为(4,1),(4,2),(3,1),(3,2)，同样的如果区间变为有序，比如[3,4] 和 [1,2]的结果是一样的，也就是说对于区间之间的逆序对，区间有序和无序结果是一样的。
但是如果区间有序会有什么好处吗？当然，如果区间有序，比如[3,4] 和 [1,2]
如果3 > 1, 显然3后面的所有数都是大于1， 这里为 4 > 1, 所以每次我们遇到后面区间值更小时，可以通过当前前面区间指针位置计数，所以在归并时那个if中进行ret累加。