CSP-J 2026解析？

一、最终答案速查

单项选择题

题号	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
答案	B	D	C	C	B	D	D	C	B	A	A	D	C	A	B

阅读程序

程序	判断题	单选题
程序（1）	16. √　17. ×　18. √	19. A　20. C　21. C
程序（2）	22. √　23. ×　24. ×	25. B　26. A　27. C
程序（3）	28. ×　29. √　30. √	31. B　32. D　33. C

完善程序

程序	①	②	③	④	⑤
进制减半	D	B	D	B	C
平衡分割	B	D	C	A	D

二、单项选择题超级详细解析

第 1 题：整数类型与精度

答案：B，long long。

题目中的数应理解为 $10^{18}+1$。

C++ 中常见类型的情况如下：

• int 通常是 32 位，最大值约为 $2.1\times10^9$，远远不够。
• float 虽然表示范围较大，但有效数字通常只有约 7 位，不能精确保存这么大的整数。
• double 有约 15～16 位十进制有效数字，而 $10^{18}+1$ 有 19 位，也无法区分 $10^{18}$ 和 $10^{18}+1$。
• long long 通常是 64 位有符号整数，最大值为 $2^{63}-1=9223372036854775807$，大于 $10^{18}+1$，并且整数范围内可以精确存储。

所以选择 B。

第 2 题：十六进制转八进制

答案：D，1365。

先把十六进制数 2F5 转成十进制：

$2F5_{16}=2\times16^2+15\times16+5=512+240+5=757$。

再把 757 不断除以 8：

• $757\div8=94\cdots5$
• $94\div8=11\cdots6$
• $11\div8=1\cdots3$
• $1\div8=0\cdots1$

余数从下往上读，得到 1365，所以选择 D。

第 3 题：整除、取模和运算顺序

答案：C，7。

代码为：

int a = 7, b = 3;
cout << a / b * b + a % b;

整数除法中，7 / 3 的结果是 2；7 % 3 的结果是 1。

乘除取模优先级相同，从左向右计算：

$7/3\times3+7\%3=2\times3+1=7$。

所以选择 C。

第 4 题：栈的出栈序列

答案：C，3，1，2，4 不可能出现。

栈的特点是“后进先出”。要先弹出 3，就必须先把 1、2、3 依次压入栈。此时栈从底到顶是：

1 2 3

弹出 3 后，栈顶是 2。下一项要求弹出 1，但 1 被 2 压在下面，不先弹出 2 就不能弹出 1。因此序列 3，1，2，4 不可能出现。

其他三个序列都可以通过适时入栈、出栈得到。

第 5 题：完全二叉树的叶子数量

答案：B，50。

在按照从 1 开始编号的完全二叉树中：

• 编号不超过 $\lfloor n/2\rfloor$ 的结点至少有一个孩子；
• 编号从 $\lfloor n/2\rfloor+1$ 到 $n$ 的结点都是叶子。

当 $n=100$ 时，叶子编号为 51～100，共：

$100-50=50$ 个。

所以选择 B。

第 6 题：3 或 5 的倍数之和

答案：D，2418。

1～100 中 3 的倍数有 33 个：

$3+6+\cdots+99=3(1+2+\cdots+33)=3\times\frac{33\times34}{2}=1683$。

5 的倍数有 20 个：

$5+10+\cdots+100=5(1+2+\cdots+20)=5\times\frac{20\times21}{2}=1050$。

15 的倍数既是 3 的倍数又是 5 的倍数，被重复计算了一次，需要减去：

$15+30+\cdots+90=15(1+2+\cdots+6)=15\times21=315$。

最终：

$1683+1050-315=2418$。

所以选择 D。

第 7 题：上楼梯动态规划

答案：D，81。

设 $f_i$ 表示走到第 $i$ 级台阶的方法数。最后一步可能走 1、2 或 3 级，因此：

$f_i=f_{i-1}+f_{i-2}+f_{i-3}$。

地面视为第 0 级，什么也不走是一种方案，所以 $f_0=1$。依次计算：

