湖南工程学院学科实践与创新协会电气部幕后揭示

news/2025/11/23 22:44:51/文章来源:https://www.cnblogs.com/Reisentyan/p/19261756

~献给挚爱的你的不思议之国幕后揭示

题面地址：https://www.cnblogs.com/Reisentyan/p/19261758

现在时间：$[2025/11/20$ $23:47]$

将揭示——

幕后真相

本场比赛难度预计：

Easy - A, B, C
Normal - D, E, H
Hard - G, I, J
Lunatic - F

截至目前，各题通过情况统计如下：

题目	提交次数	通过次数	通过率
A：铃仙的不思议之国	提交86	通过29	33.72%
B：魔法使基本：算法导论	提交86	通过19	22.09%
C：铃波那契数列	提交104	通过25	24.04%
D：纸牌士兵	提交76	通过5	6.58%
E：命中注定	提交32	通过16	50.00%
F：库因兰德（Q Island）	提交40	通过8	20.00%
G：魔法使提高：标准模板	提交46	通过24	52.17%
H：凝滞的白之庭院	提交34	通过13	38.24%
I：亿万年的星光	提交13	通过12	92.31%
J：献给挚爱的你的不思议之国	提交35	通过19	54.29%

实际比赛难度分布：

Easy - A, C, G
Normal - B, E, J
Hard - H, I
Lunatic - D, F

这个结果可以说是相当出人意料。

大家的代码我都粗略看了一遍，发现：

为何 D 题通过率如此之低？主要原因在于题面没有给出机器人名字长度的上限，很多同学默认最长为 100。只要把名字长度数组开到 10000，或者使用动态字符串，就能避免这一类错误。
赛前认为 F 题是全场最难，本来没打算出到这个强度。但由于同时存在传送与转向两种法阵，叠在一起后复杂度明显上去了。试题包中的前四组数据还是空数据，在此向大家致歉，之后在洛谷上已经删除了有问题的数据。
D、F、H 题中，很多代码都写错了方向或边界，属于比较典型的“实现细节翻车”。这些题本身并不要求高深算法，更多是在考察调试能力和对细节的敏感度。
I 题通过率异常之高，是因为这是一个非常经典的背包模型，建议还没写的同学认真补一补。
A 题本身难度不大，但因为刚开场不少同学在尝试各种写法，常见错误包括：没有使用 long long、输入输出格式写错，甚至把 0 和 1 搞反。

希望大家在赛后多对照题解，把这些细节问题都真正吃透。

A：铃仙的不思议之国

最简单的钥匙，也能打开通往幻想的大门。

题解：

#include <stdio.h>int main()
{long long num1 = 0;long long num2 = 0;long long num3 = 0;scanf("%lld %lld %lld", &num1, &num2, &num3);if (num2 % 2 == 0){printf("%lld\n", num1 - num3);}else{printf("%lld\n", num1 + num3);}return 0;
}

仔细看题面可以发现，num1 和 num3 可能会非常大，int 型是存不下的，必须使用 long long（即 long long int）。

还有就是，别把1看成0，你不是人工智能

这道题主要是让大家熟悉洛谷的评测环境，以及基础的输入输出和数据类型选择。

B：魔法使基本：算法导论

区间的总和，是程序理解世界的第一种方式，也是人理解程序的第一步。

题解：

#include <stdio.h>int main() {int n, m;scanf("%d %d", &n, &m);long long num[n + 1];num[0] = 0;for (int i = 1; i <= n; i++) {scanf("%lld", &num[i]);num[i] += num[i - 1]; // 计算前缀和}for (int i = 0; i < m; i++) {int x, y;scanf("%d %d", &x, &y);if (x > y) {int temp = x;x = y;y = temp;}printf("%lld\n", num[y] - num[x - 1]);}return 0;
}

前缀和作为最基础、也最常用的算法之一，在从入门练习到各种高级题目中都有身影，本题就是一个很典型的应用场景。

题面没有显式给出数据范围，但要意识到区间和可能会非常大，用 int 很容易溢出，建议一律使用 long long 存储前缀和。

还有不少同学因为没有使用前缀和，而是每次询问都从头循环求和，导致超时。

这类问题只要写对前缀和，时间复杂度就能从 $O(nm)$ 直接优化到 $O(n + m)$。

C：铃波那契数列

递推是算法的记忆，而公式是人类试图驯服它的语言。

题解：

