Leetcode 493. Reverse Pairs

Problem:

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:

1. The length of the given array will not exceed 50,000.
2. All the numbers in the input array are in the range of 32-bit integer.

Solution:

　　这道题再用类似Leetcode 315. Count of Smaller Numbers After Self中的插入排序方法就只能打擦边球AC了，类似的，这道题应该要想到用FenwickTree树状数组来解决。我们用一个集合s存储所有不重复的数字，然后用一个sorted数组存储排序后的唯一的数字，用一个哈希表记录了唯一的数字对应的rank值，并维护了一个FenwickTree，用rank数组对所有数字进行一个排名。和Leetcode 315类似，我们需要在这个树状数组中寻找前x个数之和，不同的是，Leetcode 315的处理比较简单，这里的x是比nums[i]/2.0小的最大值，我们可以利用这个sorted数组进行二分查找。然后不断更新这个树状数组即可。时间复杂度是O(nlogn)

Code:

class FenwickTree{
public:
    FenwickTree(int N){
        data = vector<int>(N+1);
        tree = vector<int>(N+1);
    }
    void update(int index){
        for(int i = index;i < tree.size();i+=lowBit(i))
            tree[i] += 1;
        data[index]++;
    }
    int getSum(int last){
        int result = 0;
        for(int i = last;i > 0;i-=lowBit(i))
            result += tree[i];
        return result;
    }
private:
    int lowBit(int x){
        return x&(-x);
    }
    vector<int> tree;
    vector<int> data;
};

class Solution {
public:
    int reversePairs(vector<int>& nums) {
        set<int> s(nums.begin(),nums.end());
        vector<int> sorted(s.begin(),s.end());
        unordered_map<int,int> um;
        int index = 1;
        for(auto i:s){
            um[i] = index;
            index++;
        }
        int m = nums.size();
        vector<int> rank(m);
        for(int i = 0;i != nums.size();++i)
            rank[i] = um[nums[i]];
        int result = 0;
        FenwickTree tree(s.size());
        for(int i = m-1;i >= 0;--i){
            double target = nums[i]/2.0;
            if(target <= sorted[0]) {
                tree.update(rank[i]);
                continue;
            }
            int start = 0;
            int end = sorted.size()-1;
            while(start < end){
                int pivot = start+(end-start+1)/2;
                if(sorted[pivot] >= target)
                    end = pivot-1;
                else
                    start = pivot;
            }
            result += tree.getSum(um[sorted[start]]);
            tree.update(rank[i]);
        }
        return result;
    }
};