1 题目理解

输入：int[] nums
输出：计数的数组int[] counts
规则：counts[i]表示nums中下标大于i，值小于nums[i]的个数
Example 1:
Input: nums = [5,2,6,1]
Output: [2,1,1,0]
Explanation:
To the right of 5 there are 2 smaller elements (2 and 1).
To the right of 2 there is only 1 smaller element (1).
To the right of 6 there is 1 smaller element (1).
To the right of 1 there is 0 smaller element.

2 暴力解法

对于处理每个元素nums[i]，依次数一数从i+1到n，小于nums[i]的数有多少个。

class Solution {public List<Integer> countSmaller(int[] nums) {List<Integer> list = new ArrayList<Integer>();for(int i=0;i<nums.length;i++){int c = 0;for(int j=i+1;j<nums.length;j++){if(nums[j]<nums[i]){c++;}}list.add(c);}return list;}
}

时间复杂度$O(n^2)$

3 分治法

以下内容来自力扣官网。
数一数在右侧，比自己小的元素个数，这实际上就是在求逆序对。在学习算法过程中遇到过，利用归并排序计算逆序对个数。

我们还是要在「归并排序」的「并」中做文章。我们通过一个实例来看看。假设我们有两个已排序的序列等待合并，分别是 L = { 8, 12, 16, 22, 100 } 和 R = { 7, 26, 55, 64, 91 }。一开始我们用指针 lPtr = 0 指向 L 的头部，rPtr = 0 指向 R 的头部。记已经合并好的部分为 M。

我们发现 lPtr 指向的元素大于 rPtr 指向的元素，于是把 rPtr 指向的元素放入答案，并把 rPtr 后移一位。

接着我们继续合并：

此时 lPtr 比 rPtr 小，把 lPtr 对应的数加入答案。如果我们要统计 8 的右边比 8 小的元素，这里 7 对它做了一次贡献。如果待合并的序列 L = { 8, 12, 16, 22, 100 }，R = { 7, 7, 7, 26, 55, 64, 91}，那么一定有一个时刻，lPtr 和 rPtr 分别指向这些对应的位置：

下一步我们就是把 8 加入 M 中，此时三个 7 对 8 的右边比 8 小的元素的贡献为 3。以此类推，我们可以一边合并一边计算 R 的头部到 rPtr 前一个数字对当前 lPtr 指向的数字的贡献。

我们发现用这种「算贡献」的思想在合并的过程中计算逆序对的数量的时候，只在 lPtr 右移的时候计算，是基于这样的事实：当前 lPtr 指向的数字比 rPtr 小，但是比 R 中 [0 … rPtr - 1] 的其他数字大，[0 … rPtr - 1] 的数字是在 lPtr 右边但是比 lPtr 对应数小的数字，贡献为这些数字的个数。

但是我们又遇到了新的问题，在「并」的过程中 88 的位置一直在发生改变，我们应该把计算的贡献保存到哪里呢？这个时候我们引入一个新的数组，来记录每个数字对应的原数组中的下标，例如：

排序的时候原数组和这个下标数组同时变化，则排序后我们得到这样的两个数组：

我们用一个数组 ans 来记录贡献。我们对某个元素计算贡献的时候，如果它对应的下标为 p，我们只需要在 ans[p] 上加上贡献即可。

class Solution {private int[] index;private int[] temp;private int[] tempIndex;private int[] ans;private Map<Integer,Integer> valueIndexMap;public List<Integer> countSmaller(int[] nums) {this.index = new int[nums.length];this.temp = new int[nums.length];this.tempIndex = new int[nums.length];this.ans = new int[nums.length];valueIndexMap = new HashMap<Integer,Integer>();for(int i=0;i<nums.length;i++){valueIndexMap.put(nums[i],i);}for (int i = 0; i < nums.length; ++i) {index[i] = i;}int l = 0, r = nums.length - 1;mergeSort(nums, l, r);List<Integer> list = new ArrayList<Integer>();for (int num : ans) {list.add(num);}return list;}public void mergeSort(int[] a, int l, int r) {if (l >= r) {return;}int mid = (l + r) >> 1;mergeSort(a, l, mid);mergeSort(a, mid + 1, r);merge(a, l, mid, r);}public void merge(int[] a, int l, int mid, int r) {int i = l, j = mid + 1, p = l;while (i <= mid && j <= r) {if (a[i] <= a[j]) {temp[p] = a[i];tempIndex[p] = index[i];ans[valueIndexMap.get(a[i])] += (j - mid - 1);++i;++p;} else {temp[p] = a[j];tempIndex[p] = index[j];++j;++p;}}while (i <= mid)  {temp[p] = a[i];tempIndex[p] = index[i];ans[valueIndexMap.get(a[i])] += (j - mid - 1);++i;++p;}while (j <= r) {temp[p] = a[j];tempIndex[p] = index[j];++j;++p;}for (int k = l; k <= r; ++k) {index[k] = tempIndex[k];a[k] = temp[k];}}
}

时间复杂度$O(nlogn)$