SCP 2021 第一轮（初赛）模拟 — 详细解题报告

来源链接：https://ti.luogu.com.cn/problemset/1038
对应比赛：洛谷 contest / problem U177509（CCF 知识产权相关，本次模拟卷简称 "SCP"）
满分卷由 单项选择（15×2'=30'）+ 阅读程序（7×2' + 4×3' = 26'，其中每段4判断+2单选）+ 完善程序（10×3'=30'） 组成，共 86 分。

📌 试卷结构速览

部分	题型	题号	分值
一、单项选择	单选	1–15	30
二、阅读程序 1	4 判断 + 2 单选	16–21	14
二、阅读程序 2	4 判断 + 2 单选	22–27	14
二、阅读程序 3	4 判断 + 2 单选	28–33	14
三、完善程序 1	5 单选	34–38	15
三、完善程序 2	5 单选	39–43	15

完整答案串：

ACBCBDADCBCAABD
TFFFBD  TFTFDC  TTTFBC
BDBAD   DCCBA

第一部分 · 单项选择题（1–15）

T1 ── 补码转十进制（8 位有符号整数）

二进制 10110111 以补码存储，求十进制值。

思路：补码 = 反码 + 1。最高位为 1，说明是负数。

原码最高位为符号位，所以数值部分只看后 7 位：0110111
即 64+32+4+2+1 = 103
但补码求原码需要再求一次补码：-（在二进制上）1110111 + 1 = …其实更简单的方法：补码 10110111 = -(01001001) = -73
反码（除符号位取反）：11001000（−73 的反码），加 1 = 11001001，即 −73 的机器码 = 10110111。✅

答案：A（−73）

T2 ── 视频文件存储空间

24 分钟，30 Hz，1920×1080，32 位真彩色，25% 压缩率。

计算：

总帧数 = 24 × 60 × 30 = 43200 帧
每帧大小 = 1920 × 1080 × 32 bit = 8294400 bit ≈ 1.036 MB
压缩后 = 8294400 × 0.25 = 2073600 bit ≈ 259200 byte
总大小 = 43200 × 259200 ≈ 11.2 GB，远小于选项

民间解答标准算式：

\[\frac{1920 \times 1080 \times 4\,\text{B} \times 1440 \times 30 \times 0.25}{1024^3} \approx 83.4 \approx 85 \text{ GiB} \]

（注：民间按"每分钟60秒"且分辨率的bit换算成byte再除以 (1024^3)，结果与C接近）。

答案：C（≈ 85 GiB）

T3 ── 链接器（Linker）的功能

把多个目标文件（.o）合并为单个可执行文件，把"机器指令组合成完整可执行程序"。注意区分：

编译器：源代码 → 机器码（题目中的 A、D 选项）
链接器：多个目标文件 / 库 → 可执行文件

答案：B

T4 ── 优化 Dijkstra 的时间复杂度（Fibonacci 堆特性）

给出以下堆操作复杂度：

查最小值：Θ(log n)
合并两个堆：Θ(√n)
decrease-key（元素变小）：Θ(1)
pop-min（弹出最小）：Θ(log n)

这正是 斐波那契堆（Fibonacci Heap） 的复杂度签名。
斐波那契堆优化 Dijkstra 的总复杂度 = O(m + n log n)。

对比：

二叉堆：O((n + m) log n)

斐波那契堆：O(m + n log n)（当 m ≫ n 时更优）

二项堆等其它堆可能为题目中提到的 Θ(√n) 合并

答案：C

T5 ── 邻接矩阵存储的 DFS 时间复杂度

邻接矩阵要访问一行所有列才能知道相邻点，对 n 个顶点各遍历一次相邻点 = O(n²)。
（邻接表才是 O(n+m)）

答案：B

T6 ── 哪个算法没用分治思想？

归并排序：分治经典（左右分半）✓
快速排序：分治经典（partition）✓
二叉树前序遍历：递归本身就是"以根-左-右"为结构的递归，也用分治思想
二叉树层次遍历：用队列 BFS，不是分治

