首页 › 试卷 › GESP编程能力等级认证 › GESP-C++八级 › 2025年3月CCF-GESP编程能力等级认证C++编程八级真题

2025年3月CCF-GESP编程能力等级认证C++编程八级真题 VIP

GESP-C++八级 共 27 题 2025 年 含标准答案与解析
返回试卷列表
本页为整卷浏览:先自己做一遍,再展开「查看答案与解析」核对。

一、单选题

1. 单选题

国家“以旧换新”政策仍在继续,小杨家决定在家里旧的冰箱、电视、洗衣机、微波炉中选两种换新。

其中,冰箱有4种型号可选,电视有6种型号可选,洗衣机有3种型号可选,微波炉有5种型号可选。

请问小杨家共有多少种换新的方案?( )

  • A 18
  • B 119
  • C 238
  • D 360
查看答案与解析
答案:B
解析:

根据乘法原理和加法原理,答案为 4x6 4x3+4x5+6x3+6x5+3x5 = 119。(计数原理、排列组合)

2. 单选题

小杨和3位朋友约好一起去看电影“哪吒2”。打开购票软件,他们发现,已经没有同一排连续的四个座位了(图中每个方框代表一个座位,红色方框代表已经售出)。

朋友们商量了一下,决定分为两组,每组两人在同一排的相邻两个座位,且两组之间至少有一对座位是前后相邻的。请问共有多少种购票方案?( )

  • A 495
  • B 96
  • C 7
  • D 4
查看答案与解析
答案:C
解析:

