【蓝桥杯】第十三届——模拟赛

最新推荐文章于 2022-04-10 11:53:59 发布

GoesM

最新推荐文章于 2022-04-10 11:53:59 发布

阅读量2k

点赞数 2

分类专栏： C++ 蓝桥杯文章标签：蓝桥杯

本文链接：https://blog.csdn.net/l961983207/article/details/123853527

版权

C++ 蓝桥杯专栏收录该内容

5 篇文章 0 订阅

订阅专栏

好假的模拟题，大概是入门和普及- 的题

第一题：

问题描述
以下是一个 25 行 25 列的字母矩阵，全部由字母 A 和 B 组成。
AAAAAAABABBAABABABAAAAAAA
ABBBBBABBAABBBBBABABBBBBA
ABAAABABBBABAABBBBABAAABA
ABAAABABBBBBAABAABABAAABA
ABAAABABBABABBABABABAAABA
ABBBBBABBBABAABBBBABBBBBA
AAAAAAABABABABABABAAAAAAA
BBBBBBBBABAABABBBBBBBBBBB
AABAABABBAAABBAAABABBBBBA
ABBABABBBABBAAAABBBBAAAAB
BBBBAAABABAABABAABBBAABBA
BBAABABABAAAABBBAABBAAAAA
ABABBBABAABAABABABABBBBBA
AAAABBBBBABBBBAAABBBABBAB
AABAABAAABAAABAABABABAAAA
ABBBBBBBBABABBBBABAABBABA
ABBBAAABAAABBBAAAAAAABAAB
BBBBBBBBABBAAABAABBBABBAB
AAAAAAABBAAABBBBABABAABBA
ABBBBBABBAABABAAABBBABBAA
ABAAABABABBBAAAAAAAAAABAA
ABAAABABABABBBABBAABBABAA
ABAAABABBABBABABAABAABAAA
ABBBBBABABBBBBABBAAAABAAA
AAAAAAABAABBBAABABABBABBA
请问在这个矩阵中有多少个字母 A？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整
数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
char s[10000];int ans;
int main(){
	while(1){
		cin>>s;
		for(int i=0;i<strlen(s);i++)
		if(s[i]=='A') ans++;
		if(s[0]=='*') break;
	}
	cout<<ans<<endl;
}//ans: 318

第二题：

问题描述
如果一个整数的某个数位包含 2 ，则称这个数为一个“最 2 数字”。例如：
102、2021 都是最 2 数字。
请问在 1（含）到 2021（含）中，有多少个最 2 数字。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整
数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int ans;
int main(){
	for(int i=1;i<=2021;i++){
		if(i%10==2) ans++;
		else if((i/10)%10==2) ans++;
		else if((i/100)%10==2) ans++;
		else if((i/1000)%10==2) ans++;
	}
	cout<<ans<<endl;
}//ans: 564

前两道是入门题，解释略

第三题：

问题描述
有一个整数 A=2021，每一次，可以将这个数加 1 、减 1 或除以 2，其中除以
2 必须在数是偶数的时候才允许。
例如，2021 经过一次操作可以变成 2020、2022。
再如，2022 经过一次操作可以变成 2021、2023 或 1011。
请问，2021 最少经过多少次操作可以变成 1。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整
数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

思路：递推 / dp / bfs / 最短路

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
const int N=1e6+5;int dp[N];queue<int>q;
int main(){
	int n=2021;	q.push(n);
	while(!dp[1]){
		int pos=q.front();q.pop();
		if(!dp[pos-1]){
			dp[pos-1]=dp[pos]+1;
			q.push(pos-1);
		}
		if(!dp[pos+1]){
			dp[pos+1]=dp[pos]+1;
			q.push(pos+1);
		}
		if(pos%2==0&&dp[pos/2]==0){
			dp[pos/2]=dp[pos]+1;
			q.push(pos/2);
		}
	}cout<<dp[1]<<endl;
}//14

第四题：

问题描述
对于一个 n 行 m 列的表格，我们可以使用螺旋的方式给表格依次填上正整
数，我们称填好的表格为一个螺旋矩阵。
例如，一个 4 行 5 列的螺旋矩阵如下：
1 2 3 4 5
14 15 16 17 6
13 20 19 18 7
12 11 10 9 8
请问，一个 30 行 30 列的螺旋矩阵，第 20 行第 20 列的值是多少？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整
数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

