第十一届蓝桥杯大赛 全程记录02——2020.3.22校内模拟赛（下）

前言

2020.3.22，学校组织开展了“第十一届软件类校内模拟赛——C/C++程序设计”，考试时间：2020-03-22 13:30~17:30，
本篇博客就是用来记录本次大赛的题目解读，做题思路，解题代码等等……
注：以下内容仅记录自己的做题思路，不代表标准答案！

5. 问题5

• 问题描述

  在数列 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 <= n <= 100，0 <= 数列中的数 <= 1000。
  对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。

• 分析：

这道题的本质其实就是叫我们求一个数：它的前面有比它小的，它的后面有比它大的的数，最后求出这些数的数量。

因为 n<=1000 ，所以我们可以直接用 O(n2) 暴力找。

• 解答：

#include <bits/stdc++.h>
using namespace std;
/*	在数列 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]为递增三元组的中心。
　　给定一个数列，请问数列中有多少个元素可能是递增三元组的中心。
*/

int main(int argc, char *argv[]) {
	int n; 
	int a[1000];
	int ans=0;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
	}
	
	for(int i=0;i<n;i++)
	{
		bool f1=false, f2=false;
		for(int j=0;j<i;j++)
		{
			if(a[j]<a[i])
			{
				f1=true;
				break;
			}
		}
		
		for(int k=i+1;k<n;k++)
		{
			if(a[k]>a[i])
			{
				f2=true;
				break;
			}
		}
		
		if(f1&&f2)
		{
			ans++;
		}
	}
	cout<<ans;
	return 0;
}

6. 问题6

• 问题描述

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

• 输入格式

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

• 输出格式

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

• 样例输入

   30
  

• 样例输出

   26
  

• 评测用例规模与约定

  对于 40% 的评测用例，1 <= n <= 1000。 　　
  对于 80% 的评测用例，1 <= n <= 100000。
  对于所有评测用例，1 <= n <= 1000000。

• 分析：

这也是一简单的判断数位的问题，如果直接采用枚举的方法，判断每位是否递增的话，可能只能通过40%的测试用例。

因此，考虑采用构造法，直接构造数位递增的数，这里用递归进行逐位构造。

• 解答：

#include <bits/stdc++.h>
using namespace std;
/*	一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，
	例如1135是一个数位递增的数，而1024不是一个数位递增的数。
　　给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
*/

void dfs(int num) {
	for (int i=num%10?num%10:1;i<=9;i++)
		if (num*10+i<=n) ans++,dfs(num*10+i);
}

int main() {
	int n,ans=0;
	scanf("%d",&n),dfs(0);
	printf("%d",ans); 
	return 0;
}

7. 问题7

• 问题描述

  小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。

  给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。

• 输入格式

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

• 输出格式

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

• 样例输入

   lanqiao
  

• 样例输出

   yes
  

• 样例输入

   world
  

• 样例输出

   no
  

• 评测用例规模与约定

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

• 分析：

这是一道对于字符串考查的题目，题目不难，只需要根据题意模拟出四段的判断，以及注意最后要判断尾部的合法性。

• 解答：

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

bool func(char x)
{
	if(x=='a'||x=='e'||x=='i'||x=='o'||x=='u')
	{
		return true;
	}
	else
	{
		return false;
	}
}

int main(int argc, char *argv[]) {
	char str[100];
	bool f[4]={false};
	int pos=0;
	cin>>str; 
	int len=strlen(str);
	
	while(!func(str[pos]) && pos<len)
	{
		f[0]=true; 
		pos++;
	}
	while(func(str[pos]) && pos<len)
	{
		f[1]=true;
		pos++;
	}
	while(!func(str[pos]) && pos<len)
	{
		f[2]=true;
		pos++;
	}
	while(func(str[pos]) && pos<len)
	{
		f[3]=true;
		pos++;
	}
	
	if(f[0]&&f[1]&&f[2]&&f[3]&&pos==len)
		cout<<"yes"<<endl;
	else
		cout<<"no"<<endl;
	
	return 0;
}

8. 问题8

• 问题描述

  小明想知道，满足以下条件的正整数序列的数量：
  　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。

• 分析：

这个题目，最暴力的做法就是直接深度搜索DFS，但是可能只能通过50%的测试用例，

