【LeetCode】493. Reverse Pairs 翻转对(Hard)(JAVA)
题目地址: https://leetcode.com/problems/reverse-pairs/
题目描述:
Given an array nums, we call (i, j) an important reverse pair if i < j and nums[i] > 2 * nums[j].
You need to return the number of important reverse pairs in the given array.
Example1:
Input: [1,3,2,3,1]
Output: 2
Example2:
Input: [2,4,3,5,1]
Output: 3
Note:
- The length of the given array will not exceed 50,000.
- All the numbers in the input array are in the range of 32-bit integer.
题目大意
给定一个数组 nums ,如果 i < j 且 nums[i] > 2 * nums[j] 我们就将 (i, j) 称作一个重要翻转对。
你需要返回给定数组中的重要翻转对的数量。
解题方法
- 这个题其实就是找逆序对的个数,只要采用稳定排序的方式即可
- 排序稳定且 O(nlogn) 的算法只有归并排序了
插入排序
- 采用插入排序的方式
- 在插入的时候先用二分法找出比 2 * num 大的个数
- 算法复杂度 O(n^2) ; 虽然插入的位置查找是 O(logn) ,但是插入元素的时候需要把插入位置后面的元素统一往后移,时间复杂度是 O(n)
class Solution {
public int reversePairs(int[] nums) {
int res = 0;
List<Integer> list = new ArrayList<>();
for (int i = 0; i < nums.length; i++) {
res += insert(list, nums[i]);
}
return res;
}
public int insert(List<Integer> list, int num) {
int res = 0;
if (list.size() == 0) {
list.add(num);
return res;
}
int start = 0;
int end = list.size() - 1;
while (start <= end) {
int mid = start + (end - start) / 2;
if (list.get(mid) > num * 2L) {
end = mid - 1;
} else {
start = mid + 1;
}
}
res = list.size() - start;
start = 0;
end = list.size() - 1;
while (start <= end) {
int mid = start + (end - start) / 2;
if (list.get(mid) == num) {
start = mid;
break;
}
if (list.get(mid) > num) {
end = mid - 1;
} else {
start = mid + 1;
}
}
list.add(start, num);
return res;
}
}
执行耗时:466 ms,击败了5.15% 的Java用户
内存消耗:46.6 MB,击败了98.68% 的Java用户
归并排序
- 归并排序的时间复杂度是 O(nlogn) ,并且是空间稳定的(也就是交换不会改变相对位置)
- 假设 n1 = [start, mid], n2 = [mid + 1, end], n1 和 n2 都已经排好序了,也都找除了逆序对个数,现在就需要找出 n1 和 n2 之间的逆序对个数;只要 n1 固定,然后在 n2 中找即可(可以优化用二分查找)
- 找逆序对的时候不要忘记了把 n1 和 n2 两个排序好的数组合并了
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 {
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;
}
}
}
执行耗时:73 ms,击败了44.01% 的Java用户
内存消耗:48.1 MB,击败了52.64% 的Java用户
![](https://img-blog.csdnimg.cn/20201107174624800.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2OTI3ODUz,size_16,color_FFFFFF,t_70#pic_center)