2022.7.11 模拟赛

目录

• 2022 7.11 模拟赛
  • • 比赛 link
    • $GCD$
    • 包含
    • 前缀
    • 移动

2022 7.11 模拟赛#

比赛 link#

$GCD$#

题意：

定义 $f(x)=\gcd(\text{除1以外所有因子})$

给定 $a,b$，求 $\sum_{i=a}^b f(i)$

$1<a< b\le 10^7$

思路：

签到题

容易发现，当 $x$ 为合数且 $x$ 有两个不同质因子时，$f(x)=1$

其余时候 $f(x)=a$，$a\in prime$ 且 $a|x$

线性筛质数并更新就行了

时间复杂度 $O(a+b)$

code：

#include<bits/stdc++.h>
using namespace std;

const int N=1e7+1;

#define ll long long
#define int long long

inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while(isdigit(ch)){
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*f;
}

int cnt;
int p[7000000];
bool vis[N];
int can[N];

inline void prework(){
	can[1]=1;
	for(int i=2;i<N;++i){
		can[i]=1;
		if(!vis[i])
			p[++cnt]=i,can[i]=i;
		for(int j=1;j<=cnt&&i*p[j]<N;++j){
			vis[i*p[j]]=1;
			if(i%p[j]==0) break;
		}
	}
	for(int i=1;i<=cnt;++i)
		for(ll j=p[i];j<N;j*=p[i]){
			can[j]=p[i];
		}
}

inline int solve(int n){
	ll res=0;
	for(int i=1;i<=n;++i)
		res+=1ll*can[i];
	return res;
}

signed main(){
	prework();
	int a=read(),b=read();
	printf("%lld\n",solve(b)-solve(a-1));
}

注意 $i\cdot p[j]$ 的时候会爆 $int$

不开 $long$ $long$ 的下场：$100pts\rightarrow 20pts$ ${\color{grey}wdnmd}$

${\huge一定要开 long long 啊！}$

包含#

题意：

定义 $A$ 包含 $B$：$A\&B=B$

给定一个有 $n$ 个正整数 $a_{1\sim n}$ 的集合 $S$ 和 $m$ 次询问

每次询问给你一个数 $x$，请回答 $Q$ 中是否存在一个数包含 $x$

$1\le n,m\le 10^5,1\le x\le a_i\le10^6$

思路：

第一想法：爆搜

暴力枚举并更新 $a_{1\sim n}$ 可以包含的数，这样可以做到每次查询 $O(1)$

时间复杂度 $O(2^{20}\cdot n)$

很显然不够优，考虑记忆化

若是一个数 $x\in a_i$ 且 $x$ 所有包含的数已经更新过了，那么当搜 $a_i$ 搜到 $x$ 时就可以不用更新了

这样每个数最多只会被更新一次，保证了复杂度

时间复杂度 $O(n\log a_i+m)$

code：

#include<bits/stdc++.h>
using namespace std;

const int N=1e6+1;

inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while(isdigit(ch)){
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*f;
}

int n,m,f[N];

inline void dfs(int x,int now,int bit){
	if(f[now]) return;
	if(bit>=20){
		f[now]=1;
		return;
	}
	if((x>>bit)&1) dfs(x,now-(1<<bit),bit+1);
	dfs(x,now,bit+1);
}

signed main(){
	n=read(),m=read();
	for(int i=1;i<=n;++i){
		int x=read();
		dfs(x,x,0);
	}
	for(int i=1;i<=m;++i){
		int x=read();
		puts(f[x]==1?"yes":"no");
	}
}

考场上第一想法是 $trie$，但最后写的还是爆搜

但为什么比别人的爆搜跑的都慢啊 $QAQ$

最后只有 $50pts$

前缀#

题意：

牛牛有一个 $𝑠$ 串，$𝑠$串仅由 $26$ 个小写英文字母组成，他现在将 $𝑠$ 串进行了无限次的复制扩展成了一个无线循环串。

例如一开始 $𝑠 =$ "$𝑎𝑏𝑐$"，那么牛牛就会将其变为"$𝑎𝑏𝑐𝑎𝑏𝑐𝑎𝑏𝑐\cdots$ "

若某个字符串保留其原本字符出现的顺序，并且按照顺序取出若干个字符。可以不连续，可以不取。

我们称取出的这若干个字符连成的字符串为一个子序列。

若连续取出某个字符串的前 $𝑘$ 个字符，组成一个子串，我们称该字符串为原串长度为 $𝑘$ 的前缀。

