493. Reverse Pairs

问题：

给定一个数组nums，若 i < j, nums[i] > 2*nums[j]，则称这一对 i，j为important reverse pair

求给定数组中，有多少组important reverse pair。

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.

　　

解法：

解法一：FenwickTree

方针：遍历数组，对每一个新遍历到的数nums[j]，看已经遍历过的数里面，是否存在满足要求的nums[i]（nums[i] > 2*nums[j]）

我们使用FenwickTree来记录到目前为止，满足要求的nums[i]总共有多少个。

每遍历一个数，update到FenwickTree中。

presum来得到满足要求的nums[i]的个数。

这里，我们需要使用辅助数组，sortnums来存放经过排序后的nums

使用FenwickTree来对应sortnums的计数。（相同index下）

具体做法：

每遍历一个nums[j]

在sortnums中找到<=2*nums[j]的index

那么在FenwickTree中，到目前为止所有个数 - 0～index的个数 = >2*nums[j]的个数

在sortnums中找到nums[j]的index

更新到FenwickTree.update(index，1)

⚠️ 注意：这里对于重复相同的元素，index可能会重复，但是没关系，我们要求的是计数个数，（不需要index一一对应）直接使用update方法更新增加delta=1即可。

代码参考：

class FenwickTree {
public:
    FenwickTree(int n):preSum(n+1, 0){}
    void update(int i, int delta){
        while(i<preSum.size()){
            preSum[i]+=delta;
            i+=lowbit(i);
        }
    }
    int getPreSum(int i){
        int sum=0;
        while(i>0){
            sum+=preSum[i];
            i-=lowbit(i);
        }
        return sum;
    }
private:
    vector<int> preSum;
    int lowbit(int x){
        return x&(-x);
    }
};

class Solution {
public:
    int reversePairs(vector<int>& nums) {
        FenwickTree tree(nums.size());
        vector<int> sortnums(nums);
        sort(sortnums.begin(), sortnums.end());
        int res=0;
        for(int i=0; i<nums.size(); i++){
            //对每一个j，前面遍历过的每个i，是否有满足条件nums[i] > 2*nums[j]的
            //找大于2*nums[j]的位置
            //sort从小到大，先找<=2*nums[j]的位置
            int dislower=distance(sortnums.begin(), upper_bound(sortnums.begin(),sortnums.end(),(long long)2*nums[i]));
            res+=(tree.getPreSum(nums.size())-tree.getPreSum(dislower));
            //将遍历过的元素更新到tree
            int pos_sorted_i=distance(sortnums.begin(), lower_bound(sortnums.begin(),sortnums.end(),nums[i]))+1;
            tree.update(pos_sorted_i, 1);
        }
        return res;
    }
};

解法二：

归并排序 merge Sort

在归并排序的合并两个有序数列过程中，追加一个判断，

• if 左边的数>=2倍的右边的数：res+=左边剩下的数。
• 左边下一个数

代码参考：

class Solution {
public:
    int reversePairs(vector<int>& nums) {
        int res=0;
        if(nums.size()==0) return 0;
        res = mergeSort(nums, 0, nums.size()-1);
        return res;
    }
    int mergeSort(vector<int>& nums, int start, int end) {
        int res=0;
        if (start==end) {
            return 0;
        }
        int mid = start + (end - start) / 2;
        res+=mergeSort(nums, start, mid);
        res+=mergeSort(nums, mid+1, end);
        res+=merge(nums, start, mid, end);
        return res;
    }
    int merge(vector<int>& nums, int start, int mid, int end) {
        int p = start, q = mid+1;
        int res=0;
        while(p<=mid && q<=end) {
            if(nums[p] > (long long)2*nums[q]){
                res+=(mid-p+1);
                q++;
            }else{
                p++;
            }
        }
        
        vector<int> a(end-start+1, 0);
        p = start, q = mid+1;
        int ai=0;
        while(p<=mid && q<=end) {
            if(nums[p] < nums[q]){
                a[ai]=nums[p];
                p++,ai++;
            }else{
                a[ai]=nums[q];
                q++,ai++;                
            }
        }
        while(p<=mid){
            a[ai++]=nums[p++];
        }
        while(q<=end){
            a[ai++]=nums[q++];
        }
        copy(a.begin(), a.end(), nums.begin()+start);
        return res;
    }
};