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

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

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

一、单选题

1. 单选题

某班级有8名男生和6名女生,现要选出3人组成学习小组,要求小组中至少有1名男生和1名女生,则不同的选法共有( )种。

  • A 112
  • B 168
  • C 224
  • D 288
查看答案与解析
答案:D
解析: 计算从8名男生和6名女生中选出3人且每组至少包含1名男生和1名女生的选法数。首先列出满足条件的性别组合:1男2女、2男1女。对每种组合分别计算组合数:1男2女的选法为C(8,1)×C(6,2),2男1女的选法为C(8,2)×C(6,1)。将两种情况的结果相加,得到所有符合条件的选法总数。
2. 单选题

在杨辉三角中,从第0行开始计数,第10行的所有数之和为( )。

  • A 512
  • B 1024
  • C 2048
  • D 4096
查看答案与解析
答案:B
解析: 杨辉三角的第n行对应二项式展开的系数,该行所有数之和等于2的n次方。第10行即n=10,其所有数之和为2的10次方。计算2的幂次时,每次将前一次结果乘以2,从2的0次方开始连续进行10次乘法运算即可得到结果。
3. 单选题

下列代码实现了快速幂算法,其时间复杂度为( )。

long long fastPow(long long b, long long e, long long mod) {
    long long result = 1;
    while (e > 0) {
        if (e & 1)
            result = result * b % mod;
        b = b * b % mod;
        e >>= 1;
    }
    return result;
}


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

从5本不同的数学书和4本不同的物理书中选取3本书,要求至少包含1本数学书,则不同的选法有( )种。

  • A 60
  • B 74
  • C 80
  • D 84
查看答案与解析
答案:C
解析: 计算从5本不同的数学书和4本不同的物理书中选取3本书的总选法,满足至少包含1本数学书。先计算不加限制的从9本书中选3本的组合数。再减去不符合条件的情况,即选出的3本书全为物理书的选法。符合条件的选法等于总选法减去全为物理书的选法。涉及组合数运算,需分别计算C(9,3)与C(4,3)并作差。
5. 单选题

在二叉搜索树(BST)中,若中序遍历的序列为 {1, 2, 3, 4, 5} ,且先序遍历的第一个序列元素为 3 ,则下列说法正确的是( )。

  • A 该树一定是一棵完全二叉树
  • B 元素4和5不可能是兄弟节点
  • C 元素1所在节点的深度可能大于3(根节点深度为1)
  • D 元素2一定是元素1的父节点
查看答案与解析
答案:B
解析: 中序遍历序列 {1, 2, 3, 4, 5} 表明二叉搜索树的节点按升序排列,根节点将中序序列分为左右子树。先序遍历首元素为3,说明根节点是3。由此可确定左子树包含{1,2},右子树包含{4,5}。根据二叉搜索树性质,1和2必须位于根的左子树,4和5位于右子树。左子树中2可能是1的父节点或1为2的左子节点;右子树中4和5可为任意父子关系。树的结构由先序和中序共同决定,但存在多种合法形态。深度取决于路径长度,从根到叶逐层计算。完全二叉树要求除最后一层外满填充且节点连续靠左,无法由给定条件唯一确定。
6. 单选题

在一个有向带权图中,使用Dijkstra算法求单源最短路时,若使用优先队列(小根堆)优化,其时间复杂度为 ( )。

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

对于含n个顶点( n>=2)的连通加权有向图,若图中不存在负权环,则任意两点之间的最短路径(简单路径)最多包含( )条边。

  • A n
  • B n-1
  • C n+1
  • D 无法确定,取决于图的具体边数
查看答案与解析
答案:B
解析: 在含 n 个顶点的连通加权有向图中,若不存在负权环,则任意两点间的最短路径必为简单路径。简单路径的定义是不重复经过任何顶点的路径。路径中每条边连接两个不同顶点,因此路径上最多可经过 n 个顶点。若起点为 u,终点为 v,且路径经过所有顶点,则路径中最多包含 n-1 条边,因为从第一个顶点到第 n 个顶点需要 n-1 次转移。若路径包含 n 或更多条边,则至少有一个顶点被重复访问,违背简单路径的定义。因此,最短路径所含边数不可能超过 n-1 条。
8. 单选题