根据题面可以数出—共 7 种购票方案。(计数原理、排列组合

3. 单选题

下面关于C++类构造和析构函数的说法,错误的是?( )

  • A 构造函数不能声明为虚函数。
  • B 析构函数必须声明为虚函数。
  • C 类的默认构造函数可以被声明为private。
  • D 类的析构函数可以被声明为private。
查看答案与解析
答案:B
解析:

析构函数不—定必须是虚函数,当类有虚函数并且可能被继承时才必须声明为虚函数。(面向对象:类的相 关概念)

4. 单选题

下列关于树和图的说法,【错误】的是?( )

  • A 树是一种有向无环图,有向无环图都是一棵树。
  • B 如果把树看做有向图,每个节点指向其子节点,则该图是弱连通图。
  • C N个顶点且连通的无向图,其最小生成树一定包含N-1个条边。
  • D N+1个顶点、 N条边的有向图,一定不是强连通的。
查看答案与解析
答案:A
解析:

有向的树才可以看作有向无环图,有向无环图不—定是树。(树图结构)

5. 单选题

从1到2025这2025个数中,包含数字5的个数?( )

  • A 600
  • B 601
  • C 602
  • D 603
查看答案与解析
答案:D
解析:

个位为 5 的数有 203 个,十位为 5 的数有 20  x  10 = 200 个,百位为 5 的数有 2  x  100 = 200 个,—共 有 603 个。(计数原理、排列组合)

6. 单选题

已定义 double 类型的变量 r 和 theta ,分别表示图中圆半径和圆心角。下列表达式中可以求出弦长 s 的是?( )

  • A r * cos(theta)
  • B r * cos(theta / 2) * 2
  • C r * sin(theta)
  • D r * sin(theta / 2) * 2
查看答案与解析
答案:D
解析:

从圆心向弦做垂线,由垂线定理可以得到答案为D

7. 单选题

个节点的平衡二叉树的高为?( )

  • A
  • B
  • C
  • D 无法确定。
查看答案与解析
答案:D
解析:

平衡二叉树的形态不固定,不能确定高度。(平衡二叉树)

8. 单选题

下列关于算法的说法,【错误】的是?( )

  • A 如果有足够的时间和空间,枚举法能解决一切有限的问题。
  • B 分治算法将原问题分为多个子问题进行求解,且分解出的子问题必须相互独立。
  • C 如果能找到合理的贪心原则,贪心算法往往能够比其他方法更快求解。
  • D 倍增法在搜索未知长度的有序数组时,通过动态倍增或减半步长,快速定位目标范围。
查看答案与解析
答案:B
解析:

子问题可以不独立,在解决完子问题后再合并。(算法的时空效率分析)

9. 单选题

2025 是个神奇的数字,因为它是由两个数 20 和 25 拼接而成,而且 2025 =(20+25) 2。小杨决定写个程序找找小于 N 的正整数中共有多少这样神奇的数字。

下面程序横线处应填入的是?( )

#include <string>
int count_miracle(int N) {
    int cnt = 0;
    for (int n = 1; n * n < N; n++) {
        int n2 = n * n;
        std::string s = std::to_string(n2);
        for (int i = 1; i < s.length(); i++)
            if (s[i] != '0') {
                std::string sl = s.substr(0, i);
                std::string sr = s.substr(i);
                int nl = std::stoi(sl);
                int nr = std::stoi(sr);
                if (_________) // 在此处填入选项
                    cnt++;
            }
    }
    return cnt;
}
  • A nl + nr == n
  • B nl + nr == n2
  • C (nl + nr) * (nl + nr) == n
  • D (nl + nr) ^ 2 == n2
查看答案与解析
答案:A
解析:

此时应该判断两半的和的平方是否等于原数,而原数是 n2 ,n 是其平方根,所以选择 A。(阅读模拟程序、 字符串函数)

10. 单选题

2025 是个神奇的数字,因为它是由两个数 20 和 25 拼接而成,而且 2025 =(20+25)2 。小杨决定写个程序找找小于 N 的正整数中共有多少这样神奇的数字。

该函数的时间复杂度为?( )

#include <string>
int count_miracle(int N) {
    int cnt = 0;
    for (int n = 1; n * n < N; n++) {
        int n2 = n * n;
        std::string s = std::to_string(n2);
        for (int i = 1; i < s.length(); i++)
            if (s[i] != '0') {
                std::string sl = s.substr(0, i);
                std::string sr = s.substr(i);
                int nl = std::stoi(sl);
                int nr = std::stoi(sr);
                if (_________) // 在此处填入选项
                    cnt++;
            }
    }
    return cnt;
}
  • A O(N log N)
  • B
  • C
  • D
查看答案与解析
答案:D
这道题暂未补解析。
11. 单选题

下面的欧氏筛法程序中,两个横线处应填入的分别是?( )

int primes[MAXP], num = 0;
bool isPrime[MAXN + 1] = {false};
void sieve() {
    for (int n = 2; n <= MAXN; n++) {
        if (!isPrime[n])
            primes[num++] = n;
        for (int i = 0; i < num && ________; i++) { // 在此处填入选项
            isPrime[n * primes[i]] = true;
            if (________) // 在此处填入选项
                break;
        }
    }
}
  • A n * primes[i] < MAXNn % primes[i] == 0
  • B n * primes[i] < MAXNprimes[i] > n
  • C n * primes[i] <= MAXNn % primes[i] == 0
  • D n * primes[i] <= MAXNprimes[i] > n
查看答案与解析
答案:C
解析:

第—空应该保证  n * primes[i] 不超过筛法的范围,第二空应该是如果当前  primes[i] 是 n 的最小素因子 则停止循环。(数论:质数筛法)

12. 单选题

下面Floyd算法中,横线处应该填入的是?( )

#include <iostream>
using namespace std;
#define N 21
#define INF 99999999
int map[N][N];
int main() {
    int n, m, t1, t2, t3;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j)
                map[i][j] = 0;
            else
                map[i][j] = INF;
        }
    }
    for (int i = 1; i <= m; i++) {
        cin >> t1 >> t2 >> t3;
        map[t1][t2] = t3;
    }
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                if (map[i][j] > map[i][k] + map[k][j])
                    ________; // 在此处填入选项
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cout.width(4);
            cout << map[i][j];
        }
        cout << endl;
    }
}
  • A map[i][j] = map[i][k] + map[k][j]
  • B map[i][k] = map[i][j] - map[k][j]
  • C map[i][j] = map[i][k] - map[k][j]
  • D map[k][j] = map[i][j] - map[i][k]
