leetcode.315:计算右侧小于当前元素的个数

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

示例:

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-of-smaller-numbers-after-self
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：
借鉴归并排序的思想，在归并排序的过程中不断更新count数组来获得最终的结果。
1. 归并排序的思想，将整个数组不断的二分，直到只剩一个数组，这是只包含一个元素的数组是有序的，之后利用合并有序数组的函数自下向上进行合并；
2. 在归并的过程中，合并两个有序数组的时候，在每次放入左侧子数组的元素的时候，在count数组的对应位置加上当前的右侧子数组的标记值，原理是，这个标记意味着当前结果数组中放置的右侧元素的个数，也就是原本在右边，但是小于当前放入元素的元素个数；
3. 整个数组排序完成，而在每个元素放置进入结果数组的时候，均完成了累加，而可以直观的感受的是，位于数组最右侧的元素不可能存在比其更右边的元素，因此不会再count数组中进行累加，以此类推，倒数第二个元素只会与最右边的元素进行一次归并排序并可能改变相应位置的count数组，这就是只在左侧数组放入的时候进行累加的原因；
4. 需要解决的一个问题是，在排序的过程中，元素与坐标的对应关系会发生变化，因此无法在count数组中找到对应的位置，解决的办法是，将原来的数组和下标打包成pair放入新的数组之中，对这个数组进行归并排序，比较的内容时pair的第一个元素，而累加的时候累加的是count[pair.second]。

class Solution {
public:
    vector<int> count;
    vector<int> countSmaller(vector<int>& nums) {
        vector<pair<int,int>> temp;
        int len = nums.size();
        if(len==0)return nums;
        if(len==1)
        {
            nums[0] = 0;
            return nums;
        }
        for(int i=0;i< len;i++)
        {
            temp.push_back(pair<int,int>(nums[i],i));
            count.push_back(0);
        }
        mergeSort(temp);
        return count;
    }

    void mergeSort(vector<pair<int,int>> &pairVec)
    {
        if(pairVec.size()==1)return;
        int len = pairVec.size();
        int mid = len/2;
        vector<pair<int,int>> sub1;
        vector<pair<int,int>> sub2;
        for(int i=0;i<mid;i++)
        {
            sub1.push_back(pairVec[i]);
        }
        for(int i=mid;i<len;i++)
        {
            sub2.push_back(pairVec[i]);
        }
        mergeSort(sub1);
        mergeSort(sub2);
        pairVec.clear();
        merge2Array(sub1,sub2,pairVec);
    }

    void merge2Array(vector<pair<int,int>> &vec1,vector<pair<int,int>> &vec2,vector<pair<int,int>> &vec)
    {
        int i = 0;
        int j = 0;
        while(i<vec1.size()&&j<vec2.size())
        {
            if(vec1[i].first<=vec2[j].first)
            {
                count[vec1[i].second]+=j;
                vec.push_back(vec1[i]);
                i++;
            }
            else
            {
                vec.push_back(vec2[j]);
                j++;
            }
        }

        while(i!=vec1.size())
        {
            count[vec1[i].second]+=j;
            vec.push_back(vec1[i]);
            i++;
        }
        while(j!=vec2.size())
        {
            vec.push_back(vec2[j]);
            j++;
        }
    }
};