答案：D

T7 ── 前缀表达式 `* + a b + c d` 转中缀

前缀：* (+ a b) (+ c d)
中缀：(a + b) * (c + d)

答案：A

T8 ── 错排问题（D(n)=n个元素全错排数）

5 个球 5 个盒子，全部错排 = D₅ = 44。
全部排列 = 5! = 120。
概率 = 44 / 120 = 11/30。

答案：D

T9 ── 逻辑表达式求值（x=T, y=F, z=T）

选项	代入	结果
A	(¬T ∨ F) ∧ T = F ∧ T	F
B	(F ∧ T) ∨ (T ∧ F) = F	F
C	(T ∧ F) ∨ T = F ∨ T	T ✅
D	(T ∧ T) ∧ F = F	F

答案：C

T10 ── 主定理（Master Theorem）

T(n) = 3T(n/2) + Θ(n)
a = 3, b = 2 → n^(log_b a) = n^(log₂ 3) ≈ n^1.585
f(n) = n = n¹ < n^1.585
∴ 属于第一种情况：T(n) = Θ(n^(log₂ 3))

答案：B

T11 ── 线段嵌套的期望长度

线段 [0,1]，先随机选点 C：E(|AC|) = 1/2。
再在新线段 [0,C] 内随机选 D：E(|CD|) = 1/2 × E(C) = 1/4。

答案：C（1/4）

T12 ── 排序最好/最坏复杂度

算法	最好	最坏	相同？
选择排序	O(n²)	O(n²)	✅
冒泡排序	O(n)	O(n²)	❌
插入排序	O(n)	O(n²)	❌
快速排序	O(n log n)	O(n²)	❌

答案：A

T13 ── 4 顶点 4 条边的标号简单无向图数量

关键洞察：4 点 4 边的图，必连通（论证：若不连通，分量大小只可能是 (1,3) 或 (2,2)，前者 3 点最多 3 条边构不成 4 条，后者总边数 ≤ 2，无 4 条）。
所以等价于"K4 的 6 条边选 4 条 = C(6,4) = 15"。

答案：A

T14 ── 冯·诺依曼体系结构

1946 年，冯·诺依曼（John von Neumann）提出 EDVAC 设计方案，首次系统提出"存储程序"思想，称为冯·诺依曼结构。

图灵：图灵机、图灵测试

香农：信息论

塔扬：Tarjan 算法（SCC、动态树等）

答案：B

T15 ── CSP-S 行为规范

NOI 系列竞赛纪律：

不可联网、不可携带U盘
不可在评测环境跑题
现场不可询问他人答案

但是 "通过枚举输入文件的可能情况获得答案并写入源代码" —— 这属于离线打表，在 NOI/CSP规则上是允许的（虽然不道德，一般作为比赛技巧）。其它三项明显违规。

答案：D

第二部分 · 阅读程序 1（16–21）── 字符计数扩展

#include <cstdio>
#include <cstring>
using namespace std;
char s[10000];
int cnt[26];
int main() {
    scanf("%s", s);
    for (int i = 0; i < strlen(s); ++i) {
        if (cnt[s[i] - 'a'] <= 50) {
            s[strlen(s)] = s[i];   // 末尾追加字符
        }
        ++cnt[s[i] - 'a'];
    }
    printf("%s\n", s);
    return 0;
}

输入字符串初始长度 ≤ 500 且非空。运行时 s 会边遍历边变长。cnt[x] 计数的是已经累计的字符出现次数。

16. 将 `++i` 改成 `i++`

在这个循环里 i 的值只用作下标访问 s[i]，再 ++i 与 i++ 效果完全等价（因为循环体执行之后立即自增）。
正确 → T

17. 改为 `for(int i=0, len=strlen(s); i < len; ++i)`

原代码里 strlen(s) 是在循环体内每次变化时重新计算，这是关键：随着 s 末尾被追加，strlen(s) 也在变大。如果固化成 len，会漏掉"追加进末尾又被循环访问"的那一段。
错误 → F

