【蓝桥杯】第十一届校内模拟赛C/C++组（题目+题解）

蓝桥杯 第十一届校内模拟赛C/C++组（C/C++）

---

1、单位变换

问题描述

在计算机存储中，15.125GB 是多少 MB？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案：15448

解决办法：以前你不懂没关系，但从这道题后你必须要知道一件事：在计算机中，1 G = 2¹⁰ M = 1024 M，1 M = 2¹⁰ K = 1024 K，1 B = 8 bit。所以对本题而言，可直接用计算机自带的 “计算器” 软件计算：15.125×1024=15448，即 15.125 GB = 15448 MB。

---

2、约数

问题描述

1200000 有多少个约数（只计算正约数）。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案：96

解决办法：直接暴力求解（这种时候就别谈什么数论了）。

#include<iostream>
using namespace std;

int main(){
	int ans=0,n=1200000;
	for(int i=1;i<=n;i++)
		if(n%i==0) ans++;
	cout<<ans<<endl;
}

---

3、多少个数字 9

问题描述

在 1 至 2019 中，有多少个数的数位中包含数字 9？
注意，有的数中的数位中包含多个 9，这个数只算一次。例如，1999 这个数包含数字 9，在计算时只算一个数。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案：544

解决办法：直接暴力求解（这种时候就别谈什么数论了）。

#include<iostream>
using namespace std;

bool judge(int n)
{
	while(n){
		if(n%10==9) return true;
		n/=10;
	}
	return false;
}

int main()
{
	int ans=0;
	for(int i=9;i<=2019;i++)
		if(judge(i)) ans++;
	cout<<ans<<endl;
	return 0;
}

---

4、叶节点数

问题描述

一棵包含有 2019 个结点的树，最多包含多少个叶结点？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案：2018

解决办法：要包含最多的叶节点只有一种办法，就是构建一课高度为 2 的树，这样一来，除了根节点外，其余全为叶节点，如下图所示：

---

5、数位递增的数

问题描述

一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如 1135 是一个数位递增的数，而 1024 不是一个数位递增的数。
给定正整数 $n$，请问在整数 1 至 $n$ 中有多少个数位递增的数？

输入格式

输入的第一行包含一个整数 $n$。

输出格式

输出一行包含一个整数，表示答案。

样例输入

30

样例输出

26

评测用例规模与约定

对于 40% 的评测用例，$1\le n\le 1000$。
对于 80% 的评测用例，$1\le n\le 100000$。
对于所有评测用例，$1\le n\le 1000000$。

答案：由于数据范围并不是很大，因此可以直接暴力枚举，如下：

#include<iostream>
using namespace std;

int ary[10];
bool judge(int n)		//判断某个数是否是“数位递增的数”
{
	int len=0;
	while(n){
		ary[len++]=n%10;
		n/=10;
	}
	for(int i=len-1;i>0;--i)
		if(ary[i]>ary[i-1]) return false;
	return true;
}

int main()
{
	int ans=0,n;cin>>n;
	for(int i=1;i<=n;i++)
		if(judge(i)) ans++;	
	cout<<ans<<endl;
}

---

6、元音辅音元音辅音

问题描述

小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出 yes，否则请输出 no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。

输入格式

输入一行，包含一个单词，单词中只包含小写英文字母。

输出格式

输出答案，或者为 yes，或者为 no。

样例输入

lanqiao

样例输出

yes

样例输入

world

样例输出

no

评测用例规模与约定

对于所有评测用例，单词中的字母个数不超过 100。

答案：模拟！代码如下：

#include<iostream>
#include<string>
using namespace std;

string str;
int pos;

bool isYuan(char c)	//判断是否为元音 
{
	return c=='a'||c=='e'||c=='i'||c=='o'||c=='u';
}
bool yuan()			//遍历元音段 
{
	int len=0;
	for(;pos<=str.length();pos++){
		if(!isYuan(str[pos])) break;
		len++;
	}
	return len;
}
bool zhuo()			//遍历辅音段 
{
	int len=0;
	for(;pos<=str.length();pos++){
		if(isYuan(str[pos])) break;
		len++;
	}
	return len;
}
bool serch()		//开始遍历 
{
	pos=0;
	if(zhuo()&&yuan()&&zhuo()&&yuan()&&pos==str.length()) return true;
	else return false;
}

int main()
{
	cin>>str;
	if(serch()) cout<<"yes"<<endl;
	else cout<<"no"<<endl;
	return 0;
}

---

7、递增三元组的中心

问题描述

在数列 $a[1],a[2],...,a[n]$ 中，如果对于下标 $i,j,k$ 满足 $0<i<j<k<n+1$ 且 $a[i]<a[j]<a[k]$，则称 $a[i],a[j],a[k]$ 为一组递增三元组，$a[j]$ 为递增三元组的中心。
给定一个数列，请问数列中有多少个元素可能是递增三元组的中心。

