E11 真题：CSP 入门级第一轮 2019–2025（含答案）

答案：A

无符号 $32$ 位能表示 $0 \sim 2^{32}-1$，即 $0 \sim 4294967295 \approx 4.29 \times 10^9$。

📝 这两个数背下来：$2^{31} \approx 2.1 \times 10^9$（int 的上限），$2^{32} \approx 4.3 \times 10^9$（unsigned 的上限）。选项里 $2 \times 10^9$ 是有符号 int 的上限，专门放来骗人的。

答案：B

$255 = 11111111_2$，$254 = 11111110_2$，按位与得 $11111110_2 = 254$。

📝 x & (x-1) 的作用是「抹掉最低位的那个 1」，这是位运算里最常考的一个套路（另一个是 x & (-x) 取出最低位的 1）。所以看到 x & (x-1) 就直接想「少了一个 1」——$255$ 有 $8$ 个 $1$，抹掉最低位剩 $11111110_2$。

⚠️ 如果 x & (x-1) == 0，说明 $x$ 只有一个 $1$，即 $x$ 是 $2$ 的幂。这个结论会单独出题。

答案：B

从小往大算，别从 calc(5) 往下钻：

• calc(2)：偶 → calc(1)+1 = 2
• calc(3)：奇 → calc(2)+calc(1) = 2+1 = 3
• calc(4)：偶 → calc(2)+1 = 3
• calc(5)：奇 → calc(4)+calc(3) = 3+3 = 6

📝 递归题一律列表格从小往大填，别在脑子里展开调用树——初赛的递归题几乎全都能这么算，而且不会出错。

答案：B

哈夫曼树：每次取最小的两个合并，合并结果放回去。

$\text{WPL} = 22 + 35 + 47 + 82 = 186$。

📝 别去画树再逐个数深度，太慢也容易错。WPL = 所有「合并出来的新结点」之和——每合并一次就把那个和累加起来，做完就是答案。这是初赛哈夫曼题的标准解法。

答案：B

每条有向边给起点贡献 $1$ 个出度、给终点贡献 $1$ 个入度。所以入度总和 = 出度总和 = 边数。

📝 对照记：无向图里「所有顶点度数之和 = 边数 × 2」（握手定理）。有向图分开算就各等于边数，别把两条搞混。

答案：C

正难则反：总选法减去「全男」和「全女」。

$$C(9,4) - C(5,4) - C(4,4) = 126 - 5 - 1 = 120$$

📝 看到「都有」「至少一个」，先想补集。 直接分类（1男3女+2男2女+3男1女）也能做，但要算三次还容易漏，考场上慢一倍。

⚠️ 选项里的 $126$ 就是「忘了减」，$121$ 是「只减了全男」——出题人把每一种漏算都做成了一个选项。

答案：C

原式 $(a \wedge b) \vee (\neg c \wedge a) = a \wedge (b \vee \neg c)$（提取公因子 $a$）。

逐项验（已用真值表全部八种取值核对）：

📝 逻辑题不要硬推，直接列真值表。 三个变量只有 $8$ 行，画完一定不会错；反倒是「一眼看出来」最容易翻车。

答案：D

$f[n] = (f[n-1]+f[n-2]) \bmod 7$，算前几项找周期：

n :  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 | 16 17
f :  1  1  2  3  5  1  6  0  6  6  5  4  2  6  1  0 |  1  1

第 $16$ 项开始重复 $1,1$ —— 周期是 $16$。$2025 \bmod 16 = 9$，所以 $f[2025] = f[9] = 6$。

📝 看到「取模的递推」求很大的下标，一定是找周期。 做法固定：一直往下算，直到出现连续两项和开头一样（本题是 $f[16],f[17] = 1,1$），中间隔了多少就是周期。

⚠️ 求余数时用 $2025 \bmod 16$ 而不是 $2024$——数列是从 $f[0]$ 开始编号的，别错位。