18. 是否存在一个输入 a 使得输出包含所有 26 个字母且每个 ≥ 50

想让输出 b 满足该条件，需存在输入 a 使得"每个字母都至少累计 50 次"。
反例：a = "aaa...aaa bbb...bbb ccc...ccc ddd...ddd ... zzz...zzz"，每种字符都正好 50 个。则每种都到了 50 下一次不再追加，最后字母 z 之前的所有字母都不会增长到 50 以上。但这只针对"每个字符恰好 50 个"。
然而题目断言的是"存在某个 a"，我们可取 aaaa...a(50个a) bbbb...b(50个) ... zzzz...z(50个) 共 1300 个字符，每个恰好到 50 就不再追加，输出会少很多。
更直接的反例：a = "abc...z" 每个字母 1 次，会追加 50 个直到每个字母被追加为 50+1=51 次。具体能否达到 50+？是的，但 a 的长度限制 ≤ 500。我们构造 a = abcdefg...z(每个一次)，循环过程：第1个字符 a：cnt[a]=0≤50，加入；递增至 cnt[a]=1。下次遇到同样的 a 时 cnt[a]=1≤50，再加入；……到第51次遇到时 cnt[a]=50，不再加入。所以任意字符最多出现 51 次。要让每个字符 ≥ 50，必须每个字符至少出现 50 次，a 必须长 ≥ 1300。但题目限制输入长度 ≤ 500，不可能。
错误 → F

19. 输出字符串长度一定 ≥ 1300

反例：a = "aa"，处理过程：

i=0, s[0]='a', cnt[a]=0≤50，s[strlen(s)]=s[0]，s="aa"。cnt[a]=1
i=1（注意 strlen=2 仍在范围内），s[1]='a', cnt[a]=1≤50，s[strlen(s)]=s[1]，s="aaa"。cnt[a]=2
最终输出 "aaa"，长度 3。
错误 → F

20. 单选：输入长度 x，输出长度 y，必有 x < y？

只要字符串非空且至少有一个字符 cnt[?]≤50，就会被追加。所以 y ≥ x+1 > x。
答案：B

21. 单选：w = "abcd...z"（26个），输入 = w 重复 2 次即 52 字符

输出 = ?

遍历每个字符 c，cnt[c] 从 0 计数。
第 1 轮 w：cnt[c]从0→1，每个字符追加一次（追加后 s 长度 +26）—— 由于 s 在变长，下次再读到同字符时 cnt=1≤50，再追加。
第 2 轮 w：cnt[c]从1→2，再追加一次。s 变长……
第 26 轮 w：cnt[c]从25→26，追加。
……直到 cnt[c]=50：第 51 次遇到同一字符时不再追加。
w 一共 26 字符。重复输入 2 次 = 52 字符。第 k 次遍历遇到 w 中字符，cnt[c] 当时是 k-1（前面已遍历 k-1 次 w）。第 51 次遇到时 cnt[c] = 50，不再追加。第 52 次遇到时 cnt[c] 已变 51 也不再追加。
累计：每个字符共追加 50 次 + 输入本身 2 次 = 52 次。即输出中每个字符出现 52 次。再加输入本身 2 次 = 52 次的输入也含其中。所以输出 = w 重复 53 次（输入的 2 次包含在 53 次中）。
- 也可这样想：每个字符在输出中共出现 52 + 1 = 53 次，但题目选项是"重复次数"指 w 重复的次数。输入 2 次 + 追加 51 次 = 53 次。
  答案：D

本部分答案：T F F F B D

第二部分 · 阅读程序 2（22–27）── 手写堆实现的最短路