台阶	0	1	2	3	4	5	6	7	8
方法数	1	1	2	4	7	13	24	44	81

所以走到第 8 级共有 81 种走法，选择 D。

第 8 题：BFS 入队顺序

答案：C，14 个。

BFS 的关键是：一个格子第一次被发现时就立刻标记并入队。本题严格按照“上、下、左、右”的顺序扩展。

从 S 开始，到 E 第一次入队为止，入队顺序如下：

入队编号	坐标	说明
1	(0,0)	S
2	(1,0)	从 S 向下
3	(0,1)	从 S 向右
4	(2,0)	从 (1,0) 向下
5	(1,1)	从 (1,0) 向右
6	(0,2)	从 (0,1) 向右
7	(2,1)	从 (2,0) 向右
8	(1,2)	从 (1,1) 向右
9	(2,2)	从 (2,1) 向右
10	(3,2)	从 (2,2) 向下
11	(4,2)	从 (3,2) 向下
12	(3,3)	从 (3,2) 向右
13	(4,1)	从 (4,2) 向左
14	(3,4)	E，从 (3,3) 向右

E 第一次入队时，已经入队的格子包括 S 和 E，共 14 个，所以选择 C。

第 9 题：最大公约数计数

答案：B，6 个。

因为 $\gcd(n,60)=6$，所以 $n$ 一定能写成 $n=6k$。

又因为 $60=6\times10$，于是：

$\gcd(6k,60)=6\gcd(k,10)=6$。

因此必须满足 $\gcd(k,10)=1$，也就是 $k$ 不能含有因数 2 或 5。

由 $1\le n\le100$ 得到 $1\le k\le16$。其中与 10 互质的数为：

1、3、7、9、11、13

共 6 个，对应的 $n$ 为：

6、18、42、54、66、78

所以选择 B。

第 10 题：最少硬币数量

答案：A，3 枚。

9 元可以表示为：

$9=4+4+1$。

所以 3 枚硬币可以完成。两枚硬币的和只可能是 2、5、7、8、10、12，不可能等于 9。因此最少是 3 枚，选择 A。

第 11 题：数组与指针

答案：A，输出 14,13。

初始数组：

a = {1, 3, 5, 7, 9}

p = a + 2，所以 p 指向 a[2]。

第一条赋值：

*(p - 1) = p[0] + p[2];

• p - 1 指向 a[1]；
• p[0] 是 a[2]，值为 5；
• p[2] 是 a[4]，值为 9。

因此 a[1] = 5 + 9 = 14。

第二条赋值：

p[1] = *(a + 1) - a[0];

• p[1] 是 a[3]；
• *(a + 1) 是刚刚修改后的 a[1]，值为 14；
• a[0] 为 1。

因此 a[3] = 14 - 1 = 13，最终输出 14,13，选择 A。

第 12 题：二分查找最坏比较次数

答案：D，10 次。

每比较一次，待查区间大约缩小一半。

因为：

• $2^9=512<1000$；
• $2^{10}=1024\ge1000$。

所以最坏情况下需要 10 次与数组元素比较，选择 D。

第 13 题：由前缀和还原原数组

答案：C，58。

前缀和满足：

$s_i=3i^2+i$。

根据前缀和定义：

$a_{10}=s_{10}-s_9$。

分别计算：

$s_{10}=3\times10^2+10=310$；

$s_9=3\times9^2+9=252$。

所以：

$a_{10}=310-252=58$。

选择 C。

第 14 题：中位数使距离和最小

答案：A，37。

在数轴上，使到所有点的距离之和最小的位置是这些点的中位数。

7 个点已经有序：

1、3、4、7、10、15、20

中间的第 4 个数是 7，所以取 $P=7$。

距离和为：

$6+4+3+0+3+8+13=37$。

所以选择 A。

第 15 题：握手定理

答案：B，18 条边。

无向图中所有顶点的度数之和等于边数的 2 倍。

度数总和为：