答案：B

⚠️ 这是从 char 数组的知识生搬到 string 上会踩的坑，C 和 D 都是这么设计的。记住一句：string 自己管长度，不靠 '\0'。

答案：C

关键在 void solve(int &a, int b)：a 是引用（改了会传回去），b 是副本（改了白改）。

所以 $x=10$、$y=10$。

📝 这段代码本来是「不用临时变量交换两个数」的经典写法，但这里只有一个参数是引用，交换就废了一半。 初赛最爱考的就是这种「看着像交换其实不是」。

⚠️ 看到函数参数先做一件事：把带 & 的圈出来。 不带 & 的，函数里怎么改都跟外面无关。

答案：B

从 $(1,1)$ 到 $(4,5)$：行从 $1$ 到 $4$ 要向下 $3$ 步，列从 $1$ 到 $5$ 要向右 $4$ 步，共 $7$ 步，其中挑 $3$ 步向下：

$$C(7,3) = 35$$

📝 网格路径题的公式：$C(\text{总步数},\ \text{向下步数})$。 总步数 = 行差 + 列差。

⚠️ 行差是 $4-1=3$ 不是 $4$。 选项里的 $56 = C(8,3)$、$70=C(8,4)$ 就是给「把坐标当成步数」的人准备的。棋盘再大（$8\times 8$）也跟答案无关，那是干扰信息。

答案：B

冒泡排序的交换次数 恒等于数组里的逆序对个数。$\{6,1,5,2,4\}$ 的逆序对：

$(6,1)\ (6,5)\ (6,2)\ (6,4)\ (5,2)\ (5,4)$ —— 共 6 个。（已实跑冒泡确认交换 $6$ 次）

📝 背下来：冒泡排序的交换次数 = 逆序对数，因为每交换一次相邻元素恰好消掉一个逆序对。数逆序对比模拟冒泡快得多。

⚠️ 别把「交换次数」和「比较次数」搞混：比较次数固定是 $\dfrac{n(n-1)}{2}=10$（不加提前退出的话），跟数据长什么样无关。

答案：A

$270_8 = 2\times 64 + 7\times 8 + 0 = 184$，$720 + 184 = 904$。

$904 = 3\times 256 + 8\times 16 + 8$，所以是 $388_{16}$。

📝 进制混合运算的固定套路：全部先转成十进制算，最后再转成题目要的进制。 别想着直接在八进制下做加法。

⚠️ 八进制转十进制的权是 $1, 8, 64, 512$；十六进制是 $1, 16, 256, 4096$。这两串数背熟，初赛每年都用。

答案：C

完全二叉树 $n$ 个结点时，有孩子的结点恰好是编号 $1 \sim \lfloor n/2 \rfloor$，其余全是叶子。

$$\lfloor 1000/2 \rfloor = 500 \text{ 个内部结点} \Rightarrow 1000 - 500 = 500 \text{ 个叶子}$$

📝 公式：完全二叉树的叶子数 $= \lceil n/2 \rceil$。 $n$ 是偶数时正好是 $n/2$，奇数时是 $(n+1)/2$。

⚠️ 选项里的 $512$ 是「满二叉树最后一层」，$499$、$501$ 是差一。完全二叉树 ≠ 满二叉树：满二叉树每层都填满（结点数是 $2^k-1$），完全二叉树只要求最后一层靠左连续。

答案：A

老老实实模拟，栈顶写在右边：

$P = 5, 1, 3$。

📝 栈/队列的模拟题必须画这张表，一行一步。 想着「在脑子里过一遍」是这类题唯一的失分原因。

⚠️ 注意 $7$ 一直压在栈底没出来过——选项 D 的 5,1,3,7 就是给「以为最后要清空栈」的人准备的。

答案：(1) A　(2) B　(3) B　(4) B　(5) D　(6) A

程序在数 $1 \le i < j < k \le n$ 中两两互质的三元组个数。实测各 $n$ 的输出：

