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

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

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

第 1 题

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

{{ select(1) }}

  • 从磁盘调入中央处理器
  • 从内存储器调入高速缓冲存储器
  • 从软盘调入硬盘
  • 从系统盘调入内存储器

第 2 题

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

{{ select(2) }}

  • 单任务字符方式
  • 单任务图形方式
  • 多任务字符方式
  • 多任务图形方式

第 3 题

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

{{ select(3) }}

  • 72 72
  • 32 32
  • 32 72
  • 72 32

第 4 题

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

{{ select(4) }}

  • 8
  • 1
  • 16
  • 2

第 5 题

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

{{ select(5) }}

  • (2048)10(2048)_{10}
  • (2049)10(2049)_{10}
  • (3746)8(3746)_8
  • (1AF7)16(1AF7)_{16}

第 6 题

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

{{ select(6) }}

  • 每秒执行百万条指令
  • 每秒处理百万个字符
  • 每秒执行千万条指令
  • 每秒处理千万个字符

第 7 题

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

{{ select(7) }}

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

第 8 题

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

{{ select(8) }}

  • 不确定
  • 2n−12n-1
  • 2n+12n+1
  • 2n2n

第 9 题

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

{{ select(9) }}

  • 奇数
  • 偶数
  • 可奇可偶
  • 数目固定

第 10 题

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

{{ select(10) }}

  • 插入排序
  • 归并排序
  • 选择排序
  • 快速排序

第 11 题

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

{{ select(11) }}

  • n=L+mn = L + m
  • L+m=2nL + m = 2n
  • m=L−1m = L - 1
  • n=2L−1n = 2L - 1

第 12 题

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

{{ select(12) }}

  • Windows XP
  • Arch/Info
  • Linux
  • OS/2

第 13 题

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

{{ select(13) }}

  • 主板
  • 虚拟内存
  • 总线
  • 硬盘

第 14 题

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

{{ select(14) }}

  • 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

第 15 题

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

{{ select(15) }}

  • (2,2,2,2,2)(2,2,2,2,2)
  • (1,2,1,1,1)(1,2,1,1,1)
  • (3,3,3,2,2)(3,3,3,2,2)
  • (5,4,3,2,1)(5,4,3,2,1)

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

（1）

#include <iostream>
#include <cmath>
using namespace std;
bool IsPrime(int num) {
	for (int i = 2; i <= sqrt(num); i++) {
		if (num % i == 0) return false;
	}
	return true;
}
int main() {
	int num = 0;
	cin >> num;
	if (IsPrime(num)) cout << "YES" << endl;
	else cout << "NO" << endl;
	return 0;
}

判断题

第 16 题

输入 97 时，输出为 NO。

{{ input(16) }}

第 17 题

输入 119 时，输出为 YES。

{{ input(17) }}

第 18 题

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

{{ input(18) }}

第 19 题

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

{{ input(19) }}

选择题

第 20 题

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

{{ select(20) }}

  • O(n)O(n)
  • O(n2)O(n^2)
  • O(n)O(\sqrt{n})
  • O(log⁡n)O(\log n)

第 21 题

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

{{ select(21) }}

  • 0.45
  • 0.4
  • 0.5
  • 0.35

（2）

#include <bits/stdc++.h>
using namespace std;
const int mod = 2048;
long long c, n;
long long kasumi(long long x, long long mi) {
	long long res = 1;
	while (mi) {
		if (mi & 1) {
			res = (res * x) % mod;
		}
		x = (x * x) % mod;
		mi >>= 1;
	}
	return res;
}
int main() {
	cin >> n >> c;
	if (n == 3) {
		printf("%lld", c * (c - 1));
		return 0;
	}
	long long ans = ((kasumi(c - 1, n) + (c - 1) * kasumi(-1, n)) % mod + mod) % mod;
	cout << ans << endl;
	return 0;
}

判断题

第 22 题

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

{{ input(22) }}

第 23 题

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

{{ input(23) }}

第 24 题

若输入 4 4，输出为 78。

{{ input(24) }}

第 25 题

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

{{ input(25) }}

选择题

第 26 题

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

{{ select(26) }}

  • 8
  • 12
  • 18
  • 19

（3）

