其他分享
首页 > 其他分享> > P5046 [Ynoi2019 模拟赛] Yuno loves sqrt technology I(分块+卡常)

P5046 [Ynoi2019 模拟赛] Yuno loves sqrt technology I(分块+卡常)

作者:互联网

洛谷题面传送门

zszz,lxl 出的 DS 都是卡常题(

首先由于此题强制在线,因此考虑分块,我们那么待查询区间 \([l,r]\) 可以很自然地被分为三个部分:

那么这样一来区间逆序对的来源可以有以下几种:

对于前三种情况,我们可以记录这样两个数组:

对于第四、五两种情况,显然是要求一个区间内比某个数小/大的数的个数,这个可以通过维护以下数组求出:

求出这两东东之后第四、五种情况一边前缀和带走即可。

对于第六种情况我们也类似地维护以下数组:

对于第七种情况貌似没有什么方法直接处理,不过考虑一个 trick 叫归并排序,对于两个排好序的有序数组,我们是可以在线性时间内求出它们排好序后的逆序对个数的。因此我们维护每个块排好序的数组,那么我们在 \(l\) 所在的块与 \(r\) 所在的块中跑一遍双针,即在第 \(l\) 个块排好序的数组中枚举一个 \(a_i\),那么显然在第 \(r\) 个块排好序的数组中,满足 \(a_j<a_i\) 的 \(j\) 显然组成一段前缀,那么我们就双针找出这段前缀,然后统计一下这段前缀中有多少个位置 \(\le r\) 即可。

上述情况都是针对 \(l,r\) 不在同一个整块中的情况,对于 \(l,r\) 在同一个整块中的情况,我们设 \(l,r\) 所在的整块为 \([L,R]\),那么区间 \([l,r]\) 的逆序对个数就可以用 \([L,r]\) 的逆序对个数减去 \([L,l-1]\) 中逆序对的个数,再减去 \([L,l-1]\) 与 \([l,r]\) 之间的逆序对个数,前两个值都可以通过我们之前维护的 \(pre\) 数组求出,至于第三个……相信聪明的读者们如果明白了上面的第七种情况,也能很快知道这个怎么维护。

时间复杂度 \((n+m)\sqrt{n}\),然鹅由于实现的不好,它 TLE 了,只过了第 5 个测试点。

附:20pts 的代码:

const int MAXN=1e5;
const int BLK=500;
int n,qu,a[MAXN+5],pre[MAXN+5],suf[MAXN+5],buc[MAXN+5];
pii b[BLK+5][BLK+5];int sum[BLK+5][MAXN+5];
int lft[MAXN+5][BLK+5],rit[MAXN+5][BLK+5];
int bl[BLK+5][BLK+5];
int blk_cnt=0,blk_sz=0,L[BLK+5],R[BLK+5],bel[MAXN+5];
int t[MAXN+5];
void add(int x,int v){for(int i=x;i<=n;i+=(i&(-i))) t[i]+=v;}
int ask(int x){int ret=0;for(int i=x;i;i&=(i-1)) ret+=t[i];return ret;}
ll query(int l,int r){
	if(l<1||l>n||r<1||r>n||l>r) return 0;
	if(bel[l]==bel[r]){
		ll sum=pre[r];
		if(l^L[bel[l]]) sum-=pre[l-1];
		for(int i=1,c=0;i<=R[bel[l]]-L[bel[l]]+1;i++){
			if(b[bel[l]][i].se<l) sum-=c;
			c+=(l<=b[bel[l]][i].se&&b[bel[l]][i].se<=r);
		} return sum;
	} else {
		ll sum=0;sum+=suf[l];sum+=pre[r];
		for(int i=bel[l]+1;i<bel[r];i++) sum+=pre[R[i]];
		for(int i=bel[l]+1;i<bel[r];i++) sum+=bl[i][i-1]-bl[i][bel[l]];
		for(int i=l;i<=R[bel[l]];i++) sum+=rit[i][bel[l]+1]-rit[i][bel[r]];
		for(int i=L[bel[r]];i<=r;i++) sum+=lft[i][bel[r]-1]-lft[i][bel[l]];
		for(int i=1,j=1,c=0;i<=R[bel[l]]-L[bel[l]]+1;i++){
			while(j<=R[bel[r]]-L[bel[r]]+1&&b[bel[r]][j].fi<b[bel[l]][i].fi){
				c+=(b[bel[r]][j].se<=r);j++;
			} if(b[bel[l]][i].se>=l) sum+=c;
		}
		return sum;
	}
}
int main(){
	scanf("%d%d",&n,&qu);
	blk_sz=400;blk_cnt=(n-1)/blk_sz+1;
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=blk_cnt;i++){
		L[i]=(i-1)*blk_sz+1;R[i]=min(i*blk_sz,n);
		for(int j=L[i];j<=R[i];j++) bel[j]=i;
	}
	for(int i=1;i<=n;i++) b[bel[i]][i-L[bel[i]]+1]=mp(a[i],i);
	for(int i=1;i<=blk_cnt;i++) sort(b[i]+1,b[i]+R[i]-L[i]+2);
	for(int i=1;i<=n;i++) sum[bel[i]][a[i]]++;
	for(int i=1;i<=blk_cnt;i++) for(int j=1;j<=n;j++)
		sum[i][j]+=sum[i][j-1];
	for(int i=1;i<=blk_cnt;i++){
		memset(t,0,sizeof(t));ll sum=0;
		for(int j=L[i];j<=R[i];j++){
			pre[j]=(sum+=j-L[i]-ask(a[j]));
			add(a[j],1);
		} memset(t,0,sizeof(t));sum=0;
		for(int j=R[i];j>=L[i];j--){
			suf[j]=(sum+=ask(a[j]));
			add(a[j],1);
		}
	}
	for(int i=1;i<=blk_cnt;i++){
		for(int j=1;j<=n;j++) buc[j]+=sum[i][j];
		for(int j=R[i]+1;j<=n;j++) lft[j][i]=R[i]-buc[a[j]];
	} memset(buc,0,sizeof(buc));
	for(int i=blk_cnt;i;i--){
		for(int j=1;j<=n;j++) buc[j]+=sum[i][j];
		for(int j=L[i]-1;j;j--) rit[j][i]=buc[a[j]-1];
	}
	for(int i=1;i<=blk_cnt;i++) for(int j=1;j<i;j++) for(int k=L[i];k<=R[i];k++) bl[i][j]+=lft[k][j];
	ll pre=0;
	while(qu--){
		ll l,r;scanf("%lld%lld",&l,&r);l^=pre;r^=pre;
		printf("%lld\n",pre=query(l,r));
	}
	return 0;
}