$4\times3+6\times4=12+24=36$。

所以边数为：

$36\div2=18$。

选择 B。

三、阅读程序（1）逐行注释与解析

逐行注释代码

#include <iostream>              // 引入输入输出功能。
using namespace std;             // 使用标准命名空间。

int main() {                     // 主函数，程序从这里开始执行。
    int n;                       // 定义整数 n，用来保存输入值。
    cin >> n;                    // 读入一个非负整数 n。

    int x = 1, y = 1;            // x 和 y 的初始值都为 1。

    while (n > 0) {              // 只要 n 还大于 0，就继续处理其二进制最低位。
        if (n % 2 == 0) {        // n 为偶数，说明当前二进制最低位是 0。
            ++x;                 // 每处理一个二进制位，x 都增加 1。
        } else {                 // n 为奇数，说明当前二进制最低位是 1。
            ++x;                 // 每处理一个二进制位，x 增加 1。
            ++y;                 // 遇到一个二进制位 1，y 也增加 1。
        }

        n = n / 2;               // 整除 2，相当于删掉二进制的最低位。
    }

    cout << x << ' ' << y        // 输出最终的 x 和 y，中间用空格分隔。
         << endl;
    return 0;                    // 程序正常结束。
}

程序整体作用

每执行一次循环，就删掉 $n$ 的一个二进制位。因此：

• 循环次数等于 $n$ 的二进制位数；
• x 等于“二进制位数 + 1”；
• y 等于“二进制中 1 的数量 + 1”。

当输入为 0 时，循环一次也不执行，直接输出 1 1。

第 16 题

答案：√。

输入 3，二进制为 11：

循环	n	最低位	x	y	n 除以 2 后
初始	3	—	1	1	—
第 1 次	3	1	2	2	1
第 2 次	1	1	3	3	0

最终输出 3 3，所以判断正确。

第 17 题

答案：×。

删除 else 分支中的 ++x; 后：

• 遇到二进制位 0，x 增加；
• 遇到二进制位 1，y 增加。

此时 x 和 y 分别统计 0 和 1 的数量，再各自加上初值 1，它们并不一定相等。

例如输入 7，二进制是 111。删除该语句后，x 始终为 1，而 y 变成 4，显然不相等。

第 18 题

答案：√。

原程序中，处理每一个二进制位时 x 都会增加；只有二进制位为 1 时 y 才增加。

二进制位 1 的数量不可能超过总位数，因此 x 一定不小于 y。

第 19 题

答案：A，陷入死循环。

如果条件改成 while (n >= 0)，当 n 变成 0 后：

• 0 >= 0 成立，继续循环；
• 0 % 2 == 0，x 不断增加；
• 0 / 2 仍然是 0。

所以 n 永远不会变成负数，循环无法结束。

第 20 题

答案：C，输出 4 3。

6 的二进制是 110，一共有 3 位，其中有 2 个 1。

所以：

• x = 1 + 3 = 4；
• y = 1 + 2 = 3。

输出 4 3。

第 21 题

答案：C，31 次。

第二个输出数为 2，意味着：

$1+\text{二进制中 1 的数量}=2$。

所以输入数的二进制中恰好只有一个 1，也就是输入必须是 2 的幂：

$2^0,2^1,2^2,\ldots,2^{30}$。

题目范围是 0 到 $2^{31}-1$，其中共有 31 个这样的数，所以选择 C。

四、阅读程序（2）逐行注释与解析

逐行注释代码

#include <algorithm>             // 提供 max 函数。
#include <iostream>              // 提供 cin 和 cout。
#include <string>                // 提供 string 类型。
using namespace std;             // 使用标准命名空间。

int a[100007];                   // 倒序保存第一个大整数的每一位。
int b[100007];                   // 倒序保存第二个大整数的每一位。
int c[100007];                   // 倒序保存相加结果的每一位。
int carry[100007];               // carry[i] 表示传入第 i 位的进位。
string input_str;                // 临时保存输入的大整数字符串。
int a_len, b_len;                // 保存两个大整数的位数。

