BM20 数组中的逆序对

链接：https://www.nowcoder.com/practice/96bd6684e04a44eb80e6a68efc0ec6c5

本题采用归并排序的思想对问题进行求解，即在每次递归归并中，对递归出的子问题考虑能组成逆序对的个数，来以此累加。

解题代码：

static int mod = (int) (1e9 + 7);
    //逆序对问题
    public int InversePairs(int [] array) {
        if (array == null ||array.length == 1 ) {
            return 0;
        }
        return process(array,0,array.length - 1) % mod;
    }
    
    public int process(int[] array,int l,int r) {
        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return (process(array,l,mid) + process(array,mid + 1,r) + merge(array,l,mid,r)) % mod;
    }
    
    public int merge(int[] array,int l,int mid,int r) {
        int ans = 0;
        int i = l, j = mid + 1;
        int[] help = new int[r - l + 1];
        int cnt = 0;
        while (i <= mid && j <= r) {
            if (array[i] > array[j]) {
                ans += r - j + 1;
                help[cnt++] = array[i++];
            }
            else {
                help[cnt++] = array[j++];
            }
        }
        while (i <= mid) {
            help[cnt++] = array[i++];
        }
        while (j <= r) {
            help[cnt++] = array[j++];
        }
        for (int k = 0; k < r - l + 1; k++) {//此处是help数组的长度,而不是array数组的长度
            array[k + l] = help[k];
        }
        return ans % mod;
    }

 

还可以借鉴这道题的思路：

/*利用归并排序思想,求解部分最小和的问题
     * 如arr = {1,3,4,2,5} ,则对于1来说左侧没有比1小的数，所以和为0
     *                           对于3来说左侧有个1比3小，所以和为1
     *                          对于4来说左侧有个1和3比4小，所以和为4
     *                           对于2来说左侧有个1比2小，所以和为1
     *                         对于5来说左侧有1，3，4，2比5小，所以和为10   所以总和为16
     */
    /*
     * 可以换一种思路进行求解：
     * 1.对于第一个1，之后有3，4，2，5四个数都比它大，所以共要加4次
     * 2.对于第二个3，之后有4，5两个数都比它大，所以共要加2次
     * 3.按照这个思路以此类推至最后一个元素
     * 
     * 所以可以沿用归并排序的思想，每次归并时，如果左边的数比右边的数小，则加上一次左边的这个数
     */
    
    public static int MergeAll(int[] arr)
    {
        if (arr == null || arr.length == 1) {
            return 0;
        }
        return process(arr,0,arr.length - 1);
    }
    
    public static int process(int[] arr,int l,int r)
    {
        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        
        return process(arr,l,mid) + process(arr,mid + 1,r) + Merge(arr,l,mid,r);
    }
    
    public static int Merge(int[] arr,int l,int mid,int r)
    {
        int ans = 0;
        int i = l, j = mid + 1;
        int[] help = new int[r - l + 1];
        int cnt = 0;
        while (i <= mid && j <= r) {
            if (arr[i] < arr[j]) {
                ans += arr[i] * (r - j + 1);
                help[cnt++] = arr[i++];
            }
            else {
                help[cnt++] = arr[j++];
            }
        }
        while (i <= mid) {
            help[cnt++] = arr[i++];
        }
        while (j <= r) {
            help[cnt++] = arr[j++];
        }
        for (int k = 0; k < r - l + 1; k++) {
            arr[k + l] = help[k];
        }
        return ans;
    }