在使用Floyd算法求任意两点间最短路径时,时间复杂度为。若在某次算法执行前,已经用 Dijkstra 算 法正确求出了所有点对的最短路并存入了 dist 数组。如果此时继续对该 dist 数组执行一次完整的 Floyd 算法过程 (无任何提前终止),执行完毕后 dist 数组内的值( )。

  • A 会发生改变,因为 Floyd 又做了一次松弛
  • B 不会发生改变
  • C 可能变大,因为未针对已有最短路优化
  • D 可能在某些负权图中陷入死循环
查看答案与解析
答案:B
这道题暂未补解析。
9. 单选题

关于图论中的最短路径算法,下列说法中严格正确的是( )。

  • A Dijkstra 算法能够高效处理包含负权边的有向图。
  • B Floyd 算法可以求出任意两点间的最短路径,且允许图中存在负权边(但不能有负权环)。
  • C 单源最短路径算法无法用于无向图,无向图只能通过 BFS 求解。
  • D Dijkstra 算法的每一步必定从当前未访问的节点中,选取距离起始点最远的节点进行松弛操作。
查看答案与解析
答案:B
解析: Dijkstra算法基于贪心策略,每次选择当前距离源点最近的未访问节点进行扩展,仅适用于非负权边图。Floyd算法通过动态规划计算所有顶点对之间的最短路径,可处理负权边但要求图中无负权环。单源最短路径算法适用于有向与无向图,无向图中边可视为双向有向边,BFS仅适用于无权图或权值相等的图。Dijkstra算法每步选取距离起始点最近的未访问节点,而非最远节点,松弛操作更新邻接节点的最短距离估计值。
10. 单选题

有6个人排成一排照相,其中甲、乙两人必须相邻,且丙不能站在排头的不同排法有( )种。

  • A 120
  • B 144
  • C 192
  • D 240
查看答案与解析
答案:C
解析: 将甲、乙视为一个整体单元,该单元内部有2种排列方式。将此单元与其余4人(共5个元素)进行全排列,得到所有甲、乙相邻的排列数。在这些排列中,统计丙位于排头的情况:此时排头为丙,剩余4个元素(含甲乙单元)在后4位排列。从总的甲乙相邻排列数中,减去丙在排头且甲乙相邻的排列数,即得满足条件的排法总数。计算过程需分别考虑单元排列、整体排列与限制位置的排除。
11. 单选题

下列代码试图实现Floyd算法求所有点对之间的最短路径,横线处应填入( )。

void floyd(int n, int dist[][MAXN]) {
    for (int k = 0; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                if (___________) // 在此处填入选项
                    dist[i][j] = dist[i][k] + dist[k][j];
}
  • A
    dist[i][k] + dist[k][j] < dist[i][j]
  • B
    dist[i][k] != INF && dist[k][j] != INF
  • C
    dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]
  • D
    dist[i][j] == INF
查看答案与解析
答案:C
解析: Floyd算法通过动态规划更新任意两点间的最短路径。外层循环遍历中间点k,内层双循环遍历起点i和终点j。核心操作是比较经过中间点k的路径是否比当前记录的路径更短。更新条件依赖于从i到k和从k到j的路径存在且其距离之和小于当前i到j的距离。因此需判断dist[i][k]与dist[k][j]均不为无穷大,并计算二者之和作为候选值参与比较。算法本质是在三重循环中持续优化路径估计值。
12. 单选题

用数字 0、1、2、3、4 组成无重复数字的五位偶数,共有( )个。

  • A 48
  • B 60
  • C 72
  • D 96
