#2617. 2025年9月CCF-GESP编程能力等级认证C++编程八级真题

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

GESP C++ 八级 2025年09月考试试卷

1 单选题（每题 2 分，共 30 分）

第 1 题

小杨想点一杯奶茶外卖，但还差5元起送。于是，小杨决定点一些小料。可选的小料包括：珍珠1元、椰果2元、奶冻3元、奶盖4元。每种小料最多点1份。请问共有多少种满足起送条件的点小料方案？( ) {{ select(1) }}

  • 16
  • 10
  • 9
  • 7

第 2 题

小杨和小刘是好朋友，她们在逛商场时发现新设置的大头贴自拍机，于是决定一起拍一组照片。一组照片包括4张，这4张照片没有顺序区分。拍每张照片时，可以选择有相框或无相框、两人可以分别选择有头饰或无头饰、还可以从2种位置（小杨在左，或小刘在左）中选出一种。她们不希望一组照片中出现完全相同的相框、头饰、位置的组合。请问一组照片共有多少种不同的方案？( ) {{ select(2) }}

  • 1820
  • 70
  • 24
  • 16

第 3 题

下列关于C++类的说法，错误的是( )。 {{ select(3) }}

  • 派生类对象占用的内存总是不小于基类对象。
  • 派生类可以不实现基类的虚函数。
  • 如果一个类包含纯虚函数，则它不能包含成员变量。
  • 如果一个类包含纯虚函数，则不能用它定义对象。

第 4 题

下列关于树和图的说法，错误的是( )。 {{ select(4) }}

  • 每个连通图都存在生成树。
  • 每个存在生成树的有向图，都一定是强连通的。
  • 保留树的所有节点，并把树的每个节点指向其父节点，则可以将树转换为一个有向弱连通图。
  • 保留树的所有节点，并把树的每个节点指向其子节点，则可以将树转换为一个有向无环图。

第 5 题

一对夫妻生男生女的概率相同。这对夫妻希望儿女双全。请问这对夫妻生下三个孩子时，实现儿女双全的概率是多少？( ) {{ select(5) }}

  • (\frac{1}{4})
  • (\frac{1}{2})
  • (\frac{3}{4})
  • (\frac{7}{8})

第 6 题

二项式 ((x+y)^{6}) 的展开式中 (x^{2} y^{4}) 项的系数是( )。 {{ select(6) }}

  • 720
  • 120
  • 20
  • 15

第 7 题

对一个包含(V)个顶点、(E)条边的图，执行广度优先搜索，其最优时间复杂度是( )。 {{ select(7) }}

  • (O(V))
  • (O(V+E))
  • (O\left(V^{2}\right))
  • (O(E))

第 8 题

以下关于贪心法和动态规划的说法中，错误的是( )。 {{ select(8) }}

  • 动态规划能解决大部分多阶段决策问题。
  • 对特定的问题，贪心法不一定适用。
  • 当特定的问题适用贪心法时，通常比动态规划的时间复杂度更低。
  • 对很多问题，递推实现和递归实现动态规划方法的时间复杂度相当。

第 9 题

下面程序的输出为( )。

#include <iostream> 
using namespace std;
int main() { 
    int N = 15, cnt = 0;
    for (int x = 1; x + x + x <= N; x++) 
        for (int y = x; x + y + y <= N; y++) 
            for (int z = y; x + y + z <= N; z++)
                cnt++;
    cout << cnt << endl; 
    return 0;
}

{{ select(9) }}

  • 45
  • 102
  • 174
  • 3375

第 10 题

下面程序的时间复杂度为( )。

int primes[MAXP], num = 0; 
bool isPrime[MAXN] = {false};

void sieve() {
    for (int n = 2; n <= MAXN; n++) {
        if (!isPrime[n]) 
            primes[num++] = n;
        for (int i = 0; i < num && n * primes[i] <= MAXN; i++) {
            isPrime[n * primes[i]] = true;
            if (n % primes[i] == 0)
                break;
        }
    }
}

{{ select(10) }}

  • (O(N))
  • (O(N\log\log N))
  • (O(N\log N))
  • (O(N\sqrt{N}))

