算法：分治(归并)题目练习

目录

题目一：排序数组

题目二：数组中的逆序对

题目三：计算右侧小于当前元素的个数

题目四：翻转对

---

题目一：排序数组

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

---

归并排序也就是找一个中间值mid，先排mid左边的区域，再排mid右边的区域，而左边的区域又可以分为两块，继续排序，以此类推 .....最后再将两个有序数组进行合并

这里的归并排序与上一章节的快排，都是执行了数组分块的逻辑，较为类似，所以放在一块讲解

这里可以将快排理解为二叉树的前序遍历，即先将根结点这一层分好，再去分左子树，右子树...

而归并排序，可以理解为二叉树的后序遍历，即先将左子树、右子树分完，再合并到根结点处

这里的归并排序同样分为下面几步：

①选择中间点mid
②左右区间排序
③合并左右两个数组
④将 tmp 数组数据还原到数组 nums 中

---

代码如下：

class Solution 
{
    vector<int> tmp;//临时数组放全局，相比于放局部提高效率
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        tmp.resize(nums.size());//临时数组 开空间 + 初始化
        mergeSort(nums, 0, nums.size() - 1);
        return nums;
    }

    void mergeSort(vector<int>& nums, int left, int right)
    {
        if(left >= right) return;
        //选择中间点划分
        int mid = ((right - left) >> 1) + left;
        //左右区间排序
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);
        //合并两个数组
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right)
            tmp[i++] = nums[cur1] <= nums[cur2] ? nums[cur1++] : nums[cur2++];
        //处理两个数组中可能有剩余元素的数组，即没有遍历完的数组
        while(cur1 <= mid) tmp[i++] = nums[cur1++]; 
        while(cur2 <= right) tmp[i++] = nums[cur2++];
        //还原数组
        for(int i = left; i <= right; i++) nums[i] = tmp[i - left];
    }
};

---

题目二：数组中的逆序对

在股票交易中，如果前一天的股价高于后一天的股价，则可以认为存在一个「交易逆序对」。请设计一个程序，输入一段时间内的股票交易记录 record，返回其中存在的「交易逆序对」总数。

示例 1:

输入：record = [9, 7, 5, 4, 6]
输出：8
解释：交易中的逆序对为 (9, 7), (9, 5), (9, 4), (9, 6), (7, 5), (7, 4), (7, 6), (5, 4)。

---

逆序对其实在大学的课程是学过的，只要在数组中从前往后挑选的两个数中，前一个数比后一个数大，就称这两个数为一个逆序对

解法一：暴力解法

两层for循环，依次枚举每一个组合，从所有组合中寻找逆序对，这种解法比较简单，且一定会超时，所以代码就不列举了

解法二：归并排序

下面可以对归并排序说明，即分为两部分，左边部分挑出来逆序对个数，右边部分挑出来逆序对个数，再一左一右挑出来逆序对个数，相加即可

下面可以优化为：

左半部分 -> 左排序 -> 右半部分 -> 右排序 -> 一左一右 -> 排序

策略一：找出该数之前，有多少个数比我大的(升序排列)

现在分为两部分，如下所示：

因为是升序排序的，所以此时cur1、cur2前面的部分都是小的，由于要找的逆序对时前面的数比后面的数大，所以当找到cur1大于cur2的时候，左半部分的cur1后面的其他数也肯定大于cur2，此时就不用继续比较了，直接加上后面的个数，再cur2++，往后寻找，也就是：

①nums[cur1] <= nums[cur2]：cur1++
②nums[cur] > nums[cur2]：ret += mid - cur1 + 1，cur2++

---

策略二：找出该数之后，有多少个数比我小的(降序排列)

降序排列如下所示：

①nums[cur2] < nums[cur1]：ret += right - (mid + 1) +1 = right - mid，cur1++
②nums[cur2] >= nums[cur1]：cur2++

---

代码如下：

class Solution 
{
    vector<int> tmp;
public:
    int reversePairs(vector<int>& record) 
    {
        tmp.resize(record.size());
        return mergeSort(record, 0, record.size() - 1);
    }