int main() {                     // 主函数开始。
    cin >> input_str;            // 读入第一个大整数。
    a_len = input_str.size();    // 得到第一个大整数的位数。

    for (int i = 0; i < a_len; i++) {              // 枚举第一个数的每一位。
        a[i] = input_str[a_len - i - 1] - '0';      // 逆序保存，a[0] 是个位。
    }

    cin >> input_str;            // 读入第二个大整数。
    b_len = input_str.size();    // 得到第二个大整数的位数。

    for (int i = 0; i < b_len; i++) {              // 枚举第二个数的每一位。
        b[i] = input_str[b_len - i - 1] - '0';      // 逆序保存，b[0] 是个位。
    }

    carry[0] = 0;                // 个位没有来自更低位的进位。

    for (int i = 0; i < max(a_len, b_len) + 1; i++) { // 多算一位，用来保存最高进位。
        c[i] = a[i] + b[i] + carry[i];                 // 当前位相加，再加上传入的进位。

        if (c[i] >= 10) {        // 当前位达到 10，需要向高位进 1。
            carry[i + 1] = 1;    // 下一位收到一个进位。
            c[i] -= 10;          // 当前位只保留个位数字。
        } else {                 // 当前位小于 10，不需要进位。
            carry[i + 1] = 0;    // 下一位收到的进位为 0。
        }
    }

    for (int i = max(a_len, b_len); i >= 0; i--) { // 从最高位置向个位输出。
        cout << c[i];            // 无论最高位是不是 0，都会照常输出。
    }

    cout << endl;                // 输出换行。
    return 0;                    // 程序正常结束。
}

程序整体作用与关键陷阱

这是一段高精度加法程序。数组使用“低位在前”的方式保存数字，例如 123 保存为：

a[0]=3，a[1]=2，a[2]=1

程序最大的陷阱是：它固定从 max(a_len,b_len) 输出到 0，因此总会输出“较长输入的位数 + 1”个位置。没有产生最高位进位时，最前面会多输出一个 0。

第 22 题

答案：√。

123 + 456 = 579。两个输入都是 3 位，程序输出下标 3、2、1、0，共 4 个位置。

因为没有千位进位，所以 c[3]=0，最终输出：

0579

题目说法正确。

第 23 题

答案：×。

即使两个输入都没有前导零，只要它们相加后没有产生新的最高位进位，程序仍会把额外的 c[max(a_len,b_len)] 输出出来。

例如 123 + 456 输出 0579，出现了前导零。因此说法错误。

第 24 题

答案：×。

改成 c[i] = a[i] + b[i]; 后，程序不再把低位进位加到当前位。但是“结果一定比原来小”并不成立，因为如果原本没有任何进位，修改前后结果完全相同。

例如 12 + 34 每一位相加都不超过 9，删除 carry[i] 不会改变结果。因此“必定更小”是错误的。

第 25 题

答案：B，013023。

$12345+678=13023$。

最长输入有 5 位，程序固定输出 6 个位置。最高的第 6 位为 0，因此输出：

013023

选择 B。

第 26 题

答案：A，01010。

把判断条件改成 c[i] > 10 后，恰好等于 10 时不会进位，也不会减去 10。

输入 95 15：

• 个位：$5+5=10$，条件 10 > 10 为假，所以 c[0]=10；
• 十位：$9+1=10$，仍不进位，所以 c[1]=10；
• 百位：c[2]=0。

cout 输出一个值为 10 的整数时会打印两个字符 10。从高位到低位连接起来就是：

0 + 10 + 10 = 01010

所以选择 A。

第 27 题

答案：C。

题目中的“和小于 $10^n$”说明两个 $n$ 位数相加后没有产生第 $n+1$ 位，也就是额外最高位 c[n] 为 0。

程序仍然会从下标 $n$ 输出到 0，共输出 $n+1$ 个字符。因此字符串长度一定为 $n+1$，且第一个字符是 0，选择 C。