#include <stdio.h>#define MOD 998244353long long lbnq[1001000];int main() {lbnq[0] = lbnq[1] = lbnq[2] = 1;for (int i = 3; i <= 1000000; i++) {lbnq[i] = lbnq[i - 1] + lbnq[i - 2] - lbnq[i - 3] + 1 + MOD;lbnq[i] %= MOD;}int x;scanf("%d", &x);printf("%lld\n", lbnq[x]);return 0;
}

冷知识：这个数列的名字其实并不叫铃波那契（笑）

这是一个非常经典的数列，叫什么名字我忘记了

上面的递推写法是一种做法，还有同学给出了更巧妙的闭式表达式

例如把答案按奇偶性拆成两种情况，写成关于 $(\left\lfloor \dfrac{n}{2} \right\rfloor) $的多项式形式，形式大致如下（节选自一份提交）：

long long m = n / 2;
long long result;if (n % 2 == 0) {// 如果 n 是偶数, f(n) = 1 + m * (m - 1)long long term1 = m % MOD;long long term2 = (m - 1) % MOD;// 处理 term2 可能为负数的情况if (term2 < 0) term2 += MOD;result = (1 + (term1 * term2) % MOD) % MOD;} else {// 如果 n 是奇数, f(n) = 1 + m * mlong long term = m % MOD;result = (1 + (term * term) % MOD) % MOD;}

有兴趣的同学可以自行搜索这个数列的来历和推导过程，会发现不少有趣的数学小知识。非常感谢这位同学！

这个题我故意将数据填到$10^9$，其实数据只有$10^6$，想借此卡住ai

其实ai写矩阵快速幂很稳，一次就通过，矩阵快速幂是一个很实用的算法，只是编码难度高了一点

只要一路算到n，取模不出错就可以了，记得开longlong

D：纸牌士兵

排序不是比较大小，而是在混乱中找回秩序。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>struct Robot {int va[3];       // 速度、耐久、力量char name[10005];  // 名字
};int cmp(const void *a, const void *b) {const struct Robot *ra = (const struct Robot *)a;const struct Robot *rb = (const struct Robot *)b;extern int y; // 排序依据的性能指标（全局声明）if (ra->va[y - 1] != rb->va[y - 1]) {return rb->va[y - 1] - ra->va[y - 1];  // 该性能值降序}return strcmp(ra->name, rb->name);  // 名称字典序升序
}int y; // 作为排序依据的全局变量int main() {int n, x;scanf("%d %d", &n, &x);struct Robot *arr = (struct Robot *)malloc(sizeof(struct Robot) * n);if (!arr) return 0;for (int i = 0; i < n; i++) {scanf("%d %d %d %s",&arr[i].va[0],&arr[i].va[1],&arr[i].va[2],arr[i].name);}scanf("%d", &y);qsort(arr, n, sizeof(struct Robot), cmp);int lim = (x < n ? x : n);for (int i = 0; i < lim; i++) {printf("%s %d\n", arr[i].name, arr[i].va[y - 1]);}free(arr);return 0;
}

这道结构体排序题，是我认为本场中最值得大家认真掌握的一题。

在实际工程场景中，带有多种属性的记录（例如“名称 + 多个数值指标”）非常常见，用结构体配合排序是最自然的写法。

本题的排序规则也很典型：先按某一维度降序，再按名字的字典序升序。

出错比较多的一个原因，是题面没有给出机器人名字长度的上限，很多同学直接把名字长度写死为 100，导致字符串被截断或者内存越界。只要把数组开大一些（比如 10000），或者改用动态分配、malloc 等方式，就能规避这一类问题。

之后在洛谷题面加上提示：机器人的名字长度可能有一万位，于是ac率直线上升了

我想说的是，大家需要学会debug

E：命中注定

括号匹配是人和编译器之间最基本的信任。

#include <stdio.h>#define MAXN 1000005  /* 括号串长度 < 1e6，预留一点空间 */char s[MAXN];
char st[MAXN];  /* 手写一个栈 */
int top = -1;   /* 栈顶指针，-1 表示空栈 */int main(void) {if (scanf("%s", s) != 1) {return 0;}for (int i = 0; s[i] != '\0'; i++) {if (s[i] == '(') {/* 左括号直接入栈 */st[++top] = '(';} else if (s[i] == ')') {/* 遇到右括号 */if (top < 0) {/* 栈空，说明目前为止右括号太多，直接把这个右括号压栈 */st[++top] = ')';} else if (st[top] == '(') {/* 栈顶是左括号，可以成功匹配，弹栈 */top--;} else {/* 栈顶是右括号，无法匹配，只能把这个右括号也压栈 */st[++top] = ')';}}}if (top == -1) {/* 栈空，说明所有括号完全匹配 */printf("YES\n");} else {/* 栈非空，栈里剩下的就是所有“不成对”的括号个数 */printf("NO\n");printf("%d\n", top + 1);}return 0;
}

