Ynoi2019模拟赛题解

$Ynoi2019$模拟赛题解

前言：第一次做$Ynoi$还是有被离谱到的,我从来没有做到过这么卡常的题目，我到现在$T1$都还是$70$分，$lxl$毒瘤名不虚传啊。但是不得不说，$Ynoi$的题目质量很高，对提高$DS$水平还是很有帮助的。

$T1:$ $Yuno$ $loves$ $sqrt$ $technology$ $I$

给你一个长为$n$的排列,$m$次询问，每次查询一个区间的逆序对数，强制在线。

$1\le n,m\le 10^5。$

这题非常卡常，这里我就简述做法。首先考虑序列分块，对于询问$[l,r]$，计$l$所在块为$s$，$r$所在块为$t$，则可以预处理出$[s+1,t-1]$这些块的逆序对，具体方法就是，先对每个块块内排序，枚举两个块并通过归并排序$O(\sqrt{n})$计算这两个块互相的贡献，复杂度$O(n\sqrt{n})$，记为$f(a,b)$，再用树状数组$O(n\log n)$求出每个块内的逆序对数，即为$f(a,a)$。然后做一个类似二维前缀和：$s(a,b)=f(a,b)+s(a,b-1)+s(a+1,b)-s(a+1,b-1)$，$s(a,b)$就是块$a$到块$b$的逆序对数。然后再算散块和散块之间的贡献，之间块内已经排过序了，之间把$[l,ed(s)]$和$[st(t),r]$从它们的块里抽出来，直接归并计算贡献，复杂度$O(\sqrt{n})$。接下来算散块和$[s+1,t-1]$互相的贡献，可以对于每个块$i$预处理$[1,ed(i)]$比每个数小的数个数，这个直接用一个空间$O(n\sqrt{n})$的前缀和计算即可，然后$O(1)$计算对于左右散块每个数，块$[s+1,t-1]$对其的贡献。最后算$[l,ed(s)]$和$[st(t),r]$块内逆序对数，要处理两个数组$pref[i]$表示$i$所在块的开头到$i$逆序对数，$suf[i]$表示$i$到$i$所在块的结尾逆序对数。然后记得特判$l$，$r$同块的情况，这时逆序对数即为$pref[r]-pref[l-1]$再减去$[st(s),l-1]$的逆序对数，后者之间归并排序求即可。复杂度$O(n\sqrt{n})$。

代码放一下，但卡不过去，常数有点大。