所以后来对DFS进行了一些修改，最后得到如下代码。因为结果还没出来，所以也不确定正确与否，仅供参考。

• 解答：

#include <bits/stdc++.h> 
using namespace std;
/*　小明想知道，满足以下条件的正整数序列的数量：
　　1. 第一项为 n；
　　2. 第二项不超过 n；
　　3. 从第三项开始，每一项小于前两项的差的绝对值。
　　请计算，对于给定的 n，有多少种满足条件的序列。
*/

const int N = 1001;
int  n , ans = 0;
int f[N][N]; 

int dfs(int pre , int now)
{
	if(f[pre][now] != -1)
		return f[pre][now];
	int t = 1;
	for(int i = 1;i < abs(pre - now) ;i++)
	{
		t += dfs(now , i);
	}
	return f[pre][now] = t % 10000;
}

int main()
{
	fill(f[0],f[0] + N * N ,-1);
	cin >> n;
	f[1][1] = 1;

	for(int i = 1;i <= n ;i ++)
	{
		ans = ( ans + dfs(n, i) ) % 10000;
	}
	cout << ans;
	return 0;
}

9. 问题9

• 问题描述

  小明有一块空地，他将这块空地划分为 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。

• 分析：

这道题，我们直接模拟草的生长情况就好了。

由于同一位置下长草时间更早的情况覆盖了更晚的，所以我们只需考虑一块地最先长草的状态。

way 数组控制方向，f 数组标记一块地是否长过草，dt 数组实时更新地图情况。

• 解答：

#include <bits/stdc++.h>
#define MAXN 1001
using namespace std;
/* 	小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
　　小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
　　这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，
	则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
　　请告诉小明，k 个月后空地上哪些地方有草。
*/ 

struct Point { int x,y,c; };
int n,m,k;
int way[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
char dt[MAXN][MAXN]; 
bool f[MAXN][MAXN];
queue<Point> Q; 

int main() {
	memset(f,0,sizeof(f));
	scanf("%d%d",&n,&m);
	for (int i=0;i<n;i++) {
		scanf("%s",dt[i]);
		for (int j=0;j<m;j++)
			if (dt[i][j]=='g')
				f[i][j]=true,Q.push((Point){i,j,0});
	}
	scanf("%d",&k);
	
	while(!Q.empty()) {
		Point now=Q.front(); Q.pop();
		if (now.c==k) break;
		for (int i=0;i<4;i++) {
			int tx=now.x+way[i][0],ty=now.y+way[i][1];
			if (tx<0 || tx>n || ty<0 || ty>m) continue;
			dt[tx][ty]='g';
			if (!f[tx][ty]) Q.push((Point){tx,ty,now.c+1});
		}
	}
	
	for (int i=0;i<n;i++) 
		printf("%s\n",dt[i]);
	return 0;
} 

10. 问题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。

• 分析：

这道题是一个典型的贪心算法。

由于在小明的策略下一定是要选择当前能选中好看值最大的节目，所以每次选择就是在当前能选的节目中找好看值最大的，不考虑之后如何选择。

因此，只需要按节目顺序遍历节目重要度，并按照节目好看度排序进行了，这里需要用到两个比较函数cmp1、cmp2。

• 解答：

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

struct node{
	int deep;
	int id;
};

bool cmp1(node a,node b)
{
	return a.deep > b.deep;
}

bool cmp2(node a,node b)
{
	return a.id < b.id;
}

int main()
{
	int n,m;
	cin >> n >> m;
	vector<node> ans;
	for(int i = 0;i < n ;i ++)
	{
		node temp;
		cin >> temp.deep;
		temp.id = i;
		ans.push_back(temp);
	}
	
	sort(ans.begin(),ans.end(),cmp1);
	sort(ans.begin(),ans.begin() + m,cmp2);
	
	for(int i = 0;i < m ;i ++)
	{
		cout << ans[i].deep << " ";
	}
	return 0;
}

结语

本次蓝桥杯的模拟赛，难度中等，但是因为是在疫情特殊时期，把模拟题拿来练练手也是不错的，同时此次模拟赛后也要继续保持一定量的题目训练。

俗话常说：业精于勤荒于嬉。

编码如此，人生亦然。

----------------------------以上，即为本次模拟赛全部内容。----------------------------