数组小和（单调和）_数组的单调和

 
 

  
  

   
   
数组小和的定义如下：例如，数组s=[1,3,5,2,4,6]

在s[0]的左边小于或等于s[0]的数的和为0

在s[1]的左边小于或等于s[1]的数的和为1

在s[2]的左边小于或等于s[2]的数的和为1+3=4

在s[3]的左边小于或等于s[3]的数的和为1

在s[4]的左边小于或等于s[4]的数的和为1+3+2=6

在s[5]的左边小于或等于s[5]的数的和为1+3+5+2+4=15

所以s的小和为0+1+4+1+6+15=27

给定一个数组s，实现函数返回s的小和。

  
  

  
  
对于本题，最容易想到的就是通过二重循环暴力求解，时间复杂度O(n^2)，代码如下：

  
  
public class ArraySmallSum {
 
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 2, 4, 6};
        int smallSum = 0;
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < i; j++) {
                if (arr[j] < arr[i]) {
                    smallSum += arr[j];
                }
            }
        }
        System.out.println(smallSum);
    }
}

  
  
这样的时间复杂度显然是不能令人满意的，这里我们利用归并排序，在对有序子数组进行merge的同时，累加数组小和，时间复杂度O(nlogn)，代码如下：
  
  
public class ArraySmallSum {
 
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 2, 4, 6};
        System.out.println(getSmallSum(arr));
    }
 
 
    public static int getSmallSum(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        return mergeSortRecursion(arr, 0, arr.length - 1);
    }
 
    /**
     * 递归实现归并排序
     *
     * @param arr
     * @param l
     * @param r
     * @return 返回数组小和
     */
    public static int mergeSortRecursion(int[] arr, int l, int r) {
        if (l == r) {   // 当待排序数组长度为1时，递归开始回溯，进行merge操作
            return 0;
        }
        int mid = (l + r) / 2;
        return mergeSortRecursion(arr, l, mid) + mergeSortRecursion(arr, mid + 1, r) + merge(arr, l, mid, r);
    }
 
    /**
     * 合并两个已排好序的数组s[left...mid]和s[mid+1...right]
     *
     * @param arr
     * @param left
     * @param mid
     * @param right
     * @return 返回合并过程中累加的数组小和
     */
    public static int merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];    // 辅助存储空间 O(n)
        int index = 0;
        int i = left;
        int j = mid + 1;
        int smallSum = 0;       // 新增，用来累加数组小和
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                // 当前一个数组元素小于或等于后一个数组元素时，累加小和
                // s[i] <= s[j] -> s[i] <= s[j]...s[right]
                smallSum += arr[i] * (right - j + 1);
                temp[index++] = arr[i++];
            } else {
                temp[index++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[index++] = arr[i++];
        }
        while (j <= right) {
            temp[index++] = arr[j++];
        }
        for (int k = 0; k < temp.length; k++) {
            arr[left++] = temp[k];
        }
        return smallSum;
    }
}

  
  
牛客网有道数组单调和，实际上和该题为同一道题。
另一道数组中的逆序对，与该题解法类似，只是merge时逆序对的累加条件和算法有所不同，此时merge操作的代码如下：
  
  
/**
 * 合并两个已排好序的数组s[left...mid]和s[mid+1...right]
 *
 * @param arr
 * @param left
 * @param mid
 * @param right
 * @return 返回合并过程中累加逆序对
 */
public static int merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];    // 辅助存储空间 O(n)
    int index = 0;
    int i = left;
    int j = mid + 1;
    int inverseNum = 0;       // 新增，用来累加数组逆序对
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[index++] = arr[i++];
        } else {
            // 当前一个数组元素大于后一个数组元素时，累加逆序对
            // s[i] > s[j] -> s[i]...s[mid] > s[j]
            inverseNum += (mid - i + 1);
            temp[index++] = arr[j++];
        }
    }
    while (i <= mid) {
        temp[index++] = arr[i++];
    }
    while (j <= right) {
        temp[index++] = arr[j++];
    }
    for (int k = 0; k < temp.length; k++) {
        arr[left++] = temp[k];
    }
    return inverseNum;
}

 
 


作者：stevewang
链接：http://www.jianshu.com/p/3ab5033074f1
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。