(1) 正确（A）：$n=2$ 时 $k$ 的循环 for (k = j+1; k <= 2; ...) 一次都进不去（$i=1,j=2$ 时 $k$ 从 $3$ 起步），所以那句 if 判断根本没执行过。输出 $0$。

(2) 错误（B）：$n=4$ 时原程序 $2$、删掉后 $3$——多出来的是 $(2,3,4)$：$\gcd(2,3)=1$、$\gcd(3,4)=1$，但 $\gcd(2,4)=2$。两两互质 ≠ 相邻互质。

(3) 送分题：洛谷标注「错题，请选择 B 获得分数」。

(4) 输出的答案小于原答案（B）：改成 gcd(a, a % b) 后，a 永远不变、b 每轮严格变小，最后 b 归零返回的就是最初的 a——也就是 gcd(i,j) 直接返回 i。于是条件退化成 i==1 && j==1，而 $j > i$ 永远不可能同时成立，输出恒为 $0$（$n$ 从 $2$ 到 $10$ 实测全是 $0$）。

⚠️ C（死循环）是最诱人的错误答案，但实测跑不出死循环。 因为 a % b < b 恒成立（$b>a$ 时 a % b = a < b），b 单调递减且非负，一定会到 $0$。「递归写错了」不等于「一定死循环」——这题就在考这个。

(5) 25（D）：$n=8$ 实测输出 $25$。

(6) 6（A）：$\gcd(36,42) \to \gcd(42,36) \to \gcd(36,6) \to \gcd(6,0) \to 6$。$252$ 是最小公倍数，放来骗人的。

⚠️ 题面里的行号（第 7 行、第 16 行）对应的是原卷排版，洛谷转录时缩进变了，行号对不上。 按文字描述定位：「第 7 行」= gcd 里那句递归调用，「第 16 行」= 那句 if (gcd(i,j)==1 && ...)。

答案：(1) A　(2) A　(3) B　(4) B　(5) A　(6) B

程序先排序去重，再用双指针贪心：把这些数分成尽量少的段，每段内最大值减最小值不超过 $k$，输出段数。

(1) 正确（A）：输入 3 1 / 3 2 1 → 排序去重得 $\{1,2,3\}$，$k=1$ → 分成 $\{1,2\}$ 和 $\{3\}$ 两段。实测输出 2。

(2) 正确（A）：至少 $1$ 段；最多每个数各成一段。实测 5 1 / 1 3 5 7 9 输出 $5$（上界），5 2 / 1 1 1 1 1 输出 $1$（下界）。

(3) 错误（B）：穷举了 $n \le 6$、值 $\le 6$、$k \le 5$ 的全部情况，一个反例都没有。 原因：重复的数排序后必定相邻，a[i] - a[j+1] 在它们之间是 $0$，永远不会 $> k$，所以不会多切一刀，ans 也就不变。

📝 去重在这里只是提速，不改变答案。 这题在考「你能不能分清哪些代码是必要的、哪些只是优化」。

(4) a[i] - a[j] > k（B）：这一条不一定满足——当 j == 0 时 a[0] 是全局数组的初值 $0$，比如只有一个数 $a[1]=1$、$k=10$，此时 a[1] - a[0] = 1，并不 $> k$。其余三个都恒成立（j 最多停在 i-1，所以 j < i < = n；数组严格递增所以 a[j] < a[i]）。

(5) 34（A）：$1 \sim 100$、$k=2$，每段最多装 $\{x, x+1, x+2\}$ 三个数，$\lceil 100/3 \rceil = 34$。实测输出 34。

(6) 输出的答案比原本答案更小（B）：穷举 $n \le 6$、值 $\le 7$、$k \le 5$ 的全部无序输入，「更小」出现 359044 次，「更大」出现 0 次。

