1. 小和问题

什么是小和问题呢？

这是一个数组，我们要求每一个数左边比当前数小的数的和累加起来。
2的左边没有数，说明它的小和为0。
4的左边2比4小，说明它的小和为1个2。
2的左边没有数比它小，说明它的小和为0。
1的左边没有数比它小，说明它的小和为0。
3的左边2和1比它小，说明它的小和为2个2和1个1为5。
6的左边所有数都比它小，说明它的小和为2+4+2+1+3=12。
3的左边2和1比它小，说明它的小和为2个2和1个1为5。
4的左边1，2，3比4小，说明它的小和为1个1，2个2，2个3为11。
1的左边没有数比它小，说明它的小和为0。
5的左边除了6都比5小，说明它的小和为20。
然后再把所有小和加起来：0+2+0+0+5+12+5+11+0+20=55。

那么怎么在归并排序中解决这个问题呢？

首先，下标0和下标1归并，2小于4，拷贝左边的，然后拷贝右边的。如果拷贝左边的则产生小和，那么右边有1个比2大，产生的小和个数是下标1-0=1，也就是1个2。

因为一个数不需要继续，然后下标[0，1]和[2，2]归并。首先，2和2相等，相等的时候，一定要先拷贝右边的。因为你不知道右边有多少个比当前的值大。

现在下标3和下标4归并，1小于3，先拷贝左边的，拷贝左边的就会产生小和，右边有4-3=1个比3大的。所以产生的小和数是1个1。

现在是下标[0，2]和[3，4]归并，2大于1，先拷贝右边的，拷贝右边的不产生小和。

2小于3，拷贝左边的，产生小和，产生1个2。往后移一位，还是2小于3，拷贝左边的，产生小和，产生1个2。往后移一位。

此时3小于4，拷贝右边的，不产生小和，最后再拷贝左边的，也不产生小和。后面的原理都是类似的。

总结：
1.拷贝左边的产生小和，拷贝右边的不产生小和。
2.相等的时候，一定要先拷贝右边的，因为不知道右边的有多少个数比它大。

这样做的原理是什么？
原来是算左边有多少个比它小的，现在我们算某一个数右边有多少个比它大的，如果比它大的，就会产生几个它(此时它就作为小和)。

代码实现：

2. 逆序对

什么叫做逆序对呢？
左边的数比右的数大的就叫做逆序对。

举个例子：

这个数组中，有多少个逆序对呢？(3，1)，(3，0)，(3，1)，(1，0)，(4，3)，(4，1)，(3，1)。总共有这么7个逆序对。

解题思路：
上面的小和问题求的是右边比它大，而这道题其实求的是右边比它小的。

这里还是利用归并排序的原理，其余的不变，但是在归并的时候需要一些变化。

当我们开始归并的时候，我们需要从后往前开始遍历。相等的时候，还是先拷贝右边的，因为我们不知道右边会有多少个比我小。

此时，右边的比左边小，我们就能算出当前6的逆序对，用下标直接相减就能得出。然后把左边的拷贝下来。

此时3小于4，就把右边的4拷贝下来，然后还是4，再把右边的4拷贝下来。

此时3大于2，我们就可以算出3的逆序对。这就是求逆序对的一个流程，我们需要在归并排序中进行一些改变。

代码如下：

这里要注意，一定要控制好下标，不然就会出错。

3. num>x*2的问题

这道题求的是：某个数num右边有多少个数乘2都小于等于num。

举个例子：

那么在这个数组中满足条件的有：(6，1)，(6，2)，(7，1)，(7，3)，(7，2)。就这么几个满足条件。

思路流程：

这是在合并之前的操作。此时1<1 * 2，所以右边的下标不能动，我们移动左边的下标。

此时4大于1 * 2，右边的下标需要一直移动。

当移动到下标为2的时候，移动不了了。此时我们就可以使用下标相减的方式来算出有多少个比它小的。然后左边的继续移动。

现在右边的可以移动了。就按照这样的流程。当左边的数组结束，循环就结束了。

我们是在合并前，去完成这个事情。完成这个事情的时间复杂度是O(N)，后面合并的过程也是O(N)，没有什么太多的影响。

4. 区间和的个数

难度 困难 题目链接

这道题的意思是：给定一个数组，和两个整数lower和upper，返回数组中有多少个子数组的累加和在[lower，upper]上。

解题思路：
首先，我们在解这道题前，我们需要了解一个前缀和的知识，如果大家不懂前缀和，可以看一下这篇文章：前缀和讲解！

第一步：我们要求所有下标的子数组，看有多少个子数组满足要求。
下标为0的子数组：[0，0]
下标为1的子数组：[0，1]，[1，1]
下标为2的子数组：[0，2]，[1，2]，[2，2]
… …
我们把满足要求的个数加起来返回就可以。

第二步：把前缀和数组先搞出来。

