LeetCode 493. 翻转对

博主是个菜b，学习了官方的题解才想出来答案
尽量用简单的方法解释这个题

看到这里时，大脑事实上是茫然的
啪的一声，直接暴力，很快啊，超时处置，耗子为汁。

class Solution {
    public int reversePairs(int[] nums) {
        int sum=0;
        for (int i=0;i<nums.length;i++){
            for (int j=i+1;j<nums.length;j++){
                if ((long)nums[i]>2*(long)nums[j]){
                    sum++;
                }
            }
        }
        return sum;
    }
}

上面的代码很简单，甚至在侮辱这个Hard，但是我们可以从最基础的入手，一步步整点活。
从这些方面考虑：是否存在多余的步骤，规范的数据是否有好处

多余的步骤

观察一下代码和题目，我们发现一个问题，
只要中间的某个数字num[i]拥有左边的几个小弟num[j]们，使得满足了
j <= right && (long) nums[i] > 2 * (long) nums[j]
这个神奇的要求，

1. 所有在i左侧的兄弟，只要比num[i]还大，就能直接加上num[i]合格的数量。(因为比num[i]还大，num[i]都够用，这个兄弟肯定也行）
2. 所有在i右侧的兄弟，只要比num[i]还大，但是保证在j前我也可以加

另外，我们扫描一般都是左到右（右撇子请你把左右调换吧），所以第一点没什么用，我们已经扫描过了，我已经知道他了，呐就是第二点所有在i右侧的兄弟，只要比num[i]还大，但是保证在j前我也可以加。
我们试图整理一下话语，变得更舒适：似乎想要知道第n位的数量，就可以参考，注意是参考，n位前，比num[n]小的兄弟的数量。

呐我要是把这个数字整成一个升序，是不是就能直接嘿嘿嘿了？

一开始觉得这个是不可能的，因为升序了嘛，你数字原有的位置信息就没了，肿么办？
但是回头看了一下我们已经推出来的一些结论：只要在左侧就行了，至于左侧的数字怎么排列，无所谓的，另外，如果右侧（j右侧）也是个升序，似乎第二条结论拥有了一个公式，

很快啊，我们整个例子

假设， 数组 a b c d e
我们切开 abc de，
我们已经知道了abc里面有几个，de里面有几个重要翻转数
我们想要知道总共有几个，
很简单，总共=abc+de+两块中间满足条件的数量（未知）
你可能发现了，abc和de排序不排序已经无所谓了，因为最后一个未知的量是一个从abc出num[i]，一个从de中出num[j]！
呐就可以方心大胆的动abc和de的顺序，因为有了排序，我们可以让两边的数字站个队，对他们进行统计就是很轻松的事情。
但是我们想要保证你这个abc是安全的，呐就做成递归切半嘛，直到切到不能切，然后再一步步算回来

芜湖，你会发现，这tm就是归并排序，好家伙，一个递归，一个扫描，教育这个年轻Hard题目，你哥还是你哥。

class Solution {
    public int reversePairs(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        return reversePairsRecursive(nums, 0, nums.length - 1);
    }
	//归并排序
    public int reversePairsRecursive(int[] nums, int left, int right) {
        if (left == right) {
            return 0;
        } else {
            //递归，使得mid两边已经排好序而且得出有几个
            int mid = (left + right) / 2;
            int n1 = reversePairsRecursive(nums, left, mid);
            int n2 = reversePairsRecursive(nums, mid + 1, right);
            //得到左边和右边块内部的合格数量，还差跨块的数量
            int ret = n1 + n2;
			//开始计算缺失的部分
            // 首先统计下标对的数量
            int i = left;
            int j = mid + 1;
            //这里很神奇，左边为升序，右边为升序，所有只要能满足当前i左侧的i1，就能满足i，所以j不需要重新走，直接加上j的相对位置就行了，建议画图自己悟一下
            while (i <= mid) {
                while (j <= right && (long) nums[i] > 2 * (long) nums[j]) {
                    j++;
                }
                ret += j - mid - 1;
                i++;
            }
			//统计完了，我们还要把数组的排序走完，以便交付给上一层一个已经排好序的数组
            // 随后合并两个排序数组
            int[] sorted = new int[right - left + 1];
            int p1 = left, p2 = mid + 1;
            int p = 0;
            while (p1 <= mid || p2 <= right) {
                if (p1 > mid) {
                    sorted[p++] = nums[p2++];
                } else if (p2 > right) {
                    sorted[p++] = nums[p1++];
                } else {
                    if (nums[p1] < nums[p2]) {
                        sorted[p++] = nums[p1++];
                    } else {
                        sorted[p++] = nums[p2++];
                    }
                }
            }
            for (int k = 0; k < sorted.length; k++) {
                nums[left + k] = sorted[k];
            }
            return ret;
        }
    }
}