⚠️ C（死循环）同样是个陷阱：内层 for 只让 j 单调 ++ 且有 j < i 兜底，跑不出死循环。别一看到「删了 sort」就条件反射选「以上均可能」。

答案：(1) A　(2) A　(3) B　(4) D　(5) A　(6) B

标准的最长公共子序列（LCS） 动态规划，f[i][j] = a 前 $i$ 个与 b 前 $j$ 个的 LCS 长度。

(1) 正确（A）：4 / 1 2 3 4 / 1 3 2 2 的 LCS 是 $\{1,3\}$ 或 $\{1,2\}$，长度 $2$。实测输出 2。

(2) 正确（A）：那句 f[i][j] = max(f[i][j], max(f[i-1][j], f[i][j-1])) 保证了 f 沿两个方向都单调不减，所以右下角 f[n][n] 是全表最大值。

(3) 错误（B）：删掉那一行，实测 4 / 1 2 3 4 / 1 3 2 2 从 $2$ 变成 0。因为没有它，f[i-1][j-1] 的值传不上来，只有 a[i]==b[j] 且恰好在对角线上才累加。

📝 这一行才是 LCS 的主体（「不匹配就继承」），不是可有可无的初始化。

(4) 以上均是（D）：LCS 长度 $\le n$ ✓；$\ge 0$ ✓；可以等于 $0$（实测 1 2 3 4 与 5 6 7 8 输出 $0$），所以「不一定 $\ge 1$」也对。

(5) 变大或不变（A）：实测四组，$2\to3$、$1\to4$、$1\to1$、$3\to5$、$0\to0$，没有一组变小。道理：两个序列都排好序后，LCS 就等于两个可重集合的交集大小，而那是任何排列下 LCS 的上限。

(6) 求 b 数组的最长上升子序列（B）：a 是严格递增的 $1,2,\dots,n$，所以公共子序列必然严格递增，LCS 就退化成 b 的最长上升子序列。实测 b={3,3,1,1,2} 输出 $2$（即 $1,2$），b={5,4,3,2,1} 输出 $1$。

⚠️ 洛谷标注这一小题「在原卷中被删除」，练习时可以做，但别拿它算分。

答案：① C　② B　③ B　④ B　⑤ C

行程长度解码：读到「字符 + 数字」就把该字符重复若干次，否则原样输出一个字符。

逐个选项实测（输入 A12B，正确输出 AAAAAAAAAAAAB，共 $12$ 个 A）：

⚠️ ①填 i < z.length() 实测输出也完全正确——因为 C++11 起 string 的 s[s.size()] 合法且返回 '\0'，isdigit('\0') 为假。但出题人要的是 C：i + 1 < z.length() 才是「访问前先检查边界」的正确写法。

📝 这是完善程序最值钱的一条经验：先看这个空后面紧跟着哪次数组/字符串访问，空里填的多半就是那次访问的边界保护。

答案：① B　② C　③ D　④ A　⑤ C

这是摩尔投票法（Boyer–Moore 多数投票）：擂主 + 计数器，意见相左就同归于尽，最后活下来的必属多数派。

随机化实测（精明人位置随机打乱、精明人严格过半、$N \in \{3,5,\dots,101\}$，各跑 4000 次）：

📝 ③ 为什么必须是「或」不是「且」：糊涂人的判断是乱给的，他可能碰巧说擂主是精明人。用「且」的话，只要糊涂人随口夸擂主一句就抵消不掉，多数派的优势就守不住了——实测 4000 次里错 420 次。

⚠️ 摩尔投票是初赛完善程序的常客（求「出现次数超过一半的数」也是它）。背下这个骨架：擂主 + 计数器，相同就 ++，不同就 --，归零就换人。

答案：C

$32$ 位有符号 int 用补码存储，范围是 $-2^{31} \sim 2^{31}-1$，即 $-2147483648 \sim +2147483647$。

📝 负数比正数多一个，这是补码的直接后果：$0$ 占了正数那一侧的一个位置。背这个口诀：负的那头是整的（$-2147483648$），正的那头减一（$+2147483647$）。