输入格式

输入的第一行包含一个整数 $n$。
第二行包含 $n$ 个整数 $a[1],a[2],...,a[n]$，相邻的整数间用空格分隔，表示给定的数列。

输出格式

输出一行包含一个整数，表示答案。

样例输入

5
1 2 5 3 5

样例输出

2

样例说明

$a[2]$ 和 $a[4]$ 可能是三元组的中心。

评测用例规模与约定

对于 50% 的评测用例，$2\le n\le 100，0\le 数列中的数\le 1000$。
对于所有评测用例，$2\le n\le 1000，0\le 数列中的数\le 10000$。

答案：数据范围并不是很大，可以直接暴力求解

#include<iostream>
using namespace std;

const int N=1005;
int n,ary[N];
int max(int pos)		//求区间[pos,n]之间的最大值 
{
	int num=ary[pos];
	for(int i=pos+1;i<n;i++)
		if(ary[i]>num) num=ary[i];
	return num;
}

int main()
{
	cin>>n;
	for(int i=0;i<n;i++) cin>>ary[i];
	int ans=0,minNum=ary[0];
	for(int i=1;i<n-1;i++){
		if(ary[i]>minNum && ary[i]<max(i+1)) ans++;	//如果当前数比前面的最小值大，且其后面存在比其大的值则该数是一个递增三元组的中心 
		if(ary[i]<minNum) minNum=ary[i];			//如果当前数比前面的最小值小，则更新最小值 
	}
	cout<<ans<<endl;
	return 0;
}

---

8、种草问题

问题描述

小明有一块空地，他将这块空地划分为 $n$ 行 $m$ 列的小块，每行和每列的长度都为 1。
小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
请告诉小明，$k$ 个月后空地上哪些地方有草。

输入格式

输入的第一行包含两个整数 $n,m$。
接下来 $n$ 行，每行包含 $m$ 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 $g$，表示种了草。
接下来包含一个整数 $k$。

输出格式

输出 $n$ 行，每行包含 $m$ 个字母，表示 $k$ 个月后空地的状态。如果为小数点，表示为空地，如果字母为 $g$，表示长了草。

样例输入

4 5
.g...
.....
..g..
.....
2

样例输出

gggg.
gggg.
ggggg
.ggg.

评测用例规模与约定

对于 30% 的评测用例，$2\le n,m\le 20$。
对于 70% 的评测用例，$2\le n,m\le 100$。
对于所有评测用例，$2\le n,m\le 1000，1\le k\le 1000$。

答案：本题是一道BFS的典型例题，如果有对搜索算法不是很懂的同学，请移步这一篇 “最经典的走迷宫最短路径算法” 博客修炼修炼，再来刷这个副本。当然，对BFS非常熟悉的同学请直接来Ctrl+C即可，下面是本题的完整代码：

#include<iostream>
#include<queue> 
using namespace std;

const int N=1005;
int n,m,k,nums;
char map[N][N];
struct Point{
	int x,y;
	Point(){}
	Point(int a,int b):x(a),y(b){}
};
int go[][2]={{-1,0},{1,0},{0,-1},{0,1}};	//四种行走方式 
queue<Point> q;

int bfs(int num)
{
	int fixnum=0;
	while(!q.empty() && num--){
		Point p=q.front();q.pop();
		for(int i=0;i<4;i++){
			int x=p.x+go[i][0],y=p.y+go[i][1];
			if(x>=1 && x<=n && y>=1 && y<=m && map[x][y]=='.'){
				fixnum++;
				map[x][y]='g';
				q.push(Point(x,y));
			}
		}
	}
	return fixnum;
}

int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)			//录入初始情况 
		for(int j=1;j<=m;j++){
			cin>>map[i][j];
			if(map[i][j]=='g'){
				nums++;
				q.push(Point(i,j));
			}
		}
	cin>>k;
	while(k--) nums=bfs(nums);		//k次bfs 
	for(int i=1;i<=n;i++){			//输出最终情况 
		for(int j=1;j<=m;j++)
			cout<<map[i][j];
		cout<<endl;
	}
	return 0;
}

---

9、奇怪的数列

问题描述

小明想知道，满足以下条件的正整数序列的数量：

1. 第一项为 $n$；
2. 第二项不超过 $n$；
3. 从第三项开始，每一项小于前两项的差的绝对值。

请计算，对于给定的 $n$，有多少种满足条件的序列。

输入格式

输入一行包含一个整数 $n$。

输出格式

输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。

样例输入

4

样例输出

7

样例说明

以下是满足条件的序列：

4 1
4 1 1
4 1 2
4 2
4 2 1
4 3
4 4

评测用例规模与约定