这个题可能大家会觉得莫名其妙，实际上背后对应的是一个非常基础的自动机/语法分析模型。

c语言是一个面向过程的语言，对于不同的状态你需要使用不同的操作

用栈维护“尚未被配对的括号集合”：

遇到 '(' 就入栈；
遇到 ')' 时，若栈顶为 '(' 则弹栈配对，否则将 ')' 压入栈中。

遍历结束后，若栈为空，则原串是一个合法括号序列；否则栈中剩余的元素个数，就是至少需要补上的括号数量。

可以把最终的形态想象成类似于 )))))((((( 这样的结构：前面一串多余的右括号，后面一串多余的左括号，每一个都需要再补一个相反方向的括号才能配平。

难度不高，但这个模型在之后的表达式解析、编译原理等课程中会一再出现，建议大家在心里把“括号匹配 = 栈”的映射牢牢记住。

很经典的题，大家的通过率都很高

F：库因兰德（Q Island）

如果一门语言不能拿来写模拟题，那它也就只剩下 Hello World 了。

#include <stdio.h>#define MAXN 305
#define MAXM (MAXN * MAXN + 5)/* 棋盘上的法阵编号，0 表示没有法阵 */
int ma[MAXN][MAXN];/* 每个法阵编号对应的 (x, y)，传送法阵存目标坐标，转向法阵存 (-1, -1) */
int opx[MAXM], opy[MAXM];int main(void) {int n = 0, m = 0, k = 0;if (scanf("%d", &n) != 1) return 0;scanf("%d", &m);/* 传送法阵：编号 1 ~ m */for (int i = 1; i <= m; i++) {int a, b, c, d;scanf("%d %d %d %d", &a, &b, &c, &d);ma[a][b] = i;opx[i] = c;opy[i] = d;}/* 转向法阵：编号 m+1 ~ m+k，目标坐标存 (-1, -1) */scanf("%d", &k);for (int i = 1; i <= k; i++) {int a, b;scanf("%d %d", &a, &b);int idx = m + i;ma[a][b] = idx;opx[idx] = -1;opy[idx] = -1;}int nowx = 1, nowy = 1;  /* 当前所在格子 */int nowd = 0;            /* 当前方向：0,1,2,3 *//* 方向定义dx[0] =  1, dy[0] =  0  （“向右”，即 x+1）dx[1] =  0, dy[1] = -1  dx[2] = -1, dy[2] =  0dx[3] =  0, dy[3] =  1*/int dx[4] = {1, 0, -1, 0};int dy[4] = {0, -1, 0, 1};int cnt = 0;  /* 步数计数，用来防止死循环 *//* 只要没到 (n, n) 就一直走 */while (nowx != n || nowy != n) {/* 出界：直接把位置重置到 (1,1) 并跳出循环 */if (nowx > n || nowx < 1 || nowy > n || nowy < 1) {nowx = 1;nowy = 1;break;}/* 防止死循环：超过 n*n*5 步就认为不可能到达，跳出 */if (cnt > n * n * 5) {break;}int p = ma[nowx][nowy];  /* 当前格子上的法阵编号（若为 0 则没有法阵） */if (p) {int c = opx[p];int d = opy[p];if (c == -1 && d == -1) {/* 转向法阵：顺时针旋转 90° */nowd += 1;if (nowd >= 4) nowd -= 4;} else {/* 传送法阵：直接传送到 (c, d)，并计一步 */nowx = c;nowy = d;cnt++;/* 传送后立刻重新处理新位置上的法阵，因此 continue */continue;}}/* 按当前方向走一步 */nowx += dx[nowd];nowy += dy[nowd];cnt++;}/* 结束后，判断是否停在 (n, n) */if (nowx == n && nowy == n) {printf("YES\n");} else {printf("NO\n");}return 0;
}

最难的题，其实我一开始没有想过出这么难的，结果非常出乎我的意料

在没有图片的方向的提示下，所有ai都默认向右是y-1,这也是卡住大部分同学的原因，大家只要检查一下方向，还是能过不少人

还有就是，大多数ai都会使用bfs的方式，我也不清楚是什么原理，都没有想过直接模拟一步一步走

因此，我一度以为，是数据出错了，后来检查发现，好家伙真的错了，前4个样例输入为空，我也没搞清楚怎么回事

于是就删掉出错的数据了，再次跟大家说声抱歉，后来验证，其他数据都没错

这道题对于大部分同学来说，都是一道不错的练手题

非常适合练习“模拟 + 状态追踪 + 调试能力”的题目，如果赛时没有写出来，赛后一定要找时间把它补完。

G：魔法使提高：标准模板

STL 写起来很爽，但用纯 C 写一遍，你才会真懂它在干什么。

#include <stdio.h>#define MAXN 100000    /* n < 100000 */
#define MAXLEN 105     /* 字符串长度 < 100 */char name[MAXN][MAXLEN]; /* 存所有字符串 */
int head[10005];         /* 每个桶（余数）的链表头下标，-1 表示该桶为空 */
int nxt[MAXN];           /* 单链表 next 指针 */
int main(void) {long long x;  /* 模数 */int n;        /* 元素个数 */if (scanf("%lld %d", &x, &n) != 2) {return 0;}/* 初始化所有桶为空 */for (int i = 0; i < 10005; i++) {head[i] = -1;}for (int i = 0; i < n; i++) {long long V;/* 读入数值和字符串 */scanf("%lld %s", &V, name[i]);int r = (int)(V % x);  /* 计算 V % x 作为桶编号 *//* 模拟 stack<string>：新来的元素插到链表头，相当于栈顶 */nxt[i] = head[r];head[r] = i;}/* 按桶编号从小到大输出（对应 C++ 里 map 的 key 升序） */for (int r = 0; r < x; r++) {if (head[r] == -1) continue;  /* 如果该桶为空，就不输出这一行 */printf("%d ", r);/* 按链表顺序输出，这里因为是“头插法”，顺序就是栈的 LIFO 顺序 */int idx = head[r];while (idx != -1) {printf("%s ", name[idx]);idx = nxt[idx];}printf("\n");}return 0;
}

这道题主要是想考数据结构，其实题目的要求十分清晰明了了，直接交给ai就可以一次ac

如果出现bug，只要你看得懂代码就可以自行修改

标准模板是什么？在 C++ 世界里，有一套非常强大、非常常用、几乎所有竞赛选手都离不开的工具，这就是：

STL（Standard Template Library，标准模板库）

如果把编程比喻成做菜，那么——

C 语言是从买菜 → 洗菜 → 切菜 → 全部自己动手
C++ STL 是别人已经 洗好、切好、腌好 的食材，你只需要直接 炒锅里一倒 就能出菜

其实要求大家用c语言写这道题比较困难。所以我把这题的难度标高了很多

虽然但是，这题还是很重要的

H：凝滞的白之庭院

二分查找让计算机更冷静，也逼着人类更精确。

#include <stdio.h>#define MAXN 10005long long h[MAXN];int main(void) {int n;long long x;scanf("%d %lld", &n, &x);for (int i = 1; i <= n; i++) {scanf("%lld", &h[i]);}/* 与你原代码一致的二分边界 */long long l = 1;long long r = 0x3f3f3f3f3f3f3f3f;   /* 一个非常大的数（充当右边界） */while (r >= l) {long long mid = (l + r) >> 1;long long cnt = 0;for (int j = 1; j <= n; j++) {cnt += h[j] / mid;   /* 每棵树最多能切多少段长度为 mid 的木材 */}if (cnt < x) {/* mid 太大，导致切出来的段数不足，需要缩小段长 */r = mid - 1;} else {/* mid 还可以继续往大试 */l = mid + 1;}}/* 根据你原 C++ 代码的写法，答案输出 l-1 */printf("%lld\n", l - 1);return 0;
}

正如题目下方的小字所说，没有二分就没有算法，这道题作为算法的经典代表，很有做的价值。

可以把这一类题想象成在 $0$到 $100$ 之间猜一个数字：每次询问的反馈只有“偏大”或“偏小”

你自然会先猜 $50$，然后根据反馈把区间缩小一半，再尝试区间中点。

真正的二分查找也是同样的思想，只不过这里我们是在数轴上查找“能否切出至少$x$段”的分界点。

大部分同学的错误集中在两个方面：一是没有使用 long long 处理大数据

二是二分边界条件写错，导致死循环或答案偏一位。建议在草稿上先写出区间变化过程，再对照代码逐步模拟。

I：亿万年的星光

解决 NP 难题前，先把背包 DP 写顺手。

#include <stdio.h>#define MAXK 15005  /* k < 15000 */
int dp[MAXK];       /* 一维 DP 数组，dp[j] 表示容量为 j 时的最大价值 */int main(void) {int n, k;if (scanf("%d %d", &n, &k) != 2) {return 0;}for (int i = 0; i < n; i++) {int t, v, w;scanf("%d %d %d", &t, &v, &w);if (t == 1) {/* 0/1 背包：每个物品只能选一次必须从大到小遍历容量，防止同一个物品被重复使用 */for (int j = k; j >= v; j--) {int val = dp[j - v] + w;if (val > dp[j]) {dp[j] = val;}}} else {/* 完全背包：物品可无限次选取必须从小到大遍历容量，允许多次利用同一物品 */for (int j = v; j <= k; j++) {int val = dp[j - v] + w;if (val > dp[j]) {dp[j] = val;}}}}printf("%d\n", dp[k]);return 0;
}

动态规划（DP）并不仅仅是“刷题”的技巧

它背后蕴含的思想——把一个大问题拆解成若干规模更小、结构相似的子问题，并在子问题答案的基础上进行组合——在工程和建模中都有广泛应用。

在本题中，我们设置一维数组 dp[j] 表示：背包容量为$j$时，能够获得的最大价值。初始状态为 dp[0] = 0，其余为 0。每读入一个物品，根据类型决定更新方向：

若 $t=1$，是 $0/1$ 背包，容量从大到小枚举 $j$，保证每个物品至多被使用一次；
若 $t=0$，是完全背包，容量从小到大枚举 $j$，允许在同一转移中多次利用该物品。

转移方程在两种情况下都是：
$ dp[j] = \max\bigl(dp[j],\ dp[j - v] + w\bigr), $
只是在遍历顺序上有所区别。最终输出 dp[k] 即可。

建议大家把这一题当作“混合背包”的模板认真记住，后续遇到更复杂的背包变种时，都会在这个框架上进行扩展。

J：献给挚爱的你的不思议之国

“若十五步以内无法触及彼此，那大概就真的是缘尽于此了。”
——写给所有努力靠近 y 的 x

#include <stdio.h>#define LIMIT 1000000   /* 状态数值上限，防止乱乘乱加导致越界 */
#define MAXQ 2000000    /* 队列最大长度，足够 15 步以内的 BFS 使用 */typedef struct {int val;int step;
} Node;Node q[MAXQ];
int head = 0, tail = 0;
char vis[LIMIT + 5];int main(void) {int x, y;if (scanf("%d %d", &x, &y) != 2) return 0;/* 特判：起点就是终点 */if (x == y) {printf("YES\n");return 0;}/* BFS 起点：从 (x, 0步) 出发 */q[tail].val = x;q[tail].step = 0;tail++;while (head < tail) {Node cur = q[head++];int now = cur.val;int step = cur.step;if (step > 15) continue;         /* 超过 15 步就不再考虑 */if (now < 0 || now > LIMIT) continue;if (vis[now]) continue;vis[now] = 1;if (now == y) {printf("YES\n");return 0;}if (step == 15) continue;        /* 15 步已经用完，不能再扩展 *//* 4 种操作：都算一步 *//* 1：变成 0 */if (!vis[0]) {q[tail].val = 0;q[tail].step = step + 1;if (tail < MAXQ) tail++;}/* 2：乘以 7 */long long v1 = (long long)now * 7;if (v1 >= 0 && v1 <= LIMIT && !vis[(int)v1]) {q[tail].val = (int)v1;q[tail].step = step + 1;if (tail < MAXQ) tail++;}/* 3：除以 2 */int v2 = now / 2;if (v2 >= 0 && v2 <= LIMIT && !vis[v2]) {q[tail].val = v2;q[tail].step = step + 1;if (tail < MAXQ) tail++;}/* 4：加 1 */int v3 = now + 1;if (v3 >= 0 && v3 <= LIMIT && !vis[v3]) {q[tail].val = v3;q[tail].step = step + 1;if (tail < MAXQ) tail++;}}printf("NO\n");return 0;
}

这个题其实是有一点难度的，作为搜索题，有许多边界条件，但是只要稍作限制就可以了

其实这个题还可以加速1/4，变0操作可以直接放进队列中,注意到，变0操作只执行一次是最优的

执行更多次变0操作一定会浪费步数

关于bfs广度搜索算法

想象你迷路了，站在起点，你不会乱跑，而是：