五、阅读程序（3）逐行注释与解析

逐行注释代码

#include <iostream>                  // 引入输入输出功能。
using namespace std;                 // 使用标准命名空间。

bool check_prime(int x) {            // 判断 x 是否为质数。
    if (x <= 1) return false;        // 0、1 和负数都不是质数。

    for (int i = 2; i * i <= x; i++) { // 只需试除到平方根。
        if (x % i == 0)              // 如果能被 i 整除，说明存在非平凡因数。
            return false;            // x 不是质数，立即返回 false。
    }

    return true;                     // 没找到因数，x 是质数。
}

int n;                               // 保存输入的界限 n。

void search_result(int x) {          // 搜索以十进制数字 x 为前缀的结果。
    if (!check_prime(x)) return;     // x 不是质数，整棵分支立即停止。

    if (x >= n) {                    // x 已经达到或超过 n。
        cout << x << endl;           // 输出 x。
        return;                      // 输出后不再给 x 追加数字。
    }

    for (int i = 0; i <= 9; i++) {  // 尝试在 x 的末尾追加数字 0～9。
        search_result(x * 10 + i);   // 递归检查追加一位后的新数。
    }
}

int main() {                         // 主函数开始。
    cin >> n;                        // 读入界限 n。

    for (int i = 1; i <= 9; i++)    // 分别从一位数 1～9 开始搜索。
        search_result(i);            // 搜索对应的质数前缀分支。

    return 0;                        // 程序正常结束。
}

程序整体作用

程序构造一棵“质数前缀树”：

1. 当前数字 x 必须是质数，否则立即剪枝；
2. 如果 x < n，就在末尾追加一位数字，继续搜索；
3. 如果 x >= n，输出 x，并停止向下扩展。

因此，每个输出数本身是质数，而且从右向左不断删除末位后，得到的每一级前缀也都是质数。

第 28 题

答案：×。

输入 10 时，一位质数 2、3、5、7 都小于 10，需要继续追加一位。能够输出的两位质数为：

23、29、31、37、53、59、71、73、79

共 9 行，不是 10 行，所以说法错误。

第 29 题

答案：√。

如果 $n\le5$，主函数执行到 search_result(5) 时：

• 5 是质数；
• $5\ge n$；
• 因此程序直接输出 5。

所以输出中一定包含 5。

第 30 题

答案：√。

当 $n>10$ 时，继续递归的数字最终会成为多位数。一个多位质数的个位不可能是：

0、2、4、5、6、8

因此真正有可能产生质数的末位只需要考虑 1、3、7、9。修改后的循环尝试 1、3、5、7、9，已经包含全部可能的奇数末位；末位 5 的多位数会被 check_prime 自动排除。

所以删掉偶数和 0 的尝试只减少无效搜索，不会改变输出结果。

第 31 题

答案：B，第 3 行是 29。

输入 24 时，程序按深度优先顺序搜索。

首先从 2 开始：

• 23 是质数，但 $23<24$，所以不会直接输出 23，而是继续在末尾追加数字；
• 233 是质数且不小于 24，输出第 1 行；
• 239 是质数且不小于 24，输出第 2 行；
• 之后轮到 29。29 是质数且不小于 24，输出第 3 行。

前三行是：

233
239
29

所以选择 B。

第 32 题

答案：D。

• A 错误：输出不一定递增。例如输入 24 时先输出 233、239，之后才输出 29。
• B 错误：随着 $n$ 增大，原来直接输出的一个质数节点可能继续展开成多个质数孩子，输出行数可能增加。
• C 错误：个位还可能是 1 或 9；输入较小时还可能直接输出一位质数 2 或 5。
• D 正确：大于等于 10 的输出数一定是通过某个父节点追加一位得到的，而程序只有在父节点为质数且小于 $n$ 时才会继续递归。因此删掉输出数的末位后，得到的父节点一定是质数。

第 33 题

答案：C，14 行。

输入 200 时，输出结果依次为：

233
239
293
311
313
317
373
379
593
599
719
733
739
797

