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

首先贴下自己的做法，虽然超时了。通过从后向前的遍历，并将当前元素插入右边有序元素中，则从该元素开始的右边元素都是有序的。并且遍历过程中能够通过二分查找获得的序号来计算小于自己的元素个数。贴代码

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) 
    {
        int n = nums.size();
        vector<int> res(n);
        res[n-1] = 0;
        for(int i = n-2 ; i >= 0 ; i--)
        {
            //二分查找
            int tempInt = nums[i];
            int left = i+1;
            int right = n-1;
            //二分查找
            while(left<=right)
            {
                int mid = (left+right)/2;
                if(nums[mid]>=tempInt)
                right = mid-1;
                else if(nums[mid]<tempInt)
                left = mid+1;
            }
            //待排序值大于所有
            if(left == n)
            {
                for(int j = i ; j <= n-2 ; j++)
                nums[j] = nums[j+1];
                nums[n-1] = tempInt;
                res[i] = n-1-i;
            }
            else
            {
                for(int j = i ; j <= right-1 ; j++)
                nums[j] = nums[j+1];
                nums[right] = tempInt;
                res[i] = right-i;
            }
        }
        return res;
    }
};

第二种方法是使用了树状数组的数据结构。可以用桶的方式来记录某一个数在数组中的出现频率。同样进行从后向前的遍历，对于遍历到的某一个数而言，其右边的小于当前数的个数就是桶中当前数前方所有元素的和。而这个数组求和的操作则能够使用树状数组的结构来实现。另外的一个技巧是使用离散化优化空间，其实就是将源数组中的值域连续的映射到一个连续的整数空间。原数组中每个数映射为新数组中该数组对应的完成映射之后，可通过二分查找的方式获得索引，能一定程度上减少空间消耗。代码中最复杂应当是树状数组的实现，贴代码

class Solution {
private:
    vector<int> a;
    vector<int> c;
    void Init(int length)
    {
        c.resize(length,0);
    }
    int LowBit(int x)
    {
        return x&(-x);
    }
    void Update(int pos)
    {
        while(pos<c.size())
        {
            c[pos] += 1;
            pos += LowBit(pos);
        }
    }
    int Query(int pos)
    {
        int ret = 0;
        while(pos>0)
        {
            ret += c[pos];
            pos -= LowBit(pos);
        }
        return ret;
    }

    void Discretization(vector<int>& nums)
    {
        a.assign(nums.begin(),nums.end());
        sort(a.begin(),a.end());
        a.erase(unique(a.begin(),a.end()),a.end());
    }

    int getId(int x)
    {
        return lower_bound(a.begin(),a.end(),x)-a.begin()+1;
    }
public:
    vector<int> countSmaller(vector<int>& nums) 
    {
        vector<int> resultList;
        Discretization(nums);
        Init(nums.size() + 5);
        for(int i = (int)nums.size()-1;i>=0;--i)
        {
            int id =getId(nums[i]);
            resultList.push_back(Query(id-1));
            Update(id);
        }
        reverse(resultList.begin(),resultList.end());
        return resultList;
    }
};

 还有一种归并排序的方法，很巧妙。归并排序分为两个步骤，首先分隔开，分成独自一个的个体之后就进行合并。而该题就利用了合并过程，来实现右边的小于该数的计算。假设对两组有序的数进行归并，假设在某一时刻，第一组中遍历到了i，并且在这时第二组遍历到了j，并且i<j，在排序过程中会将i放入目标数组中，而这一步骤另外一个隐含的意义就是，第二组数中j之前的所有数都小于i，不然也轮不到j，i就会被放入目标数组。于是将第二组数中小于j的数的个数加之对应的结果数组中。而在递归的过程中，某一数右边的所有数都会经过这个判断，递归完成时，也就得到了最后的答案。另外一个要点就是建立原始数组中的数与其在初始数组中的索引的对应关系。在代码中就是index这个数组。因为归并排序会改变元素的位置，所以，index数组的含义为，index该数组的某一索引以及该索引在数组中的对应值分别为某一数据在修改过的数组中的索引和其原始索引。通过维护这个数组，可以进行最终结果的累加。另一个要点是，merge函数以及mergeSort函数的数组形参要写成引用，不然排序就没有意义。贴代码

class Solution {
private:
    vector<int> index;
    vector<int> temp;
    vector<int> tempIndex;
    vector<int> res;
public:
    vector<int> countSmaller(vector<int>& nums) 
    {
        int n = nums.size();
        index.resize(n,0);
        for(int i = 0 ; i < n ; i++)
        index[i] = i;
        temp.resize(n,0);
        tempIndex.resize(n,0);
        res.resize(n,0);
        mergeSort(nums,0,n-1);
        return res;
    }
    void mergeSort(vector<int>& a,int l,int r)
    {
        if(l>=r)
        return;
        int mid = (l+r)/2;
        mergeSort(a,l,mid);
        mergeSort(a,mid+1,r);
        merge(a,l,r,mid);
    }
    void merge(vector<int>& a,int l,int r,int mid)
    {
        int i = l;
        int j = mid+1;
        int p = l;
        while(i<=mid && j<=r)
        {
            if(a[i]<=a[j])
            {
                temp[p] = a[i];
                tempIndex[p] = index[i];
                res[index[i]] += (j-mid-1);
                i++;
                p++;
            }
            else
            {
                temp[p] = a[j];
                tempIndex[p] = index[j];
                j++;
                p++;
            }
        }
        while(i<=mid)
        {
            temp[p] = a[i];
            tempIndex[p] = index[i];
            res[index[i]] += (j-mid-1);
            i++;
            p++;            
        }
        while(j<=r)
        {
            temp[p] = a[j];
            tempIndex[p] = index[j];
            j++;
            p++;            
        }
        for(int k = l ; k <= r ; k++)
        {
            a[k] = temp[k];
            index[k] = tempIndex[k];
        }
    }
};