这里我们用的是long long，因为防止int类型溢出。

第三步：转换符合范围的策略。
假设某个子数组[i，j]的累加和(也就是前缀和sum(i，j))在[lower，upper]上，说明sum(0，j) - sum(0，i-1)也在[lower，upper]上。那么我们可以进行转换：sum(0，i-1)在sum(0，j) - [lower，upper]范围上，就说明sum(i，j)在[lower，upper]上。

举个例子：
假设[lower，upper]为[10，40]，sum(0，17)为100，我们要求以17结尾的所有子数组有多少个在[10，40]上。[x，17]是由sum(0，17) - sum(0，x-1)得到的，如果我们想让[x，17]在[10，40]范围上，那么sum(0，x-1)的范围要在[60，90]，这样[x，17]才能在[10，40]范围上。

总结：假设0到 i 整体的累加和是x，求以i为结尾的子数组有多少个在[lower，upper]上，等同于去求 i 之前的所有前缀和中，有多少个前缀和在[x-upper，x-lower]上。

所以，在前缀和数组中，我们想求以x为结尾的子数组有多少在[lower，upper]上的，就可以转换成在x前面有多少个前缀和在[x-upper，x-lower]上。想求以y为结尾的子数组有多少在[lower，upper]上的，就可以转换成在y前面有多少个前缀和在[y-upper，y-lower]上。依此类推。

第四步：合并之前找出有多少个符合要求。
举个例子：

假设这两个要开始合并，范围是[-1，2]，我们是从右边的数组里开始去找左边有多少个前缀和在[x-upper，x-lower]上。

比如6这个数，那么我们就要看左边有多少个数在[4，7]这个范围上。7这个数，就要看左边有多少个在[5，8]这个范围上。8这个数就要看有多少个在[6，9]上。从这里，你可以发现：[4，7]，[5，8]，[6，9]，下限和上限都是不断增加的，也就是说它不会回退。这样这个操作的时间复杂度是O(N)。

然后，我们可以定义一个left和right：

6的范围是：[4，7]，先走right，我们可以看到R走到8的时候就超过上限了，就不能走了。然后走left，我们可以看到L走到5的时候就不需要走了，因为大于下限了。

此时，只有一个数5在[4，7]这个范围上，我们直接R-L就能得出个数。后面的过程也是一样的道理。

代码实现：

首先，我们需要划分到一个数，然后看这个数本身是否在范围上。因为我们传的是sum，所以它是[0，L]的累加和。然后总的个数是左边的个数+右边的个数+合并之前的个数。

完整代码：

class Solution {
public:
    
    int _countRangeSum(vector<long long>& sum, int L,int R,int lower, int upper)
    {
        //数组本身累加和是否在[lower，upper]上
        if(L==R)
        {
            if(sum[L]>=lower&&sum[L]<=upper)
            {
                return 1;
            }
            return 0;
        }

        //L!=R，不只一个数需要分解
        int mid=L+((R-L)>>1);
        int leftcount=_countRangeSum(sum,L,mid,lower,upper);
        int rightcount=_countRangeSum(sum,mid+1,R,lower,upper);
        int mergecount=mergesort(sum,L,mid,R,lower,upper);

        return leftcount+rightcount+mergecount;
    }

    int mergesort(vector<long long>& sum,int L,int mid,int R,int lower,int upper)
    {
        //合并之前，对于右边数组中每个数x，求左边数组中有多少个数位于[x-upper，x-lower]
        int ret=0;
        int begin1=L,end1=L;
        int begin2=mid+1,end2=R;

        while(begin2<=end2)
        {
            long long min=sum[begin2]-upper;
            long long max=sum[begin2]-lower;
            while(end1<=mid&&sum[end1]<=max)
            {
                end1++;
            }

            while(begin1<=mid&&sum[begin1]<min)
            {
                begin1++;
            }
            ret+=end1-begin1;

            begin2++;
        }

        long long* tmp=new long long[R-L+1];
        int left=L;
        int right=mid+1;
        int index=0;
        while(left<=mid&&right<=R)
        {
            if(sum[left]<sum[right])
            {
                tmp[index++]=sum[left++];
            }
            else
            {
                tmp[index++]=sum[right++];
            }
        }

        while(left<=mid)
        {
            tmp[index++]=sum[left++];
        }

        while(right<=R)
        {
            tmp[index++]=sum[right++];
        }

        for (int i = 0; i <R-L+1; ++i) {
            sum[L + i] = tmp[i];
        }

        return ret;
    }



    int countRangeSum(vector<int>& nums, int lower, int upper) {
        //前缀和数组
        vector<long long> sum;
        sum.resize(nums.size());
        sum[0]=nums[0];
        for(int i=1;i<nums.size();i++)
        {
            sum[i]=sum[i-1]+nums[i];
        }

        return _countRangeSum(sum,0,sum.size()-1,lower,upper);

    }
};