#include <cstdio>
int n, r, num[10000];
bool mark[10000];
void print() {
	for (int i = 1; i <= r; i++)
		printf ("%d ", num[i]);
	printf("\n");
}
void search(int x) {
	for (int i = 1; i <= n; i++)
		if (!mark[i]) {
			num[x] = i;
			mark[i] = true;
			if (x == r) print();
			search(x + 1);
			mark[i] = false;
		}
}
int main() {
	scanf("%d%d", &n, &r);
	search(1);
}

判断题

第 27 题

程序结束时，对任意 1≤i≤n1 \leq i \leq n，都有 mark[i]=0\text{mark}[i]=0。

{{ input(27) }}

第 28 题

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

{{ input(28) }}

第 29 题

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

{{ input(29) }}

第 30 题

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

{{ input(30) }}

选择题

第 31 题

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

{{ select(31) }}

  • 60
  • 120
  • 6
  • 720

第 32 题

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

{{ select(32) }}

  • 4 5 6 7
  • 7 6 5 4
  • 4 3 2 1
  • 1 2 3 4

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

（1）

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

#include <iostream>
#include <algorithm>
using namespace std;
struct point {	int x, y, v;} a[10000];
int cmp(const point &a, const point &b) {
	if (①) return 1;
	return 0;
}
int fat[101];
int father(int x) {
	if (fat[x] != x) return fat[x] = ②;
	return fat[x];
}
void unionn (int x, int y) {
	int fa = father(x), fb = father(y);
	if (fa != fb) fat[fa] = fb;
}
int main() {
	int i, j, n, m, k = 0, ans = 0, cnt = 0;
	cin >> n;
	for (i = 1; i <= n; i++)
		for (j = 1; j <= n; j++) {
			cin >> m;
			if (m != 0) {
				k++;a[k].x = i; a[k].y = j;	a[k].v = m;
			}
		}
	sort(a + 1, a + 1 + k, ③);
	for (i = 1; i <= n; i++) fat[i] = i;
	for (i = 1; i <= k; i++) {
		if (father(a[i].x) != ④) {
			ans += a[i].v;
			unionn(a[i].x, a[i].y);
			cnt++;
		}
		if (⑤) break;
	}
	cout << ans << endl;
	return 0;
}

第 33 题

①处应填（ ）。

{{ select(33) }}

  • a.v < b.v
  • a.v > b.v
  • a.v >= b.v
  • a.v <= b.v

第 34 题

②处应填（ ）。

{{ select(34) }}

  • father(x)
  • father(fat[x])
  • fat[father(x)]
  • x

第 35 题

③处应填（ ）。

{{ select(35) }}

  • algorithm
  • point
  • cmp
  • sizeof(a)

第 36 题

④处应填（ ）。

{{ select(36) }}

  • a[i].y
  • father(a[i].y)
  • fat[a[i].y]
  • a[i].x

第 37 题

⑤处应填（ ）。

{{ select(37) }}

  • cnt > 0
  • i == 1
  • ans == n-1
  • cnt == n-1

（2）

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

#include <iostream>
using namespace std;
int G[5][5];
int visited[5][5];
int n = 5;
void euler(int u) {
	for (int v=0; v<n; v++) {
		if (G[u][v] && ①) {
			cout << u << "->" << v << endl;
			visited[u][v] = visited[v][u] = ②;
			③
		}
	}
}
int main() {
	G[1][2] = G[2][1] = G[1][3] = ④ = 1;
	G[2][4] = G[4][2] = G[3][4] = ⑤ = 1;
	euler(1);
	return 0;
}

第 38 题

①处应填（ ）。

{{ select(38) }}

  • G[v][u]
  • !visited[u][v]
  • visited[u][v]
  • visited[v][u]

第 39 题

②处应填（ ）。

{{ select(39) }}

  • 1
  • 0
  • u
  • v

第 40 题

③处应填（ ）。

{{ select(40) }}

  • euler(v);
  • euler(u);
  • G[u][v]=0;
  • G[v][u]=0;

第 41 题

④处应填（ ）。

{{ select(41) }}

  • G[0][1]
  • G[1][0]
  • G[3][1]
  • G[0][3]

第 42 题

⑤处应填（ ）。

{{ select(42) }}

  • G[0][2]
  • G[2][0]
  • G[2][1]
  • G[4][3]
  1. 评测队列
  2. 服务状态
  3. 兼容模式
  4. 主题
  3. Powered by Hydro v5.0.1 Community