#include<iostream>
#include<algorithm>
#include<string.h>
#define gc getchar
#define pc putchar
#define pb push_back
#define f first
#define s second
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
template<class Typ> Typ &Rd(Typ &x){
	char ch=gc(),sgn=0; x=0;
	for(;ch<'0'||ch>'9';ch=gc()) sgn|=ch=='-';
	for(;ch>='0'&&ch<='9';ch=gc()) x=x*10+(ch^48);
	return sgn&&(x=-x),x;
}
template<class Typ> void Wt(Typ x){
	if(x<0) pc('-'),x=-x;
	if(x>9) Wt(x/10);
	pc(x%10^48);
}
typedef long long LL;
const int N=1e5+5;
const int S=300;
LL Ans[400][400],ans;
LL Tr[N],cnt[400][N];
LL prf[N],suf[N];
int n,Q,A[N],in[N];
int st[400],ed[400]; pii B[N];
int Ma[400],Mb[400],la,lb;
void Add(int ps,int vl){
    for(;ps<=n;ps+=ps&-ps)
        Tr[ps]+=vl;
}
LL Ask(int ps){
    LL res=0;
    for(;ps;ps-=ps&-ps)
        res+=Tr[ps];
    return res;
}
int main(){
    Rd(n),Rd(Q);
    for(int i=1;i<=n;i++) B[i]={Rd(A[i]),i};
    for(int i=1;i<=n;i++) in[i]=(i-1)/S+1;
    for(int i=1;i<=in[n];i++)
        st[i]=(i-1)*S+1,ed[i]=min(i*S,n);
    for(int i=1;i<=in[n];i++){
        sort(B+st[i],B+ed[i]+1);
        memset(Tr,0,sizeof(Tr)),Add(A[st[i]],1);
        for(int j=st[i]+1;j<=ed[i];j++)
            prf[j]=prf[j-1]+Ask(n)-Ask(A[j]),Add(A[j],1);
        Ans[i][i]=prf[ed[i]];
        memset(Tr,0,sizeof(Tr)),Add(A[ed[i]],1);
        for(int j=ed[i]-1;j>=st[i];j--)
            suf[j]=suf[j+1]+Ask(A[j]),Add(A[j],1);
    }
    for(int i=1;i<=in[n];i++)
        for(int j=i+1;j<=in[n];j++)
            for(int p1=st[i],p2=st[j];p1<=ed[i];p1++){
                while(p2<=ed[j]&&B[p2].f<=B[p1].f) p2++;
                Ans[i][j]+=(LL)(p2-st[j]);
            }
    for(int len=1;len<=in[n];len++)
        for(int i=1;i+len-1<=in[n];i++){
            int j=i+len-1;
            Ans[i][j]+=Ans[i+1][j]+Ans[i][j-1];
            Ans[i][j]-=Ans[i+1][j-1];
        }
    for(int i=1;i<=in[n];i++){
        for(int j=1;j<=n;j++) cnt[i][j]=cnt[i-1][j];
        for(int j=st[i];j<=ed[i];j++) cnt[i][A[j]]++;
    }
    for(int i=1;i<=in[n];i++)
        for(int j=1;j<=n;j++) cnt[i][j]+=cnt[i][j-1];
    for(int i=1;i<=Q;i++){
        LL L,R; Rd(L)^=ans,Rd(R)^=ans;
        if(in[L]==in[R]){
            ans=prf[R]-(L!=st[in[L]])*prf[L-1],la=lb=0;
            for(int j=st[in[L]];j<=ed[in[L]];j++)
                if(B[j].s<L) Ma[++la]=B[j].f;
                else if(B[j].s<=R) Mb[++lb]=B[j].f;
            for(int p1=1,p2=1;p1<=la;p1++){
                while(p2<=lb&&Mb[p2]<=Ma[p1]) p2++;
                ans-=(LL)(p2-1);
            }
            Wt(ans),pc('\n');
        }else{
            ans=Ans[in[L]+1][in[R]-1],la=lb=0;
            ans+=suf[L]+prf[R];
            for(int j=L;j<=ed[in[L]];j++)
                ans+=cnt[in[R]-1][A[j]]-cnt[in[L]][A[j]];
            for(int j=st[in[R]];j<=R;j++){
                ans+=(LL)(ed[in[R]-1]-st[in[L]+1]+1);
                ans-=cnt[in[R]-1][A[j]]-cnt[in[L]][A[j]];
            }
            for(int j=st[in[L]];j<=ed[in[L]];j++)
                if(B[j].s>=L) Ma[++la]=B[j].f;
            for(int j=st[in[R]];j<=ed[in[R]];j++)
                if(B[j].s<=R) Mb[++lb]=B[j].f;
            for(int p1=1,p2=1;p1<=la;p1++){
                while(p2<=lb&&Mb[p2]<=Ma[p1]) p2++;
                ans+=(LL)(p2-1);
            }
            Wt(ans),pc('\n');
        }
    }
    return 0;
}

$T2:$ $Yuno$ $loves$ $sqrt$ $technology$ $II$

给你一个长为$n$的序列$a$，$m$次询问，每次查询一个区间的逆序对数。

$1\le n,m\le 10^5，0\le a_i\le 10^9。$

注意本题时限$250ms$，$T1$时限$750ms$都极为卡常，显然$T1$做法常数太大，不能通过此题。注意到可以离线，我们需要常数更小的离线做法。注意到莫队可以做到$O(n\sqrt{m}\log n)$，但无法通过此题。这时候就要引入黑科技$\text{莫队二次离线}$。注意到莫队每次向右移动，增加的贡献是$[l,r]$中比$r$大的数，计$f(a,b)$表示$[1,b]$里比$a$位置的数大的数个数，则贡献可表示为$f(r,r)-f(r,l-1)$，对于每次右端点移动，$f(r,r)$可以$O(n\log n)$预处理，下面考虑如何求$f(r,l-1)$。注意到可以将所以$f(r,l-1)$再次离线，按第二维排序，并向数据结构中进行$n$次插入，$n\sqrt{m}$次查询求得所有$f(r,l-1)$。可以使用值域分块做到插入$O(\sqrt{n})$，查询$O(1)$，所以总复杂度即为$O(n\sqrt{n}+n\sqrt{m})$。对左端点移动的处理同右端点。下面还有一个问题：空间复杂度$O(n\sqrt{m})$，因为要把所有询问离线，无法满足空间限制。注意到莫队移动左右端点时会先移动完一个再移动另一个，那我们只要记录移动开始到移动结束的位置即可，询问时直接从开始位置循环到结束位置，空间复杂度$O(n+m)$。

代码：