思路：模拟，撞墙拐弯型；
当然这填空题excel用的好也行

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define map m
int m[40][40];
int main(){
	int n=30,num=1;
	int dir=0,x=1,y=1;
	memset(m,0x3f,sizeof(m));
	for(int i=1;i<=n;i++)
	for(int j=1;j<=n;j++)
		m[i][j]=0;
	while(num<=n*n){
		m[x][y]=num;
		if(dir==0&&!map[x][y+1]){y++;}
		else if(dir==0) {dir++,x++;}
		else if(dir==1&&!map[x+1][y]){x++;	}
		else if(dir==1){dir++;y--;}
		else if(dir==2&&!map[x][y-1]){y--;	}
		else if(dir==2){dir++;x--;	}
		else if(dir==3&&!map[x-1][y]){x--;	}
		else {dir=0,y++;}
		num++;
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++)
			cout<<map[i][j]<<" ";
		cout<<endl;
	}
	cout<<m[20][20]<<endl;
	return 0;
}//819

第五题：

问题描述
一棵二叉树有 2021 个结点。该树满足任意结点的左子树结点个数和右子树的结
点个数之差最多为 1。
定义根结点的深度为 0，子结点的深度比父结点深度多 1。
请问，树中深度最大的结点的深度最大可能是多少？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整
数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

思路：根据二叉树性质，最深深度以上的深度一定是满二叉树 ⇒ 答案=log2(n)，向上取整
易错：根节点深度为0，所以最后要ans = ans - 1 【别问，问就是我没减】

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int main(){
	int n=2021;int depth=0;
	while((1<<depth)<=n)
		depth++;
	cout<<depth-1<<endl;
	cout<<(1<<(depth-1))<<endl;
	int ans=depth;
	cout<<ans-1<<endl;
}//ans：10

第六题：

问题描述
一个和尚要挑水，每次最多能挑 a 千克，水缸最多能装 t 千克，开始时水缸为
空。
请问这个和尚最少要挑多少次可以将水缸装满？
输入格式
输入一行包含两个整数 a, t，用一个空格分隔。
输出格式
输出一行包含一个整数，表示答案。
样例输入
20 2021
样例输出
102
评测用例规模与约定
对于所有评测用例，1 <= a <= 100，1 <= t <= 10000。

思路：除法，向上取整，long long，高精度都不需要

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
inline int read(){
	char ch=getchar();bool f=true;int sum=0;
	while(ch<'0'||ch>'9'){
		if(ch=='-')f=false;ch=getchar();}
	while(ch>='0'&&ch<='9'){
		sum*=10;sum+=ch-'0';ch=getchar();}
	if(f)return sum;else return -sum;
}
int main(){
	int a=read(),t=read(),ans;
	if(t%a) ans=t/a+1;
	else ans=t/a;
	cout<<ans<<endl;
}

第七题：

问题描述
在金融领域，通常将金额的百位和千位之间、十万位和百万位之间增加逗号（千分
位分隔符），以方便阅读。一般从个位开始，每三位之前增加一个逗号。
例如：1234567890.00 通常写成 1,234,567,890.00。
注意小数点后固定保留 2 位。
给定一个包含千分位分隔符的数值，请读入后输出对应的不含千分位的数值，小数
点仍然保留 2 位。
输入格式
输入一行包含一个由千分位分隔符的数值，恰好有 2 位小数。
输出格式
输出不含千分位分隔符的数值，保留 2 位小数。
样例输入
1,234,567,890.00
样例输出
1234567890.00
评测用例规模与约定
对于所有评测用例，给定的数值整数部分不超过 12 位。

思路：字符串读入与挪位处理；

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
char s[100005],ans[100005];
int main(){
	cin>>s;int len=0;
	for(int i=0;i<strlen(s);i++)
	if(isdigit(s[i])||s[i]=='.') ans[++len]=s[i];
	else continue;
	for(int i=1;i<=len;i++)
		cout<<ans[i];
	return 0;	
}

第八题：

