GESP 客观题评测系统

普及组 CSP-J 2026 初赛模拟卷 1

CSPJ-2026-R1-Mock-1

试卷解析总览，可直接查看每题答案与解析。

一、单项选择题

（共 15 题，每题 2 分，共计 30 分；每题有且仅有一个正确选项）

第 1 题（单选题，2 分）

启动计算机引导操作系统是将操作系统（）。

从磁盘调入中央处理器

从内存储器调入高速缓冲存储器

从软盘调入硬盘

从系统盘调入内存储器

正确答案D

解析详情

【答案】D

【考点】操作系统启动过程

【解析】启动引导程序会把系统盘上的操作系统装入内存，CPU 再执行内存中的系统代码，因此选 D。

【易错点】CPU 不能直接把磁盘内容当作正在执行的操作系统。

第 2 题（单选题，2 分）

Windows 9x 是一种（）操作系统。

单任务字符方式

单任务图形方式

多任务字符方式

多任务图形方式

正确答案D

解析详情

【答案】D

【考点】操作系统类型

【解析】 Windows 9x 提供图形用户界面，并允许多个任务并发运行，属于多任务图形方式操作系统。

【易错点】不要把图形界面与单任务运行方式混为一谈。

第 3 题（单选题，2 分）

在 $24 \times 24$ 点阵的字模中，汉字“一”与“编”的字模占用字节数分别是（）。

72, 72

32, 32

32, 72

72, 32

正确答案A

解析详情

【答案】A

【考点】点阵字模存储量

【解析】每个汉字的字模都占 $24\times24=576$ 位，即 $576/8=72$ 字节；字形复杂度不影响点阵存储量。

【易错点】字节数由点阵尺寸决定，不由汉字笔画数决定。

第 4 题（单选题，2 分）

计算机的运算速度取决于给定时间内其处理器所能处理的数据量。处理器一次能处理的数据量称为字长。已知 64 位的奔腾处理器一次能处理 64 位，相当于（）字节。

8

1

16

2

正确答案A

解析详情

【答案】A

【考点】位与字节换算

【解析】 1 字节等于 8 位，所以 64 位字长相当于 $64/8=8$ 字节。

【易错点】位（bit）和字节（byte）的换算比例是 8:1。

第 5 题（单选题，2 分）

算式 $(2047)_{10}-(3\mathrm{FF})_{16}+(2000)_8$ 的结果是（）。

(2048)_{10}

(2049)_{10}

(3746)_8

(1\mathrm{AF7})_{16}

正确答案A

解析详情

【答案】A

【考点】进制转换

【解析】 $(3\mathrm{FF})_{16}=1023$ ， $(2000)_8=1024$ ，因此 $2047-1023+1024=2048$ 。

【易错点】十六进制中的 F 表示 15，八进制每一位的权是 8 的幂。

第 6 题（单选题，2 分）

计算机的运算速度可以用 MIPS 来描述，它的含义是（）。

每秒执行百万条指令

每秒处理百万个字符

每秒执行千万条指令

每秒处理千万个字符

正确答案A

解析详情

【答案】A

【考点】MIPS 含义

【解析】 MIPS 是 Million Instructions Per Second 的缩写，表示每秒执行百万条指令。

【易错点】MIPS 衡量的是指令执行数量，不是字符处理数量。

第 7 题（单选题，2 分）

设栈 $S$ 的初始状态为空，现有 5 个元素组成的序列 $\{1,2,3,4,5\}$ ，对该序列在栈 $S$ 上依次进行如下操作（从序列中的 1 开始，出栈后不再进栈）：进栈、出栈、进栈、进栈、出栈、进栈、出栈、进栈。出栈的元素序列是（）。

\{5,4,3,2,1\}

\{2,3\}

\{2,3,4\}

\{1,3,4\}

正确答案D

解析详情

【答案】D

【考点】栈操作模拟

【解析】依次操作得到：1 入栈后弹出 1；2、3 入栈后弹出 3；4 入栈后弹出 4；最后 5 入栈。因此出栈序列为 $\{1,3,4\}$ 。

【易错点】只有题目明确给出“出栈”时才弹出栈顶元素。

第 8 题（单选题，2 分）

