这题其实就是剑指offer里边的逆序对,不过改了点。这种改动让我对递归的结构有了更深的认识。
一开始吧,我是把m个数读进来然后每次翻转一遍,再算一次逆序对个数,这样的时间复杂度是多少呢?
m次翻转,统计一个序列的时间复杂度由于是归并做的,时间复杂度是O(nlogn),那总的时间复杂度就变成O(mnlogn)了...
总之是一件很不划算的事情,如何解决呢?可以利用递归的结构。
我们为每一层的遍历记下逆序对,正的序列记一次,反着的序列记一次。
那我们如果翻转的对应q是2怎么办呢?也就是4个一组然后翻转,这样想,我们翻转4个数为一组,那第三层的8,第四层的16个,相互之间的逆序对有影响吗?没有,因为这只是改变了以四个数为一组的逆序对的数目,那把递归层数小于等于2的正序列的逆序对个数和反序列的逆序对的个数交换就行了,以此类推。
这里的层数是倒着来看的,比如n表示第1层,n-1第二层,以此类推,看懂代码或许有更好的领悟:
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MAX_N 1<<20+5
int n;
ll rev[MAX_N]{0}, nor[MAX_N]{0};
void mergeSort(vector<int> &nums,vector<int> &tmp,int l,int r,int id,ll num[]){
if (l>=r) return;
int mid=(l+r)/2;
mergeSort(nums,tmp,l,mid,id-1,num);
mergeSort(nums,tmp,mid+1,r,id-1,num);
ll cnt=0;
int left=l, pos=l, right=mid+1;
while(left<=mid&&right<=r){
if(nums[left]<=nums[right]){
tmp[pos]=nums[left++];
}else{
cnt+=mid-left+1;
tmp[pos]=nums[right++];
}
pos++;
}
num[id]+=cnt;//这里注意不是直接赋值
while(left<=mid){
tmp[pos++]=nums[left++];
}
while(right<=r){
tmp[pos++]=nums[right++];
}
copy(tmp.begin()+l,tmp.begin()+r+1,nums.begin()+l);
}
ll solve(int x){
for (int i = x; i >= 0; --i) {
swap(nor[i],rev[i]);
}
ll res=0;
for (int i = 0; i <= n; ++i) {
res+=rev[i];
}
return res;
}
int main() {
// while(cin>>n){
cin>>n;
int totalNum=1<<n;
vector<int> nums1(totalNum, 0);
vector<int> nums2(totalNum,0);
for (int i = 0; i < totalNum; ++i) {
cin>>nums1[i];
nums2[i]=nums1[i];
}
reverse(nums2.begin(),nums2.end());
int m;
cin>>m;
vector<int> q(m,0);
for (int i = 0; i < m; ++i) {
cin>>q[i];
}
// for (int num:q) {
// cout<<num<<" ";
// }
// cout<<endl;
vector<int> tmp(totalNum);
mergeSort(nums1, tmp, 0,totalNum-1, n, rev);
mergeSort(nums2,tmp,0,totalNum-1,n,nor);
for (int i = 0; i < m; ++i) {
printf("%lld\n", solve(q[i]));
}
// }
return 0;
}
这里要感谢看的一个博文: