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

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

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

一、单选题

1. 单选题

假设一个算法时间复杂度的递推式是那么这个算法的时间复杂度是( )。

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

下面关于“唯一分解定理”和“素数筛法”的说法中,错误的是( )。

  • A 如果预处理出n以内每个数的最小质因子,那么可以在O(logn)时间内完成任意一个不超过 的整数的质因 数分解。
  • B 线性筛(欧拉筛)能够保证每个合数只被其最小质因子筛掉一次,这一性质依赖于唯一分解定理。
  • C 唯一分解定理保证:若一个数未被任何不超过其平方根的质数筛去,则它一定是质数。
  • D 唯一分解定理是埃氏筛时间复杂度为的根本原因。
查看答案与解析
答案:D
这道题暂未补解析。
3. 单选题

若字符串 与字符串 的最长公共子序列(LCS)长度为 5,则( )。

  • A 它们的编辑距离为 5
  • B 它们至少有 5 个公共字符
  • C 它们最长公共子串长度为 5
  • D 它们一定长度相等
查看答案与解析
答案:B
解析: 最长公共子序列(LCS)是指两个字符串中按顺序出现且字符相同的最长子序列,不要求连续。LCS长度为5表示存在5个字符在两个字符串中以相同顺序出现。编辑距离衡量通过插入、删除、替换操作将一个字符串转换为另一个的最少步数,与LCS无直接数值对应关系。公共字符数量至少等于LCS长度,因为LCS由实际存在的字符构成。最长公共子串要求字符连续,其长度小于或等于LCS长度,但不一定相等。字符串长度可以不同,LCS长度仅反映公共部分的顺序匹配程度,不约束总长度是否一致。
4. 单选题

对于一棵包含 个顶点( n>=2)的树,其所有顶点的度数之和必定等于( )。

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

题 关于哈希表(Hash Table)在不考虑扩容且采用简单均匀哈希函数的前提下,下列说法中错误的是( )。

  • A 装载因子越大,发生冲突的概率通常越高
  • B 开放定址法在删除元素时实现相对复杂
  • C 链地址法在最坏情况下查找时间复杂度为
  • D 查找哈希表的时间复杂度总是
查看答案与解析
答案:D
这道题暂未补解析。
6. 单选题

深度优先搜索(DFS)在遍历图时,每当访问到某个顶点后,选择一个相邻的未访问顶点继续搜索,直到某个顶点的所有相邻顶点均已被访问,则退回到前一顶点继续搜索。该算法主要运用了( )。

  • A 分治
  • B 贪心
  • C 动态规划
  • D 回溯
查看答案与解析
答案:D
解析: 深度优先搜索在访问顶点后,选择一个未访问的相邻顶点深入遍历,当无法继续前进时,返回上一顶点尝试其他分支。该过程依赖于系统调用栈或手动维护栈记录路径,每次回退到前一状态以探索其余可能路径。这种机制体现的是在搜索过程中保存状态并在无路可走时退回尝试其他选择的行为模式。分治将问题拆解为独立子问题求解;贪心每一步选择当前最优解;动态规划保存子问题结果避免重复计算;回溯则通过逐步构建解并在不可行时撤销选择继续搜索。
7. 单选题

下面程序的运行结果为( )。

#include <iostream>
#include <algorithm>

bool check(int n, int a[], int k, int dist) {
    int cnt = 1;
    int last = a[0];

    for (int i = 1; i < n; i++) {
        if (a[i] - last >= dist) {
            cnt++;
            last = a[i];
        }
    }

    return cnt >= k;
}

int solve(int n, int a[], int k) {
    std::sort(a, a + n);

    int l = 0;
    int r = a[n - 1] - a[0];

    while (l < r) {
        int mid = (l + r + 1) / 2;
        if (check(n, a, k, mid))
            l = mid;
        else
            r = mid - 1;
    }

    return l;
}

int main() {
    int a[] = {1, 2, 8, 4, 9};
    int n = 5;
    int k = 3;

    std::cout << solve(n, a, k) << std::endl;

    return 0;
}


  • A 2
  • B 3
  • C 4
  • D 5