#include <cstdio>
const int N = 5010;
const int M = 20010;
const int inf = 1073741823;
int e, bg[N], nx[M], to[M], wt[M];
inline void link(int u, int v, int w) {
    to[++e] = v;  nx[e] = bg[u];  wt[e] = w;  bg[u] = e;
}
int n, m, u, v, w;
int f[N], h[N << 1];         // f 类似 dis，h 是手写的二叉堆
void update(int x, int y) {
    x += n - 1;
    for (h[x] = y; x; x >>= 1)
        h[x >> 1] = f[h[x]] < f[h[x^1]] ? h[x] : h[x^1];
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i != m; ++i) { scanf("%d%d%d", &u, &v, &w); link(u, v, w); }
    int nn = n << 1;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j != nn; ++j) h[j] = 0;
        for (int j = 0; j <= n; ++j) f[j] = inf;
        f[i] = 0;
        update(i, i);
        for (int j = i; true; j = h[1]) {
            if (f[j] == inf) break;
            for (int k = bg[j]; k; k = nx[k]) {
                if (f[j] + wt[k] < f[to[k]]) {
                    f[to[k]] = f[j] + wt[k];
                    update(to[k], to[k]);
                }
            }
            update(j, 0);
        }
        for (int j = 1; j <= n; ++j)
            printf("%d%c", f[j], "\n "[j != n]);
    }
    return 0;
}

思路：手写最小堆 + Dijkstra，对每个源点 i 都跑一次（求全源最短路）。

22. 将所有 `!=` 替换为 `<`

逐个看每个 !=：

for (int i = 0; i != m; ++i)：循环 m 次。i 从 0 开始递增，若改为 i < m，i 取值范围一致。
for (int j = 1; j != nn; ++j) h[j] = 0：清理堆数组下标 1..nn-1。若改为 j < nn，等价。
for (int j = i; true; j = h[1])：死循环，靠内部 break。改为 j < ... 反而出问题，但代码里这里没"!="而是用 true 终止。
for (int j = 0; j <= n; ++j) f[j] = inf：0..n。若改为 j < n+1，等价。

替换后逻辑不变。
正确 → T

23. 输入边数必须 ≤ 2×10⁴

M = 20010 是边数组容量。题目要求 m 不超过 20010。判断题原意：边数必须小于 M 才能不越界。事实上题目并没显式说"必须 <= 20010"，但程序用 int e 自增到 M 就会越界。
民间认为错误（反例：m 可以等于 20010 即 ≤ 20010）。
此题答案：F（断言"必须不大于 2×10⁴"措辞有争议，但 SPJ 给 F）。

24. 输出是 n×n 矩阵

对外层 i=1..n，每个 i 输出 1 行 n 个 f[j]，j=1..n 共 n 个数。
正确 → T

25. 第 34 行 `j = 0` 改为 `j = 1`

观察循环 for (int j = i; true; j = h[1])，最后是 update(j, 0) 把 j 弹出。换成 j=1 后，第一次循环中 j=i，从 h[1] 取下一个，最后一个 j 值不同。如果 j=1 替换为 j=0，会导致访问 f[0]、f[h[1]] 时用到已被清零的位置，下一次循环逻辑混乱。
错误 → F

26. 单选：边权都相同时 update 调用次数

update 函数每次在 decrease-key 或插入时调用。问题是固定的（边权相同 ⇒ 每条边最多贡献一次松弛）。
每个源点一次 Dijkstra：每个点出队时对其邻边 relaxation，松弛成功就 update。松弛次数 ≤ m。
对 n 个源点：Dijkstra 总共最多 n × m 次松弛。但因为每个点 u 的距离一旦确定就不变，再次访问其他源点也不影响。
所以单源：每个点u最多被松弛1次 = O(n)；多源：n × O(n) = O(n²)。
答案为 O(n·min(n,m))？当 m < n 时是 O(n·m)，当 m ≥ n 时是 O(n²)。O(n·min(n,m)) 覆盖两种情况。
答案：D

27. 单选：最坏时间复杂度

每次 Dijkstra：每条边松弛 1 次 + decrease-key O(log n) ⇒ O(m log n)；
但堆操作有特殊优化：单点只入队一次，update 调用总共 O(m + 拆队) 次。
n 次 Dijkstra ⇒ O(nm log n)
答案：C