⚠️ A、B、D 三个选项都是「两头对称」或「正的那头多一个」，全是同一个误解的不同变体。

答案：A

先把所有数换成十进制再算：

$$14_8 = 12,\quad 1010_2 = 10,\quad D_{16} = 13,\quad 1101_2 = 13$$ $$(12 - 10) \times 13 - 13 = 2 \times 13 - 13 = 13$$

📝 混进制运算的唯一正确姿势：全转十进制 → 算 → 需要的话再转回去。 想在原进制下直接加减乘，考场上百分之百会错。

⚠️ 最容易错的是 $14_8 = 12$（不是 $14$）和 $1101_2 = 13$（跟 $D_{16}$ 恰好相等，出题人故意的）。

答案：B

每部门至少 $1$ 人、共选 $4$ 人，人数分配只有三种：

📝 「每组至少一个」的题：先枚举人数分配方案，再对每种方案用乘法原理。 分配方案很少（这里只有 3 种），列出来比想公式快。

⚠️ 选项 A 的 $120$ 是 $C(10,4)-C(4,4)-\dots$ 之类的错误补集算法；这题不能用补集，因为「至少一个」的反面有三种情况还会重叠，比正面算还麻烦。

答案：D

格雷码的定义：相邻两个码只差一个二进制位。公式 $g(n) = n \oplus (n \gg 1)$：

0->0000  1->0001  2->0011  3->0010
4->0110  5->0111  6->0101  7->0100

D 完全吻合。

• A 最后一项 1000：从 0101 到 1000 变了 3 位 ✗
• B 后两项顺序反了（0100, 0101）✗
• C 第 4→5 项 0010 → 0100 变了 2 位 ✗

📝 不必背格雷码表，只要逐对检查「是不是只差一位」，四个选项十几秒就能筛掉三个。

⚠️ 题面说「$0$ 至 $8$」但每个选项只列了 $8$ 个码（对应 $0\sim7$），按 $0\sim7$ 判断即可。

答案：D

$$1\text{MB} = 1024 \times 1024 = 1048576 \text{ 字节},\quad \times 8 = 8388608 \text{ 位}$$

⚠️ 这题的坑就是 B：$1048576$ 是字节数，不是位数。题目问的是 bit。看到 bit / byte 一定要停一下，差了 $8$ 倍。

📝 记住 1 字节 = 8 位，$2^{20} = 1048576$，$2^{23} = 8388608$。

答案：C

C++ 的基本（内置）数据类型：int、long long、float、double、char、bool。

struct 是关键字，用来自己定义构造类型，本身不是一种数据类型。

📝 分清两类：基本类型是语言自带的（int/char/float/double/bool）；构造类型是你拼出来的（数组、struct、union、指针）。

答案：D

C++ 的三种循环：for、while、do-while。repeat-until 是 Pascal 的语法，C++ 里没有。

📝 C++ 里跟 repeat-until 最像的是 do-while，但条件相反：repeat ... until (条件) 是「条件成立就停」，do {...} while (条件) 是「条件成立就继续」。

⚠️ do-while 是初赛常客（考它的分号、考它至少执行一次）。别因为平时不写就不认识。

答案：B

'a' 的 ASCII 码是 $97$，$97 + 13 = 110$，而 $110$ 对应 'n'。

📝 ASCII 三个基准值背死：'0' = 48，'A' = 65，'a' = 97。其余全靠加减。

⚠️ 数字母时容易差一：'a' 是第 1 个，加 13 落在第 14 个字母 —— a,b,c,d,e,f,g,h,i,j,k,l,m,n。用 ASCII 码算比数字母可靠。

答案：B

二分查找每次把范围砍半，$1000$ 个元素最多需要 $\lceil \log_2 1001 \rceil = 10$ 次。

验证：$2^{10} = 1024 > 1000 \ge 2^9 = 512$。