对于一个字符串$𝑡$，若某字符串的至少一个子序列为 $𝑡$ 。则称它是一个“含 $𝑡$ 序列串”

牛牛想要知道对于给定的 $𝑡$，他想要知道 $𝑠$ 的一个最短前缀满足它是一个“含 $𝑡$ 序列串”，它的长度有多长？

由于答案可能非常大，所以他要求你输出答案对 $998244353$ 取余数后的结果即可。

特别的，如果 $𝑆$ 串不存在任何一个前缀满足他是一个“含 $𝑡$ 序列串”，请输出" $-1$"表示无解。

$𝑡$ 串中除了 $26$ 个英文字母以外还会出现"$*$"，表示一个通配符。统配符可以视为任意字母。

例如循环 $𝑠$ 串为"$𝑎𝑏𝑐𝑎𝑏𝑐𝑎𝑏𝑐𝑎𝑏𝑐. . . $"，𝑡串为"$𝑎 ∗ 𝑐𝑎$$"时，最短含𝑡序列前缀长 $4$。而当𝑡串为"$𝑎 ∗∗ 𝑐𝑎$"时，最短含 $𝑡$ 序列前缀长 $7$。

除此之外，牛牛输入的𝑡串还可能非常非常长，最长可以达到 $10^{10^5}$这么长。

思路：

究极大模拟

还要高精

是真滴毒瘤啊 $qwq$

code：

#include <bits/stdc++.h>
using namespace std;

#define int long long

const int mod=998244353;
const int N=1e5+5;

char S[N],t[N];
vector <int> K[27];
int T,id[N][2],c[N],len,ans;

inline void add(int &x,int y){
	x+=y;
	if(x>=mod) x-=mod;
}

inline int work(int l,int r,int C1,int C2){
    int number=0,s=0,tot=0,pos;
    for(int i=l;i<=r;++i) 
    	c[i-l+1]=t[i]-'0';
    for(pos=r-l+1;!c[pos];--pos);
    --c[pos];
    for(int i=pos+1;i<=r-l+1;++i)
    	c[i]=9;
    for(int i=l;i<=r;++i,number=s%C1)
    	s=number*10+c[i-l+1],c[++tot]=s/C1;
    s=0;
    for(int i=tot;i;--i){
    	s+=c[i]*C2;
    	c[i]=s%10;
    	s/=10;
    }
    for(int i=1;i<=tot;++i)
    	s=(s*10+c[i])%mod;
    add(ans,s);
    return number;
}

signed main(){
    scanf("%s",S);
    len=strlen(S);
    for(int i=0;i<len;++i) 
    	K[S[i]^96].push_back(i),id[i][0]=K[S[i]^96].size()-1;
    for(int i=0;i<len;++i) 
    	K[0].push_back(i),id[i][1]=i;
    cin>>T;
    for(;T;--T){
        scanf("%s",t);
        int lent=strlen(t);
        ans=0;
        int l=0,r=0,beg=len-1,flag=1;
        for(int f=0,now;l<lent;l=++r){
            if(t[l]=='*') t[l]=96,f=1;
            else f=0;
            int G=t[l]^96,sz=K[G].size(),nxt;
            if(!sz){
            	flag=0;
            	break;
            }
            if(l+1<lent&&isdigit(t[l+1]))
                while(r+1<lent&&isdigit(t[r+1]))
                	++r;
            if(K[G][sz-1]<=beg) 
            	nxt=K[G][0];
            else 
            	nxt=*upper_bound(K[G].begin(),K[G].end(),beg);
            if(beg<nxt) add(ans,nxt-beg);
            else add(ans,len-beg+nxt);
            beg=nxt;
            if(l<r){
        		if(now=work(l+1,r,sz,len)){
            		nxt=K[G][(id[beg][f]+now)%sz];
                    if(beg<nxt) add(ans,nxt-beg);
                    else add(ans,len-beg+nxt);
                    beg=nxt;
                }
            }
        }
        if(!flag) puts("-1");
        else printf("%d\n",ans);
    }
    return 0;
} 

考场上没看，直接跳了

你没看到我题面都是直接复制的吗

移动#

题意：

共有 $1\sim n$ 这 $n$ 个闸门，它们分别处在 $1\sim n$ 这 $n$ 个点上

你要从 $0$ 号点走到 $n+1$ 号点

告诉你 $m$ 次闸门 $x$ 的开关操作，$x$ 会从 $l_i$ 开始一直关到 $r_i$

若是在某一时刻 $i$ 号闸门是关着的，那么你不能停在这