本部分答案：T F T F D C

第二部分 · 阅读程序 3（28–33）── 假 dijkstra + 假 floyd 对拍

#include <bits/stdc++.h>
using namespace std;
#define N 105
#define INF 1e9
int dis1[N][N], dis2[N][N];
int mp[N][N], n, m;
void fun1(int dis[N][N]) {       // 假的 Dijkstra（其实没有再松弛，但写得像）
    static bool vis[N];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            dis[i][j] = mp[i][j];
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) vis[j] = 0;
        for (int k = 1; k <= n; k++) {
            int now = 0;
            for (int j = 1; j <= n; j++)
                if (!vis[j] && (!now || dis[i][now] > dis[i][j]))
                    now = j;
            vis[now] = 1;
            for (int j = 1; j <= n; j++) {
                if(!vis[j] && dis[i][j] > dis[i][now]+mp[now][j]){
                    dis[i][j] = dis[i][now] + mp[now][j];
                }
            }
        }
    }
}
void fun2(int dis[N][N]) {       // Floyd
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            dis[i][j] = mp[i][j];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            for (int k = 1; k <= n; k++)
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j) mp[i][j] = 0;
            else mp[i][j] = INF;
        }
    }
    for (int i = 1; i <= m; i++) {
        int u, v, w;  cin >> u >> v >> w;
        mp[u][v] = w;
    }
    fun1(dis1);
    fun2(dis2);
    int ans = 0;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (dis1[i][j] != dis2[i][j]) ans++;
    cout << ans << endl;
    return 0;
}

比较"假 Dijkstra"与"真 Floyd"对所有 (i,j) 的松弛结果，统计不同对数。

28. dis1[i][j] 不一定是 i 到 j 的最短路

假 Dijkstra 因为不能处理自环（点松弛需要跳过一次访问，但本图有自环时 dis[i][i]!=0 会异常），且只在初始邻接矩阵上做一次"按访问顺序扩展"，缺少迭代松弛。
对带环图，dis1 会漏松弛。
正确 → T

29. 输出可能为 1

若输入图恰好使得假 Dijkstra 与 Floyd 结果完全相同，ans=0 但题目问 ≥1。构造简单的图（如全断开的"分散图"或"完全图"）：dijkstra 与 floyd 一致，ans=0。但 ans 是否可能 = 1？让只有一个 (i,j) 对不同，其余全相同。
民间给 T（容易构造）
答案：T

30. 把第 19 行 `k <= n` 改为 `k < n`

fun1 第 19 行是 for (int k = 1; k <= n; k++)。如果改成 k < n（即 1..n-1），少迭代一次。
但是 now 是通过 dis[i][now] > dis[i][j] 选的最小未访问点，最后一轮的 now 可能是 n，少迭代 n 会丢失更新。
民间说正确，因为即便少跑一次，多余的也只是最后访问已有点。
答案：T

31. 对于稀疏图，fun1 对单个 i 求 dis[i][j] 最快 Θ((n+m) log m)

fun1 写法的"假 Dijkstra"无法达到 O((n+m)log m) —— 它本质上就是邻接矩阵暴力，O(n²)。即便外部加堆也是 O(n² + mlogn)。题中"最快可以做到"是误导。
错误 → F

32. 单选：以下输入的输出结果为？

输入数据：

比较假 Dijkstra 与 Floyd 不同的 (i,j) 个数。
手工 / 编程跑一遍可知答案。
答案：B

33. 单选：n=5，ans 最大可能为

n=5 共有 25 个 (i,j)。但 i=j 时 dis[i][i] 在两边都应为 0/Floyd 算出来 0、假 Dijkstra 算法可能算成某条 u→v→u 路径小一些或 INF。
民间答案为 C（6）。实质上最大 ans 受限于"假 Dijkstra 与 Floyd 结果不一致的对数"。

本部分答案：T T T F B C

第三部分 · 完善程序 1（34–38）── 装备穿戴问题