问题描述
小蓝有一个插板，形状用一个 n * m 的 01 矩阵表示，0 表示板面，1 表示插孔。
小蓝还有一个插头，形状用一个 r * c 的 01 矩阵表示，0 表示没有伸出的部分，
1 表示伸出的部分。插头伸出的部分必须插在插孔里面。
为了安全，插头插到面板上不能有任何部分超过插板边界（包括没有伸出的部
分）。
插头和插板都不能旋转，也不能翻转。请求出插头插入插板的合理位置。
输入格式
输入的第一行包含两个整数 n, m。
接下来 n 行，每行一个长度为 m 的 01 串，表示插板的形状。
接下来一行包含两个整数 r, c。
接下来 r 行，每行一个长度为 c 的 01 串，表示插头的形状。
输出格式
如果插头没办法安全插入插板中，输出“NO”。否则输出两个数 a, b，表示插头
的第 1 行第 1 列对应插板的第 a 行第 b 列。如果有多种情况满足要求，输出 a
最小的方案，如果 a 最小的方案有多个，输出在 a 最小的前提下 b 最小的方
案。
样例输入
3 4
0110
0000
0000
3 3
000
010
000
样例输出
NO
样例说明
在插头不超出范围的前提下无法插入。
样例输入
4 7
1110100
1101111
0001111
0000011
2 3
111
011
样例输出
2 4
评测用例规模与约定
对于 50% 的评测用例，2 <= n, m, r, c <= 20。
对于所有评测用例，2 <= n, m, r, c <= 100。

思路：看了眼数据范围，暴力循环O(nmrc) 能过

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
inline int read(){
	char ch=getchar();bool f=true;int sum=0;
	while(ch<'0'||ch>'9'){
		if(ch=='-')f=false;ch=getchar();}
	while(ch>='0'&&ch<='9'){
		sum*=10;sum+=ch-'0';ch=getchar();}
	if(f)return sum;else return -sum;
}
char back[200][200],key[200][200];
int n,m,r,c;//O(n^2 * m^2)
int main(){
	n=read(),m=read();
	for(int i=0;i<n;i++)
		cin>>back[i];
	r=read(),c=read();
	for(int j=0;j<r;j++)
		cin>>key[j];
	bool flag=false;
	for(int i=0;i<n;i++)
	for(int j=0;j<m;j++){
		if(i+r>=n||j+c>=m) continue;
		
		flag=true;
		for(int l=0;l<r;l++)
		for(int k=0;k<c;k++)
		if(key[l][k]=='1' && back[i+l][j+k]!=key[l][k])
			flag=false,l=r,k=c;//break
		
		if(flag) {
			cout<<i+1<<" "<<j+1;
			i=n,j=m;//break
		}
	}
	if(!flag) cout<<"NO"<<endl;
	return 0;	
}

第九题：

问题描述
给定正整数 a, b, c，请问有多少个正整数，是其中至少两个数的约数。
输入格式
输入一行包含三个正整数 a, b, c。
输出格式
输出一行包含一个整数，表示答案。
样例输入
30 70 35
样例输出
6
样例说明
1、2、5、7、10、35 满足条件。
评测用例规模与约定
对于 50% 的评测用例，1 <= a, b, c <= 1000000。
对于所有评测用例，a, b, c 不超过 10**12（10 的 12 次方）

思路：看了看别人都说直接开long long暴力就行，我在这儿就顺手回忆一个gcd吧
至少是两个数的约数 ⇐ ⇒ 两两gcd()求最大公因数，至少是某一个gcd的因数。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define ll long long
ll a,b,c;
ll gcd(ll x,ll y){
	if(x>y) swap(x,y);
	if(y%x==0) return x;
	return gcd(x,y%x);
} ll tot;
int main(){
	cin>>a>>b>>c;
	ll A=gcd(a,b),B=gcd(a,c),C=gcd(b,c);
	cout<<A<<endl<<B<<endl<<C<<endl;
	//求ABC三个数字不同约数个数	
	for(ll i=1;i<=max(max(A,B),C);i++)
	if((A%i) && (B%i) && (C%i)) continue;
	else tot++;
	cout<<tot<<endl;
	
}

第十题：

问题描述
小蓝很喜欢玩汉诺塔游戏。
游戏中有三根柱子，开始时第一根柱子上有 n 个圆盘，从上到下圆盘的大小依次
为 1 到 n。
每次，可以将一个盘子从一根柱子上移动到另一根柱子上，这个盘子必须是柱子最
上方的盘子，而且移到的柱子上的盘子必须比这个盘子大。
小蓝的目标是将所有的盘子移动到第三根柱子上。
汉诺塔是个经典问题，当盘子数量为 n 时，最少需要移动 2n-1 步，其中 2n
表示 2 的 n 次方。
小蓝已经玩了一会儿（不一定按最优方案玩），他想知道，对于他目前的局面，最
少还需要多少步可以到达目标。
输入格式
输入的第一行包含三个非负整数 a, b, c，分别表示目前每根柱子上的盘子数。在
本题中，n=a+b+c。
第二行包含 a 个整数，相邻的整数之间使用一个空格分隔，表示第一根柱子上的
盘子，盘子按从上到下（从小到大）的顺序给出。
第三行包含 b 个整数，相邻的整数之间使用一个空格分隔，表示第二根柱子上的
盘子，盘子按从上到下（从小到大）的顺序给出。
第四行包含 c 个整数，相邻的整数之间使用一个空格分隔，表示第三根柱子上的
盘子，盘子按从上到下（从小到大）的顺序给出。
输出格式
输出一行包含一个整数，表示答案。
样例输入
1 2 3
1
2 3
4 5 6
样例输出
7
评测用例规模与约定
对于 30% 的评测用例，2 <= n <= 5。
对于所有评测用例，2 <= n <= 60

