2025 CSP-S提高级（第一轮）C++真题以及答案

2025 CSP-S提高级（第一轮）C++真题

考试时间：60分钟总分：100 及格分：60

一、单选题 (共15题，每题2分)

1、有5个红色球和5个蓝色球，除颜色外完全相同，将10个球排成一排，要求任意两个蓝色球都不能相邻，有多少种不同的排列方法？

A：25

B：30

C：6

D：120

【正确答案】

【试题解析】

先将所有红色球排成一排，会形成6个空隙，每个空隙最多放一个蓝色球，从6个空隙中选5个放蓝球，方案数为C(6,5)=6。

2、在KMP算法中，对于模式串P='abacaba'，其next数组（next $i$ 定义为模式串P $0...i$ 最长公共前后缀的长度，且数组下标从0开始）的值是什么？

A：{0,0,1,0,1,2,3}

B：{0,1,2,3,4,5,6}

C：{0,0,1,1,2,2,3}

D：{0,0,0,0,1,2,3}

【正确答案】

【试题解析】

next $i$ 定义为P $0..i$ 最长公共前后缀（不能是P $0..i$ 本身，需同时是前缀与后缀）的长度。

i=0时，P $0..i$ 为"a"，长度0；

i=1时，P $0..i$ 为"ab"，长度0；

i=2时，P $0..i$ 为"aba"，长度1；

i=3时，P $0..i$ 为"abac"，长度0；

i=4时，P $0..i$ 为"abaca"，长度1；

i=5时，P $0..i$ 为"abacab"，长度2；

i=6时，P $0..i$ 为"abacaba"，长度3。

3、对一个大小为16（下标0-15）的数组构建满线段树，查询区间 $3,11$ 时，最少需要访问多少个树结点（包括路径上的父结点和完全包含在查询区间内的结点）？

A：7

B：8

C：9

D：10

【正确答案】

【试题解析】

满线段树结构为：

$0,15$ 分为 $0,7$ 和 $8,15$ ；

$0,7$ 分为 $0,3$ 和 $4,7$ ；

$8,15$ 分为 $8,11$ 和 $12,15$ ；

$0,3$ 分为 $0,1$ 和 $2,3$ 。

查询 $3,11$ 时，需访问 $0,15$ 、 $0,7$ 、 $8,15$ 、 $0,3$ 、 $4,7$ 、 $8,11$ 、 $2,3$ 、 $3,3$ ，共8个节点。

4、将字符串"cat""car""cart""case""dog""do"插入一个空的Trie树（前缀树）中，构建完成的Trie树（包括根节点）共有多少个结点？

A：8

B：9

C：10

D：11

【正确答案】

【试题解析】

按Trie树构建规则，依次插入各字符串，统计节点总数。

5、对于一个包含n个结点和m条边的有向无环图（DAG），其拓扑排序的结果有多少种可能？

A：只有1种

B：最多n种

C：等于n-m种

D：以上都不对

【正确答案】

【试题解析】

拓扑排序是找到n个节点的排列顺序，使图中每一条a指向b的边，在排列中a都出现在b前面。举例n=3、m=0时，任何1-3的排列都符合要求，数量为3!=6种，A、B、C选项均不符合。

6、在一个大小为13的哈希表中，使用闭散列法的线性探查来解决冲突，哈希函数为H(key)=key mod 13，依次插入关键字18、26、35、9、68、74，插入74后，它最终被放置在哪个索引位置？

A：5

B：7

C：9

D：11

【正确答案】

【试题解析】

哈希冲突指key1≠key2但H(key1)=H(key2)，计算各关键字哈希值及插入位置：

18 mod 13=5，插入下标5；

26 mod 13=0，插入下标0；

35 mod 13=9，插入下标9；

9 mod 13=9（冲突），插入下标10；

68 mod 13=3，插入下标3；

74 mod 13=9（冲突，9、10均被占），插入下标11。

7、一个包含8个顶点的完全图（顶点编号1到8），任意两点之间的边权重等于两顶点编号的差的绝对值，该图的最小生成树总权重是多少？

A：7

B：8

C：9

D：10

【正确答案】

【试题解析】

最小生成树是选边构成树且权值和最小。用Kruskal算法，将边权从小到大排序，边权最小的边为(1,2)、(2,3)、(3,4)、(4,5)、(5,6)、(6,7)、(7,8)，权值均为1，总和7。

8、如果一棵二叉搜索树的后序遍历序列是2,5,4,8,12,10,6，那么该树的前序遍历是什么？

A：6,4,2,5,10,8,12

B：6,4,5,2,10,12,8

C：2,4,5,6,8,10,12

