写的让人伤心的翻转对（leetcode493）

给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个重要翻转对。

你需要返回给定数组中的重要翻转对的数量。

示例 1:
输入: [1,3,2,3,1]
输出: 2


示例 2:
输入: [2,4,3,5,1]
输出: 3
注意:

给定数组的长度不会超过50000。
输入数组中的所有数字都在32位整数的表示范围内。

看到这个题目，我没想到什么好的方法，老老实实的暴力破解吧

初级版

public int reversePairs(int[] nums) {
     int len = nums.length;
     List<Integer> list = Arrays.stream(nums).boxed().map(x -> x + x).collect(Collectors.toList());
     log.info("list:{}",list);
     int result = 0, m = 0;
     for(int i = 0; i < len; i++){
         int temp = nums[i];
         for(int k = i + 1; k < len; k++){
             if(temp > list.get(k)){
                 result++;
             }
         }
     }
     return reslut;
}

示例 [2147483647,2147483647,2147483647,2147483647,2147483647,2147483647]
也就是int的最大值时，代码运行与预期就有差别了

int i = 2147483647时，i +1 得到的是 -2147483648，就像贪吃蛇，最大的与最小的联在一起了。

这也是个坑呀！

运行超时版

public int reversePairs(int[] nums) {
     int len = nums.length;
     int result = 0, m = 0;
     for(int i = 0; i < len; i++){
         int temp = nums[i];
         for(int k = i + 1; k < len; k++){
         // 若是奇数，相等的也符合条件。 
             if(temp/2 > nums[k] || (temp % 2 == 1 && temp/2 == nums[k])){
                 result++;
             }
         }
     }
	 return reslut;
}

这里判断条件 temp/2 > nums[k] || (temp % 2 == 1 && temp/2 == nums[k]) 要考虑奇偶数
因为7/2=3，然而它运行超时了……

最后，看了官方的解法，原来可以借用归并排序来，想想之前还写过文章介绍 归并排序，可看题目时，确实没想到归并排序。

一旦知道用归并排序，实现就起来就不难了，直接上代码

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 {
            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;
            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;
        }
    }