在有 $n$ 个叶节点的哈夫曼树中，节点总数为（）。

不确定

2n-1

2n+1

2n

正确答案B

解析详情

【答案】B

【考点】哈夫曼树节点数

【解析】哈夫曼树是严格二叉树，若有 $n$ 个叶节点，则内部节点有 $n-1$ 个，总节点数为 $2n-1$ 。

【易错点】不要把叶节点数直接当作树的总结点数。

第 9 题（单选题，2 分）

电线上停着两种鸟（A 和 B），可以看出相邻的两只鸟将电线划分为一个线段。这些线段可分为两类：一类是线段两端的鸟种类相同，另一类是线段两端的鸟种类不同。已知电线的两个端点处恰好停着种类相同的鸟，那么两端的鸟种类不同的线段数目一定是（）。

奇数

偶数

可奇可偶

数目固定

正确答案B

解析详情

【答案】B

【考点】序列相邻变化次数

【解析】沿电线从一端走到另一端，每遇到异种鸟就切换一次种类。两端鸟种相同，切换总次数必为偶数。

【易错点】中间同种鸟的数量不影响“异种相邻”次数的奇偶性。

第 10 题（单选题，2 分）

从未排序序列中挑选元素，并将其依次放入已排序序列（初始时为空）的一端，这种排序方法称为（）。

插入排序

归并排序

选择排序

快速排序

正确答案C

解析详情

【答案】C

【考点】选择排序

【解析】选择排序每轮从未排序部分选出一个目标元素，并把它放到已排序部分的一端。

【易错点】插入排序是把当前元素插入已有序列的适当位置，描述重点不同。

第 11 题（单选题，2 分）

对于一棵满二叉树，若其叶节点数为 $m$ 、分支节点数为 $L$ 、总节点数为 $n$ ，则下列关系式恒成立的是（）。

n=L+m

L+m=2n

m=L-1

n=2L-1

正确答案A

解析详情

【答案】A

【考点】二叉树节点分类

【解析】满二叉树的节点只分为叶节点和分支节点，所以总节点数恒有 $n=L+m$ 。此外满二叉树满足 $m=L+1$ ，故 $n=2L+1$ 。

【易错点】由 $m=L+1$ 推导总节点数时符号容易写反。

第 12 题（单选题，2 分）

以下不是操作系统名字的是（）。

Windows XP

Arch/Info

Linux

OS/2

正确答案B

解析详情

【答案】B

【考点】操作系统常识

【解析】 Windows XP、Linux 和 OS/2 都是操作系统；Arch/Info 是地理信息系统相关软件，不是操作系统。

【易错点】不要仅凭名称中含有斜杠就判断软件类别。

第 13 题（单选题，2 分）

以下不是个人计算机的硬件组成部分的是（）。

主板

虚拟内存

总线

硬盘

正确答案B

解析详情

【答案】B

【考点】计算机硬件组成

【解析】主板、总线和硬盘都是实体硬件；虚拟内存是操作系统利用存储空间形成的内存管理机制。

【易错点】“内存”一词不代表虚拟内存本身是物理硬件。

第 14 题（单选题，2 分）

已知元素 $(8,25,14,87,51,90,6,19,20)$ ，这些元素以（）的顺序全部入栈，再全部出栈，可使栈的出栈顺序满足：8 在 51 之前；90 在 87 之后；20 在 14 之后；25 在 6 之前；19 在 90 之后。

20,6,8,51,90,25,14,19,87

51,6,19,20,14,8,87,90,25

19,20,90,8,6,25,51,14,87

6,25,51,8,20,19,90,87,14

正确答案D

解析详情

【答案】D

【考点】栈的后进先出

【解析】全部入栈后再全部出栈，出栈顺序是入栈序列的逆序。D 逆序后为 $14,87,90,19,20,8,51,25,6$ ，逐一满足题目给出的五个先后条件。

【易错点】应在逆序后的出栈序列上核对全部条件。

第 15 题（单选题，2 分）

假设我们用向量 $\boldsymbol{d}=(a_1,a_2,\cdots,a_5)$ 表示无向连通图 $G$ 的 5 个顶点的度数，下面给出的（）组 $\boldsymbol{d}$ 值合理。

(2,2,2,2,2)