30分思路：
状压bfs，状态转移。 dp[i][j][k]表示到达三根柱子状态分别为 i,j,k的最小操作数
// 数组大小：(1<<5) ^3 = (1<<15)，时间复杂度也这么大 ==>可行
具体操作：开队列，bfs，将可到达的下一个状态存入队列即可；类似第三题，比第三题多开一个struct的事。
代码略。（因为没写）

100分思路:
（我这么蒟蒻，连汉诺塔都不会玩，更别说这道变形题的正解。所以寻求了frf大佬）
【看此段前建议先学汉诺塔裸题】
其实从三柱汉诺塔、四柱汉诺塔，我们都可以总结出来一个汉诺塔的最核心思路：
如果要把前n个盘子全放到b柱，且第n个盘子在a柱
则必须先将前(n-1)个盘子按顺序放在非a非b的某个柱，再将第n个盘子挪到b柱，然后再将前(n-1)个挪到第n个上面
由此形成递推
由此推出本题思路：从
n到1判断盘子的情况，
n盘应该放在3，如果n不在3，
则我们考虑要把n挪到3，那就需要先把前n-1个放在非n非3的柱子上，dfs(n-1,非n非3)，
再把n挪到3，ans++
再把n-1从非n非3挪到n的上面，也就是第三根柱子, ans+=dp[n-1] ;
如果n在3，则我们考虑要把n-1挪到3，dfs( n-1,3)

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cmath>
#include<map>
#include<ctime>
#include<cstdlib>
using namespace std;
inline int read(){
	char ch=getchar();bool f=true;int sum=0;
	while(ch<'0'||ch>'9'){
		if(ch=='-')f=false;ch=getchar();}
	while(ch>='0'&&ch<='9'){
		sum*=10;sum+=ch-'0';ch=getchar();}
	if(f)return sum;else return -sum;
}
#define dp(x) ((1<<x)-1)
int n;
int len[5];//len[i]表示第i个柱子的高度 
int location[100];//location[i]表示数字i所在的柱子编号 
long long ans;
void dfs(int x,int right){//正在判断第x个盘子，它最终的目的地在第right根柱子
	if(x==0) return ;
	//对于x，判断其是否在他该在的位置上
	if(location[x]==right) dfs(x-1,right);//如果x在位置，那就把前x-1个放在x上面
	else {int ls;
		for(ls=1;ls<=3;ls++) 
		if(ls!=right&&ls!=location[x]) break;
		dfs(x-1,ls);//如果x不在，则先把前x-1个放在非x当前位置且非right位置 
		ans++;//再将x挪到正确位置
		ans+=dp(x-1);//再把前x-1个放在x上面 
	}
	return; 
} 
int main(){
	len[1]=read(),len[2]=read(),len[3]=read();
	n=len[1]+len[2]+len[3];
	for(int i=1;i<=3;i++)
	for(int j=len[i];j;j--)
		location[read()]=i;
	dfs(n,3);cout<<ans<<endl;
	return 0;	
}

模拟题搞完了，
发现自己只会前9道入门题，汉诺塔这个普及题我就不会了
由此推出我真菜我去无用焦虑了
各位有缘再见

GoesM

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
3
评论
【蓝桥杯】第十三届——模拟赛

好假的模拟题，大概是入门和普及- 的题第一题：问题描述以下是一个 25 行 25 列的字母矩阵，全部由字母 A 和 B 组成。AAAAAAABABBAABABABAAAAAAAABBBBBABBAABBBBBABABBBBBAABAAABABBBABAABBBBABAAABAABAAABABBBBBAABAABABAAABAABAAABABBABABBABABABAAABAABBBBBABBBABAABBBBABBBBBAAAAAAAABABABABABABAAAAAAABBB
复制链接

扫一扫