【伪清奇思路】寻找数组中的逆序对个数

题目来源：剑指offer

1. 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
2. 示例：
   输入：
   1,2,3,4,5,6,7,0
   输出
   7

需要仔细研究一下示例，光看题目，会以为前面一个数字大于后面的数字，是需要相邻的。但是研究算例之后发现并非如此。只要是位置上的前后就可以了。

1. 剑指上归并排序思路

其实，思路很简单，但是既然是和归并排序思路一致，为了方便记忆，就已经以真正的归并排序为基准，写出这个代码来，而书上的这套代码就不太好。一方面是借用归并的思路，一方面又不借用归并的常规代码，何况也并没有什么大的优化，会造成记忆的混乱。
因此，我在归并排序常规代码基准上写出了这个代码，非常简单。但是还是有挺多需要注意的地方。

1.1 常规二路归并代码

void msort(int a[],int low,int high)
{
    if(low >= high)
        return;
    int mid = (low+high)/2;
    msort(a,low,mid);//左路有序
    msort(a,mid+1,high);//右路有序
    merge(a,low,mid,high);//左右路有序的进行合并
}
int *b = new int[sizeof(a)/sizeof(a[0])];//全局辅助数组
void merge(int a[],int b[],int low,int mid,int high)
{
    int i = low,j = mid+1 , k =low;
    for(;i <= high; ++i)
        b[i] = a[i];
    i = low;
    while(i <= mid && j <= high)
    {
        if(b[i] >= b[j])
            a[k++] = b[i++];
        else
            a[k++] = b[j++];
    }
    while(i <= mid)
        a[k++] = b[i++]; //前半段没复制完，后一段已空。
    //同理
    while(j <= high)
        a[k++] = b[j++]; 
}
delete [] b;

1.2 改进再哪里

merge是一个从小到大的递归的过程，所以说每次只在merge时候计算逆序对是不会重复的。
那么假设现在前半段有序数列为$A$，后半段为$B$。

$$A = {a_{1}, a_{2},a_{3},...a{n}}，B = {b_{1}, b_{2},b_{3},...b{m}}$$
那么，当存在b[i] >= b[j]，再这里公式表示就是 $a_{i} > b_{j}$。那么，由于数列 $A$是递增的，那么意味着从$a_{i}到a{n}$都能和 $b_{j}$构成逆序对。
因此，根据这个，完成了以下代码：

    int count = 0;
    int InversePairs(vector<int> data) {
        //这个逆序对是不用连续的，所以排序过程中比较的都可以
        //这个适合于归并排序，不容易多数
        if(data.size() == 0)
            return 0;
        vector<int> copy; // 因为是vector，在结束之后会自动释放的。
        int Len = data.size();
        for(int i =0;i<Len;++i)
            copy.push_back(data[i]);
        msort(data,copy,0,Len-1);
        return count;
    }
    void msort(vector<int> &data,vector<int> &copy,int low,int high)
    {
        if(low >= high)
        {
            return;
        }
        int mid = low + (high - low)/2;;
        msort(data,copy,low,mid);
        msort(data,copy,mid+1,high);
        InversePairsCount(data,copy,low,high,mid);
    }
    void InversePairsCount(vector<int> &data,vector<int> &copy,int low,int high,int mid)
    {
        int i = low , j = mid+1, k = low;
        for(int i =low ;i<=high;++i)
            copy[i] = data[i];
        i = low;
        while(i <= mid && j<= high)
        {
            if(copy[i] <= copy[j])
            {
                data[k++] = copy[i++];
            }
            else
            {
                data[k++] = copy[j++];
                count = (count + mid - i+1)%1000000007;
            }
        }
        while(i <= mid)
            data[k++] = copy[i++];
        while(j <= high)
            data[k++] = copy[j++];
    }