查看答案与解析
答案:B
解析: 确定五位偶数的个位只能是0、2、4中的一个。分情况讨论:当个位为0时,其余四位从1、2、3、4中任取四个全排列;当个位为2或4时,需排除万位为0的情况。先确定个位选择,再安排万位(不能为0),最后安排中间三位。每种个位情况下,计算有效排列数并求和。所有数字不重复使用,每一位的选取依赖于前几位的选择限制,需按位置逐步分析可选数字个数。
13. 单选题

在一个无向带权图中,若使用 Prim 算法从顶点 0 开始构造最小生成树(边权均为正整数,且 graph[u][v] == 0 表示无边),下列代码中横线处应填入( )。

int prim(vector<vector<int>>& graph, int n) {
    vector<bool> inMST(n, false);
    vector<int> minEdge(n, INT_MAX);
    minEdge[0] = 0;
    int result = 0;
    for (int i = 0; i < n; i++) {
        int u = -1;
        for (int j = 0; j < n; j++)
            if (!inMST[j] && (u == -1 || minEdge[j] < minEdge[u]))
                u = j;
        inMST[u] = true;
        result += minEdge[u];
        for (int v = 0; v < n; v++)
            if (___________) // 在此处填入选项
                minEdge[v] = graph[u][v];
    }
    return result;
}


  • A
    graph[u][v] && !inMST[v] && graph[u][v] < minEdge[v]
  • B
    !inMST[v] && graph[u][v] < minEdge[v]
  • C
    graph[u][v] > 0 && !inMST[v]
  • D
    !inMST[v] && minEdge[v] > 0
查看答案与解析
答案:A
解析: Prim算法从顶点0开始,维护一个集合inMST表示已在生成树中的顶点,minEdge数组记录各顶点到生成树的最小边权。每轮选择未加入生成树且minEdge值最小的顶点u,将其加入生成树,并更新所有与其邻接且未加入生成树的顶点v:若边(u,v)存在且其权值小于当前minEdge[v],则用该权值更新minEdge[v]。图中graph[u][v]为0表示无边,因此需判断graph[u][v] > 0。更新条件需确保v不在生成树中且新边权有效且更小。
14. 单选题

已知三个点在平面直角坐标系中的坐标。下列 C++ 表达式中,在精度误差范围1e-8内能正确计算判断这三个点是三点共线的表达式是( )。

  • A
    (x2-x1)/(y2-y1) == (x3-x1)/(y3-y1)
  • B
    (x2-x1)*(y3-y1)-(x3-x1)*(y2-y1) == 0
  • C
    fabs((x2-x1)*(y3-y1)-(x3-x1)*(y2-y1)) < 1e-8
  • D
    fabs((x2-x1)/(y2-y1)-(x3-x1)/(y3-y1)) < 1e-8
查看答案与解析
答案:C
这道题暂未补解析。
15. 单选题

在64位操作系统下(LP64 / LLP64 模型),下面代码的输出结果是()。

#include <iostream>
using namespace std;

int main() {
    int a[4] = {1, 2, 3, 4};
    int (*p)[4] = &a;
    int *q = a;

    cout << sizeof(a) << " ";
    cout << sizeof(p) << " ";
    cout << sizeof(p + 1) << " ";
    cout << sizeof(q + 1) << " ";
    cout << (p + 1) - p << " ";
    cout << (q + 1) - q << endl;
}


  • A 16 8 8 8 1 1
  • B 16 8 16 8 1 1
  • C 16 8 8 4 4 1
  • D 16 8 8 8 4 1
查看答案与解析
答案:A
解析: 首先确定各数据类型的大小:int类型在64位系统下占4字节;数组a有4个int元素,故整个数组占用16字节。p是指向长度为4的int数组的指针,其本身为指针,在64位系统下占8字节。q是int指针,同样占8字节。&a表示整个数组的地址,其类型为int(*)[4],与p一致。计算sizeof(a)时,返回整个数组占用的字节数。计算sizeof(p)、sizeof(q)时,返回指针本身的大小。对p和q进行解引用操作后,分别得到数组首地址对应的值或首个元素的值。通过逐项分析每个表达式的类型和内存布局,可推导出各输出项的具体数值。

