信息学奥赛 CSP-J 2026 初赛模拟卷 2

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

1. 文件型病毒传染的主要对象是（　　）。 {{ select(1) }}

• 文本文件
• 系统文件
• 可执行文件
• $EXE$ 和 $COM$ 文件

2. $24$ 针打印机的分辨率约为 $180dpi$。$dpi$ 数越大，打印精度越高。其中单位 $dpi$ 是指（　　）。 {{ select(2) }}

• 印点/厘米
• 印点/毫米
• 印点/英寸
• 印点/寸

3. 内存地址最重要的特点是（　　）。 {{ select(3) }}

• 随机性
• 唯一性
• 顺序性
• 连续性

4. 多媒体计算机是指（　　）。 {{ select(4) }}

• 具有多种功能的计算机
• 具有多种外设的计算机
• 能处理多种媒体的计算机
• 能借助多种媒体操作的计算机

5. 最早的计算机的用途是（　　）。 {{ select(5) }}

• 科学计算
• 自动控制
• 系统仿真
• 辅助设计

6. $CPU$ 中（　　）相当于运算器中的一个存储单元，它的存取速度比存储器快得多。 {{ select(6) }}

• 存放器
• 辅存
• 主存
• 寄存器

7. 计算机软件一般指的是（　　）。 {{ select(7) }}

• 系统软件和应用软件
• 应用软件和自由软件
• 培训软件和管理软件
• 编辑软件和科学计算软件

8. 操作系统在（　　）计算机中普遍开始应用。 {{ select(8) }}

• 第一代
• 第二代
• 第三代
• 第四代

9. 计算机中的数有浮点与定点两种，其中用浮点表示的数通常由（　　）组成。 {{ select(9) }}

• 指数与基数
• 尾数与小数
• 阶码与尾数
• 整数与小数

10. 假设用一字节来表示整数，最高位用作符号位，其他位表示数值。例如，$00000001$ 表示 $+1$，$10000001$ 表示 $-1$。采用这种表示法的整数 $A$ 的范围应该是（　　）。 {{ select(10) }}

• $-127 \le A \le 127$
• $-128 \le A \le 128$
• $-128 \le A < 128$
• $-127 < A < 127$

11. 下列叙述中，正确的是（　　）。 {{ select(11) }}

• 线性表的线性存储结构优于链表存储结构
• 队列的操作方式是先进后出
• 栈的操作方式是先进先出
• 二维数组逻辑上可以理解为它的每个数据元素为一个线性表的线性表

12. 用某种排序方法对线性表 $25,84,21,47,15,27,68,35,20$ 进行排序，节点变化如下：

(1) $25,84,21,47,15,27,68,35,20$；
(2) $20,15,21,25,47,27,68,35,84$；
(3) $15,20,21,25,35,27,47,68,84$；
(4) $15,20,21,25,27,35,47,68,84$。

那么，排序方法是（　　）。 {{ select(12) }}

• 选择排序
• 希尔排序
• 合并排序
• 快速排序

13. 如果某二叉树的前序遍历序列为 $STUWV$，中序遍历序列为 $UWTVS$，那么该二叉树的后序遍历序列是（　　）。 {{ select(13) }}

• $WUVTS$
• $UWVTS$
• $VWUTS$
• $WUTSV$

14. 下列关于数据结构的叙述中，正确的是（　　）。 {{ select(14) }}

• 顺序存储方式的优点是存储密度大，且插入、删除运算效率高
• 链表中的每一个节点都包含一个非空指针项
• 包含 $n$ 个节点的二叉排序树的最大检索长度为 $\log_2 n$
• 将一棵树转换为二叉树后，根节点没有右子树

15. 表达式 $(1+34)*5-56/7$ 的后缀表达式为（　　）。 {{ select(15) }}

• 1 34 + 5 56 7 - * /
• - * + 1 34 5 / 56 7
• 1 34 + 5 * 56 7 / -
• 1 34 5 * + 56 7 /

---

二、阅读程序（程序输入不超过数组或字符串定义的范围；判断题正确填 ✓，错误填 ✗；除特殊说明外，判断题每题 2 分，选择题每题 3 分，共计 40 分）

(1)