查看答案与解析
答案:A
解析:

根据 Floyd 算法,如果 i 到 k 加上 k 到 j 的最短路长度小于当前 i 到 j 的最短路长度,则用前者更新后者。 (图论算法: Floyd 算法)

13. 单选题

下面Floyd算法程序的时间复杂度为?( )

#include <iostream>
using namespace std;
#define N 21
#define INF 99999999
int map[N][N];
int main() {
    int n, m, t1, t2, t3;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j)
                map[i][j] = 0;
            else
                map[i][j] = INF;
        }
    }
    for (int i = 1; i <= m; i++) {
        cin >> t1 >> t2 >> t3;
        map[t1][t2] = t3;
    }
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                if (map[i][j] > map[i][k] + map[k][j])
                    ________; // 在此处填入选项
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cout.width(4);
            cout << map[i][j];
        }
        cout << endl;
    }
}
  • A O(N)
  • B
  • C
  • D
查看答案与解析
答案:C
解析:

22, 23 ,24 行,循环共执行 o(n3) 次。(图论算法:  Floyd 算法)

14. 单选题

下列程序实现了输出杨辉三角形,代码中横线部分应该填入的是?( )

#include <iostream>
using namespace std;
#define N 35
int a[N];
int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        a[i] = 1;
        for (int j = i - 1; j > 0; j--)
            ________; // 在此处填入选项
        for (int j = 0; j <= i; j++)
            cout << a[j] << " ";
        cout << endl;
    }
    return 0;
}
  • A a[j] += a[j + 1]
  • B a[j] += a[j - 1]
  • C a[j - 1] += a[j]
  • D a[j + 1] += a[j]
查看答案与解析
答案:B
解析:

根据组合数的递推式 ci,j = ci - 1,j + ci - 1,j - 1 可以知道应该选择 B (这里使用了滚动数组)。(杨辉三角)

15. 单选题

下列程序实现了输出杨辉三角形,其时间复杂度为?( )

#include <iostream>
using namespace std;
#define N 35
int a[N];
int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        a[i] = 1;
        for (int j = i - 1; j > 0; j--)
            ________; // 在此处填入选项
        for (int j = 0; j <= i; j++)
            cout << a[j] << " ";
        cout << endl;
    }
    return 0;
}
  • A O(n)
  • B O(n log n)
  • C
  • D
查看答案与解析
答案:C
这道题暂未补解析。

二、判断题

16. 判断题

表达式 '5' - 3.0 的结果为 2.0 ,类型为 double 。( )

  • A对
  • B错
查看答案与解析
答案:错
解析:

字符  '5' 对应的值是 53,因此结果是  50.0 。( C++表达式)

17. 判断题

在C++语言中,如果想要在一个函数内调用一个类的私有方法,可以在该类中将该函数声明为友元函数。( )

  • A对
  • B错
查看答案与解析
答案:对
解析:

友元函数可以访问类的私有和保护成员,这使得它们能够直接操作类的内部数据。(面向对象:类的相关概 念)

18. 判断题

插入排序一般是稳定的。( )

  • A对
  • B错
查看答案与解析
答案:对
解析:

因为按照原序列的顺序插入,所以可以保证相同元素的相对顺序不变。(排序算法:插入排序)

19. 判断题

5个相同的红球和4个相同的蓝球排成一排,要求蓝球不能相邻,则一共有15种排列方案。( )

  • A对
  • B错
查看答案与解析
答案:对
解析:

 根据插板法,答案为15种。(计数原理、排列组合)

20. 判断题

