【蓝桥】第十一届软件类校内模拟赛（一）

前言

本题解为第十一届软件类校内模拟赛个人题解，但非官方满分题解，因此，可能存在下列问题

• 题意理解错误，导致答案错误。
• 代码中存在一些问题，导致答案错误。
• 算法复杂度的分析有误，导致不能在规定时间内得出结果。

因报名属于软件类，故本篇题解全部由 C++ 语言完成，第一次进行校内模拟，没有想到无法查看题目，且木得官方题解，因此题目名称是根据问题描述总结（已忘记题目原名称qwq）。

因此蒟蒻在此提供思路为主，附有非题解代码，如有出错（很有可能）欢迎大佬们指正，祝大佬们们在正赛中取得好成绩。

填空题

1题目描述

求1200000的所有约数有所少个？

96

#include
using namespace std;

int main(){
	int ans = 0 ,i,n=1200000;
	for( i=1;i*i<n;++i){
		if(n%i==0)ans+=2;
	}
	if(i*i==n)ans+=1;
	printf("%d",ans);//96
}

2题目描述

15.125GB是多少MB？

15488

计算器敲一敲

3题目描述

在1至2019中，有多少个数的数位中包括数字9？

544

#include
using namespace std;

int main(){
	int n=2019,ans=0,f,j;
	for(int i=9;i<=n;++i){
		f=0;
        j=i;
		while(j){
			if(j%10==9){
				f=1;
				break;
			}
			j/=10;
		}
		if(f)ans++;
	}
	printf("%d",ans);//544
}

4题目描述

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

2018

根×1+叶×2018

编程题

5元音辅音

小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
输入格式
　　输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式
　　输出答案，或者为yes，或者为no。
样例输入
lanqiao
样例输出
yes
样例输入
world
样例输出
no
评测用例规模与约定
　　对于所有评测用例，单词中的字母个数不超过100。

代码1：
判断变更次序，超过3次变更即为不符合，注意开头要为确定为辅音

#include
typedef long long ll;
using namespace std;
#define ri register int
int n,sum;
char qwq[5]={'a','e','i','o','u'};
int main()
{
 	//std::ios::sync_with_stdio(false);
	string s,a,b,c,d;
	cin>>s;
	for(ri i=0;i<s.length();++i)
	{
		bool f=0;
		for(ri j=0;j<5;++j)
		if(s[i]==qwq[j])
		{
			f=1;
			break;
		}
		if(f==1)
			s[i]='1';
		else
			s[i]='0';
	}
	for(ri i=0;i<s.length()-1;++i)
	{
		if(s[i]!=s[i+1])
			sum++;
	}
	if(sum==3&&s[0]=='0')
		cout<<"yes";
	else
		cout<<"no";
	return 0;
}

代码2：

//[辅音][元音][辅音][元音]
#include 
typedef long long ll;
using namespace std;
#define ri register int
int main()
{
	set<char>f;set<char>y;
	for(int i='a';i<='z';i++)
	{
		if(i=='a'||i=='e'||i=='i'||i=='o'||i=='u')
		{
			y.insert(i);
		}
		else
		{
			f.insert(i);
		}
	}
	string s;

	while(cin>>s){

	int p=0;int aa=0,bb=0,cc=0,dd=0;
	while(f.find(s[p])!=f.end())
	{
		aa=1;
		p++;
	}
	while(y.find(s[p])!=y.end())
	{
		bb=1;
		p++;
	}
	while(f.find(s[p])!=f.end())
	{
		cc=1;
		p++;
	}
	while(y.find(s[p])!=y.end())
	{
		dd=1;
		p++;
	}
	if(p==s.length()&&aa==1&&bb==1&&cc==1&&dd==1)
		cout<<"yes"<<endl;
	else
		cout<<"no"<<endl;
	}
	return 0;
}

6递增三元组中心

在数列 a[1], a[2], …, a[n] 中，如果对于下标 i, j, k 满足 0 则称 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。

思路：
50分方法：
很容易理解的是
一个数 只要左边有比它小的
右边有比它大的 即符合
所以暴力解法就是直接暴力 没啥好说的

