赛题及输入文件下载:2019年第十届蓝桥杯大赛软件类省赛C/C++B组
填空A : 组队
作为篮球队教练,你需要从名单(见附件)中选出 1 号位至 5 号位各一名球员, 组成球队的首发阵容。
每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少?
解析:
使用赛题附件team.txt
暴力枚举
把每位球员用一个结构体表示,五个分数分别是结构体内的成员变量
答案
490
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
struct P
{
int a, b, c, d, e;
} p[25];
int main()
{
freopen("team.txt", "r", stdin);
int t;
while (cin >> t)
{
cin >> p[t].a >> p[t].b >> p[t].c >> p[t].d >> p[t].e;
}
int maxscore = -1;
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= 20; j++)
for (int k = 1; k <= 20; k++)
for (int l = 1; l <= 20; l++)
for (int m = 1; m <= 20; m++)
{
if (i != j && i != k && i != l && i != m && j != k && j != l && j != m && k != l && k != m && l != m)
{
int score = p[i].a + p[j].b + p[k].c + p[l].d + p[m].e;
maxscore = max(score, maxscore);
}
}
cout << maxscore << endl;
return 0;
}
填空B :年号字串
小明用字母 A 对应数字 1,B 对应 2,以此类推,用 Z 对应 26。对于 27 以上的数字,小明用两位或更长位的字符串来对应,例如 AA 对应 27,AB 对 应 28,AZ 对应 52,LQ 对应 329。
请问 2019 对应的字符串是什么?
解析:
27进制问题,要找到三个字母’α’,’β’,’γ’,使得 α*26*26 + β*26 + γ = 2019
暴力枚举这三个字母即可
答案:
BYQ
#include <iostream>
using namespace std;
int main()
{
for (char a = 'A'; a <= 'Z'; a ++)
for (char b = 'A'; b <= 'Z'; b ++)
for (char c = 'A'; c <= 'Z'; c ++)
if ((a-'A'+1)*26*26 + (b-'A'+1)*26 + (c-'A'+1) == 2019)
cout << a << " " << b << " " << c << endl;
return 0;
}
填空C : 数列求值
给定数列 1, 1, 1, 3, 5, 9, 17, …,从第 4 项开始,每项都是前 3 项的和。求第 20190324 项的最后 4 位数字。
解析:
不需要建立大小为20190324的数组,使用一个大小为4的滚动数组即可
取最后4位可对10000取模
答案:
4659
#include <iostream>
using namespace std;
const int P = 10000;
int main()
{
int a[4];
int n = 20190324;
a[0] = a[1] = a[2] = 1;
a[3] = 3;
for (int i = 3; i < n; i++)
{
a[0] = a[1] % P;
a[1] = a[2] % P;
a[2] = a[3] % P;
a[3] = a[0] + a[1] + a[2];
}
cout << a[3] << endl;
return 0;
}
填空D : 数的分解
把 2019 分解成 3 个各不相同的正整数之和,并且要求每个正整数都不包 含数字 2 和 4,一共有多少种不同的分解方法?
注意交换 3 个整数的顺序被视为同一种方法,例如 1000+1001+18 和 1001+1000+18 被视为同一种。
解析:
暴力枚举三个数字会超时
for (int i = 1; i < 2019; i ++)
for (int j = 1; j < 2019; j ++)
for (int k = 1; k < 2019; k ++)
if (i + j + k == 2019)
...
可以进行如下优化:
- 3个数字一定存在大小关系
for (int i = 1; i * 3 < 2019; i ++)
for (int j = i + 1; j + i < 2019; j ++)
for (int k = j + 1; k + j + i < 2019; k ++)
if (i + j + k == 2019 && Check(i, j, k))
...
- 第三个数k可以通过
2019-i-j
得到
for (int i = 1; i * 3 < 2019; i ++)
for (int j = i + 1; j + i < 2019; j ++)
if (Check(i, j, 2019-i-j))
...
答案:
40785
#include <iostream>
using namespace std;
//检查数字num是否包含2或4
bool Check(int num)
{
while(num)
{
if (num % 10 == 2 || num % 10 == 4)
return false;
num /= 10;
}
return true;
}
int main()
{
int N = 2019;
int ans = 0;
for (int i = 1; i < N / 3; ++i)
if (Check(i))
for (int j = i + 1; N - i - j > j; ++j)
if (Check(j) && Check(N - i - j))
ans++;
cout << ans << endl;
return 0;
}
填空E : 迷宫
下图给出了一个迷宫的平面图,其中标记为 1 的为障碍,标记为 0 的为可 以通行的地方。
010000
000100
001001
110000
迷宫的入口为左上角,出口为右下角,在迷宫中,只能从一个位置走到这 个它的上、下、左、右四个方向之一。
对于上面的迷宫,从入口开始,可以按DRRURRDDDR 的顺序通过迷宫, 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。
对于下面这个更复杂的迷宫(30 行 50 列),请找出一种通过迷宫的方式, 其使用的步数最少,在步数最少的前提下,请找出字典序最小的一个作为答案。 请注意在字典序中D<L<R<U。(如果你把以下文字复制到文本文件中,请务 必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt, 内容与下面的文本相同)
解析:
BFS,使用结构体记录每一个点,每个点需要额外记录已经走过的路径
按照DLRU的顺序定义Next数组,可以直接得出最小字典序的情况
答案:
DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn = 55;
char g[maxn][maxn];
bool vis[maxn][maxn];
string ans;
int n, m;
struct point
{
int x, y;
string path;
point(int _x, int _y, string _path)
{
x = _x;
y = _y;
path = _path;
}
point() {}
};
int Next[4][2] = {1, 0, 0, -1, 0, 1, -1, 0};
char ops[5] = {'D', 'L', 'R', 'U'};
void bfs()
{
queue<point> Q;
Q.push(point(0, 0, ""));
while (!Q.empty())
{
point head = Q.front();
Q.pop();
int x = head.x;
int y = head.y;
string path = head.path;
for (int k = 0; k < 4; k++)
{
int nx = x + Next[k][0];
int ny = y + Next[k][1];
if (nx == n - 1 && ny == m - 1)
{
ans = path + ops[k];
return;
}
if (g[nx][ny]=='0' && !vis[nx][ny] && nx < n && ny < m && nx >= 0 && ny >= 0)
{
vis[nx][ny] = 1;
Q.push(point(nx, ny, path + ops[k]));
}
}
}
}
int main()
{
freopen("maze.txt", "r", stdin);
n = 30;
m = 50;
for (int i = 0; i < n; i++)
scanf("%s", g[i]);
bfs();
cout << ans << endl;
return 0;
}
大题F:特别数的和
小明对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0),在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574。
请问,在 1 到 n中,所有这样的数的和是多少?
输入:
输入一行包含两个整数 n。
输出格式:
输出一行,包含一个整数,表示满足条件的数的和。
样例输入:
40
样例输出:
574
数据范围:
对于所有评测用例,1 ≤ n≤ 10000 。
解析:
和D题差不多。
在答案可能很大的情况下,应该使用long long存储答案(本题用int也行)。
#include <iostream>
#include <algorithm>
using namespace std;
int n;
bool check(int num)
{
while (num)
{
int a = num % 10;
if (a == 2 || a == 0 || a == 1 || a == 9)
return false;
num /= 10;
}
return true;
}
int main()
{
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++)
if (!check(i))
ans += i;
cout << ans << endl;
return 0;
}
大题G:完全二叉树的权值
给定一棵包含 N 个节点的完全二叉树,树上每个节点都有一个权值,按从 上到下、从左到右的顺序依次是 A1, A2, · · · A**N
现在小明要把相同深度的节点的权值加在一起,他想知道哪个深度的节点 权值之和最大?如果有多个深度的权值和同为最大,请你输出其中最小的深度。
注:根的深度是 1。
输入:
第一行包含一个整数 N。 第二行包含N个整数A1,A2,··· An。
输出格式:
输出一个整数代表答案。
样例输入:
7
1 6 5 4 3 2 1
样例输出:
2
数据范围:
对于所有评测用例,1 ≤ N≤ 100000,−100000 ≤ Ai≤ 100000。
解析:
完全二叉树满足:后一个深度的节点个数是前一层节点个数的2倍
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
int main()
{
int n;
cin >> n;
ll maxv = -INF, ans = 0; // maxv记录最大权值,ans为权值之和最大的深度
// 遍历深度
// length为当前深度节点的个数,因为是完全二叉树,满足的条件是:后一层的节点个数是前一层节点个数的2倍
for (int i = 0, length = 1, depth = 1; i < n; depth ++, length *= 2)
{
ll curv = 0; // curv记录当前深度权值之和
for (int j = 0; j < length && i < n; j ++, i ++ )
{
int x;
cin >> x;
curv += x;
}
if (curv > maxv)
{
maxv = curv;
ans = depth;
}
}
cout << ans << endl;
return 0;
}
大题H:等差数列
数学老师给小明出了一道等差数列求和的题目。但是粗心的小明忘记了一部分的数列,只记得其中 N个整数。
现在给出这 N个整数,小明想知道包含这 N个整数的最短的等差数列有几项?
输入:
输入的第一行包含一个整数 N。 第二行包含N个整数A1,A2,···,An。(注意A1 ~ An并不一定是按等差数列中的顺序给出)
输出格式:
输出一个整数表示答案。
样例输入:
5
2 6 4 10 20
样例输出:
10
样例说明:
包含 2、6、4、10、20 的最短的等差数列是 2、4、6、8、10、12、14、16、 18、20。
数据范围:
对于所有评测用例,2 ≤ N≤ 100000,0 ≤ Ai≤ 10^9。
解析:
题目可以理解为:对于N个数,最少补多少个数可以使这些数成为等差数列,即项数要最小。
对于升序排列的N个数,首项(a1)和尾项(an)一定是固定的。因为没有必要在第一个数前或最后一个数后再补充数列元素。
项数 = (an-a1) / d + 1
公差d越大,项数越小
有如下两个结论(两者用一个即可):
- 公差d一定可以整除数列中每一个数ai减第一个数a1,即:
(ai-a1)%d = 0
,则公差d最大为(ai-a1)
的最大公因数 - 公差d一定可以整除数列中每一个数ai减最后一个数an,即:
(an-ai)%d = 0
,则公差d最大为(an-ai)
的最大公因数
注意:需要特判公差全为0的情况
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 100010;
int n;
int a[maxn];
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}
int main()
{
cin >> n;
for (int i = 1; i <= n; i ++ )
cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 2; i <= n; i ++ )
a[i] -= a[1];
int d = a[2];
for (int i = 3; i <= n; i ++ ) d = gcd(d, a[i]);
if (d) cout << a[n] / d + 1 << endl;
else cout << n << endl;
return 0;
}