使用 math.h 或 cmath 头文件中的函数,表达式 pow(2, 5) 的结果类型为 int 、值为 32 。( )

  • A对
  • B错
查看答案与解析
答案:错
解析:

结果类型应该是 double。(数学库、 pow函数)

21. 判断题

C++是一种面向对象编程语言,C则不是。多态是面向对象三大特性之一,虚函数是动态多态的代表特性。因此,使用C语言无法实现虚函数。( )

  • A对
  • B错
查看答案与解析
答案:错
解析:

C 语言可以通过函数指针实现类似虚函数的功能。(面向对象编程)

22. 判断题

在 N 个节点的平衡二叉树中查找指定元素的最差时间复杂度为  O(N) 。( )

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

定义 int 类型的变量 a 和 b ,求二次函数  取最小值时 x 的值,可以通过表达式 -a / 2.0 求得。( )

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

判断无向图中是否有环,可以通过广度优先搜索实现。( )

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

从32名学生中选出4人分别担任班长、副班长、学习委员和组织委员,共有 C(32, 4) 种不同的选法。( )

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

三、简答题

26. 简答题

上学

时间限制:1 s,内存限制:512 MB

【问题描述】

C 城可以视为由 n 个结点与 m 条边组成的无向图。这些结点依次以 1、2、……、n 标号,边依次以 1、2、……、m 标号。

第 i 条边(1<=i<=m)连接编号为 ui 与 vi 的结点,长度为 li 米。

小 A 的学校坐落在 C 城中编号为 s 的结点。小 A 的同学们共有 q 位,他们想在保证不迟到的前提下,每天尽可能晚地出门上学。但同学们并不会计算从家需要多久才能到学校,于是找到了聪明的小 A。

第 i 位同学(1<=i<=q )告诉小 A,他的家位于编号为 hi 的结点,并且他每秒能行走 1 米。请你帮小 A 计算,每位同学从家出发需要多少秒才能到达学校呢?

【输入描述】

第一行,四个正整数 n、m、s、q,分别表示 C 城的结点数与边数,学校所在的结点编号,以及小 A 同学们的数量。

接下来 m 行,每行三个正整数 ui、vi、li,表示 C 城中的一条无向边。

接下来 q 行,每行一个正整数 hi,表示一位同学的情况。

【输出描述】

共 q 行,对于每位同学,输出一个整数,表示从家出发到学校的最短时间。

【样例输入1】

5 5 3 3
1 2 3
2 3 2
3 4 1
4 5 3
1 4 2
5
1
4

【样例输出1】

4
3
1

【数据范围】

对于 20% 的测试点,保证 q=1。

对于另外 20% 的测试点,保证 1<=n<=500,1<=m<=500  。

对于所有测试点,保证 1<=n<=2×10^5,1<=m<=2×10^5 ,1<=q<=2×10^5 ,1<=ui、vi、hi<=n ,1<=li<=10^6 。

保证给定的图联通。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;cstdio&gt; #include &lt;queue&gt; #include &lt;iostream&gt; using namespace std; const int N = 2e5 + 5; const int E = N &lt;&lt; 1; const long long oo = 1e18; int n, m, s, q; int h[N], to[E], nx[E], wt[E], et; int vis[N]; long long d[N]; priority_queue &lt;pair&lt;long long, int&gt;&gt; pq; void ae(int u, int v, int w) {     et++;     to[et] = v;     nx[et] = h[u];     wt[et] = w;     h[u] = et; } int main() {     scanf("%d%d%d%d", &amp;n, &amp;m, &amp;s, &amp;q);     for (int i = 1; i &lt;= m; i++) {         int u, v, l;         scanf("%d%d%d", &amp;u, &amp;v, &amp;l);         ae(u, v, l);         ae(v, u, l);     }     for (int i = 1; i &lt;= n; i++)         d[i] = oo;     d[s] = 0;     pq.push({0, s});     while (!pq.empty()) {         auto p = pq.top();         pq.pop();         int u = p.second;         if (vis[u])             continue;         vis[u] = 1;         for (int i = h[u]; i; i = nx[i])             if (d[u] + wt[i] &lt; d[to[i]]) {                 d[to[i]] = d[u] + wt[i];                 pq.push({-d[to[i]], to[i]});             }     }     while (q--) {         int p;         scanf("%d", &amp;p);         printf("%lld\n", d[p]);     }     return 0; }</pre>
这道题暂未补解析。
27. 简答题