1  #include <iostream>
2  using namespace std;
3  void hanoi(int n,char a,char b,char c) {
4      if (n == 1)
5          cout << n << " " << a << " " << c << endl;
6      else {
7          hanoi(n-1, a, c, b);
8          cout << n << " " << a << " " << c << endl;
9          hanoi(n-1, b, a, c);
10     }
11 }
12 int main() {
13     int n;
14     cin >> n;
15     hanoi(n, 'A', 'B', 'C');
16     return 0;
17 }

判断题

16. 当 $n \ge 0$ 时，程序不会出现死循环。（ ） {{ select(16) }}

• √
• ×

17. 输出共有 $2^n$ 行。（ ） {{ select(17) }}

• √
• ×

18. 当 $n > 0$ 时，将第 $4$ 行的 == 改为 <=，程序输出结果必定不变。（ ） {{ select(18) }}

• √
• ×

19. 将第 $5$ 行的 n 改为 1，程序输出结果必定不变。　（ ） {{ select(19) }}

• √
• ×

选择题

20. 此程序的时间复杂度是（　　）。 {{ select(20) }}

• $O(n)$
• $O(n^2)$
• $O(n^3)$
• $O(2^n)$

21. 若要求输出不超过 $15$ 行，则下列 $n$ 值中（　　）是合法的。 {{ select(21) }}

• $0$
• $4$
• $5$
• $6$

(2)

1  #include <cstdio>
2  #define N 1005
3  using namespace std;
4  int num[N];
5  int main() {
6      int a1 = 1,n,x;
7      scanf("%d", &n);
8      num[1] = 1;
9      for (int i=1; i<=n; ++i) {
10         x = 0;
11         for (int j=1; j<=a1; ++j) {
12             num[j] = num[j] * 5 + x;
13             x = num[j] / 10;
14             num[j] %= 10;
15         }
16         if (x > 0) num[++a1] = x;
17     }
18     printf("0.");
19     for (int i=a1; i<n; ++i) putchar('0');
20     for (int i=a1; i>=1; i--) printf("%d", num[i]);
21     putchar('\n');
22     return 0;
23 }

判断题

22. 程序输出的是 $5^n$ 的值。　　（　　） {{ select(22) }}

• √
• ×

23. 程序执行到倒数第 $3$ 行时，$i$ 的值为 $1$。　　（　　） {{ select(23) }}

• √
• ×

24. 程序结束前，对于任意 $1 \le i \le a1$，都有 $0 \le \text{num}[i] \le 9$。　　（　　） {{ select(24) }}

• √
• ×

25. 程序输出的是一个小数，且小数末尾可能有多余的 $0$。　　（　　） {{ select(25) }}

• √
• ×

选择题

26. 此程序的时间复杂度是（　　）。 {{ select(26) }}

• $O(n)$
• $O(n^2)$
• $O(n^3)$
• $O(n\log n)$

27. 若 $n = 3$，则输出为（　　）。 {{ select(27) }}

• $8$
• $0.125$
• $0.8$
• $125$

(3)

1  #include <iostream>
2  using namespace std;
3  int l,n,m,a[50005], ans;
4  bool check(int dis) {
5      int count=0, last =0;
6      for (int i=1; i<=n+1; i++)
7          if (a[i] - last < dis) count++;
8          else last = a[i];
9      if (count > m) return 0;
10     return 1;
11 }
12
13 int main() {
14     // 输入保证 l,n,m,a[i] 是正整数，且 a[i] 严格递增
15     cin >> l >> n >> m;
16     for (int i=1; i<=n; i++) cin >> a[i];
17     a[n+1] = l;
18     int fl = 0, fr = l;
19     while (fl <= fr) {
20         int mid = (fl + fr) / 2;
21         if (check(mid)) fl=mid+1, ans=mid;
22         else fr=mid-1;
23     }
24     cout << ans << endl;
25     return 0;
26 }

判断题

28. 将 main() 函数中 while 之前的 fl = 0 改为 fl = 1，程序输出结果必定不变。　　（　　） {{ select(28) }}

• √
• ×

29. 程序结束前，必有 fl > fr。　　（　　） {{ select(29) }}

• √
• ×

30. 若主函数中执行 check(mid) 返回 1，则最终的 ans 小于或等于此时的 mid。　　（　　） {{ select(30) }}

• √
• ×

选择题

31. 此程序的时间复杂度是（　　）。 {{ select(31) }}

• $O(n^2)$
• $O(n l)$
• $O(n \log l)$
• $O(n \log n)$

32. 若输入如下，则输出为（　　）。