(1,2,2,1,1)

(3,3,3,2,2)

(5,4,3,2,1)

正确答案A

解析详情

【答案】A

【考点】无向图度数序列

【解析】无向图度数和必须为偶数，且 5 个顶点的简单图中每个度数不超过 4。A 可由一个 5 阶环实现；其余选项或度数和为奇数，或出现度数 5。

【易错点】度数和为偶数只是必要条件，还要检查度数上界和可实现性。

二、阅读程序（1）

程序输入不超过数组或字符串定义的范围；判断题正确填 ✓，错误填 ✗。

 1 | #include <iostream>
 2 | #include <cmath>
 3 | using namespace std;
 4 | bool IsPrime(int num) {
 5 |     for (int i = 2; i <= sqrt(num); i++) {
 6 |         if (num % i == 0) return false;
 7 |     }
 8 |     return true;
 9 | }
10 | int main() {
11 |     int num = 0;
12 |     cin >> num;
13 |     if (IsPrime(num)) cout << "YES" << endl;
14 |     else cout << "NO" << endl;
15 |     return 0;
16 | }

第 16 题（判断题，2 分）

输入 97 时，输出为 `NO`。

正确答案错误

解析详情

【答案】错误

【考点】素数判断程序

【解析】 97 没有不超过 $\sqrt{97}$ 的整数因子，`IsPrime(97)` 返回 `true`，程序输出 `YES`。

【易错点】题目判断的是实际输出，不是题干给出的预期文本。

第 17 题（判断题，2 分）

输入 119 时，输出为 `YES`。

正确答案错误

解析详情

【答案】错误

【考点】合数判定

【解析】 $119=7\times17$ ，循环在 `i=7` 时找到因子并返回 `false`，程序输出 `NO`。

【易错点】只试除较小的 2、3、5 不足以判定 119 为素数。

第 18 题（判断题，2 分）

若将第 5 行的 `<=` 改成 `<`，程序输出不会改变。

正确答案错误

解析详情

【答案】错误

【考点】试除法边界

【解析】若把 `<=` 改为 `<`，完全平方数的平方根不会被试除。例如 49 将跳过因子 7，从而被误判为素数。

【易错点】试除上界必须包含平方根本身。

第 19 题（判断题，2 分）

当程序执行第 8 行时，`i` 的值为 `sqrt(num)`。

正确答案错误

解析详情

【答案】错误

【考点】变量作用域

【解析】 `i` 在第 5 行 `for` 初始化语句中定义，只在该循环内有效；执行第 8 行时已经不存在可访问的变量 `i`。

【易错点】循环结束后的数学终值不等于变量在作用域外仍然存在。

第 20 题（单选题，3 分）

最坏情况下，此程序的时间复杂度是（）。

O(\mathrm{num})

O(\mathrm{num}^2)

O(\sqrt{\mathrm{num}})

O(\log \mathrm{num})

正确答案C

解析详情

【答案】C

【考点】试除法时间复杂度

【解析】最坏情况下循环从 2 检查到 $\sqrt{\mathrm{num}}$ ，迭代次数与 $\sqrt{\mathrm{num}}$ 同阶，因此复杂度为 $O(\sqrt{\mathrm{num}})$ 。

【易错点】`sqrt(num)` 只出现一次，不能再额外开一次平方根。

第 21 题（单选题，3 分）

若输入为 20 以内的正整数，则输出 `YES` 的概率是（）。

0.45

0.4

0.5

0.35

正确答案A

解析详情

【答案】A

【考点】程序边界条件与概率

【解析】 1 到 20 中有 8 个素数；该程序还会把 1 误判为素数，所以共有 9 个输入输出 `YES`，概率为 $9/20=0.45$ 。

【易错点】必须按给定程序计算，不能直接只数数学意义上的素数。

二、阅读程序（2）

 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int mod = 2048;
 4 | long long c, n;
 5 | long long kasumi(long long x, long long mi) {
 6 |     long long res = 1;
 7 |     while (mi) {
 8 |         if (mi & 1) {
 9 |             res = (res * x) % mod;
10 |         }
11 |         x = (x * x) % mod;
12 |         mi >>= 1;
13 |     }
14 |     return res;
15 | }
16 | int main() {
17 |     cin >> n >> c;
18 |     if (n == 3) {
19 |         printf("%lld", c * (c - 1));
20 |         return 0;
21 |     }
22 |     long long ans = ((kasumi(c - 1, n) + (c - 1) * kasumi(-1, n)) % mod + mod) % mod;
23 |     cout << ans << endl;
24 |     return 0;
25 | }