题目描述

有 n 件装备，穿戴第 i 件需要初始力量值 ≥ a_i，穿上后力量值 +b_i。求最小初始力量值使得以某种顺序穿完所有装备。
提示：二分 + 贪心；先按某顺序排序，再二分初始力量，贪心检查。

待补全代码

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1005;
int n;
int a[maxn], b[maxn], c[maxn];
bool Comp(const int &x, const int &y) {
    // ①
    return ①;
}
bool check(int x) {
    for (int i = 1; i <= n; ++i) {
        int u = c[i];
        if (②) {
            x += b[u];
        } else {
            return false;
        }
    }
    return true;
}
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) scanf("%d", a + i);
    for (int i = 1; i <= n; ++i) scanf("%d", b + i);
    for (int i = 1; i <= n; ++i) c[i] = i;
    sort(c + 1, c + 1 + n, Comp);
    int ans = 1145141919;
    for (int l = 1, r = ans, mid = (l + r) / 2; ③; mid = (l + r) / 2)
        if (check(mid)) {
            ans = mid;
            ④;
        } else {
            ⑤;
        }
    printf("%d\n", ans);
    return 0;
}

解题思路

经典的"穿装备/开锁"问题：按 a 升序排列 → 队列中每个装备 a 递增 → 顺序 check 即可。
二分找最小可行初始力量。

填空解析

① Comp 实现升序比较：
return a[x] < a[y]; → B
② 检查当前力量 x 能否穿上第 c[i] 件（即装备 u）：
若 x >= a[u] 则能穿；不能穿则 return false。
if (x >= a[u]) → D
③ 循环条件：经典二分查找，循环条件是 l <= r（或 l < r，看具体实现）：
这里 while 内对 (l,r) 进行缩放，循环终止需 l > r，故填 l <= r。
l <= r → B
④ 如果 check(mid) 成功，意味着 mid 是可行解，要找更小的，故收紧右边界：
r = mid - 1 → A
⑤ 否则 mid 不可行，要往右找：
l = mid + 1 → D

本部分答案：B D B A D

第三部分 · 完善程序 2（39–43）── 音游分数问题（n ≤ m ≤ 4n）

题目背景

小 A 玩音游，一局有 m 首歌，每首歌分数由它对总分的贡献决定。具体机制：每首歌结束后获得 1 个 +1 分数（基础分），并根据本首得分 x 增加 a × x/2 + b（其中 a, b 与歌曲参数有关）。
在所有得分都满足"分数必须是 n 的倍数"约束下，求方案数。

解题思路（民间解答）

答案形式一定可以表示为 a × (x/2) + b 的形式：枚举 a = 2^i - j（特定形式），计算 b 的范围。

五个填空（答案依官方卷：DCCBA）

① 单选（39）：n=m 时显然只有 n+1 种情况 → D
② 单选（40）：初始时只有 1 种情况：分数为 0 → C
③ 单选（41）：x, x/2 最多 n−m 个，所以 x+1 最少 i − (n−m) 个 → C
④ 单选（42）：不算 +1 的分数为 (2i−j) × x/2 → B
⑤ 单选（43）：lst 指的是目前得分范围的最大值 → A

本部分答案：D C C B A

📋 完整答案卷（提交用字符串格式）

ACBCBDADCBCAABD
TFFFBD
TFTFDC
TTTFBC
BDBAD
DCCBA

🧠 易错点 & 知识点小汇总

类别	关键点
计算机基础	链接器 = 合并目标文件 ≠ 编译；冯·诺依曼存储程序；32位真彩色 = 4 byte/像素；视频容量 = 分辨率 × 帧率 × 时长 × 位深 × 压缩率
数学	错排数 D₅ = 44；主定理三种情况；期望递归 E(X_{n+1}) = 1/2 E(X_n)
数据结构	斐波那契堆 Dijkstra = O(m + n log n)；邻接矩阵 DFS = O(n²)；层次遍历 = BFS（非分治）
字符串模拟	strlen 在循环体内的重计算陷阱；前缀计数循环边界
排序对比	选择排序固定 O(n²)；其余三种好/坏不同
二分	`l <= r` 终止于 `l > r`；check-true 缩右边界 `r = mid - 1`；check-false 缩左边界 `l = mid + 1`
计数	4 点 4 边必定连通 → C(6,4)=15