100分方法：
dp解法: 维护两个数组
分别是最长上升子序列的长度
和最长下降子序列的长度(倒序搜索)
转移方程: dp[i] = max(dp[i], dp[j] + 1)

下面给出暴力挣扎
代码1

#include
typedef long long ll;
const int inf = 10000000 + 10;
const int sz = 100010;
using namespace std;
#define ri register int
inline void rd(int &x){
	char c=getchar();bool f=0;x=0;
	while(c>'9'||c<'0'){if(c=='-')f=1;c=getchar();}
	while(c<='9'&&c>='0'){x=x*10+c-'0';c=getchar();}
	if(f) x*=-1;}
inline void we(int x){
	if(x<0) putchar('-'),x*=-1;
	if(x/10) we(x/10);
	putchar(x%10+'0');}
int n,a[sz];
int ans,sum,num;
int main()
{
 	std::ios::sync_with_stdio(false);
	cin>>n;
	for(ri i=1;i<=n;++i)
	{
		cin>>a[i];
	}
	for(ri i=1;i<n+1;++i)
		for(ri j=i+1;j<n+1;++j)
			for(ri k=j+1;k<n+1;++k)
			{
				if(a[i]<a[j]&&a[j]<a[k])
				{
					ans++;
					a[j]=-1;break;
				}
			}
	cout<<ans;
	return 0;
}

代码2

#include
using namespace std;
const int sz = 1e3+3;
int n,a[sz];

int Max(int b){
	int ans = a[b];
	for(int i=b;i<n;++i)if(a[i]>ans)ans=a[i];
	return ans;
}

int main(){
	scanf("%d",&n);
	for(int i=0;i<n;++i)scanf("%d",&a[i]);
	int Min=a[0],ans;
	for(int i=1;i<n-1;++i){
		if(Min<a[i]&&a[i]<Max(i+1))ans++;
		if(Min>a[i])a[i]=Min;
	}
	printf("%d\n",ans);
}

7数位递增逆序数

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

#include
typedef long long ll;
const int inf = 10000000 + 10;
const int sz = 1000010;
using namespace std;
#define ri register int
int n,sum,ans,num,tmp;
int main()
{
 	std::ios::sync_with_stdio(false);
    cin>>n;
	num=1;
	for(ri i=1;i<=n;++i)
    {
		bool f=0;
    	num=i;
		tmp=inf;

		while(num>0)
		{
			int qwq=num%10;
			if(qwq>tmp)
			{
				f=1;
				break;
			}
			num/=10;
			tmp=qwq;
		}
		if(f==0)
			ans++;
	}
    cout<<ans;
	return 0;
}

8长草

小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
　　小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
　　这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
　　请告诉小明，k 个月后空地上哪些地方有草。
输入格式
　　输入的第一行包含两个整数 n, m。
　　接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。
　　接下来包含一个整数 k。
输出格式
　　输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
样例输入
4 5
.g…
…
…g…
…
2
（样例由于csdn编辑器原因显示有问题，样例输入可看代码里）
样例输出
gggg.
gggg.
ggggg
.ggg.
评测用例规模与约定
　　对于 30% 的评测用例，2 <= n, m <= 20。
　　对于 70% 的评测用例，2 <= n, m <= 100。
　　对于所有评测用例，2 <= n, m <= 1000，1 <= k <= 1000。
思路：

70分做法：
遍历k次矩阵，在每一个当前是字符 g 的上下左右处做上标记，每次遍历结束后将标记处改为字符 g 即可。
这样时间复杂度为 Θ(4knm)，可以通过70%的测评用例。

100分做法：
bfs跑一跑，相当于多起点BFS

/*样例输入
4 5
.g...
.....
..g..
.....
2
*/
#include
#define ri register int
using namespace std;
const int sz=1010,size=sz*sz;
int n,m,k;
char mmp[sz][sz],res[sz][sz];
int st[sz][sz];
typedef struct{
	int x, y;}p;