D：12,8,10,5,2,4,6

【正确答案】

【试题解析】

二叉搜索树性质为"树根左子树点权≤树根点权，右子树点权≥树根点权，且左右子树也为二叉搜索树"。

后序遍历最后一个数为根节点6；

左子树节点为2、5、4，根为4（左子树2，右子树5）；

右子树节点为8、12、10，根为10（左子树8，右子树12）；

前序遍历为6,4,2,5,10,8,12。

9、一个0-1背包问题，背包容量为20，现有5个物品，重量和价值分别为7,5,4,3,6和15,12,9,7,13，装入背包的物品能获得的最大总价值是多少？

A：43

B：41

C：45

D：44

【正确答案】

【试题解析】

0-1背包中物品要么选要么不选，分类讨论：

装5个物品：总重量25>20，不合法；

装4个物品：移走一个物品使总价值最大，选重量3、4、6、7的物品，价值和7+9+13+15=44；

装3个物品：价值最大的3个物品价值和40<44。

10、在一棵以结点1为根的树中，结点12和结点18的最近公共祖先（LCA）是结点4，下列哪个结点的LCA组合是不可能出现的？

A：LCA(12,4)=4

B：LCA(18,4)=4

C：LCA(12,18,4)=4

D：LCA(12,1)=4

【正确答案】

【试题解析】

因树以1为根，1是所有节点的祖先，LCA(12,1)应为1，而非4。

11、递归关系式T(n)=2T(n/2)+O(n²)描述了某个分治算法的时间复杂度，该算法的时间复杂度是多少？

A：O(n)

B：O(nlogn)

C：O(n2)

D：O(n2logn)

【正确答案】

【试题解析】

用主定理或递归树法。递归树中：

第1层总时间复杂度n2；

第2层2*(n/2)2=n2/2；

第3层4*(n/4)2=n2/4；

......总和为n2*(1+1/2+1/4+...)≤2n2，时间复杂度为O(n2)。

12、在一个初始为空的最小堆（min-heap）中，依次插入元素20,12,15,8,10,5，然后连续执行两次"删除最小值"（delete-min）操作，此时堆顶元素是什么？

A：10

B：12

C：15

D：20

【正确答案】

【试题解析】

最小堆堆顶是最小值：

插入后堆为 $5,8,12,20,10,15$ ；

第一次删最小值5，堆调整为 $8,10,12,20,15$ ；

第二次删最小值8，堆调整为 $10,15,12,20$ ，堆顶为10。

13、1到1000之间，不能被2、3、5中任意一个数整除的整数有多少个？

A：266

B：267

C：333

D：734

【正确答案】

【试题解析】

设全集U（1-1000），集合X（2的倍数）、Y（3的倍数）、Z（5的倍数）：

|U|=1000，|X|=500，|Y|=333，|Z|=200；

|X∩Y|=166，|X∩Z|=100，|Y∩Z|=66，|X∩Y∩Z|=33；

用容斥原理：1000-500-333-200+166+100+66-33=266。

14、斐波那契数列定义为F(0)=0，F(1)=1，F(n)=F(n-1)+F(n-2)，使用朴素递归方法计算F(n)的时间复杂度是指数级的，而使用动态规划（或迭代）方法的时间复杂度是线性的，造成这种差异的根本原因是？

A：递归函数调用栈开销过大

B：操作系统对递归深度有限制

C：朴素递归中存在大量的重叠子问题未被重复利用

D：动态规划使用了更少的数据存储空间

【正确答案】

【试题解析】

朴素递归会重复计算大量重叠子问题（如计算F(5)需算F(4)和F(3)，算F(4)又需算F(3)和F(2)），动态规划通过存储子问题结果避免重复计算。

15、有5个独立的、不可抢占的任务A1,A2,A3,A4,A5需在一台机器上执行（从时间0开始），每个任务有处理时长和截止时刻（原文部分数据表述可能存在排版问题），为使总惩罚最小，应选择哪个任务作为第一个执行任务？

A：处理时间最短的任务A5

B：截止时间最早的任务A3

C：处理时间最长的任务A4

D：任意一个任务都可以

【正确答案】

【试题解析】

举例"25 9 10 15"方案中，A3作为开头可使总惩罚为0，其他任务开头可能无法实现。

二、组合题（阅读程序） (共18题，每题2分)

1、阅读程序（一）

1-6题组合题