每次移到左边或右边的点，且需要花费 $1$ 单位的时间

求最小需要花费多少时间

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

思路：

考场上乱搞了一个贪心，跑过了所有手造数据，因此直接交了

$70pts$，code：

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+5;

#define pb push_back

inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while(isdigit(ch)){
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*f;
}

int n,m,cnt;
int q[N];
bool vis[N];

struct node{
	int s,e;
	int id;
	inline bool operator < (const node x) const{
		return id+s==x.id+x.s?(id==x.id?e>x.e:id>x.id):id+x.s>x.id+s;
	}
};

vector <node> p[N];

signed main(){
	n=read(),m=read();
	for(int i=1;i<=m;++i){
		int x=read(),s=read(),e=read();
		p[x].pb({s,e,x});
		vis[x]=1;
	}
	for(int i=1;i<=n;++i)
		if(!vis[i]) q[++cnt]=i;
	q[++cnt]=n+1;
	for(int i=1;i<=cnt;++i){
		int a=q[i];
		for(int j=q[i-1]+1;j<a;++j){
			for(auto x:p[j]) p[a].pb(x);
			p[j].clear();
		}
		sort(p[a].begin(),p[a].end());
	}
	int nowtime=0,nowpos=0;
	for(int i=1;i<=cnt;++i){
		int a=q[i];
		for(auto x:p[a]){
			int s=x.s,e=x.e,id=x.id;
			if(id-nowpos>=s-nowtime)
				if(e>nowtime) nowtime=e,nowpos=id-1;
				else if(e==nowtime) nowpos=min(nowpos,id-1);
			else{
				nowtime+=q[i]-nowpos;
				nowpos=q[i];
				break;
			}
		}
		if(nowpos!=q[i]){
			nowtime+=q[i]-nowpos;
			nowpos=q[i];
		}
	}
	cout<<nowtime<<endl;
}

为什么这题分最高啊喂

正解是 $dp$，但是用最短路维护

因为考虑一个点可以移动到左右两个点，所以整一个 $priority\_queue$ 记录最短时间并更新左右两个点

更新时需满足两个闸门同时开启

时间复杂度 $O(n\log m)$

code：

#include<bits/stdc++.h>
using namespace std;

const int N=2e5+5;
const int inf=2e9;

#define pb push_back

inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while(isdigit(ch)){
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*f;
}

struct pii{
	int a,b;
	inline bool operator < (const pii A) const{
		return a==A.a?b<A.b:a<A.a;
	}
};

vector <pii> v[N],cur;
int id[N],f[N];
int n,m;

struct pt{
	int id,x,t;
};

inline bool operator > (pt a,pt b){
	return a.t>b.t;
}

priority_queue <pt,vector <pt>,greater <pt> > p;

inline void cal(pt a,int x){
	int r=v[a.x][a.id-id[a.x]].b;
	int i=lower_bound(v[x].begin(),v[x].end(),(pii){a.t+1,0})-v[x].begin()-1;
	if(v[x][i].b>=a.t+1&&f[id[x]+i]>a.t+1){
		f[id[x]+i]=a.t+1;
		p.push({id[x]+i,x,a.t+1});
	}
	++i;
	for(;i<(int)v[x].size()&&v[x][i].a<=r+1;++i){
		if(f[id[x]+i]>v[x][i].a){
			f[id[x]+i]=v[x][i].a;
			p.push({id[x]+i,x,v[x][i].a});
		}
	}
}

signed main(){
	n=read(),m=read();
	for(int i=1;i<=m;++i){
		int x=read(),y=read(),z=read();
		v[x].pb({y,z});
	}
	v[0].pb({0,inf});
	v[n+1].pb({0,inf});
	id[1]=1;
	for(int i=1;i<=n;++i){
		sort(v[i].begin(),v[i].end());
		cur.clear();
		int mx=-1;
		for(auto x:v[i]){
			if(x.a>mx+1) cur.pb({mx+1,x.a-1});
			mx=max(mx,x.b);
		}
		cur.pb({mx+1,inf});
		v[i]=cur;
		id[i+1]=id[i]+v[i].size();
	}
	memset(f,0x3f,sizeof(f));
	f[0]=0;
	p.push({0,0,0});
	while(!p.empty()){
		auto x=p.top();
		p.pop();
		if(x.t>f[x.id]) continue;
		if(x.x>0) cal(x,x.x-1);
		if(x.x<=n) cal(x,x.x+1);
	}
	cout<<f[id[n+1]]<<endl;
}