共 14 行，所以选择 C。

六、完善程序（1）进制减半

核心原理

输入数原本使用 $mn$ 进制，其中这里的 $mn$ 表示 $m\times n$。程序把答案数组 b 当作 $n$ 进制数，并使用低位在前的方式保存。

每读入一个原进制数位 x，相当于：

$A_{new}=A_{old}\times(mn)+x$。

因为目标是 $n$ 进制，所以乘以 $n$ 相当于整体左移一位；剩下还需要把每一位乘以 $m$。这正是①使用 b[j - 1] * m 的原因。

补全并逐行注释后的代码

#include <iostream>                      // 引入输入输出功能。

constexpr int N = 100005;               // 数组容量上限。
long long b[N];                          // 低位在前保存 n 进制结果。

int main() {                             // 主函数开始。
    long long n, m, d;                   // n 是目标进制，m 参与构成原进制，d 是输入位数。
    std::cin >> n >> m >> d;             // 读入 n、m 和位数 d。

    int len = 1;                         // 当前 n 进制数组长度，初始表示数值 0。

    for (int i = 0; i < d; i++) {       // 从高位到低位依次读入原数的每一位。
        long long x;                     // 保存当前读入的原进制数位。
        std::cin >> x;                   // 读入当前数位 x。

        for (int j = len; j >= 1; j--)  // 从高位向低位移动，避免覆盖旧数据。
            b[j] = b[j - 1] * m;         // ①选 D：乘 m，并借助下标加 1 完成乘 n 的移位。

        b[0] = x;                        // ②选 B：最低位放入新读到的 x。
        len++;                           // 左移后先把有效长度增加 1。

        for (int j = 0; j < len; j++)   // 从低位向高位进行 n 进制进位。
            if (b[j] >= n) {            // 当前位不符合 n 进制数位范围，需要进位。
                b[j + 1] += b[j] / n;   // ③选 D：商是需要传给高一位的进位。
                b[j] = b[j] % n;        // ④选 B：余数是当前位最终保留的数位。

                if (j + 1 == len)       // 如果进位产生了新的最高位，
                    len++;              // 就把有效长度再增加 1。
            }
    }

    while (len > 1 && b[len - 1] == 0)  // ⑤选 C：删除多余前导零，但数值 0 至少保留一位。
        len--;                           // 缩短有效长度。

    for (int i = len - 1; i >= 0; i--) // 从最高位到最低位输出。
        std::cout << b[i] << ' ';       // 输出当前 n 进制数位。

    return 0;                            // 程序正常结束。
}

各空详细解析

①：D，b[j - 1] * m

旧数乘以 $mn=m\times n$。在 $n$ 进制中，乘以 $n$ 就是把所有数位向高位移动一格，因此新位置 b[j] 来自旧位置 b[j-1]；同时还要乘以 $m$。

所以填写：

b[j - 1] * m

②：B，x

完成旧数乘以原进制后，还要加上新读入的最低位 x，因此直接令：

b[0] = x;

③：D，b[j] / n

在 $n$ 进制中，如果当前位达到或超过 $n$，整除 $n$ 得到向高位传递的进位。

④：B，b[j] % n

当前位最终只能保留除以 $n$ 的余数，范围必定在 0 到 $n-1$ 之间。

⑤：C，len > 1 && b[len - 1] == 0

需要删除最高位多余的 0，但表示数值 0 时必须至少输出一位，所以条件必须是 len > 1，不能把长度减到 0。

七、完善程序（2）平衡分割

题意整理

题目原文中“第 $p_i+1$ 个数到第 $p_i+1$ 个数”应理解为“第 $p_i+1$ 个数到第 $p_{i+1}$ 个数”。

程序要枚举字符串的所有连续分段方法。每一段计算平均值，最终让所有分段平均值中的最大值与最小值之差尽可能小。

split(l,cnt,mnb,mxb) 的含义是：