查看答案与解析
答案:B
解析: 程序包含两个函数:check 和 solve。check 函数接收数组 a、其长度 n、整数 k 和 dist,判断在排序后的数组中能否选出至少 k 个元素,使得相邻被选元素之间的差值不小于 dist。通过贪心策略遍历数组,统计满足条件的元素个数 cnt,并与 k 比较返回布尔结果。solve 函数先对数组排序,然后使用二分查找确定最大化的最小距离。左边界 l 初始化为 0,右边界 r 初始化为最大值与最小值之差。在 while 循环中,取 mid 为当前尝试的距离,根据 check 结果调整边界:若满足则增大下界,否则减小上界。最终逼近最优解。主函数调用 solve 并输出结果。
8. 单选题

下面程序的时间复杂度是( ),假设数组 的值域范围是 。

#include <iostream>
#include <algorithm>

bool check(int n, int a[], int k, int dist) {
    int cnt = 1;
    int last = a[0];

    for (int i = 1; i < n; i++) {
        if (a[i] - last >= dist) {
            cnt++;
            last = a[i];
        }
    }

    return cnt >= k;
}

int solve(int n, int a[], int k) {
    std::sort(a, a + n);

    int l = 0;
    int r = a[n - 1] - a[0];

    while (l < r) {
        int mid = (l + r + 1) / 2;
        if (check(n, a, k, mid))
            l = mid;
        else
            r = mid - 1;
    }

    return l;
}

int main() {
    int a[] = {1, 2, 8, 4, 9};
    int n = 5;
    int k = 3;

    std::cout << solve(n, a, k) << std::endl;

    return 0;
}


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

某二叉树共有 10 个结点,记为 A~J,已知它的先序遍历序列为:A B D H I E C F J G,中序遍历序列为:H D I B E A F J C G,则该二叉树的后序遍历序列是( )。

  • A H I D E B J F G C A
  • B H I D B E J F G C A
  • C I H D E B J F G C A
  • D H I D E B F J G C A
查看答案与解析
答案:A
解析: 根据先序遍历序列确定根节点,结合中序遍历序列划分左右子树。先序序列首元素为当前子树根节点,在中序序列中定位该节点,其左侧为左子树中序序列,右侧为右子树中序序列。通过左右子树结点数量反推先序序列中对应子树的范围。递归构建左右子树结构,直至所有子树均分解至空或单个结点。后序遍历顺序为左子树、右子树、根节点,依据重建的树结构按此顺序收集结点即可得到后序序列。
10. 单选题

下面哪一个可能是下图的深度优先遍历序列( )。

  • A 1, 5, 4, 8, 7, 9, 6, 3, 2
  • B 1, 5, 8, 4, 7, 9, 6, 3, 2
  • C 2, 5, 8, 7, 9, 6, 3, 4, 1
  • D 8, 9, 6, 3, 2, 5, 1, 4, 7
查看答案与解析
答案:B
这道题暂未补解析。
11. 单选题

关于泛洪算法(Flood Fill)的说法,正确的是( )。

  • A 泛洪算法只适用于二维网格中的四连通或八连通问题。
  • B 泛洪算法必须使用递归方式实现。
  • C 泛洪算法本质上是对图进行一次从起点出发的搜索
  • D 泛洪算法只能用于统计连通块个数,不能用于计算面积或周长。
查看答案与解析
答案:C
解析: 泛洪算法是一种基于图搜索的技术,从指定起点出发,遍历所有可达节点,常用于标记或修改连通区域。该算法不限于二维网格,可应用于任意图结构;实现方式包括递归和非递归(如使用栈或队列),无强制要求;其应用不仅限于统计连通块个数,还可用于计算面积、周长等属性。连通性判断取决于访问机制而非维度或方向限制。算法核心为节点访问与扩展,不依赖特定数据结构或实现形式。
12. 单选题