📝 口诀：$2^{10} \approx 1000$、$2^{20} \approx 10^6$、$2^{30} \approx 10^9$。 这三个近似值在初赛（估比较次数）和复赛（估复杂度）都天天用。

⚠️ 选项 A 的 $25$ 是 $1000/40$ 之类的瞎算，C 的 $7$ 是 $\log_2 128$。

答案：A

Notepad（记事本）是 Windows 里的一个应用程序，不是操作系统。Linux、Windows、macOS 都是操作系统。

📝 初赛的计算机常识题基本就在这几组词里打转：操作系统（Windows / Linux / macOS / Android / iOS / UNIX）、应用软件（记事本 / Office / 浏览器）、编程语言、浏览器。分清哪个是哪类就够了。

答案：B

握手定理：无向图中每条边给它的两个端点各贡献 $1$ 度，所以

$$\sum \deg(v) = 2 \times |E|$$

📝 和有向图对照记（CSP 2025 第 5 题正好考了有向图）：

⚠️ 由此还能推出一个常考结论：无向图中度数为奇数的顶点必定有偶数个。

答案：A

前序 $[A,B,D,E,C,F,G]$、中序 $[D,B,E,A,F,C,G]$：

1. 前序第一个 $A$ 是根 → 在中序里 $A$ 左边 $[D,B,E]$ 是左子树、右边 $[F,C,G]$ 是右子树
2. 左子树前序 $[B,D,E]$ → 根 $B$，中序 $[D,B,E]$ → 左 $D$、右 $E$
3. 右子树前序 $[C,F,G]$ → 根 $C$，中序 $[F,C,G]$ → 左 $F$、右 $G$

        A
      /   \
     B     C
    / \   / \
   D   E F   G

后序（左 → 右 → 根）：$[D, E, B, F, G, C, A]$

📝 固定套路：前序给根，中序给左右分界。 递归两三层就出来了。

⚠️ 后序的最后一个一定是根——先看这一位就能砍掉 B、D 两个选项（它们结尾是 $C$）。这是最快的排除法。

答案：D

用栈模拟（能弹就弹，不能弹就继续压）：

D 卡在哪：弹 $1$、弹 $3$（此时栈内 $2$）、弹 $5$（此时栈内 $2,4$，栈顶是 $4$）→ 下一个要弹 $2$，但 $2$ 被压在 $4$ 下面，出不来。

📝 判定口诀：出栈序列中，某个数后面比它小的那些数，必须是递减的。 D 里 $5$ 后面跟着 $2, 4$ ——$2$ 比 $4$ 小却排在前面，违规。

⚠️ 不确定就老实模拟，六个数最多十几步，比套规律稳。

答案：A

捆绑法：$3$ 个女生必须相邻 → 把她们看成一个整体。

• 整体 + $5$ 个男生 = $6$ 个单位排列：$6! = 720$
• 整体内部 $3$ 个女生自己排：$3! = 6$

$$720 \times 6 = 4320$$

📝 「必须相邻」用捆绑法（乘内部排列），「不能相邻」用插空法（先排其他人，再往空隙里插）。这两句话记住，这类题就没有第三种花样。

⚠️ 选项 B 的 $5040 = 7!$ 是「忘了男生只有 5 个」，D 的 $2880$ 是漏乘了一部分。

答案：B

编译器把源代码翻译成机器代码（目标代码）。

📝 编译 vs 解释（初赛高频对照）：

⚠️ A（直接执行源代码）说的是解释器，D（管内存）说的是操作系统/运行时。

答案：(1) A　(2) B　(3) A　(4) B　(5) A

程序统计 $2 \sim n$ 的素数个数与素数之和。实测输出：

(1) 正确（A）：$10$ 以内素数是 $2,3,5,7$，共 $4$ 个，和为 $17$。实测 4 17。