第 22 题（判断题，2 分）

将第 9 行和第 11 行中的圆括号去掉，程序输出不变。

正确答案正确

解析详情

【答案】正确

【考点】运算符优先级与结合性

【解析】去掉第 9、11 行乘法外层的括号后，表达式分别成为 `res * x % mod` 和 `x * x % mod`；乘法与取模同级且从左到右结合，结果不变。

【易错点】这里去掉的是乘法括号，不是整个取模结构。

第 23 题（判断题，2 分）

将第 12 行的 `mi >>= 1` 改为 `mi *= 0.5`，程序输出不变。

正确答案正确

解析详情

【答案】正确

【考点】快速幂指数折半

【解析】在题目预期的非负整数范围内，`mi >>= 1` 与整型变量执行 `mi *= 0.5` 都得到向下取整的 $mi/2$ ，循环过程不变。

【易错点】该结论依赖题目按常规整数范围讨论，不要把右移误解为除以 1。

第 24 题（判断题，2 分）

若输入 `4 4`，输出为 78。

正确答案错误

解析详情

【答案】错误

【考点】快速幂程序求值

【解析】输入 `4 4` 时， $3^4+3\times(-1)^4=81+3=84$ ，取模后仍为 84，并非 78。

【易错点】输入顺序是先读 `n` 再读 `c`。

第 25 题（判断题，2 分）

此程序的时间复杂度为 $O(\log n)$ 。

正确答案正确

解析详情

【答案】正确

【考点】快速幂复杂度

【解析】循环每次把指数 `mi` 折半，迭代次数为 $O(\log n)$ ；主函数中的其余运算均为常数时间。

【易错点】快速幂不是执行 $n$ 次乘法。

第 26 题（单选题，4 分）

若输入 `3 4`，输出为（）。

8

12

18

19

正确答案B

解析详情

【答案】B

【考点】程序分支模拟

【解析】输入 `3 4` 后满足 `n == 3`，直接输出 $c(c-1)=4\times3=12$ 。

【易错点】命中特判后立即返回，不会执行后面的通用公式。

二、阅读程序（3）

 1 | #include <cstdio>
 2 | int n, r, num[10000];
 3 | bool mark[10000];
 4 | void print() {
 5 |     for (int i = 1; i <= r; i++)
 6 |         printf("%d", num[i]);
 7 |     printf("\n");
 8 | }
 9 | void search(int x) {
10 |     for (int i = 1; i <= n; i++)
11 |         if (!mark[i]) {
12 |             num[x] = i;
13 |             mark[i] = true;
14 |             if (x == r) print();
15 |             search(x + 1);
16 |             mark[i] = false;
17 |         }
18 | }
19 | int main() {
20 |     scanf("%d%d", &n, &r);
21 |     search(1);
22 | }

第 27 题（判断题，2 分）

程序结束时，对任意 $1 \le i \le n$ ，都有 `mark[i] = 0`。

正确答案正确

解析详情

【答案】正确

【考点】回溯状态恢复

【解析】每次递归前把 `mark[i]` 设为 `true`，递归返回后又设回 `false`；所有调用结束时数组恢复到初始的全 0 状态。

【易错点】要观察递归调用之后的回溯语句。

第 28 题（判断题，2 分）

若 $n<r$ ，则程序无输出。

正确答案正确

解析详情

【答案】正确

【考点】排列枚举边界

【解析】当 $n<r$ 时，最多只能选出 $n$ 个互不相同的数字，递归无法到达 `x == r` 的打印条件，因此没有输出。

【易错点】程序不允许重复选择已被 `mark` 的数字。

第 29 题（判断题，2 分）

若输入 `4 3`，则输出中数字 1 和 2 的个数不同。

正确答案错误

解析详情

【答案】错误

【考点】排列中的对称计数

