LeetCode493：翻转对（Java）

如题：

• 我们要找出下标更小的数大于某一个下标更大的数的两倍，就构成一个翻转对。题目中并不要求我们返回构成翻转对的是哪两个数，只需要返回有几个翻转对，因此只需要遍历数组然后在遍历的时候进行统计即可。

  • 但是如果使用嵌套for循环遍历数组，时间复杂度太高，因此应该考虑其他能够复杂度更低但是又能够遍历一个完整数组的方式：二路归并排序。

• 二路归并排序会先将左边的排好序，再将右边的排好序，然后利用merge函数将左右两边的子数组合并，注意：我们在合并的时候其实就已经对两个子数组遍历了。等到归并排序结束，我们就能够遍历整个数组。

• 二路归并排序时间复杂度是nlogn，其中logn代表merge函数对左右子数组合并的次数，n代表每次合并操作的复杂度。因此我们可以理解为merge函数的时间复杂度为O(n)，我们会调用logn次merge函数。

  • 意思就是：merge函数里面遍历两个子数组将它们合并的复杂度是O(n)，此时如果我们在merge函数中进行我们自己需要的遍历，保证我们新增的遍历操作时间复杂度不超过O(n)，这样加上原本的合并操作，时间复杂度最多也是O(2n)，忽略常数后时间复杂度不变。

• 因此可以得出结论：我们可以利用归并排序中merge函数仅调用logn次就能遍历整个数组的特点，在merge函数组增加一个时间复杂度为O(n)的遍历操作，这样就能够避免嵌套for循环的n²时间复杂度。

• 代码如下：

  class Solution {
      private int[] temp;//临时数组，用来在merge函数中辅助合并两个子数组
      private int count;//统计翻转对数量
  
      public int reversePairs(int[] nums) {
          int length = nums.length;
          temp = new int[nums.length];
          //为临时数组初始化，长度和给定数组一样，我们不用每次merge的时候都根据当前需要
          //合并的两个子数组长度初始化temp，只需要在temp中对应区域覆盖上新的数据，
          //然后仅操作这段区域即可
          sort(nums, 0, nums.length - 1);
          return count;
      }
  
      public void sort(int[] nums, int left, int right) {
          if (left == right) {
              return;
          }
          int mid = left + ((right - left) >> 2);
          //这里不能(right+left)/2，因为可能为导致溢出
          sort(nums, left, mid);
          sort(nums, mid + 1, right);
          merge(nums, left, mid, right);
      }
  
      public void merge(int[] nums, int left, int mid, int right) {
          //在temp数组中指定区域覆盖上新数据
          System.arraycopy(nums, left, temp, left, right - left + 1);
          //下面是关键：从end开始找翻转对，end是右子数组开始位置
          int end = mid + 1;
          //遍历左子数组，和end所在右子数组比较是否构成翻转对，此时我们应该利用归并排序特性：
          //左子数组和右子数组都是已经排好序的，因此在左子数组中靠左的位置如果和end构成了翻转对，
          //那么左子数组中这个位置之后的肯定都和end构成翻转对。因此我们不需要将左子数组的每个
          //元素都在右子数组中从头开始比较，只需要从右子数组中上一轮比较退出的索引开始
          for (int i = left; i <= mid; i++) {
              //由于两倍过后可能数字溢出，需要转成Long
              //end从右子数组第一个元素开始，如果这个元素和左子数组的第一个元素构成翻转对，
              //那么翻转对数量为1，相当于此时(end+1)-(mid+1),这个式子代表当前end位置有多少
              //翻转对，如果构成翻转对就让end右移，退出的时候end刚好是上一轮加一的位置，因此退出
              //后翻转对数量为end-(mid+1)
              while (end < right + 1 && (long) nums[i] > (long) nums[end] * 2){
                  end++;
              }
              count += end-mid-1;//依次累加统计翻转对数量
          }
          //统计过后对左右数组进行合并
          for (int i = left, m = left, n = mid + 1, k = 0; i <= right; i++) {
              if (m == mid + 1) {
                  nums[i] = temp[n++];
              } else if (n == right + 1) {
                  nums[i] = temp[m++];
              } else if (temp[m] < temp[n]) {
                  nums[i] = temp[m++];
              } else {
                  nums[i] = temp[n++];
              }
          }
      }
  }