有 6 个字符,它们出现的次数分别为: {2, 3, 3, 4, 6, 8} ,现在用哈夫曼编码为这些字符编码,最小加权路径长度 WPL(每个字符的出现次数 它的编码长度,再把每个字符结果加起来)的值为( )。

  • A 58
  • B 60
  • C 62
  • D 64
查看答案与解析
答案:D
解析: 将给定的字符频次按从小到大排列,构建哈夫曼树:每次选取频次最小的两个节点合并为新节点,新节点的权值为两者之和,重复此过程直至只剩一个根节点。合并过程中,每个字符的编码长度等于其在树中的深度。计算最小加权路径长度WPL时,将每个字符的频次乘以其对应编码长度(即合并时参与的层数),累加所有结果。整个过程基于贪心策略,确保频次小的字符路径更长,频次大的字符路径更短,从而使得总加权路径长度最小。
13. 单选题

关于单链表、双链表和循环链表,下列说法正确的是( )。

  • A 在单链表中,若已知某结点的指针,则可以在时间内删除该结点。
  • B 循环链表中一定不存在空指针
  • C 在循环双链表中,尾结点的 next 指针一定为 NULL。
  • D 在带头结点的循环单链表中,判定链表是否为空只需判断头结点的 next 是否指向自身
查看答案与解析
答案:D
这道题暂未补解析。
14. 单选题

下列关于树的遍历的说法中,正确的一项是( )。

  • A 对任意一棵树进行深度优先遍历,所得序列一定唯一。
  • B 已知一棵二叉树的先序遍历和后序遍历序列,可以唯一确定这棵二叉树
  • C 已知一棵二叉树的先序遍历和中序遍历序列,可以唯一确定这棵二叉树。
  • D 一棵二叉树的中序遍历序列是单调递增的,则该二叉树一定是二叉平衡树。
查看答案与解析
答案:C
解析: 深度优先遍历的序列唯一性取决于访问子节点的顺序是否固定。先序与后序遍历组合无法唯一确定二叉树结构,因缺乏根节点在序列中的明确分割位置。先序与中序遍历可唯一确定二叉树,先序提供根节点信息,中序区分左右子树范围。中序遍历单调递增仅说明节点值在中序下有序,不保证树形结构满足平衡条件。遍历序列的重建能力依赖于能否划分左右子树区间并定位根节点。
15. 单选题

下面这个有向图的强连通分量的个数是( )2026.3。

  • A 3
  • B 4
  • C 5
  • D 6
查看答案与解析
答案:B
这道题暂未补解析。

二、判断题

16. 判断题

C++ 语言中,表达式 4 ^ 2 的结果类型为 int ,值为 6 。

  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 分析表达式中运算符的语义:'^' 在 C++ 中为按位异或运算符,非数学幂运算;确定操作数类型:4 和 2 均为整型字面量,默认类型为 int;根据 C++ 类型规则,两个 int 操作数进行按位异或运算,结果类型仍为 int;按位异或运算的执行基于二进制位逐位计算,参与运算的两个整数转换为二进制形式后,相同位值为 0,不同位值为 1,最终合成结果整数。
17. 判断题

C++ 中引用可以重新绑定。

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 引用在C++中是别名机制,绑定到初始化时指定的对象后无法更改。引用必须在定义时初始化,且不能重新指向其他对象。重新绑定意味着解除当前绑定并关联新对象,这与引用的底层实现机制冲突。指针可通过赋值改变所指向地址,但引用不具备此操作。语言标准规定引用一经绑定即固定,无语法支持重新绑定。任何试图修改引用的行为实际是对所绑定对象的操作。
18. 判断题

在 C++ 中,若函数形参为引用类型,则在函数内部对该形参的修改会影响对应的实参。

  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 在C++中,当函数形参为引用类型时,该形参成为实参的别名,二者绑定至同一内存地址。引用本身不分配独立存储空间,所有对形参的操作直接作用于原对象。函数调用时,实参被用来初始化引用形参,建立绑定关系。一旦绑定完成,对引用形参的读取或修改均等效于对实参本身的读取或修改。此机制由编译器保障,无需运行时额外解引用操作。引用形参的存在使得函数能够访问并改变外部对象的状态,其行为由语言标准明确规定,与指针不同,引用一经初始化不可重新绑定。