【解析】输入 `4 3` 会枚举所有 4 个数取 3 个的排列。由对称性，每个数字出现的总次数相同，所以数字 1 和 2 的个数相同。

【易错点】不能只观察输出的前几行判断整体出现次数。

第 30 题（判断题，2 分）

此程序的时间复杂度为 $O(n)$ 。

正确答案错误

解析详情

【答案】错误

【考点】回溯枚举复杂度

【解析】程序枚举长度为 $r$ 的排列，输出规模为 $A_n^r$ ；当 $r=n$ 时达到 $n!$ 量级，显然不是 $O(n)$ 。

【易错点】递归层数是 $r$ ，但分支数会产生大量排列。

第 31 题（单选题，3 分）

若输入 `6 3`，则函数 `print` 的执行次数为（）。

60

120

6

720

正确答案B

解析详情

【答案】B

【考点】排列数

【解析】输入 `6 3` 时会打印从 6 个数中依次取 3 个的所有排列，次数为 $A_6^3=6\times5\times4=120$ 。

【易错点】顺序不同算不同结果，应使用排列数而不是组合数。

第 32 题（单选题，3 分）

若输入 `7 4`，则输出的最后一行为（）。

`4567`

`7654`

`4321`

`1234`

正确答案B

解析详情

【答案】B

【考点】字典序枚举

【解析】每层循环都按 1 到 7 的顺序选择数字，因此输出按字典序递增；最大的 4 位排列是 `7654`。

【易错点】最后一行不是把全部 7 个数字逆序，只取前 4 个位置。

三、完善程序（1）Kruskal 最小生成树

Kruskal 求最小生成树的思想：首先将 $n$ 个点看作 $n$ 个独立的集合，将所有边排序（从小到大）。然后按排好的顺序枚举每一条边，判断这条边连接的两个点是否属于同一集合。若不属于同一集合，则将这条边加入最小生成树，并将两个点所在的集合合并为一个集合。若属于同一集合，则跳过。直到找到 $n-1$ 条边为止。

 1 | #include <iostream>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | struct point { int x, y, v; } a[10000];
 5 | int cmp(const point &a, const point &b) {
 6 |     if (①) return 1;
 7 |     return 0;
 8 | }
 9 | int fat[101];
10 | int father(int x) {
11 |     if (fat[x] != x) return fat[x] = ②;
12 |     return fat[x];
13 | }
14 | void unionn(int x, int y) {
15 |     int fa = father(x), fb = father(y);
16 |     if (fa != fb) fat[fa] = fb;
17 | }
18 | int main() {
19 |     int i, j, n, m, k = 0, ans = 0, cnt = 0;
20 |     cin >> n;
21 |     for (i = 1; i <= n; i++)
22 |         for (j = 1; j <= n; j++) {
23 |             cin >> m;
24 |             if (m != 0) {
25 |                 k++; a[k].x = i; a[k].y = j; a[k].v = m;
26 |             }
27 |         }
28 |     sort(a + 1, a + 1 + k, ③);
29 |     for (i = 1; i <= n; i++) fat[i] = i;
30 |     for (i = 1; i <= k; i++) {
31 |         if (father(a[i].x) != ④) {
32 |             ans += a[i].v;
33 |             unionn(a[i].x, a[i].y);
34 |             cnt++;
35 |         }
36 |         if (⑤) break;
37 |     }
38 |     cout << ans << endl;
39 |     return 0;
40 | }

第 33 题（单选题，3 分）

① 处应填（）。

a.v < b.v

a.v > b.v

a.v >= b.v

a.v <= b.v

正确答案A

解析详情

【答案】A

【考点】排序比较函数

【解析】 Kruskal 需要按边权从小到大排序，所以当 `a.v < b.v` 时比较函数应返回真。

【易错点】使用 `<=` 或 `>=` 会破坏严格弱序要求。

第 34 题（单选题，3 分）

② 处应填（）。

father(x)

father(fat[x])

fat[father(x)]

x

正确答案B

解析详情

【答案】B

【考点】并查集路径压缩

【解析】当 `fat[x] != x` 时，应递归查找父节点的根，即 `father(fat[x])`，并把结果回写给 `fat[x]` 完成路径压缩。

【易错点】递归调用 `father(x)` 会在同一节点上无限递归。