然后就到了奇淫的卡常时间了,我首先玄学般地三分了下块长并加了个 IO 优化,然鹅并没有什么卵用,该 T 的还是 T 掉了。

其次我们注意到再求 \(lft,rit\) 的过程用到了维护第 \(i\) 个块 occurrence 的前缀和数组 \(sum_{i,j}\),事实上这东西大可不必提前预处理出来,这样耗时间又耗空间,因此我将它改为,维护一个临时数组 \(c_j\),扫到第 \(i\) 块时再求出这一块的前缀和,我还加了一个小小的剪枝,就是求出这一块中 \(a_i\) 的最小值 \(mn\),求前缀和时从 \(mn\) 开始枚举,正确性显然,但是似乎用处不大。

接下来我发现这个 \(lft\) 和 \(rit\) 数组定义与功能类似,都可以求某个前缀小于某个数的个数,事实上它们完全可以合并成一个数组,因此我就把求 \(rit\) 那一部分的 \(n\sqrt{n}\) 删掉,然后几个细节稍微改了改,常数确实小了不少,第五个测试点又原来 546ms 变成了 371ms,第四个点时而 A 时而 T,剩下三个点仍然 TLE。

附:40pts 的代码:

using namespace fastio;
const int MAXN=1e5;
const int BLK=500;
int n,qu,a[MAXN+5],pre[MAXN+5],suf[MAXN+5],buc[MAXN+5];
pii b[BLK+5][BLK+5];int c[MAXN+5];
int lt[MAXN+5][BLK+5],bl[BLK+5][BLK+5];
int blk_cnt=0,blk_sz=0,L[BLK+5],R[BLK+5],bel[MAXN+5];
int t[MAXN+5];
void add(int x,int v){for(int i=x;i<=n;i+=(i&(-i))) t[i]+=v;}
int ask(int x){int ret=0;for(int i=x;i;i&=(i-1)) ret+=t[i];return ret;}
ll query(int l,int r){
	if(l<1||l>n||r<1||r>n||l>r) return 0;
	if(bel[l]==bel[r]){
		ll sum=pre[r];
		if(l^L[bel[l]]) sum-=pre[l-1];
		for(int i=1,c=0;i<=R[bel[l]]-L[bel[l]]+1;i++){
			if(b[bel[l]][i].se<l) sum-=c;
			c+=(l<=b[bel[l]][i].se&&b[bel[l]][i].se<=r);
		} return sum;
	} else {
		ll sum=0;sum+=suf[l];sum+=pre[r];
		for(int i=bel[l]+1;i<bel[r];i++) sum+=pre[R[i]]+bl[i][i-1]-bl[i][bel[l]];
		for(int i=l;i<=R[bel[l]];i++) sum+=lt[i][bel[r]-1]-lt[i][bel[l]];
		for(int i=L[bel[r]];i<=r;i++) sum+=(L[bel[r]]-R[bel[l]]-1)-(lt[i][bel[r]-1]-lt[i][bel[l]]);
		for(int i=1,j=1,c=0;i<=R[bel[l]]-L[bel[l]]+1;i++){
			while(j<=R[bel[r]]-L[bel[r]]+1&&b[bel[r]][j].fi<b[bel[l]][i].fi){
				c+=(b[bel[r]][j].se<=r);j++;
			} if(b[bel[l]][i].se>=l) sum+=c;
		}
		return sum;
	}
}
int main(){
	read(n);read(qu);
	blk_sz=450;blk_cnt=(n-1)/blk_sz+1;
	for(int i=1;i<=n;i++) read(a[i]);
	for(int i=1;i<=blk_cnt;i++){
		L[i]=(i-1)*blk_sz+1;R[i]=min(i*blk_sz,n);
		for(int j=L[i];j<=R[i];j++) bel[j]=i;
	}
	for(int i=1;i<=n;i++) b[bel[i]][i-L[bel[i]]+1]=mp(a[i],i);
	for(int i=1;i<=blk_cnt;i++) sort(b[i]+1,b[i]+R[i]-L[i]+2);
	for(int i=1;i<=blk_cnt;i++){
		memset(t,0,sizeof(t));ll sum=0;
		for(int j=L[i];j<=R[i];j++){
			pre[j]=(sum+=j-L[i]-ask(a[j]));
			add(a[j],1);
		} memset(t,0,sizeof(t));sum=0;
		for(int j=R[i];j>=L[i];j--){
			suf[j]=(sum+=ask(a[j]));
			add(a[j],1);
		}
	}
	for(int i=1;i<=blk_cnt;i++){
		int mn=n+1,s=0;
		for(int j=L[i];j<=R[i];j++) c[a[j]]++,chkmin(mn,a[j]);
		for(int j=mn;j<=n;j++) s+=c[j],buc[j]+=s;
		for(int j=L[i];j<=R[i];j++) c[a[j]]--;
		for(int j=1;j<=n;j++) lt[j][i]=buc[a[j]-1];
	}
	for(int i=1;i<=blk_cnt;i++) for(int j=1;j<i;j++)
		for(int k=L[i];k<=R[i];k++) bl[i][j]+=R[j]-lt[k][j];
	ll pre=0;
	while(qu--){
		ll l,r;read(l);read(r);l^=pre;r^=pre;
		print(pre=query(l,r),'\n');
	} print_final();
	return 0;
}

