蓝桥杯 第十一届校内模拟赛C/C++组(C/C++)
1、单位变换
问题描述
在计算机存储中,15.125GB 是多少 MB?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
答案:15448
解决办法:以前你不懂没关系,但从这道题后你必须要知道一件事:在计算机中,1 G = 210 M = 1024 M,1 M = 210 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 n n,请问在整数 1 至 n n n 中有多少个数位递增的数?输入格式
输入的第一行包含一个整数 n n n。
输出格式
输出一行包含一个整数,表示答案。
样例输入
30
样例输出
26
评测用例规模与约定
对于 40% 的评测用例, 1 ≤ n ≤ 1000 1 \le n \le 1000 1≤n≤1000。
对于 80% 的评测用例, 1 ≤ n ≤ 100000 1 \le n \le 100000 1≤n≤100000。
对于所有评测用例, 1 ≤ n ≤ 1000000 1 \le n \le 1000000 1≤n≤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 ] a[1], a[2], ..., a[n] a[1],a[2],...,a[n] 中,如果对于下标 i , j , k i, j, k i,j,k 满足 0 < i < j < k < n + 1 0<i<j<k<n+1 0<i<j<k<n+1 且 a [ i ] < a [ j ] < a [ k ] a[i]<a[j]<a[k] a[i]<a[j]<a[k],则称 a [ i ] , a [ j ] , a [ k ] a[i], a[j], a[k] a[i],a[j],a[k] 为一组递增三元组, a [ j ] a[j] a[j] 为递增三元组的中心。
给定一个数列,请问数列中有多少个元素可能是递增三元组的中心。输入格式
输入的第一行包含一个整数 n n n。
第二行包含 n n n 个整数 a [ 1 ] , a [ 2 ] , . . . , a [ n ] a[1], a[2], ..., a[n] a[1],a[2],...,a[n],相邻的整数间用空格分隔,表示给定的数列。输出格式
输出一行包含一个整数,表示答案。
样例输入
5
1 2 5 3 5样例输出
2
样例说明
a [ 2 ] a[2] a[2] 和 a [ 4 ] a[4] a[4] 可能是三元组的中心。
评测用例规模与约定
对于 50% 的评测用例, 2 ≤ n ≤ 100 , 0 ≤ 数列中的数 ≤ 1000 2 \le n \le 100,0 \le 数列中的数 \le 1000 2≤n≤100,0≤数列中的数≤1000。
对于所有评测用例, 2 ≤ n ≤ 1000 , 0 ≤ 数列中的数 ≤ 10000 2 \le n \le 1000,0 \le 数列中的数 \le10000 2≤n≤1000,0≤数列中的数≤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 n n 行 m m m 列的小块,每行和每列的长度都为 1。
小明选了其中的一些小块空地,种上了草,其他小块仍然保持是空地。
这些草长得很快,每个月,草都会向外长出一些,如果一个小块种了草,则它将向自己的上、下、左、右四小块空地扩展,这四小块空地都将变为有草的小块。
请告诉小明, k k k 个月后空地上哪些地方有草。输入格式
输入的第一行包含两个整数 n , m n, m n,m。
接下来 n n n 行,每行包含 m m m 个字母,表示初始的空地状态,字母之间没有空格。如果为小数点,表示为空地,如果字母为 g g g,表示种了草。
接下来包含一个整数 k k k。输出格式
输出 n n n 行,每行包含 m m m 个字母,表示 k k k 个月后空地的状态。如果为小数点,表示为空地,如果字母为 g g g,表示长了草。
样例输入
4 5 .g... ..... ..g.. ..... 2
样例输出
gggg. gggg. ggggg .ggg.
评测用例规模与约定
对于 30% 的评测用例, 2 ≤ n , m ≤ 20 2 \le n, m \le 20 2≤n,m≤20。
对于 70% 的评测用例, 2 ≤ n , m ≤ 100 2 \le n, m \le 100 2≤n,m≤100。
对于所有评测用例, 2 ≤ n , m ≤ 1000 , 1 ≤ k ≤ 1000 2 \le n, m \le 1000,1 \le k \le 1000 2≤n,m≤1000,1≤k≤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、奇怪的数列
问题描述
小明想知道,满足以下条件的正整数序列的数量:
- 第一项为 n n n;
- 第二项不超过 n n n;
- 从第三项开始,每一项小于前两项的差的绝对值。
请计算,对于给定的 n n n,有多少种满足条件的序列。
输入格式
输入一行包含一个整数 n 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 1 \le n \le 5 1≤n≤5;
对于 50% 的评测用例, 1 ≤ n ≤ 10 1 \le n \le 10 1≤n≤10;
对于 80% 的评测用例, 1 ≤ n ≤ 100 1 \le n \le 100 1≤n≤100;
对于所有评测用例, 1 ≤ n ≤ 1000 1 \le n \le 1000 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<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 题怎么可能那么简单)。发现果然有问题,第三点的意思是 “从第三项开始,每一项小于前两项的差的绝对值” 。这里有两点需要引起注意:
- “从第三项开始”,说明这个序列不是只有 3 项,也许有更多项
- “每一项小于前两项的差的绝对值”,注意是差的绝对值!!!
于是等我注意到这个点的时候,整个人都懵了,因为时间确实不够了
但是等一下!!!第三点不是一个递归的描述么?
因此可以直接用递归来求解本题,但是本题的数据范围最大达到了 1000,满分肯定是不可能的了。但是你仔细看,会发现一个很吓人的事:对于 50% 的评测用例, 1 ≤ n ≤ 10 1 \le n \le10 1≤n≤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 n n 个节目。然后晚会的时间有限,他只能最终选择其中的 m m m 个节目。
这 n n n 个节目是按照小明设想的顺序给定的,顺序不能改变。
小明发现,观众对于晚上的喜欢程度与前几个节目的好看程度有非常大的关系,他希望选出的第一个节目尽可能好看,在此前提下希望第二个节目尽可能好看,依次类推。
小明给每个节目定义了一个好看值,请你帮助小明选择出 m m m 个节目,满足他的要求。输入格式
输入的第一行包含两个整数 n , m n, m n,m ,表示节目的数量和要选择的数量。
第二行包含 n n n 个整数,依次为每个节目的好看值。输出格式
输出一行包含 m m m 个整数,为选出的节目的好看值。
样例输入
5 3
3 1 2 5 4样例输出
3 5 4
样例说明
选择了第 1, 4, 5 个节目。
评测用例规模与约定
对于 30% 的评测用例, 1 ≤ n ≤ 20 1 \le n \le 20 1≤n≤20;
对于 60% 的评测用例, 1 ≤ n ≤ 100 1 \le n \le 100 1≤n≤100;
对于所有评测用例, 1 ≤ n ≤ 100000 , 0 ≤ 节目的好看值 ≤ 100000 1 \le n \le 100000,0 \le 节目的好看值 \le 100000 1≤n≤100000,0≤节目的好看值≤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;
}