第 35 题（单选题，3 分）

③ 处应填（）。

algorithm

point

cmp

sizeof(a)

正确答案C

解析详情

【答案】C

【考点】`std::sort` 比较器

【解析】 `sort(first, last, comp)` 的第三个参数应是比较函数，本题已定义的函数名为 `cmp`。

【易错点】头文件名、结构体类型和数组大小都不能充当此处比较器。

第 36 题（单选题，3 分）

④ 处应填（）。

a[i].y

father(a[i].y)

fat[a[i].y]

a[i].x

正确答案B

解析详情

【答案】B

【考点】Kruskal 判环

【解析】一条边可以加入生成树的条件是两端点的根不同，因此右侧应写 `father(a[i].y)` 与左端点的根比较。

【易错点】直接比较父节点值不能保证得到集合代表元。

第 37 题（单选题，3 分）

⑤ 处应填（）。

cnt > 0

i == 1

ans == n - 1

cnt == n - 1

正确答案D

解析详情

【答案】D

【考点】生成树边数

【解析】 `cnt` 记录已经选入的边数；含 $n$ 个顶点的生成树恰有 $n-1$ 条边，所以 `cnt == n - 1` 时可停止。

【易错点】`ans` 是边权和，不是已选边数。

三、完善程序（2）欧拉路径

欧拉路径问题是指从图中的一个顶点出发，是否能够一次性不回头地走遍所有的边（一次且仅一次）。算法代码如下。

 1 | #include <iostream>
 2 | using namespace std;
 3 | int G[5][5];
 4 | int visited[5][5];
 5 | int n = 5;
 6 | void euler(int u) {
 7 |     for (int v = 0; v < n; v++) {
 8 |         if (G[u][v] && ①) {
 9 |             cout << u << "->" << v << endl;
10 |             visited[u][v] = visited[v][u] = ②;
11 |             ③
12 |         }
13 |     }
14 | }
15 | int main() {
16 |     G[1][2] = G[2][1] = G[1][3] = ④ = 1;
17 |     G[2][4] = G[4][2] = G[3][4] = ⑤ = 1;
18 |     euler(1);
19 |     return 0;
20 | }

第 38 题（单选题，3 分）

① 处应填（）。

G[v][u]

!visited[u][v]

visited[u][v]

visited[v][u]

正确答案B

解析详情

【答案】B

【考点】欧拉路径边访问标记

【解析】只有邻接矩阵中存在边且该边尚未访问时才应继续，因此条件为 `G[u][v] && !visited[u][v]`。

【易错点】`visited[u][v]` 为真表示已经走过，逻辑方向不能写反。

第 39 题（单选题，3 分）

② 处应填（）。

1

0

u

v

正确答案A

解析详情

【答案】A

【考点】无向边标记

【解析】走过边 $(u,v)$ 后应把两个方向的访问标记同时设为 1，防止之后重复经过同一条无向边。

【易错点】邻接矩阵的两个对称位置表示同一条无向边。

第 40 题（单选题，3 分）

③ 处应填（）。

euler(v);

euler(u);

G[u][v] = 0;

G[v][u] = 0;

正确答案A

解析详情

【答案】A

【考点】欧拉路径递归

【解析】当前从 `u` 走到相邻顶点 `v` 后，应递归调用 `euler(v)`，继续从新顶点查找未访问边。

【易错点】再次调用 `euler(u)` 会停留在原顶点。

第 41 题（单选题，3 分）

④ 处应填（）。

G[0][1]

G[1][0]

G[3][1]

G[0][3]

正确答案C

解析详情

【答案】C

【考点】无向图邻接矩阵

【解析】语句已经设置 `G[1][3]`，无向边还需设置其对称位置 `G[3][1]`，因此选 C。

【易错点】对称位置应交换行、列下标。

第 42 题（单选题，3 分）

⑤ 处应填（）。

G[0][2]

G[2][0]

G[2][1]

G[4][3]

正确答案D

解析详情

【答案】D

【考点】无向图邻接矩阵

【解析】语句已经设置 `G[3][4]`，对应的反向位置是 `G[4][3]`，两者同时赋 1 才表示无向边。

【易错点】不要把已有的边 `G[2][4]` 的对称项与本空混淆。