第 11 题

下列Dijkstra算法，假设图中顶点数(V)、边数(E)，则程序的时间复杂度为( )。

typedef struct Edge { 
    int in, out; // 从下标in顶点到下标out顶点的边
    int len;     // 边长度
} Edge; 

// v:顶点个数,graph:出边邻接表,start:起点下标,dis:输出每个顶点的最短距离 
void dijkstra(int v, Edge * graph[], int start, int * dis) { 
    struct Edge * next;
    const int MAX_DIS = 0x7fffff;
    for (int i = 0; i < v; i++) 
        dis[i] = MAX_DIS;
    dis[start] = 0;
    int * visited = new int[v];
    for (int i = 0; i < v; i++)
        visited[i] = 0;
    visited[start] = 1; 
    for (int t = 0; ; t++) {
        int min = MAX_DIS, minv = -1;
        for (int i = 0; i < v; i++) {
            if (visited[i] == 0 && min > dis[i]) {
                min = dis[i];
                minv = i;
            }
        }
        if (minv < 0)
            break;
        visited[minv] = 1; 
        for (Edge * e = graph[minv]; e != NULL; e = e->next)
            if (dis[e->out] > dis[minv] + e->len)
                dis[e->out] = dis[minv] + e->len;
    }
    delete[] visited;
}

{{ select(11) }}

  • (O(V^{2}))
  • (O(V+E))
  • (O(E\log V))
  • (O(V\log E))

第 12 题

下面count_triple函数的时间复杂度为( )。

int gcd(int m, int n) { 
    if(m == 0) return n; 
    return gcd(n % m, m);
}

int count_triple(int n) { 
    int cnt=0;
    for(int v=1; v*v*4<=n; v++)
        for(int u=v+1; u*(u+v)*2<=n; u+=2)
            if(gcd(u,v)==1){
                int a=u*u-v*v;
                int b=u*v*2; 
                int c=u*u+v*v;
                cnt +=n/(a+b+c);
            }
    return cnt;
}

{{ select(12) }}

  • (O(n^2))
  • (O(n^2 \log n))
  • (O(n))
  • (O(n\log n))

第 13 题

下面merge_sort函数试图实现归并排序算法，横线处应该填入的是( )。

#include <vector>
using namespace std;

void merge_sort(vector<int>& arr, int Left, int right) { 
    if(right - Left <= 1)
        return;
    int mid = (Left + right) / 2; 
    merge_sort(__); // 在此处填入选项
    merge_sort(__); // 在此处填入选项
    vector<int> temp(right - Left);
    int i = Left, j = mid, k = 0;
    while (i < mid && j < right) 
        if(arr[i] <= arr[j]) 
            temp[k++] = arr[i++];
        else 
            temp[k++] = arr[j++];
    while (i < mid) 
        temp[k++] = arr[i++];
    while (j < right) 
        temp[k++] = arr[j++];
    for(i = Left, k = 0; i < right; ++i, ++k)
        arr[i] = temp[k];
}

{{ select(13) }}

  • arr, Left, mid;
arr, mid, right

  • arr, Left, mid+1;
arr, mid+1, right

  • arr, Left, mid;
arr, mid + 1, right

  • arr, Left, mid + 1;
arr, mid + 1, right + 1

第 14 题

下面Prim算法程序中，横线处应该填入的是( )。

#include <iostream>
#include <vector> 
#include <algorithm>
using namespace std;

int prim(vector<vector<int>> & graph, int n) { 
    vector<int> key(n, INT_MAX);
    vector<int> parent(n, -1); 
    key[0] = 0;
    for (int i = 0; i < n; i++) { 
        int u = min_element(key.begin(), key.end()) - key.begin();
        if (key[u] == INT_MAX) break;
        for (int v = 0; v < n; v++) {
            if (__________) { // 在此处填入选项
                key[v] = graph[u][v];
                parent[v] = u;
            }
        }
    }
    int sum = 0;
    for (int i = 0; i < n; i++) { 
        if (parent[i] != -1) { 
            cout << "Edge: " << parent[i] << " - " << i << " Weight: " << key[i] << endl;
            sum += key[i];
        }
    }
    return sum;
}