    int mergeSort(vector<int>& nums, int left, int right)
    {
        if(left >= right) return 0;

        int ret = 0;
        //找中间点，将数组分为两部分
        int mid = ((right - left) >> 1) + left;
        //左边数组 + 排序 + 右边数组 + 排序
        ret += mergeSort(nums, left, mid);
        ret += mergeSort(nums, mid + 1, right);
        //一左一右的数
        int cur1 = left, cur2 = mid + 1, i = 0;
        //策略一：升序版本
        while(cur1 <= mid && cur2 <= right)
        {
            if(nums[cur1] <= nums[cur2])
            {
                tmp[i++] = nums[cur1++];
            }
            else
            {
                ret += mid - cur1 + 1;
                tmp[i++] = nums[cur2++];
            }
        }
        //策略二：降序版本
        // while(cur1 <= mid && cur2 <= right)
        // {
        //     if(nums[cur1] > nums[cur2])
        //     {
        //         ret += right - cur2 + 1;
        //         tmp[i++] = nums[cur1++];
        //     }
        //     else
        //     {
        //         tmp[i++] = nums[cur2++];
        //     }
        // }
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];
        //还原数组
        for(i = left; i <= right; i++) nums[i] = tmp[i - left];
        return ret;
    }
};

---

题目三：计算右侧小于当前元素的个数

给你一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是  nums[i] 右侧小于 nums[i] 的元素的数量。

示例 1：

输入：nums = [5,2,6,1]
输出：[2,1,1,0] 
解释：
5 的右侧有 2 个更小的元素 (2 和 1)
2 的右侧仅有 1 个更小的元素 (1)
6 的右侧有 1 个更小的元素 (1)
1 的右侧有 0 个更小的元素

示例 2：

输入：nums = [-1]
输出：[0]

示例 3：

输入：nums = [-1,-1]
输出：[0,0]

---

这道题与上一道题的逆序对比较像，上一题是直接求逆序对的数量，而此题是求每个元素有几个右边比它小的元素的数量

解法：归并排序(分治)

上一题讲到了有两个策略：

策略一：求一个数左边有多少个数比我大(升序)

策略二：求一个数右边有多少个数比我小(降序)

此题使用策略二比较方便些，图如下所示：

所以就有下面两种情况：

①nums[cur1] <= nums[cur2]：cur2++
②nums[cur1] > nums[cur2]：数组中cur1这个位置的数 = 原始下标 + right - cur2 + 1

那么由于归并排序是会改变数组中元素位置的，怎么能够记住数组中原始下标的位置呢？

利用哈希的思想， 创建一个和nums等规模大小的数组，并记录原始的下标，在nums数组的元素移动时，该数组也跟着移动即可

由于此时多了一个index下标数组，所以还需要多创建一个辅助数组，需要注意的是在使用nums数组的辅助数组tmpNums时，index数组的辅助数组tmpIndex也需要使用，为了最终能够找到原始下标

在处理一左一右两部分时，由于需要记录cur1位置的数值，那么就需要该位置的数值所对应的原始下标，原始下标为index[cur1]，找到了原始下标，那么此时往最终的数组中写时，就变为了：
ret[index[cur1]]

---

代码如下：

class Solution 
{
    vector<int> ret;      //最终结果
    vector<int> index;    //原始下标
    int tmpNums[500010];  //辅助数组
    int tmpIndex[500010]; //辅助数组
public:
    vector<int> countSmaller(vector<int>& nums) 
    {
        int n = nums.size();
        ret.resize(n), index.resize(n); 
        //初始化 index 数组
        for(int i = 0; i < n; i++) index[i] = i;
        mergeSort(nums, 0, nums.size() - 1);
        return ret;
    }

