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

---

1.单位变换

问题描述
　　在计算机存储中，15.125GB是多少MB？
答案提交
　　这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案：15448
解决办法：用计算机自带的“计算器”软件计算：15.125×1024=15448

---

2.约数

问题描述
　　1200000有多少个约数（只计算正约数）。
答案提交
　　这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

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

#include
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
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
解决办法：只有一个点为根节点，其余全为叶节点，如下图所示：

---

5.数位递增的数

问题描述
　　一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如1135是一个数位递增的数，而1024不是一个数位递增的数。
　　给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
输入格式
　　输入的第一行包含一个整数 n。
输出格式
　　输出一行包含一个整数，表示答案。
样例输入
30
样例输出
26
评测用例规模与约定
　　对于 40% 的评测用例，1 <= n <= 1000。
　　对于 80% 的评测用例，1 <= n <= 100000。
　　对于所有评测用例，1 <= n <= 1000000。

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

#include
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
#include
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 　　给定一个数列，请问数列中有多少个元素可能是递增三元组的中心。
输入格式
　　输入的第一行包含一个整数 n。
　　第二行包含 n 个整数 a[1], a[2], …, a[n]，相邻的整数间用空格分隔，表示给定的数列。
输出格式
　　输出一行包含一个整数，表示答案。
样例输入
5
1 2 5 3 5
样例输出
2
样例说明
　　a[2] 和 a[4] 可能是三元组的中心。
评测用例规模与约定
　　对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
　　对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。

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

#include
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 <= n, m <= 20。
　　对于 70% 的评测用例，2 <= n, m <= 100。
　　对于所有评测用例，2 <= n, m <= 1000，1 <= k <= 1000。

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

#include
#include 
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 <= n <= 5；
　　对于 50% 的评测用例，1 <= n <= 10；
　　对于 80% 的评测用例，1 <= n <= 100；
　　对于所有评测用例，1 <= n <= 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
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 <= n <= 10。我们知道，递归树在20层以内都不容易超时，而本题50%的数据都小于10，那说明递归算法至少可以得50%的分（想到这点，我已经很尽力了），下面给出这50分算法的完整代码：

#include
#include
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 <= n <= 20；
　　对于 60% 的评测用例，1 <= n <= 100；
　　对于所有评测用例，1 <= n <= 100000，0 <= 节目的好看值 <= 100000。

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

#include
#include
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;
}