19. 判断题

如果一个最值问题可以用动态规划在多项式时间内求解,那么也一定存在一种贪心策略,可以在多项式时间 内求得最优解。

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 动态规划适用于具有最优子结构和重叠子问题的问题,通过自底向上求解所有子问题保证全局最优。贪心算法基于贪心选择性质,在每一步选择局部最优,期望达到全局最优,其正确性依赖于问题是否满足贪心选择性和最优子结构。两个算法的适用条件不同:动态规划能解决的问题不一定满足贪心选择性质,因此无法保证存在贪心策略得到最优解。判断时需分析两类算法对问题结构性质的要求差异,不能由动态规划可解推出贪心策略必然存在。
20. 判断题

使用归并排序对 个元素进行排序时,无论最好、最坏还是平均情况,时间复杂度均为

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

在无向连通图中删除一条边,该图就一定变成非连通图。

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析无向连通图中边的性质,区分桥边与非桥边。桥边是唯一连接两个连通分量的边,删除后图不再连通;非桥边存在于环中,其删除不会破坏图的连通性。判断删除某条边是否导致图不连通,需考察该边是否属于图中的某个环。若边在环中,则存在替代路径保持连通;若边不在任何环中,则为桥边,删除后图分裂为两个连通分量。因此,边的删除对连通性的影响由其在图结构中的位置决定。
22. 判断题

在一个无向图中,每个顶点有不同的编号,在执行深度优先遍历过程中选择下一个顶点时总是优先选择编号更小的相邻顶点,则从指定顶点开始的遍历序列是唯一的。

  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 深度优先遍历从指定顶点开始,访问当前顶点后,依次选择未被访问的相邻顶点进行递归遍历。当存在多个未访问的相邻顶点时,选择编号最小的顶点作为下一个访问对象。该选择策略在每一步都具有确定性,即在相同状态下每次执行都会选取同一顶点。遍历过程中顶点的访问顺序由起始顶点和每一步的邻接顶点选择规则共同决定。图的结构和顶点编号唯一确定了每一步可选的相邻顶点集合及其排序。由于每一步的选择均依据编号大小进行比较并取最小值,不存在随机或并列情况下的任意选取。因此,从同一顶点出发,按照此规则生成的遍历序列由图的连接关系和顶点编号完全决定。
23. 判断题

若所有字符出现频率相同,则哈夫曼编码一定会得到完全二叉树

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析字符频率相同时哈夫曼树构建过程中每次选择两个最小频率节点合并的机制;考察该过程是否必然使所有非叶节点都有两个子节点;结合完全二叉树定义,即除最后一层外每层节点均满,且最后一层节点靠左连续排列,判断该结构在等频条件下是否唯一确定;考虑当所有字符频率相同且字符数为2的幂次或非2的幂次时,构建过程中是否存在必须补全左右子树的情况;根据哈夫曼算法的贪心策略,相同频率下任意选取两个节点不影响后续结构生成的可能性。
24. 判断题

使用 math.h 或 cmath 头文件中的函数,表达式 sin(90) 的结果为 1 。

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析表达式 sin(90) 的计算过程:math.h 或 cmath 中的三角函数接受弧度制输入;角度值 90 需转换为弧度才能得到对应正弦值;直接传入整数 90 视为弧度输入,不等于 π/2 弧度的精确值;标准库函数按 IEEE 浮点规范执行计算,结果为 sin(90 radians),非 sin(90°);若需计算角度制正弦值,需将角度乘以 π/180 转换为弧度后再传入函数。
25. 判断题

