【每日一题】数组中的逆序对

2020.04.24

是一道难度为Hard的题目，主要原因是数据率较大。因此需要算法进行优化。如果是暴力的方法复杂度是$O(n^2)$无法解决。因此这道题很巧妙的运用了归并排序的一些思想来解决。

主要思想是，首先将数组按照归并排序进行分解。在每次进行合并的时候，判断左侧数组是否大于右侧数组，如果是则找到了逆序数，并且左侧数组后面的所有数字页都大于当前的右侧数组的头元素。

利用归并算法计算逆序对是常用算法思想。

class Solution:
    def __init__(self):
        self.ans = 0

    def reversePairs(self, nums: List[int]) -> int:
        if not nums:
            return 0
        self.divide(nums)
        return self.ans
        
    def divide(self, nums):
        n = len(nums)
        if n == 1:
           return nums 
        left = 0
        right = n-1
        mid = left+(right-left)//2
        # 注意二分法，这里的取值必须是mid+1,对应这个n-1的初始值
        left = self.divide(nums[:mid+1])
        right = self.divide(nums[mid+1:])
        #print(left,right)
        nums_sort = self.merger(left, right)
        return nums_sort
    
    def merger(self, left, right):
        nl = len(left)
        nr = len(right)
        i = 0
        j = 0
        nums = []
        while i<nl and j<nr:
            if right[j]<left[i]:
                #print(right[j], left[i])
                self.ans += nl-i
                nums.append(right[j])                
                j += 1
            else:
                nums.append(left[i])                
                i += 1
        if right:
            nums += right[j:]
        if left:
            nums += left[i:]
        return nums

注意几个归并算法经常出现的小问题：

1. 归并每次左侧是[:mid+1]，右侧也是[mid+1:]。这样才可以有效避免最后两个元素无法进一步分解。
2. 归并算法：
   • 当只有一个元素，返回
   • 计算中值坐标
   • 递归左侧，递归右侧
   • 对左侧和右侧进行排序
   • 返回排序后的数组

练习：利用归并算法计算逆序对

与之类似的题目还有

这道题和前面的题目很像，都是计算类似的逆序对。我们同样可以采用归并的方法计算。
只是在判断nums[i]>2*nums[j]时需要注意。这类题目都是针对右侧数组的头元素计算左侧存在多少满足条件的逆序数字。

这道题在并时需要执行两次循环，第一次统计每个右侧数组的头元素对应了多少逆序对。第二次实现排序。

class Solution:
    def __init__(self):
        self.ans = 0

    def reversePairs(self, nums: List[int]) -> int:
        if not nums:
            return 0
        self.divide(nums,0, len(nums)-1)
        return self.ans

    def divide(self, nums, left, right):
        if left == right:
            return [nums[left]]
        mid = left+(right-left)//2
        n_left = self.divide(nums, left, mid)
        n_right = self.divide(nums, mid+1, right)
        nums_sort = self.merge(n_left, n_right)
        return nums_sort
    
    def merge(self, left, right):
        nl = len(left)
        nr = len(right)
        i = 0
        j = 0
        nums_sort = []
        # 统计右侧头元素存在多少逆序对
        while i<nl and j<nr:
            if left[i]>2*right[j]:
                self.ans += nl-i
                # 只有完成对当前的统计，才移动右侧指针，改变头元素
                j += 1
            else:
                i += 1
        i = 0
        j = 0
        while i<nl and j<nr:              
            if left[i]<right[j]:
                nums_sort.append(left[i])
                i += 1
            else:
                nums_sort.append(right[j])
                j += 1                    
        if right:
            nums_sort += right[j:]
        if left:
            nums_sort += left[i:]
        return nums_sort