leetcode练习 Reverse Pairs

几次练手之后，决定进军hard难度
最近的课程主要讲的是分治，就选择了相关的题目。

Given an array nums, we call (i, j) an important reverse pair if i < j and nums[i] > 2*nums[j].

You need to return the number of important reverse pairs in the given array.

Example1:

Input: [1,3,2,3,1]
Output: 2
Example2:

Input: [2,4,3,5,1]
Output: 3
Note:
The length of the given array will not exceed 50,000.
All the numbers in the input array are in the range of 32-bit integer.

是一个逆序对的题目
跟普通的逆序对不一样，这次乘了个2，感觉会带来一些影响。

首先当然是按照朴素的方法写一下试试（毕竟是hard难度，希望不大
果不其然

不出意料的超时了……
分析复杂度，O($n^2$)，太慢了，于是思考改进。

耍了小聪明，因为选的是分治类的题目，很自然的往分治的思想上靠。又发现和归并排序其实有点相似，于是转换为如下思想：
每次将给出的数组分为两个部分，每个部分按顺序排好，就可以保证左边的部分的index始终小于右边的部分，从而满足条件i < j。
每个部分处理的时候把值按从小到大顺序排好，这样在合并相邻两个数组的时候(如[x, y]， [p,q])，若判断y > 2*q，那么肯定有y>2*p，就可以把p,q都加入计数，如果y不满足，就换到x继续判断p，q，以此类推。

$T(n) = 2T(n/2) + O(n)$

$T(n) = O(nlogn)$ (主定理，即大师定理)

所以，关键就在于始终保证小数组是顺序排列的。然而，因为这道题目有个2倍的关系，如果不额外进行处理，则会出现y < 2*q 且 y > q的情况，就会在合并的时候把数值更大的y排到q的前面，从而对下一层处理产生影响。对此，我的处理是使用一次sort函数保证顺序。

class Solution {
public:
    void merge(vector<int> &nums, int left, int mid, int right, int &cnt) {
        if (left >= right) return;
        int lp = mid;
        int rp = right;
        vector<int> result;
        while (lp >= left && rp >= mid+1) {
            long x = nums[lp];
            long y = nums[rp];
            if (x > 2 * y) {
                cnt += (rp-mid);
                result.push_back(nums[lp]);
                lp--;
            } else {
                result.push_back(nums[rp]);
                rp--;
            }
        }
        while (lp >= left) {
            result.push_back(nums[lp]);
            lp--;
        }
        while (rp >= mid+1) {
            result.push_back(nums[rp]);
            rp--;
        }
        sort(result.begin(), result.end()); // still have question
        for (int i = left, j = 0; i <= right, j < (right-left+1); i++, j++) {
            nums[i] = result[j];
        }
    }
    void divide(vector<int> &nums, int left, int right, int &cnt) {
        if (left >= right) return;
        int mid = (left + right) / 2;
        divide(nums, left, mid, cnt);
        divide(nums, mid+1, right, cnt);
        merge(nums, left, mid, right, cnt);
    }
    int reversePairs(vector<int>& nums) {
        int cnt = 0;
        divide(nums, 0, nums.size()-1, cnt);
        return cnt;
    }
};

然而速度不是很理想。。。

仍然需要改进。
网上看到一个利用二分查找的，研究过后再行改进。不过我感觉问题可能出在sort上，最好能找到其它方法绕过。今天先到这里，第一次hard，难度没有想象中的大，但是遇到了不少麻烦，结果也不是很满意，应该能从中学到更多的东西，需要细细咀嚼。