赛题及输入文件下载：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;
}
1501
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