二、判断题

16. 判断题

在C++中,若结构体中包含一个 static 成员变量,则该变量的存储空间属于结构体对象的一部分。( )

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 结构体中的 static 成员变量属于类类型本身而非结构体对象实例;其存储空间由程序数据区分配,不随结构体对象的创建而分配在对象内存中;该变量被所有结构体实例共享,生命周期与程序运行期一致;结构体定义仅声明 static 成员变量,定义需在结构体外单独进行;sizeof 运算符计算结构体大小时不包含 static 成员变量所占空间。
17. 判断题

在C++中,若函数参数类型为 const int & ,则该参数既可以绑定左值,也可以绑定右值。( )

  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 在C++中,const引用(const T&)具有延长临时对象生命周期的能力。当函数参数为const int&时,该参数可绑定到左值,因为左值具有明确的内存地址和持久性;同时也能绑定到右值,包括字面量和临时对象,原因是编译器会为右值创建临时变量,并将const引用绑定到该临时变量上,且该临时变量的生命周期被扩展至引用本身的生命周期。此行为由语言标准规定,适用于所有符合标准的实现。
18. 判断题

若一个无向图的最小生成树唯一,则图中所有边权必定各不相同。( )

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析无向图最小生成树唯一性与边权关系时,需考察最小生成树构造过程中边的选择机制。当存在多条边具有相同权重时,在满足不形成环的前提下,这些边可能互为替代地被选入生成树。若某时刻可选择的边中存在权值相等的不同边,且各自参与构成不同生成树,则最小生成树不唯一。但即使存在权值相同的边,若其在图中的位置导致仅有一种方式能将其纳入生成树而不形成环,此时仍可能产生唯一最小生成树。因此,边权是否互异并非决定最小生成树唯一性的充分或必要条件,应通过图结构与边权分布共同确定生成树的唯一性。
19. 判断题

若一个图中所有顶点的度数为偶数,则一定存在欧拉回路。( )

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析图中每个顶点的度数是否均为偶数;根据欧拉回路存在的充要条件,判断该图是否连通且所有顶点度数为偶数;若图不连通,则即使所有顶点度数为偶数,也无法形成单一欧拉回路;检查图的连通性与顶点度数之间的关系,确认两者同时满足时才能保证欧拉回路存在;仅凭所有顶点度数为偶数这一条件,无法单独推出欧拉回路必然存在。
20. 判断题

如果将一个连通无向图中所有边的权值都统一增加同一个正整数常数C,形成图。则的最小生成树中每条边在中对应的边组成的树,一定是的最小生成树。( )

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

在图论算法中,Kruskal算法和Prim算法都可以用来求解最小生成树,且这两者的贪心策略无论在任何连通无向图上求得的最小生成树总边权和必定相同。( )

  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: Kruskal算法通过按边权递增顺序依次选择不构成环的边,逐步连接所有顶点;Prim算法从任意起始顶点出发,每次选择与当前生成树相连且权值最小的边扩展树结构。两种算法均基于贪心策略,每次决策仅依赖当前可选边的最小权值。在任意连通无向图中,若边权唯一确定,则所有最小生成树的总边权和由图的拓扑结构和边权分布共同决定。无论采用何种贪心路径构建,最终生成树的边集可能不同,但其总边权和始终等于该图最小生成树的数学定义所规定的值。算法过程不引入额外约束,故二者求得的总边权和必然一致。
22. 判断题

在动态规划问题中,“状态转移方程+递推”和“递归+记忆化搜索”通常是解决同一问题的两种不同实现方式,它们的时间复杂度总是相同的。( )

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析动态规划中状态转移方程与递推的实现机制,明确其通过迭代方式按序计算各状态值的过程;分析递归与记忆化搜索的实现机制,明确其以递归调用为基础,在搜索路径中存储已计算状态值的方式;比较两者在处理相同状态空间时的计算次数与访问频率;考察时间复杂度是否由状态总数和每个状态的计算耗时共同决定;确认两种方法在状态计算次数和重复子问题处理上的一致性。
23. 判断题