割裂

时间限制:1 s,内存限制:512 MB

【问题描述】

小杨有一棵包含 n 个节点的树,其中节点的编号从 1 到 n。

小杨设置了 a 个好点对 {<u1,v1>、<u2,v2>、……、<ua,va>} 和 1 个坏点对 {<bu,bv>}。一个节点能够被删除,当且仅当:

◆ 删除该节点后对于所有的 i(1<=i<=a),好点对 ui 和 vi 仍然连通;

◆ 删除该节点后坏点对 bu 和 bv 不连通。

如果点对中的任意一个节点被删除,其视为不连通。

小杨想知道,有多少个节点能够被删除。

【输入描述】

第一行包含两个正整数 n、a,含义如题面所示。

之后 n - 1 行,每行包含两个正整数 xi、yi,代表存在一条连接节点 xi 和 yi 的边。

之后 a 行,每行包含两个正整数 ui、vi,代表一个好点对 <ui,vi>。

最后一行包含两个正整数 bu、bv,代表坏点对 <bu,bv>。

【输出描述】

输出一个正整数,代表能够删除的节点个数。

【样例输入】

6 2
1 3
1 5
3 6
3 2
5 4
5 4
5 3
2 6

【样例输出】

2

【数据范围】

对于全部数据,保证有 。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;bits/stdc++.h&gt; using namespace std; const int N = 1e6+10; int n, k; vector&lt;int&gt; e[N]; int f[N][25], dep[N], g[N], h[N]; void dfs(int u, int fa) {     dep[u] = dep[fa] + 1;     f[u][0] = fa;     for(int i = 1; i &lt;= 20; i++) {         f[u][i] = f[f[u][i - 1]][i - 1];     }     for(auto v: e[u]) {         if(v == fa) continue;         dfs(v, u);     } } int lca(int u, int v) {     if(dep[u] &lt; dep[v]) swap(u, v);     int t = dep[u] - dep[v];     for(int i = 0; i &lt;= 20; i++) {         if(t &amp; (1 &lt;&lt; i)) u = f[u][i];     }     for(int i = 20; i &gt;= 0; i--) {         if(f[u][i] != f[v][i])             u = f[u][i], v = f[v][i];     }     if(u == v) return u;     return f[u][0]; } int ans; void dfs2(int u, int fa) {     for(auto v: e[u]) {         if(v == fa) continue;         dfs2(v, u);         g[u] += g[v];         h[u] += h[v];     }     if(!g[u] &amp;&amp; h[u]) {         ans++;     } } void solve() {     cin &gt;&gt; n &gt;&gt; k;     for(int i = 1; i &lt; n; i++) {         int u, v;         cin &gt;&gt; u &gt;&gt; v;         e[u].push_back(v);         e[v].push_back(u);     }     dfs(1, 0);     for(int i = 1; i &lt;= k; i++) {         int u, v;         cin &gt;&gt; u &gt;&gt; v;         int lc = lca(u, v);         g[u]++, g[v]++, g[lc]--, g[f[lc][0]]--;     }     int u, v;     cin &gt;&gt; u &gt;&gt; v;     int lc = lca(u, v);     h[u]++, h[v]++, h[lc]--, h[f[lc][0]]--;     dfs2(1, 0);     cout &lt;&lt; ans &lt;&lt; '\n'; } int main() {     solve(); }</pre>
这道题暂未补解析。