    void mergeSort(vector<int>& nums, int left, int right)
    {
        if(left >= right) return;

        int mid = ((right - left) >> 1) + left;
        //先处理左右两部分
        //[left, mid] [mid + 1, right]
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);
        //处理一左一右两部分
        int cur1 = left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid && cur2 <= right)
        {
            if(nums[cur1] <= nums[cur2])
            {
                tmpNums[i] = nums[cur2];
                tmpIndex[i++] = index[cur2++];
            }
            else
            {
                ret[index[cur1]] += right - cur2 + 1;
                tmpNums[i] = nums[cur1];
                tmpIndex[i++] = index[cur1++];
            }
        }
        //处理可能没处理完的排序过程
        while(cur1 <= mid)
        {
            tmpNums[i] = nums[cur1];
            tmpIndex[i++] = index[cur1++];
        }
        while(cur2 <= right)
        {
            tmpNums[i] = nums[cur2];
            tmpIndex[i++] = index[cur2++];
        }
        //还原数组
        for(int i = left; i <= right; i++)
        {
            nums[i] = tmpNums[i - left];
            index[i] = tmpIndex[i - left];
        }
    }
};

---

题目四：翻转对

给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个重要翻转对。

你需要返回给定数组中的重要翻转对的数量。

示例 1:

输入: [1,3,2,3,1]
输出: 2

示例 2:

输入: [2,4,3,5,1]
输出: 3

注意:

1. 给定数组的长度不会超过50000。
2. 输入数组中的所有数字都在32位整数的表示范围内。

---

这道题和逆序对那道题非常相似，逆序对是求前面的数大于后面的数的个数，而这道题是求前面的数大于后面数的两倍的个数

解法一：暴力枚举

暴力枚举就是固定一个数，枚举后面的数，以此类推，找到符合条件组合的个数，时间一定会超时，就不多说了，看下面的解法

解法二：分治

讲一个数组分为两部分，先求左边的翻转对的个数，再求右边翻转对的个数，再求一左一右的翻转对的个数

那么接下来，需要考虑怎么使用归并，能够解决此题

依旧是两种策略：

策略一：计算当前元素后面，有多少元素的2倍比我小（降序）

策略二：计算当前元素前面，有多少元素的一半比我大（升序）

与前面的计算方式不同的是，逆序对那道题，由于与递归排序的 if 语句中的判断条件是一样的，都是 nums[cur1] 与 nums[cur2] 比较，所以可以在递归的过程中，进行 ret++

而这道题是 nums[cur1] 与 2 * nums[cur2] 进行比较，不同的判断条件可能会导致遗漏，

所以在归并之前，先来判断这种情况有多少个翻转对，如果采用的是策略一，就让 ret += right - cur2 + 1，直到 cur1 <= mid 这个判断条件结束，下面再进行这一次的归并排序，以此类推

---

代码如下：

class Solution 
{
    int tmp[50010]; //辅助数组
public:
    int reversePairs(vector<int>& nums) 
    {
        return mergeSort(nums, 0, nums.size() - 1);
    }

    int mergeSort(vector<int>& nums, int left, int right)
    {
        if(left >= right) return 0;
        int ret = 0;
        //根据中间元素划分区间
        int mid = ((right - left) >> 1) + left;
        //计算左右两侧的翻转对
        ret += mergeSort(nums, left, mid);
        ret += mergeSort(nums, mid + 1, right);
        //先计算翻转对的数量
        int cur1 =  left, cur2 = mid + 1, i = 0;
        while(cur1 <= mid) //降序
        {
            while(cur2 <= right && nums[cur1] / 2.0 <= nums[cur2]) cur2++;
            if(cur2 > right) break;
            ret += right - cur2 + 1;
            cur1++;
        }
        //合并两个有序数组
        cur1 = left, cur2 = mid + 1;
        while(cur1 <= mid && cur2 <= right)
        {
            tmp[i++] = nums[cur1] <= nums[cur2] ? nums[cur2++] : nums[cur1++];
        }
        //处理没有处理完毕的数组
        while(cur1 <= mid) tmp[i++] = nums[cur1++];
        while(cur2 <= right) tmp[i++] = nums[cur2++];
        //恢复数组
        for(int i = left; i <= right; i++) nums[i] = tmp[i - left];
        return ret;
    }
};

---

分治中，关于归并的题目到此结束

---