315. Count of Smaller Numbers After Self

问题：

给定一个数组，从左向右遍历数组每一个元素，

对每一个元素，记录，其右边比他小的元素个数到res数组中。

求res数组。

Example:
Input: [5,2,6,1]
Output: [2,1,1,0] 
Explanation:
To the right of 5 there are 2 smaller elements (2 and 1).
To the right of 2 there is only 1 smaller element (1).
To the right of 6 there is 1 smaller element (1).
To the right of 1 there is 0 smaller element.

　　

类似：493. Reverse Pairs

解法：

解法一：FenwickTree

使用以下辅助变量：

• sortedNums：ftree，对给定数组，进行排序。
• FenwickTree：sortnums，记录到目前为止，某个排序位置X以前，共有多少元素。（即<=X的元素有多少个）

由于本题，要求的是某元素以右的更小元素个数。

我们从后往前进行遍历，即可利用已经记录的结果。

最后将得到的res进行反转reverse即可。

代码参考：

class FenwickTree {
public:
    FenwickTree(int n):tree(n+1,0) {}
    void update(int i, int delta) {
        while(i<tree.size()){
            tree[i]+=delta;
            i+=lowbit(i);
        }
    }
    int preSum(int i){
        int sum=0;
        while(i>0){
            sum+=tree[i];
            i-=lowbit(i);
        }
        return sum;
    }
private:
    vector<int> tree;
    int lowbit(int x) {
        return x&(-x);
    }
};
class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) {
        vector<int> res;
        FenwickTree ftree(nums.size());
        vector<int> sortnums(nums);
        sort(sortnums.begin(), sortnums.end());
        for(int i=nums.size()-1; i>=0; i--){
            int pos = distance(sortnums.begin(), lower_bound(sortnums.begin(), sortnums.end(), nums[i]));
            res.push_back(ftree.preSum(pos));
            ftree.update(pos+1, 1);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

解法二：mergeSort

⚠️ 注意：由于mergeSort会打乱原来数组的顺序，在mergeSort过程中，要同时保存计数结果，

需要同时将原来的index位置，存入，使得在mergeSort的过程中，也能找到原来的位置，进行计数。

• vector<vector<int>> numspos(nums.size(), vector<int>(2,0));

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) {
        vector<int> res(nums.size(), 0);
        vector<vector<int>> numspos(nums.size(), vector<int>(2,0));
        for(int i=0; i<nums.size(); i++){
            numspos[i][0]=nums[i];
            numspos[i][1]=i;
        }
        mergeSort(numspos, res, 0, nums.size()-1);
        return res;
    }
    void mergeSort(vector<vector<int>>& nums, vector<int>& res, int start, int end) {
        if(end<=start) return;
        int mid = start + (end - start) / 2;
        mergeSort(nums, res, start, mid);
        mergeSort(nums, res, mid+1, end);
        merge(nums, res, start, mid, end);
    }
    void merge(vector<vector<int>>& nums, vector<int>& res, int start, int mid, int end) {
        int p=start, q=mid+1, t=0;
        vector<vector<int>> tmp(end-start+1, vector<int>(2,0));
        for(p=start; p<=mid; p++){
            while(q<=end && nums[p][0]>nums[q][0]){
                q++;
            }
            res[nums[p][1]]+=(q-1-mid);
        }
        p=start, q=mid+1;
        while(p<=mid && q<=end){
            if(nums[p][0]>nums[q][0]){
                tmp[t++]=nums[q++];
            } else {
                tmp[t++]=nums[p++];
            }
        }
        while(p<=mid){
            tmp[t++]=nums[p++];
        }
        while(q<=end){
            tmp[t++]=nums[q++];
        }
        copy(tmp.begin(), tmp.end(), nums.begin()+start);
    }
};