然后就到了最奇怪的部分了,我注意到询问的时候写了这样一句话:

for(int i=l;i<=R[bel[l]];i++) sum+=lt[i][bel[r]-1]-lt[i][bel[l]];

然后我就灵机一动,尝试交换 \(lt\) 的两维,并寻思这样效率会加快多少。

然鹅出乎意料的是,作了这样一个小小的变动后,它竟然 AC 了!而且竟然还抢到了(目前,截至 2021.7.18)的最优解。

为什么我会想到作这样一个变动?注意到在上面的语句中,后面一维的值与枚举变量 \(i\) 无关,因此如果交换这两维,后面一维访问的下标就是一段连续的区间,访问的地址也是一段完整的区间,这样就能大大提高访问速度。

AC 代码:

using namespace fastio;
const int MAXN=1e5;
const int BLK=500;
int n,qu,a[MAXN+5],pre[MAXN+5],suf[MAXN+5],buc[MAXN+5];
pii b[BLK+5][BLK+5];int c[MAXN+5];
int lt[BLK+5][MAXN+5],bl[BLK+5][BLK+5];
int blk_cnt=0,blk_sz=0,L[BLK+5],R[BLK+5],bel[MAXN+5];
int t[MAXN+5];
void add(int x,int v){for(int i=x;i<=n;i+=(i&(-i))) t[i]+=v;}
int ask(int x){int ret=0;for(int i=x;i;i&=(i-1)) ret+=t[i];return ret;}
ll query(int l,int r){
	if(l<1||l>n||r<1||r>n||l>r) return 0;
	if(bel[l]==bel[r]){
		ll sum=pre[r];
		if(l^L[bel[l]]) sum-=pre[l-1];
		for(int i=1,c=0;i<=R[bel[l]]-L[bel[l]]+1;i++){
			if(b[bel[l]][i].se<l) sum-=c;
			c+=(l<=b[bel[l]][i].se&&b[bel[l]][i].se<=r);
		} return sum;
	} else {
		ll sum=0;sum+=suf[l];sum+=pre[r];
		for(int i=bel[l]+1;i<bel[r];i++) sum+=pre[R[i]]+bl[i][i-1]-bl[i][bel[l]];
		for(int i=l;i<=R[bel[l]];i++) sum+=lt[bel[r]-1][i]-lt[bel[l]][i];
		for(int i=L[bel[r]];i<=r;i++) sum+=(L[bel[r]]-R[bel[l]]-1)-(lt[bel[r]-1][i]-lt[bel[l]][i]);
		for(int i=1,j=1,c=0;i<=R[bel[l]]-L[bel[l]]+1;i++){
			while(j<=R[bel[r]]-L[bel[r]]+1&&b[bel[r]][j].fi<b[bel[l]][i].fi){
				c+=(b[bel[r]][j].se<=r);j++;
			} if(b[bel[l]][i].se>=l) sum+=c;
		}
		return sum;
	}
}
int main(){
	read(n);read(qu);
	blk_sz=460;blk_cnt=(n-1)/blk_sz+1;
	for(int i=1;i<=n;i++) read(a[i]);
	for(int i=1;i<=blk_cnt;i++){
		L[i]=(i-1)*blk_sz+1;R[i]=min(i*blk_sz,n);
		for(int j=L[i];j<=R[i];j++) bel[j]=i;
	}
	for(int i=1;i<=n;i++) b[bel[i]][i-L[bel[i]]+1]=mp(a[i],i);
	for(int i=1;i<=blk_cnt;i++) sort(b[i]+1,b[i]+R[i]-L[i]+2);
	for(int i=1;i<=blk_cnt;i++){
		memset(t,0,sizeof(t));ll sum=0;
		for(int j=L[i];j<=R[i];j++){
			pre[j]=(sum+=j-L[i]-ask(a[j]));
			add(a[j],1);
		} memset(t,0,sizeof(t));sum=0;
		for(int j=R[i];j>=L[i];j--){
			suf[j]=(sum+=ask(a[j]));
			add(a[j],1);
		}
	}
	for(int i=1;i<=blk_cnt;i++){
		int mn=n+1,s=0;
		for(int j=L[i];j<=R[i];j++) c[a[j]]++,chkmin(mn,a[j]);
		for(int j=mn;j<=n;j++) s+=c[j],buc[j]+=s;
		for(int j=L[i];j<=R[i];j++) c[a[j]]--;
		for(int j=1;j<=n;j++) lt[i][j]=buc[a[j]-1];
	}
	for(int i=1;i<=blk_cnt;i++) for(int j=1;j<i;j++)
		for(int k=L[i];k<=R[i];k++) bl[i][j]+=R[j]-lt[j][k];
	ll pre=0;
	while(qu--){
		ll l,r;read(l);read(r);l^=pre;r^=pre;
		print(pre=query(l,r),'\n');
	} print_final();
	return 0;
}

标签:Ynoi2019,blk,P5046,sum,sqrt,int,MAXN,BLK,逆序
来源: https://www.cnblogs.com/ET2006/p/luogu-P5046.html