Ynoi2019模拟赛题解

关注

原创 2023-02-14 20:04:11 372 阅读 AI 写同款· GEO 优化 ›

自研SSD固件：从零实现固态硬盘底层存储控制系统本文探讨了自主开发SSD固件的可行性及实现方案。分析表明，虽然NAND Flash控制协议标准化且存在开源参考实现，但开发仍面临FTL设计复杂度高、性能调优等挑战。推荐采用FPGA平台（如Xilinx Zynq-7000）搭配SLC NAND Flash的方案，预计开发周期9-12个月。系统采用分层架构设计，包含主机接口层、FTL层和闪存接口层，核心模块需实现NAND Flash底层驱动、地址映射管理和垃圾回收等功能。文中提供了关键数据结构和基础驱动代码示例，包括页读写、块擦除等操作。该方案着重解决NAND 阅读详情

$Yn o i 2019$ 模拟赛题解

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

$T 1 :$ $Y u n o$ $l o v es$ $s q r t$ $t ec hn o l o g y$ $I$

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

$1≤n,m≤105。1\leq n,m \leq 10^5。$

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

$T 2 :$ $Y u n o$ $l o v es$ $s q r t$ $t ec hn o l o g y$ $II$

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

$1≤n,m≤105，0≤ai≤109。1\leq n,m\leq 10^5，0\leq a_i\leq 10^9。$

注意本题时限 $250 m s$ ， $T 1$ 时限 $750 m s$ 都极为卡常，显然 $T 1$ 做法常数太大，不能通过此题。注意到可以离线，我们需要常数更小的离线做法。注意到莫队可以做到 $O(nmlog⁡n)O(n\sqrt m\log{n})$ ，但无法通过此题。这时候就要引入黑科技 $莫队二次离线\textbf{莫队二次离线}$ 。注意到莫队每次向右移动，增加的贡献是 $[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$ 次插入， $nmn\sqrt{m}$ 次查询求得所有 $f (r, l - 1)$ 。可以使用值域分块做到插入 $O(n)O(\sqrt{n})$ ，查询 $O (1)$ ，所以总复杂度即为 $O(nn+nm)O(n\sqrt{n}+n\sqrt{m})$ 。对左端点移动的处理同右端点。下面还有一个问题：空间复杂度 $O(nm)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;
}

$T 3 :$ $Y u n o$ $l o v es$ $s q r t$ $t ec hn o l o g y$ $III$

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

$1≤n,m≤5×105，0≤ai≤109。1\leq n,m\leq 5\times 10^5，0\leq a_i\leq 10^9。$

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