对于 20% 的评测用例，$1\le n\le 5$；
对于 50% 的评测用例，$1\le n\le 10$；
对于 80% 的评测用例，$1\le n\le 100$；
对于所有评测用例，$1\le n\le 1000$。

答：做这道题的时候我犯了个错误，看第 3 点看得不仔细（一扫而过），然后在看下面的样例数据的时候，我理解成了这个数字序列是只有 3 项，其中 1、2 项如题目中的 1、2 点所述，然后第 3 项需要满足 “小于第 1 项与第 2 项的差”，于是就将题目的意思理解成了如下的序列：

5 1 0
5 1 1
5 1 2
5 1 3

5 2 0
5 2 1
5 2 2

5 3 0
5 3 1

5 4 0

5 5 0

根据这样的思路得出了以下的代码：

#include<iostream>
using namespace std;

const int MOD=10000;

int main()
{
	int ans=0,n;cin>>n;
	for(int i=1;i<n;i++)
		ans=(ans+i)%MOD;
	ans=(ans+1)%MOD;
	cout<<ans<<endl;
} 

后来做完了所有题，回来检查（主要是感觉第 9 题怎么可能那么简单）。发现果然有问题，第三点的意思是 “从第三项开始，每一项小于前两项的差的绝对值” 。这里有两点需要引起注意：

1. “从第三项开始”，说明这个序列不是只有 3 项，也许有更多项
2. “每一项小于前两项的差的绝对值”，注意是差的绝对值！！！

于是等我注意到这个点的时候，整个人都懵了，因为时间确实不够了

但是等一下！！！第三点不是一个递归的描述么？

因此可以直接用递归来求解本题，但是本题的数据范围最大达到了 1000，满分肯定是不可能的了。但是你仔细看，会发现一个很吓人的事：对于 50% 的评测用例，$1\le n\le 10$。我们知道，递归树在 20 层以内都不容易超时，而本题 50% 的数据都小于 10，那说明递归算法至少可以得 50% 的分（想到这点，我已经很尽力了），下面给出这 50 分算法的完整代码：

#include<iostream>
#include<cmath>
using namespace std;

const int MOD=10000;
int ans;
void gofront(int a,int b)
{
	for(int i=1;i<fabs(a-b);i++)
		gofront(b,i);
	ans=(ans+1)%MOD;
}

int main()
{
	int n;cin>>n;
	for(int i=1;i<=n;i++)
		gofront(n,i);
	cout<<ans<<endl;
	return 0;
}

如果想得满分，需要往 DP 或记忆化搜索的的方向思考，欢迎想到答案的大佬留言互动

---

10、晚会节目

问题描述

小明要组织一台晚会，总共准备了 $n$ 个节目。然后晚会的时间有限，他只能最终选择其中的 $m$ 个节目。
这 $n$ 个节目是按照小明设想的顺序给定的，顺序不能改变。
小明发现，观众对于晚上的喜欢程度与前几个节目的好看程度有非常大的关系，他希望选出的第一个节目尽可能好看，在此前提下希望第二个节目尽可能好看，依次类推。
小明给每个节目定义了一个好看值，请你帮助小明选择出 $m$ 个节目，满足他的要求。

输入格式

输入的第一行包含两个整数 $n,m$ ，表示节目的数量和要选择的数量。
第二行包含 $n$ 个整数，依次为每个节目的好看值。

输出格式

输出一行包含 $m$ 个整数，为选出的节目的好看值。

样例输入

5 3
3 1 2 5 4

样例输出

3 5 4

样例说明

选择了第 1, 4, 5 个节目。

评测用例规模与约定

对于 30% 的评测用例，$1\le n\le 20$；
对于 60% 的评测用例，$1\le n\le 100$；
对于所有评测用例，$1\le n\le 100000，0\le 节目的好看值\le 100000$。

答案：
其实本题就是在考结构体的多级排序（两次排序就 ok 啦）。下面直接给出完整代码：

#include<iostream>
#include<algorithm>
using namespace std;

const int N=100005;
int n,m,value;
struct perform{						//定义结构体：节目 
	int pos,value;
	perform(){}
	perform(int a,int b):pos(a),value(b){}
};
perform p[N];
bool cmp1(perform p1,perform p2)	//设置的排序规则1：按节目好看程度降序排序 
{ return p1.value>p2.value; }
bool cmp2(perform p1,perform p2)	//设置的排序规则2：按节目的序号升序排序 
{ return p1.pos<p2.pos; }

int main()
{
	cin>>n>>m;
	for(int i=0;i<n;i++){
		cin>>value;
		p[i]=perform(i,value);
	}
	sort(p,p+n,cmp1);				//第一次针对节目的好看程度进行降序排序 
	sort(p,p+m,cmp2);				//第二次针对前面最好看的m个节目的序号进行升序排序 
	for(int i=0;i<m;i++)
		cout<<p[i].value<<" ";
	return 0;
}

END

---