int main() {
    int n, m; 
    cin >> n >> m;
    vector<vector<int>> graph(n, vector<int>(n, 0));
    for (int i = 0; i < m; i++) { 
        int u, v, w;
        cin >> u >> v >> w; 
        graph[u][v] = w;
        graph[v][u] = w;
    }
    int result = prim(graph, n); 
    cout << "Total weight of the minimum spanning tree: " << result << endl;
    return 0;
}

{{ select(14) }}

  • graph[u][v] >= 0 && key[v] > graph[u][v]
  • graph[u][v] <= 0 && key[v] > graph[u][v]
  • graph[u][v] == 0 && key[v] > graph[u][v]
  • graph[u][v] != 0 && key[v] > graph[u][v]

第 15 题

下面的程序使用出边邻接表表达的带权无向图，从顶点0到顶点3的最短路径长度是( )。

#include <vector>
using namespace std;

class Edge { 
public: 
    int dest; 
    int weight; 
    Edge(int d, int w) : dest(d), weight(w) {}
};

class Graph {
private:
    int num_vertex;
public: 
    vector<vector<Edge>> vve;
    Graph(int v) : num_vertex(v), vve(v) {}
    void addEdge(int s, int d, int w) {
        vve[s].emplace_back(d, w);
        vve[d].emplace_back(s, w);
    }
};

int main() { 
    Graph g(4); 
    g.addEdge(0, 1, 8); 
    g.addEdge(0, 2, 5);
    g.addEdge(1, 2, 1); 
    g.addEdge(1, 3, 3);
    g.addEdge(2, 3, 7);
    return 0;
}

{{ select(15) }}

  • 12
  • 11
  • 10
  • 9

2 判断题（每题 2 分，共 20 分）

第 16 题

C++语言中，表达式'9' ^ 3的结果值为'999'。( ) {{ select(16) }}

  • 正确
  • 错误

第 17 题

下列C++语言代码，能够安全地输出arr[5]的值。( )

int n = 5; 
int arr[n] = {1, 2, 3};
std::cout << arr[5];

{{ select(17) }}

  • 正确
  • 错误

第 18 题

对n个元素的数组进行排序，最差情况的时间复杂度为 (O(n^{2}))。( ) {{ select(18) }}

  • 正确
  • 错误

第 19 题

有4个红球、3个蓝球和2个绿球排成一排（相同色球视为完全相同），则不同的排列方案数为1260种。( ) {{ select(19) }}

  • 正确
  • 错误

第 20 题

使用math.h或cmath头文件中的函数，对于int类型的变量x，表达式fabs(x)和sqrt(x * x)的结果总是近似相等的。( ) {{ select(20) }}

  • 正确
  • 错误

第 21 题

运算符重载是C++语言静态多态的一种典型体现，而使用C语言则无法实现运算符重载。( ) {{ select(21) }}

  • 正确
  • 错误

第 22 题

存在一个简单无向图满足：顶点数为6，边数为8，6个顶点的度数分别为3、3、3、3、2、2。( ) {{ select(22) }}

  • 正确
  • 错误

第 23 题

已知两个double类型的变量r和theta分别表示一个扇形的圆半径及圆心角（弧度），则扇形的周长可以通过表达式(2 + theta) * r求得。( ) {{ select(23) }}

  • 正确
  • 错误

第 24 题

Dijkstra算法的时间复杂度为 (O(V^{2}))，其中 (V) 为图中顶点的数量。( ) {{ select(24) }}

  • 正确
  • 错误

第 25 题

从32名学生中选出2人分别担任男生班长和女生班长（男生班长必须是男生，女生班长必须是女生），则共有 (C(32,2) / 2) 种不同的选法。( ) {{ select(25) }}

  • 正确
  • 错误
  1. Language
  2. 兼容模式
  3. 主题
  3. Worker 0, 78ms
  4. Powered by Hydro v5.0.0-beta.7 Community