对于任意正整数 ,二项式(a+b)n展开式中各项的二项式系数之和等于2n。

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

使用快速排序对n个元素进行排序时,无论最好、最坏还是平均情况,时间复杂度为O(nlogn)。( )

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

使用倍增法预处理区间最值问题时,预处理的时间复杂度为O(nlogn),查询的时间复杂度为O(1)。( )

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

三、简答题

26. 简答题

消息查找

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false;">#include &lt;cstdio&gt; #include &lt;algorithm&gt; using namespace std; const int N = 1e5 + 5; const int C = 2e3 + 5; const int oo = 1e9; int n, q; int r[N], mark[N], pos[N]; int p[C], cnt; int d[C][C]; int pre[N], suf[N]; int main() {     scanf("%d%d", &amp;n, &amp;q);     for (int i = 1; i &lt;= n; i++)     {         scanf("%d", &amp;r[i]);         if (r[i])             mark[i] = mark[r[i]] = 1;     }     for (int i = 1; i &lt;= n; i++)     {         if (mark[i])         {             p[++cnt] = i;             pos[i] = cnt;         }     }     for (int i = 1; i &lt;= cnt; i++)     {         for (int j = 1; j &lt;= i; j++)             d[i][j] = oo;         d[i][i] = 0;         for (int j = i; j &gt; 1; j--)         {             d[i][j - 1] = min(d[i][j - 1], d[i][j] + p[j] - p[j - 1]);             if (r[p[j]])             {                 int k = pos[r[p[j]]];                 d[i][k] = min(d[i][k], d[i][j] + 1);             }         }     }     for (int i = 1; i &lt;= n; i++)     {         pre[i] = pre[i - 1];         if (mark[i])             pre[i] = i;     }     suf[n + 1] = n + 1;     for (int i = n; i; i--)     {         suf[i] = suf[i + 1];         if (mark[i])             suf[i] = i;     }     while (q--)     {         int x, y;         scanf("%d%d", &amp;x, &amp;y);         if (pre[x] &lt; suf[y])         {             printf("%d\n", x - y);         }         else         {             printf("%d\n", x - pre[x] + d[pos[pre[x]]][pos[suf[y]]] + suf[y] - y);         }     }     return 0; }</pre>
这道题暂未补解析。
27. 简答题

子图最短路

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false;">#include &lt;cstdio&gt; #include &lt;algorithm&gt; using namespace std; const int N = 105; const int mod = 1e9; int n, m; int f[N][N]; int g[N][N]; int ans; int main() {     scanf("%d%d", &amp;n, &amp;m);     for (int i = 1; i &lt;= n; i++)     {         for (int j = 1; j &lt;= n; j++)             f[i][j] = mod;         f[i][i] = 0;     }     for (int i = 1; i &lt;= m; i++)     {         int u, v, w;         scanf("%d%d%d", &amp;u, &amp;v, &amp;w);         f[u][v] = min(f[u][v], w);         f[v][u] = min(f[v][u], w);     }     for (int l = 1; l &lt;= n; l++)     {         for (int i = 1; i &lt;= n; i++)             for (int j = 1; j &lt;= n; j++)                 g[i][j] = f[i][j];         for (int r = l; r &lt;= n; r++)         {             for (int i = 1; i &lt;= n; i++)                 for (int j = 1; j &lt;= n; j++)                     g[i][j] = min(g[i][j], g[i][r] + g[r][j]);             for (int i = l; i &lt;= r; i++)                 for (int j = i; j &lt;= r; j++)                     ans = (ans + g[i][j]) % mod;         }     }     printf("%d\n", ans);     return 0; }</pre>
这道题暂未补解析。