25 5 2
2 11 14 17 21

{{ select(32) }}

• $3$
• $4$
• $5$
• $6$

---

三、完善程序（单选题，每小题 3 分，共计 30 分）

(1)

$Dijkstra$ 算法是由荷兰计算机科学家 $Dijkstra$ 于 $1959$ 年提出的，是从图中一个顶点到其余各顶点的最短路径算法，解决的是有向图中的最短路径问题。$Dijkstra$ 算法的主要特点是以源点为中心向外扩展，直到扩展到终点为止。

1  #include <iostream>
2  using namespace std;
3  int main() {
4      int edgs;
5      int points;
6      int dis[10];
7      int flag[10];
8      int infinity=9999999;
9      cin >> points >> edgs;
10     int edg[10][10];
11     for (int i=1; i<=points; i++) {
12         for (int j=1; j<=points; j++) {
13             if (i == j) {
14                 edg[i][j]= ① ;
15             } else {
16                 edg[i][j]= ② ;
17             }
18         }
19     }
20     int point1, point2, quanzhi;
21     for (int i=1;i<=edgs; i++) {
22         cin >> point1 >> point2 >> quanzhi;
23         edg[point1][point2] = ③ ;
24     }
25     for (int i=1; i<=points; i++) dis[i] = edg[1][i];
26     for (int i=1; i<=points; i++) flag[i]=0;
27     flag[1]=1;
28     int min,u;
29     for (int i=1; i<=points-1; i++) {
30         // 源点到源点不用比较，因此总的次数少一次
31         min = infinity;
32         for (int j=1; j<points; j++) {
33             if (flag[j]==0 && dis[j]<min) {
34                 // 核心思想：依次比较出离源点最近的点
35                 min = ④ ;
36                 u=j;
37             }
38         }
39         flag[u] = 1;
40         for (int v=1; v<=points; v++) {
41             // 找出离源点最近的点后，更新 dis 里面的源点到各个点的值是否最小
42             if (edg[u][v] < infinity) {
43                 if (dis[v] > dis[u] + edg[u][v]) {
44                     dis[v] = ⑤ ;
45                 }
46             }
47         }
48     }
49     for (int i=1; i<=points; i++) cout << dis[i]<<" ";
50     cout << endl;
51     return 0;
52 }

33. ① 处应填（　　）。 {{ select(33) }}

• infinity
• dis[i]
• 0
• 1

34. ② 处应填（　　）。 {{ select(34) }}

• infinity
• dis[i]
• 0
• 1

35. ③ 处应填（　　）。 {{ select(35) }}

• quanzhi
• 0
• infinity
• 1

36. ④ 处应填（　　）。 {{ select(36) }}

• j
• dis[j]
• flag[j]
• i

37. ⑤ 处应填（　　）。 {{ select(37) }}

• dis[u]
• edg[u][v]
• dis[u] + edg[u][v]
• infinity

(2)

（完全背包问题）有一个容量为 $10$ 的背包，另有 $5$ 种物品，每种物品数量无限，其重量分别为 $5,4,3,2,1$，价值分别为 $1,2,3,4,5$。设计算法，实现背包内物品价值最大。代码如下（输出 $50$）。

1  #include <iostream>
2  #include <algorithm>
3  using namespace std;
4  int main() {
5      int total_weight=10;
6      int w[6] = {0,5,4,3,2,1};
7      int v[6] = {0,1,2,3,4,5};
8      int dp[11] = { ① };
9      for (int i=1; i<= ② ; i++)
10         for (int j=w[i]; j<= ③ ; j++)
11             dp[j] = ④ ;
12     cout << ⑤ << endl;
13     return 0;
14 }

38. ① 处应填（　　）。 {{ select(38) }}

• 0
• 5
• 10
• 15

39. ② 处应填（　　）。 {{ select(39) }}

• 5
• 6
• 10
• 15

40. ③ 处应填（　　）。 {{ select(40) }}

• 5
• 6
• 10
• 15

41. ④ 处应填（　　）。 {{ select(41) }}

• dp[j] + v[i]
• dp[j-w[i]] + v[i]
• min(dp[j], dp[j-w[i]] + v[i])
• max(dp[j], dp[j-w[i]] + v[i])

42. ⑤ 处应填（　　）。 {{ select(42) }}

• v[10]
• dp[10]
• w[10]
• total_weight