• l：下一段从第 l 个元素开始；
• cnt：目前已经使用的切分位置数量；
• mnb：已确定各段平均值的最小值；
• mxb：已确定各段平均值的最大值。

补全并逐行注释后的代码

#include <algorithm>                              // 提供 min 和 max。
#include <iomanip>                                // 提供 fixed 和 setprecision。
#include <iostream>                               // 提供输入输出功能。
using namespace std;                              // 使用标准命名空间。

constexpr int N = 25;                             // 数组容量，大于题目最大 n=20。
int n, a[N];                                      // n 是长度，a 保存转换后的十六进制数位值。
char s[N];                                        // 保存输入的十六进制字符串。
double ans = 1e100;                               // 答案初始化为一个极大的数。

int value(char c) {                               // 把十六进制字符转换成 0～15。
    return c - (c < 'A' ? '0' : 'A' - 10);       // ①选 B：数字减 '0'，字母减 'A' 后再加 10。
}

void split(int l, int cnt, double mnb, double mxb) { // 枚举从位置 l 开始的下一段。
    if (l > n) {                                  // l 超过 n，说明所有元素已经完成分段。
        if (cnt == 0) return;                     // 没有切分位置，即只有一段，不符合 k>=1。
        ans = min(ans, mxb - mnb);                // 用本次方案的极差更新最优答案。
        return;                                   // 当前分段方案处理结束。
    }

    int sum = 0;                                  // 保存当前尝试分段 a[l..r] 的元素和。

    for (int r = l; r <= n; ++r) {               // ②选 D：枚举这一段的右端点 r。
        sum += a[r];                              // 把新扩展到的 a[r] 加入当前段。
        double nwb = sum * 1.0 / (r - l + 1);     // ③选 C：计算 a[l..r] 的平均值。

        split(r + 1,                              // ④选 A：下一段从 r+1 开始。
              cnt + (r < n),                      // r<n 表示这里产生了一个真正的切分位置。
              min(mnb, nwb),                      // 更新所有分段平均值的最小值。
              max(mxb, nwb));                     // 更新所有分段平均值的最大值。
    }
}

int main() {                                      // 主函数开始。
    cin >> n >> s + 1;                            // 读入长度和字符串，从 s[1] 开始保存。

    for (int i = 1; i <= n; ++i)                 // 枚举字符串中的每个字符。
        a[i] = value(s[i]);                       // 转换成对应的十进制数值。

    split(1, 0, 1e100, -1e100);                  // ⑤选 D：从位置 1 开始，尚未切分。

    cout << fixed                                 // 使用普通小数形式输出，
         << setprecision(6)                       // 保留小数点后 6 位，
         << ans;                                  // 输出最小极差。

    return 0;                                     // 程序正常结束。
}

各空详细解析

①：B

对于字符 0～9：

c - '0'

对于字符 A～F：

c - 'A' + 10

选项 B：

c - (c < 'A' ? '0' : 'A' - 10)

当 c >= 'A' 时，展开为 c - ('A' - 10)，也就是 c - 'A' + 10。

②：D

当前段必须从 l 开始，右端点可以是 l、l+1、……、n，因此循环为：

int r = l; r <= n; ++r

这样才能枚举所有可能的连续段。

③：C

区间 a[l..r] 的长度是 r-l+1，平均值是：

sum * 1.0 / (r - l + 1)

乘以 1.0 是为了进行浮点除法，避免整数除法丢失小数部分。

④：A

当前段选择为 a[l..r] 后：

• 下一段从 r+1 开始；
• 只有当 r<n 时，r 才是真正的切分位置，所以 cnt 增加 r<n；
• 新的最小平均值是 min(mnb,nwb)；
• 新的最大平均值是 max(mxb,nwb)。

⑤：D

数组从 1 开始使用，所以初始位置是 1；还没有切分，所以 cnt=0。

为了让第一段平均值能够正确更新最小值和最大值：

• mnb 初始化为极大值 1e100；
• mxb 初始化为极小值 -1e100。

因此调用为：

split(1, 0, 1e100, -1e100);