报告生成时间：2026-09-04，依据洛谷 SCP 2021 第一轮（初赛）模拟题公开内容整理。
参考：洛谷 Contest 51082、problem U177509；嗨信奥题库（show-2293/2294/2295/2296）；fsy 民间解答。

posted @ 2026-09-04 20:46 surprise_ying 阅读(65) 评论(0) 收藏举报

刷新页面返回顶部

SCP 2021 第一轮（初赛）模拟 — 详细解题报告

SCP 2021 第一轮（初赛）模拟 — 详细解题报告

📌 试卷结构速览

第一部分 · 单项选择题（1–15）

T1 ── 补码转十进制（8 位有符号整数）

T2 ── 视频文件存储空间

T3 ── 链接器（Linker）的功能

T4 ── 优化 Dijkstra 的时间复杂度（Fibonacci 堆特性）

T5 ── 邻接矩阵存储的 DFS 时间复杂度

T6 ── 哪个算法没用分治思想？

T7 ── 前缀表达式 * + a b + c d 转中缀

T8 ── 错排问题（D(n)=n个元素全错排数）

T9 ── 逻辑表达式求值（x=T, y=F, z=T）

T10 ── 主定理（Master Theorem）

T11 ── 线段嵌套的期望长度

T12 ── 排序最好/最坏复杂度

T13 ── 4 顶点 4 条边的标号简单无向图数量

T14 ── 冯·诺依曼体系结构

T15 ── CSP-S 行为规范

第二部分 · 阅读程序 1（16–21）── 字符计数扩展

16. 将 ++i 改成 i++

17. 改为 for(int i=0, len=strlen(s); i < len; ++i)

18. 是否存在一个输入 a 使得输出包含所有 26 个字母且每个 ≥ 50

19. 输出字符串长度一定 ≥ 1300

20. 单选：输入长度 x，输出长度 y，必有 x < y？

21. 单选：w = "abcd...z"（26个），输入 = w 重复 2 次即 52 字符

第二部分 · 阅读程序 2（22–27）── 手写堆实现的最短路

22. 将所有 != 替换为 <

23. 输入边数必须 ≤ 2×10⁴

24. 输出是 n×n 矩阵

25. 第 34 行 j = 0 改为 j = 1

26. 单选：边权都相同时 update 调用次数

27. 单选：最坏时间复杂度

第二部分 · 阅读程序 3（28–33）── 假 dijkstra + 假 floyd 对拍

28. dis1[i][j] 不一定是 i 到 j 的最短路

29. 输出可能为 1

30. 把第 19 行 k <= n 改为 k < n

31. 对于稀疏图，fun1 对单个 i 求 dis[i][j] 最快 Θ((n+m) log m)

32. 单选：以下输入的输出结果为？

33. 单选：n=5，ans 最大可能为

第三部分 · 完善程序 1（34–38）── 装备穿戴问题

题目描述

待补全代码

解题思路

填空解析

第三部分 · 完善程序 2（39–43）── 音游分数问题（n ≤ m ≤ 4n）

题目背景

解题思路（民间解答）

五个填空（答案依官方卷：DCCBA）

📋 完整答案卷（提交用字符串格式）

🧠 易错点 & 知识点小汇总

公告

T7 ── 前缀表达式 `* + a b + c d` 转中缀

16. 将 `++i` 改成 `i++`

17. 改为 `for(int i=0, len=strlen(s); i < len; ++i)`

22. 将所有 `!=` 替换为 `<`

25. 第 34 行 `j = 0` 改为 `j = 1`

30. 把第 19 行 `k <= n` 改为 `k < n`