首页 › 试卷 › 信息学奥赛 › 信息学奥赛-提高级 › 2025年CCF非专业级别软件能力认证第一轮 (CSP-S)提高级C++语言试题

2025年CCF非专业级别软件能力认证第一轮 (CSP-S)提高级C++语言试题 VIP

信息学奥赛-提高级 共 46 题 2025 年 含标准答案与解析
返回试卷列表
本页为整卷浏览:先自己做一遍,再展开「查看答案与解析」核对。

一、单选题

1. 单选题

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


  • A

    25

  • B

    30

  • C

    6

  • D

    120

查看答案与解析
答案:C
解析:

先将所有红色球排成一排,会形成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}
查看答案与解析
答案:A
解析:

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
查看答案与解析
答案:B
解析:

满线段树结构为:  

[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
查看答案与解析
答案:D
解析:

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

5. 单选题

对于一个包含n个结点和m条边的有向无环图(DAG),其拓扑排序的结果有多少种可能? 


  • A

    只有1种

  • B

    最多n种

  • C

    等于n-m种

  • D

    以上都不对

查看答案与解析
答案: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
查看答案与解析
答案:D
解析:

哈希冲突指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
查看答案与解析
答案:A
解析:

最小生成树是选边构成树且权值和最小。用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
查看答案与解析
答案:A
解析:

二叉搜索树性质为“树根左子树点权≤树根点权,右子树点权≥树根点权,且左右子树也为二叉搜索树”。  

后序遍历最后一个数为根节点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
查看答案与解析
答案:D
解析:

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
查看答案与解析
答案:D
解析:

因树以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)
查看答案与解析
答案:C
解析:

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

第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
查看答案与解析
答案:A
解析:

最小堆堆顶是最小值:  

插入后堆为[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
查看答案与解析
答案:A
解析:

设全集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 动态规划使用了更少的数据存储空间
查看答案与解析
答案:C
解析:

朴素递归会重复计算大量重叠子问题(如计算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 任意一个任务都可以
查看答案与解析
答案:B
解析:

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

20. 单选题

当输入的n=4的时候,程序输出的答案为?

  • A 11
  • B 12
  • C 24
  • D 9
查看答案与解析
答案:A
这道题暂未补解析。
21. 单选题

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

  • A 输出的答案比原答案要小
  • B 无法确定输出的答案
  • C 程序可能陷入死循环
  • D 没有影响
查看答案与解析
答案:D
这道题暂未补解析。
22. 单选题

假如删去第14行的“if (flag[i]) continue;”,输入3,得到的输出答案是?

  • A 27
  • B 3
  • C 16
  • D 12
查看答案与解析
答案:C
这道题暂未补解析。
27. 单选题

函数guess1在运行过程中,cnt_broken的值最多为?

  • A 0
  • B 1
  • C 2
  • D n
查看答案与解析
答案:B
这道题暂未补解析。
28. 单选题

函数guess2在运行过程中,最多使用的猜测次数的量级为? 

  • A O(n)
  • B O(n²)
  • C

    O(√n)

  • D

    O(logn)

查看答案与解析
答案:C
这道题暂未补解析。
29. 单选题

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

  • A 100,14
  • B 100,13
  • C 99,14
  • D 99,13
查看答案与解析
答案:A
这道题暂未补解析。
34. 单选题

当输入为“3 15 1 2 -1 2 1 2”时,输出结果为?

  • A 4
  • B 8
  • C 0
  • D 10
查看答案与解析
答案:B
这道题暂未补解析。
35. 单选题

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

  • A O(n)
  • B O(mnlogmn)
  • C O(mn/2logmn/2)
  • D O(m3/2(log mn/2+log P))
查看答案与解析
答案:C
这道题暂未补解析。
36. 单选题

本题所求出的是?

  • 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的解的数量

查看答案与解析
答案:D
这道题暂未补解析。
38. 单选题

①处应填?  

  • A 0
  • B 1
  • C -1
  • D false
查看答案与解析
答案:A
这道题暂未补解析。
39. 单选题

②处应填?  

  • A d[u][!used]
  • B d[u][used]
  • C d[t][used]
  • D INF
查看答案与解析
答案:B
这道题暂未补解析。
40. 单选题

③处应填?

  • A d[v][1]
  • B d[v][used]
  • C d[u][used]
  • D d[v][0]
查看答案与解析
答案:B
这道题暂未补解析。
41. 单选题

④处应填?

  • A d[v][0]
  • B d[v][1]
  • C d[u][0]
  • D d[u][1]
查看答案与解析
答案:C
这道题暂未补解析。
42. 单选题

⑤处应填?

  • A d[t][1]
  • B d[t][0]
  • C min(d[t][0], d[t][1])
  • D d[t][0] + d[t][1]
查看答案与解析
答案:C
这道题暂未补解析。
44. 单选题

②处应填? 

  • 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)
查看答案与解析
答案:B
这道题暂未补解析。
45. 单选题

④处应填?  

  • A (signature>>i) & 1
  • B (signature >> i) ^ 1
  • C signature | (1 << i)
  • D (signature >> 1) | 1
查看答案与解析
答案:A
这道题暂未补解析。
46. 单选题

⑤处应填?  

  • 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]
查看答案与解析
答案:B
这道题暂未补解析。

二、简答题

16. 简答题
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;
}
查看答案与解析
答案:(缺答案,待补录)
这道题暂未补解析。
23. 简答题
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;
}
查看答案与解析
答案:(缺答案,待补录)
这道题暂未补解析。
30. 简答题
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;
}
查看答案与解析
答案:(缺答案,待补录)
这道题暂未补解析。
37. 简答题

特殊最短路

题目背景

给定一个含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;
}
查看答案与解析
答案:(缺答案,待补录)
这道题暂未补解析。
43. 简答题

生产线测试

题目背景

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

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

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

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

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

`test_subset()` 函数为抽象测试接口,输入所有批次的方案并返回一个二进制编码;该编码表示为每批次的检测结果(即最低位是第1批次、最高位是第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;
}
查看答案与解析
答案:(缺答案,待补录)
这道题暂未补解析。

三、判断题

17. 判断题

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

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
18. 判断题

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

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
19. 判断题

删除第19行的“flag[i]=false;”,对答案不会产生影响。

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
24. 判断题

当输入为“6 5 1”时,猜测次数为5;当输入“6 5 2”时,猜测次数为3。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
25. 判断题

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

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
26. 判断题

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

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
31. 判断题

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

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
32. 判断题

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

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
33. 判断题

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

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。