p q[size];
int dx[4]={0,- 1,0,1},dy[4]={-1,0,1,0};
void bfs(int x,int y)
{
	int h=0,t=-1;
	q[++t]=(p){x,y};
	st[x][y]=0;
	while(h<=t){
		p tt=q[h++];
		int x=tt.x,y=tt.y;
		for(ri i=0;i<4;++i)
		{
			int a=x+dx[i],b=y+dy[i];
			if(a>=0&&a<n&&b>=0&&b<m&&
			st[a][b]>st[x][y]+1&&st[x][y]+1<=k)
			{
				st[a][b]=st[x][y]+1;
				res[a][b]='g';
				q[++t]=(p){a,b};
			}
		}
	}
}
int main()
{
	cin>>n>>m;
	for(ri i=0;i<n;++i)
		cin>>mmp[i],strcpy(res[i],mmp[i]);
	cin>>k;
	memset(st,0x3f,sizeof(st));
	for(ri i=0;i<n;++i)
		for(ri j=0;j<m;++j)
		if(mmp[i][j]=='g')
			bfs(i,j);
	for(ri i=0;i<n;++i)
	puts(res[i]);
	return 0;
}

9序列数

​小明想知道，满足以下条件的正整数序列的数量：
第一项为 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；
​ 对于 50% 的评测用例，1 <= n <= 10；
​ 对于 80% 的评测用例，1 <= n <= 100；
​ 对于所有评测用例，1 <= n <= 1000。
思路：
50分方法：
靠dfs暴力能滚一半

80分方法：
画解答树，化成小的子问题，记忆化搜索优化时间

100分方法：
大概率是某个dp去推推，等官方那边消息吧qwq

50暴力滚粗：

#include
typedef long long ll;
const int inf = 10000000 + 10;
const int p = 10000;
using namespace std;
#define ri register int
inline void rd(int &x){
	char c=getchar();bool f=0;x=0;
	while(c>'9'||c<'0'){if(c=='-')f=1;c=getchar();}
	while(c<='9'&&c>='0'){x=x*10+c-'0';c=getchar();}
	if(f) x*=-1;}
inline void we(int x){
	if(x<0) putchar('-'),x*=-1;
	if(x/10) we(x/10);
	putchar(x%10+'0');}
int n,sum[1010],ans,num;
void dfs(int a,int b){
	ans=(ans+1)%p;
	if(abs(a-b)<=1) return;
	for(ri i=1;i<abs(a-b);++i)
		dfs(b,i);
	return;
}
int main()
{
 	std::ios::sync_with_stdio(false);
	cin>>n;
    for(ri i=1;i<=n;++i)
		dfs(n,i);
	cout<<ans;
	return 0;
}

10选节目static RMQ

小明要组织一台晚会，总共准备了 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。

思路：
麻烦的题：

60分做法：
令每个节目的好看程度依次为 a1, a2, …, an ，余下还需要选择的节目数量为 c，则

c=m 时，在a1, a2, …,an−c中找到最大值作为第一个节目即可，并令 i = 最大值的下标；
c 直到 (n−c)−i==c为止（即当剩余可选区间长度与还需选择的数量相等时）。

时间复杂度：

总的时间复杂度等于遍历区间的长度乘以遍历的区间个数。
在最糟糕的情况下，需要遍历的区间个数与 m 相等，需要遍历的区间长度为 n−m，即 O(m(n−m))，可以通过60%的数据。

100分做法：
实际上，该问题是一个求静态区间最值 (static RMQ) 问题。
使用任何一种能在 O(log₂n)的时间内求出长度为 n 的区间最值的数据结构都可以使本题有一个 O(mlog₂(n−m)) 的算法复杂度上界，从而能够拿到满分。

可以实现满分做法的数据结构有：

• Sparse Table（ST表）

• Segment Tree（线段树/区间树）

• Binary Indexed Tree（树状数组/二叉索引树）

可采取的算法：

• 规约LCA + 分块

方法千万条，AC第一条，这里所写的都仅供参考，以大赛官方为准啦，在此摆出以供大佬取其精华，去其糟粕，祝诸位大佬们节节高！