#include<iostream>
#include<vector>
#include<string.h>
#include<algorithm>
#define pb push_back
#define f first
#define s second
using namespace std;
typedef long long ll;
typedef double lf;
typedef pair<int,int> pii;
#define gc getchar 
#define pc putchar
template<class Typ> Typ &Rd(Typ &x){
	char ch=gc(),sgn=0; x=0;
	for(;ch<'0'||ch>'9';ch=gc()) sgn|=ch=='-';
	for(;ch>='0'&&ch<='9';ch=gc()) x=x*10+(ch^48);
	return sgn&&(x=-x),x;
}
template<class Typ> void Wt(Typ x){
	if(x<0) pc('-'),x=-x;
	if(x>9) Wt(x/10);
	pc(x%10^48);
}
const int N=1e5+5;
const int M=340;
int n,m,A[N],Num[N],len,Tr[N]; 
struct Qry{int l,r,id;}Qr[N];
struct Opt{int st,ed,sgn,id;};
vector<Opt> Lc[N],Rc[N];
ll s1[N],s2[N],ans[N];
int Tg[M],sum[N],st[M],ed[M];
int in(int x){return (x-1)/M+1;}
bool cmp(Qry a,Qry b){return in(a.l)==in(b.l)?a.r<b.r:in(a.l)<in(b.l);}
void Add(int ps){for(;ps<=len;ps+=ps&-ps) Tr[ps]++;}
int Ask(int ps){int sm=0; for(;ps;ps-=ps&-ps) sm+=Tr[ps]; return sm;}
int main(){
    Rd(n),Rd(m);
    for(int i=1;i<=n;i++) Num[++len]=Rd(A[i]);
    sort(Num+1,Num+len+1),len=unique(Num+1,Num+len+1)-Num-1;
    for(int i=1;i<=n;i++) A[i]=lower_bound(Num+1,Num+len+1,A[i])-Num;
    for(int i=1;i<=n;i++) s1[i]=s1[i-1]+Ask(len)-Ask(A[i]),Add(A[i]);
    memset(Tr,0,sizeof(Tr));
    for(int i=n;i>=1;i--) s2[i]=s2[i+1]+Ask(A[i]-1),Add(A[i]);
    for(int i=1;i<=m;i++) Rd(Qr[i].l),Rd(Qr[i].r),Qr[i].id=i;
    sort(Qr+1,Qr+m+1,cmp);
    for(int i=1,l=1,r=0;i<=m;i++){
        if(r<Qr[i].r) ans[Qr[i].id]+=s1[Qr[i].r]-s1[r],
            Rc[l-1].pb({r+1,Qr[i].r,-1,Qr[i].id}),r=Qr[i].r;
        if(r>Qr[i].r) ans[Qr[i].id]-=s1[r]-s1[Qr[i].r],
            Rc[l-1].pb({Qr[i].r+1,r,1,Qr[i].id}),r=Qr[i].r;
        if(Qr[i].l<l) ans[Qr[i].id]+=s2[Qr[i].l]-s2[l],
            Lc[r+1].pb({l-1,Qr[i].l,-1,Qr[i].id}),l=Qr[i].l;
        if(Qr[i].l>l) ans[Qr[i].id]-=s2[l]-s2[Qr[i].l],
            Lc[r+1].pb({Qr[i].l-1,l,1,Qr[i].id}),l=Qr[i].l;
    }
    for(int i=1;i<=in(len);i++)
        st[i]=(i-1)*M+1,ed[i]=min(i*M,len);
    for(int i=1;i<=n;i++){
        for(int j=A[i]-1;j>=st[in(A[i])];j--) sum[j]++;
        for(int j=in(A[i])-1;j>=1;j--) Tg[j]++;
        for(auto j:Rc[i]) for(int k=j.st;k<=j.ed;k++)
            ans[j.id]+=j.sgn*(sum[A[k]]+Tg[in(A[k])]);
    }
    memset(sum,0,sizeof(sum)),memset(Tg,0,sizeof(Tg));
    for(int i=n;i>=1;i--){
        for(int j=A[i]+1;j<=ed[in(A[i])];j++) sum[j]++;
        for(int j=in(A[i])+1;j<=in(len);j++) Tg[j]++;
        for(auto j:Lc[i]) for(int k=j.st;k>=j.ed;k--)
            ans[j.id]+=j.sgn*(sum[A[k]]+Tg[in(A[k])]);
    }
    for(int i=1;i<=m;i++) ans[Qr[i].id]+=ans[Qr[i-1].id];
    for(int i=1;i<=m;i++) Wt(ans[i]),pc('\n');
    return 0;
}