include <algorithm>
include <cstdio>
include <cstring>
bool flag $27$ ;
int n;
int p $27$ ;
int ans = 0;
void dfs(int k) {
if (k == n + 1) {
++ans;
return;
}
for (int i = 1; i <= n; ++i) {
if (flag $i$ ) continue;
if (k > 1 && i == p $k 1$ + 1) continue;
p $k$ = i;
flag $i$ = true;
dfs(k + 1);
flag $i$ = false;
}
return;
}
int main() {
scanf("%d", &n);
dfs(1);
printf("%d\n", ans);
return 0;
}

1、当输入的n=3的时候，程序输出的答案为3。

A：正确

B：错误

2、在dfs函数运行过程中，k的取值会满足1≤k≤n+1。

A：正确

B：错误

3、删除第19行的"flag $i$ =false;"，对答案不会产生影响。

A：正确

B：错误

4、当输入的n=4的时候，程序输出的答案为？

A：11

B：12

C：24

D：9

5、如果因为某些问题，导致程序运行第25行的dfs函数之前，数组p的初值并不全为0，则对程序的影响是？

A：输出的答案比原答案要小

B：无法确定输出的答案

C：程序可能陷入死循环

D：没有影响

6、假如删去第14行的"if (flag $i$ ) continue;"，输入3，得到的输出答案是？

A：27

B：3

C：16

D：12

2、阅读程序（二）

7-13题组合题

include <algorithm>
include <cstdio>
include <cstring>
define ll long long
int cnt_broken = 0;
int cnt_check = 0;
int n, k;
inline bool check(int h) {
printf("now check:%d\n", h);
++cnt_check;
if (cnt_broken == 2) {
printf("You have no egg!\n");
return false;
}
if (h >= k) {
++cnt_broken;
return true;
} else {
return false;
}
}
inline bool assert_ans(int h) {
if (h == k) {
printf("You are Right using %d checks\n", cnt_check);
return true;
} else {
printf("Wrong answer!\n");
return false;
}
}
inline void guess1(int n) {
for (int i = 1; i <= n; ++i) {
if (check(i)) {
assert_ans(i);
return;
}
}
}
inline void guess2(int n) {
int w = 1;
while (w * (w + 1) / 2 < n) {
++w;
}
int ti = w;
int nh = 0;
while (true) {
nh += ti;
if (nh > n) {
nh = n;
}
if (check(nh)) {
for (int j = nh ti + 1; j < nh; ++j) {
if (check(j)) {
assert_ans(j);
return;
}
}
assert_ans(nh);
return;
}
--ti;
if (ti == 0) {
assert_ans(n);
return;
}
}
}
int main() {
scanf("%d%d", &n, &k);
int t;
scanf("%d", &t);
if (t == 1) {
guess1(n);
} else {
guess2(n);
}
return 0;
}

1、当输入为"6 5 1"时，猜测次数为5；当输入"6 5 2"时，猜测次数为3。

A：正确

B：错误

2、不管输入的n和k具体为多少，t=2时的猜测数总是小于等于t=1时的猜测数。

A：正确

B：错误

3、不管t=1或t=2，程序都一定会猜到正确结果。

A：正确

B：错误

4、函数guess1在运行过程中，cnt_broken的值最多为？

A：0

B：1

C：2

D：n

5、函数guess2在运行过程中，最多使用的猜测次数的量级为？

A：O(n)

B：O(n²)

C：O(√n)

D：O(logn)

6、当输入的n=100的时候，代码中t=1和t=2分别需要的猜测次数最多分别为？

A：100,14

B：100,13

C：99,14

D：99,13

3、阅读程序（三）

13-18题组合题

include <algorithm>
include <cstdio>
include <cstring>
include <vector>
define ll long long
int n, m;
std::vector<int> k, p;
inline int mpow(int x, int k) {
int ans = 1;
for (; k; k = k >> 1, x = x * x) {
if (k & 1) {
ans = ans * x;
}
}
return ans;
}
std::vector<int> ans1, ans2;
int cnt1, cnt2;
inline void dfs(std::vector<int> &ans, int &cnt, int l, int r, int v) {
if (l > r) {
++cnt;
ans.push_back(v);
return;
}
for (int i = 1; i <= m; ++i) {
dfs(ans, cnt, l + 1, r, v + k $l$ * mpow(i, p $l$ ));
}
return;
}
std::vector<int> cntans1;
int main() {
scanf("%d%d", &n, &m);
k.resize(n + 1);
p.resize(n + 1);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &k $i$ , &p $i$ );
}
dfs(ans1, cnt1, 1, n >> 1, 0);
dfs(ans2, cnt2, (n >> 1) + 1, n, 0);
std::sort(ans1.begin(), ans1.end());
int newcnt1 = 1;
cntans1.push_back(1);
for (int i = 1; i < cnt1; ++i) {
if (ans1 $i$ == ans1 $newcnt1 1$ ) {
++cntans1 $newcnt1 1$ ;
} else {
ans1 $newcnt1++$ = ans1 $i$ ;
cntans1.push_back(1);
}
}
cnt1 = newcnt1;
std::sort(ans2.begin(), ans2.end());
int las = 0;
ll ans = 0;
for (int i = cnt2 1; i >= 0; --i) {
while (las < cnt1 && ans1 $las$ + ans2 $i$ < 0) {
++las;
}
if (las < cnt1 && ans1 $las$ + ans2 $i$ == 0) {
ans += cntans1 $las$ ;
}
}
printf("%lld\n", ans);
return 0;
}