(2) 错误（B）：i <= n/2 依然是一个正确的素数判定（只是慢），实测 countPrimes(20) 还是 8（$2,3,5,7,11,13,17,19$），不是 $6$。

📝 注意 $n=2$、$n=3$ 时 n/2 是 $1$，循环一次都不进，直接返回 true——恰好正确。 这是这题最容易想岔的地方。

(3) 正确（A）：sumPrimes 确实是 $2 \sim n$ 全部素数之和。

(4) 328（B）：$50$ 以内素数之和 $= 2+3+5+7+11+13+17+19+23+29+31+37+41+43+47 = 328$。实测确认。

(5) 将不能正确计算（A）：改成 i <= n 后，循环会走到 i == n，而 n % n == 0 恒成立，于是每个数都被判成合数，实测输出 0 0。

⚠️ i * i <= n 不能随手改成 i <= n。 前者到 $\sqrt{n}$ 就停（正确且快），后者不但慢，还因为把 $n$ 自己算进除数而彻底错掉。改成 i < n 才是「慢但对」。

答案：(1) A　(2) B　(3) B　(4) A　(5) B　(6) A

这是「最小花费爬楼梯」：dp[i] = 站上第 $i$ 级的最小花费，每次可从前一级或前两级上来。实测：

(1) 正确（A）：{10,15,20} 实测输出 15。

(2) 错误（B）：dp[i-3] 语法上完全合法，编译不会报错——它只是会在 $i=2$ 时访问 dp[-1] 造成运行期越界。

⚠️ 「越界」和「编译错误」是两回事。 数组下标是负数，编译器管不着；出事在运行时。这是初赛判断题的常客。

(3) 错误（B）：反例就在眼前——{10,15,20} 的最小元素是 $10$，程序输出 $15$。

(4) 6（A）：经典样例，走 $1 \to 1 \to 1 \to 1 \to 1 \to 1$ 共 $6$。实测确认。

(5) 30（B）：实测 {10,15,30,5,5,10,20} 输出 30。

(6) 10（A）：改成 dp[i-1] + cost[i-2] 后，{5,10,15} → dp[1]=5、dp[2]=5+5=10、dp[3]=10+10=20，返回 min(dp[3], dp[2]) = 10。实测确认。

答案：(1) B　(2) A 和 B 都选　(3) A 和 B 都选　(4) B　(5) C　(6) D

customFunction(a, b) 递归 $b$ 次、每次加一个 a，所以它等于 $a \times (b+1)$。主函数输出的是 pow(result, 2)。实测：

(1) 错误（B）：customFunction(2,3) = 2 \times 4 = 8，不是 $64$。$64$ 是 pow(8,2) 的结果——题目问的是「函数的返回值」，不是「程序的输出」。

⚠️ 这是本题最狠的一刀。 看清楚问的是「返回值」还是「输出」，两者差一个平方。

(2)(3) 洛谷标注为错题，要求同时选【正确】和【错误】才能拿到对应分数。

（就题论题：$b$ 为负数时 b == 0 永远不成立，确实会无限递归直到栈溢出；$b$ 越大递归层数越多，运行时间确实越长。两句本身都成立。）

(4) 25（B）：$5 \times (4+1) = 25$。实测确认。

(5) 144（C）：$f = 3 \times 4 = 12$，$12^2 = 144$。实测确认。

(6) 36（D）：改成 a + customFunction(a-1, b-1) 后是 $3+2+1+0 = 6$（每层 a 也减 $1$），$6^2 = 36$。实测确认。

📝 递归题先写出通项：原式 $f(a,b) = a(b+1)$，改后 $f(a,b) = a + (a-1) + \dots$。写出来比一层层展开快得多。

答案：① A　② B　③ D　④ A 和 C　⑤ D

判断 $num$ 是不是完全平方数：从 $i=1$ 试到 $\lfloor\sqrt{num}\rfloor$，看有没有 $i^2 = num$。