$T3:$ $Yuno$ $loves$ $sqrt$ $technology$ $III$

给你一个长为$n$的序列$a$，$m$次询问，每次查询一个区间的众数的出现次数，强制在线。

$1\le n,m\le 5\times 10^5，0\le a_i\le 10^9。$

考虑序列分块。对于询问$[l,r]$，记$l$所在块为$s$，$r$所在块为$t$，则可以先预处理出$[s+1,t-1]$的区间众数。具体求法就是从一个块$i$开始往后扫描依次加入每个数，更新每个数出现次数时和答案取$max$即可。然后区间众数有一个性质：要么是$[s+1,t-1]$的答案，要么在散块中出现。这也很好证，如果一个数不是$[s+1,t-1]$的众数，而且不在散块中出现，显然出现次数比$[s+1,t-1]$的众数少。下面只要求出散块里每个数在$[s+1,t-1]$出现次数，和答案取$max$就好了，注意到一共有$\sqrt{n}$级别的数，要求$O(1)$查询在$[s+1,t-1]$出现次数。显然前缀和可以做到，但是空间不够。于是有一个我认为很巧妙的方法可以实现：对每个数开一个$vector$，把它出现的所有位置插入这个$vector$，然后记录每个位置在$vector$里的下标，记为$ps[i]$。查询时一开始令$ans$等于$[s+1,t-1]$的众数出现次数，然后对应左边散块的每个位置$i$，只要$ps[i]+ans$也在$[l,r]$中，就令$ans+1$。对应右边散块的每个位置$i$，只要$ps[i]-ans$也在$[l,r]$中，就令$ans+1$。然后就做完了，时间复杂度$O(n\sqrt{n})$，空间复杂度$O(n)$，常数很小。

#include<iostream>
#include<vector>
#include<algorithm>
#include<string.h>
#define gc getchar
#define pc putchar
#define pb push_back
#define f first
#define s second
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
template<class Typ> Typ &Rd(Typ &x){
	char ch=gc(),sgn=0; x=0;
	for(;ch<'0'||ch>'9';ch=gc()) sgn|=ch=='-';
	for(;ch>='0'&&ch<='9';ch=gc()) x=x*10+(ch^48);
	return sgn&&(x=-x),x;
}
template<class Typ> void Wt(Typ x){
	if(x<0) pc('-'),x=-x;
	if(x>9) Wt(x/10);
	pc(x%10^48);
}
const int N=5e5+5;
const int Len=750;
int n,m,A[N],Ans[Len][Len],ps[N],ans;
int cnt[N],st[Len],ed[Len],in[N];
int Num[N],len; vector<int> Id[N];
int main(){
	Rd(n),Rd(m);
	for(int i=1;i<=n;i++) Num[++len]=Rd(A[i]);
	sort(Num+1,Num+len+1);
	len=unique(Num+1,Num+len+1)-Num-1;
	for(int i=1;i<=n;i++)
		A[i]=lower_bound(Num+1,Num+len+1,A[i])-Num;
	for(int i=1;i<=n;i++)
		Id[A[i]].pb(i),ps[i]=Id[A[i]].size()-1;
	for(int i=1;i<=n;i++) in[i]=(i-1)/Len+1;
	for(int i=1;i<=in[n];i++)
		st[i]=(i-1)*Len+1,ed[i]=min(i*Len,n);
	for(int i=1;i<=in[n];i++){
		for(int j=i;j<=in[n];j++){
			Ans[i][j]=Ans[i][j-1];
			for(int k=st[j];k<=ed[j];k++)
				Ans[i][j]=max(Ans[i][j],++cnt[A[k]]);
		}
		memset(cnt,0,sizeof(cnt));
	}
	for(int i=1;i<=m;i++){
		int L,R; Rd(L)^=ans,Rd(R)^=ans;
		if(in[R]-in[L]<=1){
			ans=0;
			for(int j=L;j<=R;j++)
				ans=max(ans,++cnt[A[j]]);
			for(int j=L;j<=R;j++) cnt[A[j]]--;
			Wt(ans),pc('\n');
		}else{
			ans=Ans[in[L]+1][in[R]-1];
			for(int i=L;i<=ed[in[L]];i++)
				while(ps[i]+ans<Id[A[i]].size()
					&&Id[A[i]][ps[i]+ans]<=R) ans++;
			for(int i=st[in[R]];i<=R;i++)
				while(ps[i]-ans>=0&&Id[A[i]][ps[i]-ans]>=L) ans++;
			Wt(ans),pc('\n');
		}
	}
    return 0;
}