1、删除第51行的"std::sort(ans2.begin(), ans2.end());"后，输出的结果不会受到影响。

A：正确

B：错误

2、假设计算过程中不发生溢出，函数mpow(x, k)的功能是求出x的k次方的值。

A：正确

B：错误

3、代码中第39行到第50行的目的是为了将ans1数组进行"去重"操作。

A：正确

B：错误

4、当输入为"3 15 1 2 -1 2 1 2"时，输出结果为？

A：4

B：8

C：0

D：10

5、记程序结束前p数组元素的最大值为P，则该代码的时间复杂度是？

A：O(n)

B：O(mnlogmn)

C：O(mn/2logmn/2)

D：O(m3/2(log mn/2+log P))

6、本题所求出的是？

A：满足a,b,c∈ $1,m$ 的整数方程a3 +b2=c2的解的数量

B：满足a,b,c∈ $1,m$ 的整数方程a2 +b2=c2的解的数量

C：满足x∈ $0,m$ 的整数方程Σk_i・x_i^p_i=0的解的数量

D：满足x∈ $1,m$ 的整数方程Σk_i・x_i^p_i=0的解的数量

三、单选题（完善程序） (共10题，每题3分)

1、完善程序（一）

1-6题组合题

特殊最短路

题目背景

给定一个含N个点、M条边的带权无向图，边权非负。起点为S，终点为T。对于一条S到T的路径，可以在整条路径中，至多选择一条边作为"免费边"：当第一次经过这条被选中的边时，费用视为0；如果之后再次经过该边，则仍按其原始权重视计费。点和边均允许重复经过。求从S到T的最小总费用。

以下代码求解了上述问题。试补全程序。

include <algorithm>

include <iostream>

include <queue>

include <vector>

using namespace std;

const long long INF = 1e18;

struct Edge {

int to;

int weight;

};

struct State {

long long dist;

int u;

int used_freebie; // 0 for not used, 1 for used

bool operator>(const State &other) const {

return dist > other.dist;

}

};

int main() {

int n, m, s, t;

cin >> n >> m >> s >> t;

vector<vector<Edge>> adj(n + 1);

for (int i = 0; i < m; ++i) {

int u, v, w;

cin >> u >> v >> w;

adj $u$ .push_back({v, w});

adj $v$ .push_back({u, w});

}

vector<vector<long long>> d(n + 1, vector<long long>(2, INF));

priority_queue<State, vector<State>, greater<State>> pq;

d $s$ $0$ = 0;

pq.push( ① ); // ①处待完善（注：原文①处对应初始化相关）

while (!pq.empty()) {

State current = pq.top();

pq.pop();

long long dist = current.dist;

int u = current.u;

int used = current.used_freebie;

if (dist > ② ) { // ②处待完善

continue;

}

for (const auto &edge : adj $u$ ) {

int v = edge.to;

int w = edge.weight;

// 情况1：不使用免费边

if (d $v$ $used$ > ③ + w) { // ③处待完善

d $v$ $used$ = d $u$ $used$ + w;

pq.push({d $v$ $used$ , v, used});

}

// 情况2：使用免费边（仅当未使用过）

if (used == 0 && d $v$ $1$ > ④ + 0) { // ④处待完善

d $v$ $1$ = d $u$ $0$ + 0;

pq.push({d $v$ $1$ , v, 1});

}

cout << ⑤ << endl; // ⑤处待完善

return 0;

}

1、①处应填？

A：0

B：1

C：-1

D：false

2、②处应填？

A：d $u$ $!used$

B：d $u$ $used$

C：d $t$ $used$

D：INF

3、③处应填？

A：d $v$ $1$

B：d $v$ $used$

C：d $u$ $used$

D：d $v$ $0$

4、④处应填？

A：d $v$ $0$

B：d $v$ $1$

C：d $u$ $0$

D：d $u$ $1$

5、⑤处应填？

A：d $t$ $1$

B：d $t$ $0$

C：min(d $t$ $0$ , d $t$ $1$ )

D：d $t$ $0$ + d $t$ $1$

2、完善程序（二）

6-10题组合题

生产线测试

题目背景

工厂打算通过客户反馈来间接测试生产线，从而找到存在缺陷的生产线。工厂有n条生产线（编号0～n-1），已知其中恰有一条生产线存在缺陷。每一轮测试为，从若干生产线的产品取样混合成一个批次发给客户。若该批次中包含缺陷生产线的产品，客户将要求退货（结果记为1），否则正常收货（记为0）。受售后压力限制，在所有发货批次中，最多只能有k次退货（即结果为1的次数≤k）。工厂的目标是，设计最少的间接测试轮数w（发货总批次），保证根据客户收货或退货的反馈结果，唯一确定存在缺陷的生产线。

以下程序实现了工厂的目标，包含两部分：

i) 确定w的最小值，并设计最优测试方案；

ii) 根据测试结果推断存在缺陷的生产线。