逐个选项实测（测 $1,2,3,4,5,9,16,17,99,100$）：

⚠️ ④ 为什么 A 也算对（题面标了「本题有多个可能选项」）：return num = 2 * i; 是赋值不是比较，它的值是 $2i$，而 $i \ge 1$ 所以非零，转成 bool 就是 true——碰巧和标准答案等价。实测 $10$ 组输入结果与 true 完全一致。

📝 但考场上请填 true。 靠「赋值表达式的值非零」蒙对，换个数据就翻车（比如 $i$ 可能是 $0$ 的场合）。这题是特例，不是可以学的写法。

⚠️ ③ 的 = 与 ==：if (num = i * i) 能编译、能运行、但恒为真（除非 $i=0$）。这是 C++ 最经典的坑，初赛年年考。

答案：① B　② B　③ B　④ B　⑤ C

汉诺塔的标准三步：先把上面 $i-1$ 个借助目标柱挪到中转柱 → 把最大的那个挪到目标柱 → 再把 $i-1$ 个借助起始柱挪到目标柱。

函数签名是 dfs(int i, char src, char tmp, char tgt)，对号入座：

实测（n=3 应为 7 步的标准解）：

标准答案     n=1: A->C                                    [1 步]
             n=2: A->B A->C B->C                          [3 步]
             n=3: A->C A->B C->B A->C B->A B->C A->C      [7 步]  ← 正确
③填 src,tmp,tgt  n=2: A->C A->C B->C                      ← 非法，盘子叠错柱子
④填 src,tmp,tgt  n=2: A->B A->C A->C                      ← 非法
①填 0            n=1: 3 步（应为 1 步）                    ← 多做一层
②填 src,tmp      n=1: A->B（应为 A->C）                    ← 挪错柱子
⑤填 i            n=2: 无限递归                             ← 规模不减

📝 递归填空的通用查法：先确认出口（①②），再确认「规模一定要变小」（⑤），最后才推参数顺序（③④）。 出口和规模这两条一错就是死循环或者答案差一倍，比参数顺序好查得多。

⚠️ 三根柱子的顺序千万别用「感觉」。 把签名 (i, src, tmp, tgt) 抄在草稿纸上，然后问自己「这一步是从哪挪到哪、剩下那根当中转」，对着填。

答案：B

const 声明常量，值不能被修改。

📝 const 在竞赛里最常见的用法是 const int N = 100005; 拿来开数组。

答案：D

八进制加法：逢 8 进 1。转十进制算：

$$12345670_8 = 2739128,\quad 07654321_8 = 2054353$$ $$2739128 + 2054353 = 4793481 = 22222211_8$$

📝 也可以直接列竖式在八进制下加（从右往左）：$0+1=1$，$7+2=11_8$（写 1 进 1），$6+3+1=12_8$（写 2 进 1）……注意第 1、2 位不进位，从第 3 位起才开始连续进位，所以末两位是 11 而不是 21。

⚠️ 选项 A 的 $22222221_8$ 是「以为每一位都进位」的结果——这题四个选项差别就在末几位，必须真算，不能看个大概。

答案：A

data 是一个 union Data 类型的对象（不是指针），访问成员用 点号 .：data.value = 3.14;

📝 两个箭头的规矩：

• 对象用 .：data.value
• 指针用 ->：p->value（等价于 (*p).value）

⚠️ B、D 把变量名和成员名写反了；C 用了 -> 但 data 不是指针。

📝 联合体（union）的要点：所有成员共用同一块内存，所以只有最后写入的那个成员是有效的。sizeof(union) = 最大成员的大小。这跟结构体（每个成员各占各的）是完全不同的。

答案：A

头插法的三步，顺序不能乱：

Node* newNode = new Node;   // 1. 造新结点
newNode->data = 42;         // 2. 填数据
newNode->next = head;       // 3. 新结点指向原来的头
head = newNode;             // 4. 头指针改指向新结点