在一个无向连通图中,从任意顶点开始进行深度优先遍历,最终得到的 DFS 生成树一定包含图中的所有顶 点。

  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 深度优先遍历从指定起始顶点出发,沿边访问可达顶点,每条被遍历的边加入生成树。遍历过程中,未访问的相邻顶点被递归访问,直至所有从起始点可达的顶点均被处理。无向连通图中任意顶点对之间存在路径,因此从任一顶点出发的 DFS 可访问全部顶点。生成树由遍历过程中实际使用的边构成,覆盖所有被访问顶点。由于图连通,所有顶点均被访问,故生成树包含全部顶点。遍历顺序不影响顶点覆盖性,只影响边的选择。生成树结构依赖于遍历路径,但顶点集合始终为全集。

三、简答题

26. 简答题

拆分

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false;">#include &lt;cstdio&gt; using namespace std; typedef long long ll; const int mod = 1000000000; ll qpow(ll a, ll b) {     ll res = 1;     while (b) {         if (b &amp; 1) res = res * a % mod;         a = a * a % mod;         b &gt;&gt;= 1;     }     return res; } int main() {     int t;     scanf("%d", &amp;t);     while (t--) {         int n;         scanf("%d", &amp;n);         if (n == 2) {             puts("2");             continue;         }         if (n == 3) {             puts("3");             continue;         }         int r = n % 3;         int q = n / 3;         ll ans;         if (r == 0) {             ans = qpow(3, q);         } else if (r == 1) {             ans = qpow(3, q - 1) * 4 % mod;         } else { // r == 2             ans = qpow(3, q) * 2 % mod;         }         printf("%lld\n", ans);     }     return 0; }</pre>
这道题暂未补解析。
27. 简答题

物流网络

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false;">#include &lt;algorithm&gt; #include &lt;iostream&gt; #include &lt;queue&gt; #include &lt;vector&gt; using namespace std; typedef long long ll; const ll INF = 1e18; struct Highway {   int u, v;   int fee, b;   bool operator&lt;(const Highway &amp;other) const {     return b &lt; other.b;   } }; void solve() {   int n, m;   cin &gt;&gt; n &gt;&gt; m;   vector&lt;Highway&gt; highways(m);   for (int i = 0; i &lt; m; i++) {     cin &gt;&gt; highways[i].u &gt;&gt; highways[i].v &gt;&gt; highways[i].fee &gt;&gt; highways[i].b;   }   sort(highways.begin(), highways.end());   vector&lt;vector&lt;pair&lt;int, int&gt;&gt;&gt; g(n + 1); // to, fee   vector&lt;ll&gt; dp1(n + 1, INF);   vector&lt;ll&gt; dpn(n + 1, INF);   dp1[1] = 0;   dpn[n] = 0;   ll answer = INF;   auto dijk = [&amp;](int s, vector&lt;ll&gt;&amp; dist) {     priority_queue&lt;pair&lt;ll, int&gt;, vector&lt;pair&lt;ll, int&gt;&gt;, greater&lt;&gt;&gt; q;     q.emplace(dist[s], s);     while (!q.empty()) {       auto [d, u] = q.top();       q.pop();       if (d &gt; dist[u]) continue;       for (auto [v, w] : g[u]) {         if (dist[v] &gt; d + w) {           dist[v] = d + w;           q.emplace(dist[v], v);         }       }     }   };   for (auto &amp;r : highways) {     int u = r.u, v = r.v;     int w = r.fee, bb = r.b;     // 核心:这里 + bb!你原版漏掉了     if (dp1[u] != INF &amp;&amp; dpn[v] != INF)       answer = min(answer, dp1[u] + dpn[v] + bb);     if (dp1[v] != INF &amp;&amp; dpn[u] != INF)       answer = min(answer, dp1[v] + dpn[u] + bb);     // 再加边进图     g[u].emplace_back(v, w);     g[v].emplace_back(u, w);     // 重新跑Dijkstra更新最短路     dijk(1, dp1);     dijk(n, dpn);   }   if (answer == INF) cout &lt;&lt; -1 &lt;&lt; '\n';   else cout &lt;&lt; answer &lt;&lt; '\n'; } int main() {   ios::sync_with_stdio(false);   cin.tie(nullptr);   solve();   return 0; }</pre>
这道题暂未补解析。