该程序确定w最小值的方法为：由于不同的生产线故障时，测试应当返回不同的结果，因此w轮测试的可能结果数不应少于生产线数量。

`test_subset()` 函数为抽象测试接口，输入所有批次的方案并返回一个二进制编码；该编码表示为每批次的检测结果（即最低位是第1批次、最高位是第w批次）；其实现在此处未给出。

试补全程序。

include <algorithm>

include <cstddef>

include <iostream>

include <vector>

using namespace std;

long long comb(int w, int i) { // 计算组合数C(w,i)

if (i < 0 || i > w) {

return 0;

}

long long res = 1;

for (int t = 1; t <= i; ++t) {

res = res * (w t + 1) / t;

}

return res;

}

long long count_patterns(int w, int k) { // 计算长度为w、1的个数≤k的码字总数

long long total = 0;

for (int t = 0; t <= min(w, k); ++t) {

total += comb(w, t);

}

return total;

}

int test_subset(const vector<vector<int>> &plan); // 抽象测试接口

int solve(int n, int k) {

// 第1步：求最小w

int w = 1;

while ( ① ) { // ①处待完善

++w;

}

cout << w << endl;

// 第2步：生成n个长度为w、含1的数量不超过k的二进制串，保存在code里面

vector<vector<int>> code(n, vector<int>(w, 0));

int idx = 0;

for (int ones = 0; ones <= k && idx < n; ++ones) {

vector<int> bits(w, 0);

fill(bits.begin(), bits.begin() + ones, 1);

do {

for (int b = 0; b < w; ++b) {

code $idx$ $b$ = bits $b$ ;

}

++idx;

if (idx >= n) {

break;

}

} while ( ② ); // ②处待完善

}

// 第3步：生成测试方案plan

vector<vector<int>> plan(w);

for (int i = 0; i < w; ++i) {

for (int j = 0; j < n; ++j) {

if ( ③ ) { // ③处待完善

plan $i$ .push_back(j); // 将第j条生产线产品混合到第i轮测试

}

// 第4步：调用测试接口

int signature = test_subset(plan);

// 第5步：结果解码，将signature转为二进制串sig_bits

vector<int> sig_bits(w, 0);

for (int i = 0; i < w; ++i) {

if ( ④ ) { // ④处待完善

sig_bits $i$ = 1;

}

// 第6步：匹配sig_bits与code，找到缺陷生产线

for (int j = 0; j < n; ++j) {

if ( ⑤ ) { // ⑤处待完善

return j;

}

return -1;

}

int main() {

int n, k;

cin >> n >> k;

int ans = solve(n, k);

cout << ans << endl;

return 0;

}

1、①处应填？

A：(1 << w) < n

B：count_patterns(w, k) < n

C：count_patterns(k, w) < n

D：comb(w, k) < n

2、②处应填？

A：next_permutation(bits.begin(), bits.end())

B：prev_permutation(bits.begin(), bits.end())

C：next_permutation(bits.begin(), bits.begin() + ones)

D：prev_permutation(bits.begin(), bits.begin() + ones)

3、③处应填？

A：(j>>i) & 1

B：(i >> j) & 1

C：code $i$ $j$ = 1

D：code $j$ $i$ == 1

4、④处应填？

A：(signature>>i) & 1

B：(signature >> i) ^ 1

C：signature | (1 << i)

D：(signature >> 1) | 1

5、⑤处应填？

A：is_permutation(code $j$ .begin(), code $j$ .end(), sig_bits.begin())

B：code $j$ == sig_bits

C：plan $j$ == sig_bits

D：code $j$ $i$ == sig_bits $i$