题目
数组小和的定义如下：
例如，数组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(nlogn)，空间复杂度为O(n)
题目链接
思路
归并的实现并不困难，难的是为什么可以用归并完成。这个就需要换方向思考了。
对于每个数，我们需要的是它左侧所有小于等于它的数之和。对于所有的数找到它的和。然后累加得到结果。
如果只看结果，我们可以发现，如果s[i]右边大于它的数有n个，那么这个数在最后的最后结果中的贡献就是n * s[i]。
比如题目描述的例子
在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]右边有五个数大于等于它，所以s[0]被加了五次，s[1]右边有三个数大于等于它，所以s[1]被加了三次。后面都是如此。所以可以在归并的过程中每次找s[i]右边大于等于它的有多少个。
import java.util.*;
/**
* @author 香榭的落叶
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n], temp = new int[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
System.out.println(mergeSort(arr, 0, n - 1, temp));
}
static long mergeSort(int[] arr, int l, int r, int[] temp) {
if (l == r) return 0;
int mid = l + (r - l) / 2;
return mergeSort(arr, l, mid, temp)
+ mergeSort(arr, mid + 1, r, temp)
+ merge(arr, l, mid, r, temp);
}
static long merge(int[] arr, int l, int mid, int r, int[] temp) {
int i = l, j = mid + 1;
long ret = 0;
int idx = l;
while (i <= mid && j <= r) {
//之前在这有一个疑问，归并的时候[l, mid],[mid + 1, r]肯定是有序的
//为什么计算结果的时候不加上[i + 1, mid]这一段
ret += arr[i] <= arr[j] ? (r - j + 1) * arr[i] : 0;
temp[idx++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
}
while (i <= mid) temp[idx++] = arr[i++];
while (j <= r) temp[idx++] = arr[j++];
//参数含义：src, srcPos, dest, destPos, len
System.arraycopy(temp, l, arr, l, r - l + 1);
return ret;
}
}
后来仔细思考了下，在递归子过程的时候就已经把前面那一段计算过了。
比如数组arr = [1, 3, 5, 2, 4]。它的递归时的子过程如下：
[1, 3, 5], [2, 4]
[1, 3] [5]， [2], [4]
[1],[3] [5]
在[1],[3]merge的过程中已经计算过3的小和，在[1, 3] 与 [5]merge的时候不需要加上3。即每次归并的时候是范围更大的两段进行归并，而这个时候[i + 1, mid]这一段已经在上一轮归并被累加了。