题目描述
在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
输入描述:
题目保证输入的数组中没有的相同的数字
数据范围:
对于%50的数据,size<=10^4
对于%75的数据,size<=10^5
对于%100的数据,size<=2*10^5
示例1
输入
1,2,3,4,5,6,7,0
输出
7
归并排序思想
首先还是提出两个问题,带着问题来看题解,我觉得效率更好。
Q1:为什么归并排序需要额外的空间?
Q2:为什么此题的最优解法可以借助归并排序的思想?
A1: 首先回答一下第一个问题,为什么归并排序需要额外空间?
显然我们知道,归并排序的过程就是,递归划分整个区间为基本相等的左右区间,直到左右区间各只有一个数字,然后就合并两个有序区间。
问题就出在了合并两个有序区间上,需要额外的空间。
为什么呢?
这里我举个例子,比如需要合并的两个有序区间为[3 4] 和 [1 2]
我们需要得到最后的结果为[1 2 3 4], 如果不需要额外的空间的话,是做不到的,
当比较1 和 3 的时候, 1 比 3 小,就会覆盖原来的位置。
A2:回答第二个问题之前,先了解一下归并排序的过程,主要有以下两个操作:
- 递归划分整个区间为基本相等的左右两个区间
- 合并两个有序区间
可能看了代码,更好理解:
// 合并过程
void merge__(vector<int> &arr, int l, int mid, int r) {
// 在这个地方创建额外空间,是一种不好的做法,更好的做法,等下讲
vector<int> tmp(r - l + 1);
int i = l, j = mid + 1, k = 0;
while (i <= mid && j <= r) {
if (arr[i] >= arr[j]) {
tmp[k++] = arr[j++];
}
else {
tmp[k++] = arr[i++];
}
}
while (i <= mid) {
tmp[k++] = arr[i++];
}
while (j <= r) {
tmp[k++] = arr[j++];
}
for (k = 0, i = l; i <= r; ++i, ++k) {
arr[i] = tmp[k];
}
}
// 递归划分过程
void merge_sort__(vector<int> &arr, int l, int r) {
// 只有一个数字,则停止划分
if (l >= r) {
return;
}
int mid = l + ((r - l) >> 1);
merge_sort__(arr, l, mid);
merge_sort__(arr, mid + 1, r);
// 合并两个有序区间
merge__(arr, l, mid, r);
}
// 要排序的数组 arr
void merge_sort(vector<int>& arr) {
merge_sort__(arr, 0, arr.size() - 1);
}
明白了归并排序的过程,那么回答问题2.
如果两个区间为[4, 3] 和[1, 2]
那么逆序数为(4,1),(4,2),(3,1),(3,2),同样的如果区间变为有序,比如[3,4] 和 [1,2]的结果是一样的,也就是说区间有序和无序结果是一样的。
但是如果区间有序会有什么好处吗?当然,如果区间有序,比如[3,4] 和 [1,2]
如果3 > 1, 显然3后面的所有数都是大于1, 这里为 4 > 1, 明白其中的奥秘了吧。所以我们可以在合并的时候利用这个规则。
直接上代码:
class Solution {
private:
const int kmod = 1000000007;
public:
int InversePairs(vector<int> data) {
int ret = 0;
merge_sort__(data, 0, data.size() - 1, ret);
return ret;
}
void merge_sort__(vector<int> &arr, int l, int r, int &ret) {
if (l >= r) {
return;
}
int mid = l + ((r - l) >> 1);
merge_sort__(arr, l, mid, ret);
merge_sort__(arr, mid + 1, r, ret);
merge__(arr, l, mid, r, ret);
}
void merge__(vector<int> &arr, int l, int mid, int r, int &ret) {
vector<int> tmp(r - l + 1);
int i = l, j = mid + 1, k = 0;
while (i <= mid && j <= r) {
if (arr[i] > arr[j]) {
tmp[k++] = arr[j++];
// 奥妙之处
ret += (mid - i + 1);
ret %= kmod;
}
else {
tmp[k++] = arr[i++];
}
}
while (i <= mid) {
tmp[k++] = arr[i++];
}
while (j <= r) {
tmp[k++] = arr[j++];
}
for (k = 0, i = l; i <= r; ++i, ++k) {
arr[i] = tmp[k];
}
}
};
刚才提到在函数内部开辟额外空间的做法很不好。因为这样会涉及到频繁的构建 vector 和析构vector,所以比较好的做法是:直接在最外层开辟一个足够大的数组,然后传引用到函数。
代码如下:
class Solution {
private:
const int kmod = 1000000007;
public:
int InversePairs(vector<int> data) {
int ret = 0;
// 在最外层开辟数组
vector<int> tmp(data.size());
merge_sort__(data, tmp, 0, data.size() - 1, ret);
return ret;
}
void merge_sort__(vector<int> &arr, vector<int> &tmp, int l, int r, int &ret) {
if (l >= r) {
return;
}
int mid = l + ((r - l) >> 1);
merge_sort__(arr, tmp, l, mid, ret);
merge_sort__(arr, tmp, mid + 1, r, ret);
merge__(arr, tmp, l, mid, r, ret);
}
void merge__(vector<int> &arr, vector<int> &tmp, int l, int mid, int r, int &ret) {
int i = l, j = mid + 1, k = 0;
while (i <= mid && j <= r) {
if (arr[i] > arr[j]) {
tmp[k++] = arr[j++];
ret += (mid - i + 1);
ret %= kmod;
}
else {
tmp[k++] = arr[i++];
}
}
while (i <= mid) {
tmp[k++] = arr[i++];
}
while (j <= r) {
tmp[k++] = arr[j++];
}
for (k = 0, i = l; i <= r; ++i, ++k) {
arr[i] = tmp[k];
}
}
};
时间复杂度:O(NlogN)
空间复杂度:O(N)