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

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

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

一、单选题

1. 单选题

GESP活动期间,举办方从获胜者ABCDE五个人中选出三个人排成一队升国旗,其中A不能排在队首,请问有多少种排法?

  • A 24
  • B 48
  • C 32
  • D 12
查看答案与解析
答案:B
解析:

排列组合问题。A不能排队首,因此第一位有4种选法;第二位不能与第一位相同,因此有4种选法;第三位不能与前两位相同,有3种选法;共计4*4*3=48种。

2. 单选题

7进制数235转换成3进制数是( )。

  • A 11121
  • B 11122
  • C 11211
  • D 11112
查看答案与解析
答案:A
解析:

先将235转换成十进制124,然后再转换成3进制即可。

3. 单选题

0,1,2,3,4,5这些数字组成一个三位数,请问没有重复数字的情况下,有多少种组法( )。

  • A 180
  • B 120
  • C 80
  • D 100
查看答案与解析
答案:D
解析:

一共6个数字,百位不能为0,因此有5种可能;然后再选2个数字排列,就是P(5,2),答案是5*P(5,2)=100

4. 单选题

有V个顶点、E条边的图的深度优先搜索遍历时间复杂度为( )。

  • A O(V)
  • B O(E)
  • C O(V+E)
  • D O(log(V+E))
查看答案与解析
答案:C
解析:

每个顶点每条边都会被访问一次,所有时间复杂度是C。

5. 单选题

一对夫妻生男生女的概率相同。已知这对夫妻有两个孩子,其中一个是女孩,另一个是男孩的概率是多少?

  • A
  • B
  • C
  • D
查看答案与解析
答案:C
解析:

概率知识。每次男孩和女孩的概率都是1/2。

6. 单选题

从1到2024这2024个数中,共有( )个包含数字6的数。

  • A 544
  • B 546
  • C 564
  • D 602
查看答案与解析
答案:A
解析:

1位数字,只有1个6。

2位数字,有6的情况是6*,*表示0到9,共10种;*6,*表示1-9(除掉6),共8种,所以两位数有6的共18种。

3位数字,有6的情况,1位数字6,十位补0,*06,*表示1-9(除掉6),有8种;两位数前面加数字1-9(除掉6),(含6),818=144,百位是6的有600-699,共100个数字,总计100+144+8=252种。

同理1000-1999,1位数补成4位数,1006;2位数补成10(含6),3位数前面加1,有1+18+252=271种。

2000-2024有2个含数字6的数字,总数是1+18+252+271+2=544.

7. 单选题

二进制数 100.001 转换成十进制数是( )。

  • A 4.25
  • B 4.125
  • C 4.5
  • D 4.75
查看答案与解析
答案:B
这道题暂未补解析。
8. 单选题

以下函数声明,哪个是符合C++语法的?( )。

  • A void BubbleSort(char a[][], int n);
  • B void BubbleSort(char a[][20], int n);
  • C void BubbleSort(char a[10][], int n);
  • D void BubbleSort(char[,] a, int n);
查看答案与解析
答案:B
解析:

考察的是二维数组定义的知识。二维数组第二维长度必须确定。

9. 单选题

下面有关C++重载的说法,错误的是( )。

  • A 两个参数个数不同的函数可以重名。
  • B 两个参数类型不同的函数可以重名。
  • C 两个类的方法可以重名。
  • D 所有C++运算符均可以重载。
查看答案与解析
答案:D
解析:

不能重载的运算符还是挺多的。“::”、“.”、“?:”等。

10. 单选题

小于或等于给定正整数n的数中,与n互质的数的个数,我们称为欧拉函数,记作。下面说法错误的是( )。

  • A 如果n是质数,那么。
  • B 两个质数一定是互质数。
  • C 两个相邻的数一定是互质数。
  • D 相邻的两个质数不一定是互质数。
查看答案与解析
答案:D
解析:

两个不同的质数是互质数。

11. 单选题

已知一棵二叉树有10个节点,则其中至多有( )个节点有2个子节点。

  • A 4
  • B 5
  • C 6
  • D 3
查看答案与解析
答案:A
解析:

可以画图模拟一下,最多是4个。设度为0的结点数为n0,度为1的结点数为n1,度为2的结点数为n2,由题意:

n0+n1+n2=10。在二叉树中有:n0=n2+1;所以有2*n2+n1=9;所以n1的值为奇数,最小的值为1,所以n2=4。

12. 单选题

二项展开式的系数,正好满足杨辉三角的规律。当n=10时,二项式展开式中xy9项的系数是( )。

  • A 5
  • B 9
  • C 10
  • D 8
查看答案与解析
答案:C
解析:

该项系数应为C(10, 1)=10。

13. 单选题

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

bool notPrime[N] = {false};
void sieve() {
	for (int n = 2; n * n < N; n++)
		if (!notPrime[n])
			for (int i = n * n; i < N; i += n)
				notPrime[i] = true;
}
  • A O(N)
  • B O(N×logN)
  • C O(N×loglogN)
  • D O(N2)
查看答案与解析
答案:C
解析:

代码是求欧拉筛,参数有些优化,时间复杂度是C。

14. 单选题

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

int gcd(int m, int n) {
	if (m == 0)
		return n;
	return gcd(n % m, m);
}
  • A
  • B O(log(n))
  • C O(n)
  • D O(1)
查看答案与解析
答案:B
解析:

欧几里得算法的最坏时间复杂度。在最坏的情况,m和n为菲波那切数列中相邻的两项,所以时间复杂度是O(logn)。

15. 单选题

下面程序的输出为( )。

#include <iostream>
using namespace std;
int main() {
	int cnt = 0;
	for (int x = 0; x <= 10; x++)
		for (int y = 0; y <= 10; y++)
			for (int z = 0; z <= 10; z++)
				if (x + y + z <= 15)
					cnt++;
	cout << cnt << endl;
	return 0;
}
  • A 90
  • B 91
  • C 710
  • D 711
查看答案与解析
答案:D
这道题暂未补解析。

二、判断题

16. 判断题

ABCDE五个小朋友,排成一队跑步,其中AB两人必须排在一起,一共有48种排法。

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

排列组合捆绑法。AB在一起,看成1个人,AB和BA共2中情况,所以是排队是:2*A(4,4)=48。

17. 判断题

已知 double 类型的变量 a 和 b ,则执行语句 a = a + b; b = a - b; a = a - b; 后,变量 a 和 b 的值会互换。

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

a和b是double类型,加减会造成精度的损失,导致2个变量值不能互换。

18. 判断题

一个袋子中有3个完全相同的红色小球、2个完全相同的蓝色小球。每次从中取出1个,再放回袋子,这样进行3次后,可能的颜色顺序有8种。

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

已知 int 类型的变量 a 和 b 中分别存储着一个直角三角形的两条直角边的长度,则斜边的长度可以通过表达式 sqrt(a * a + b * b) 求得。

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

根据勾股定理求出。

20. 判断题

在一个包含 v 个顶点、 e 条边的带权连通简单有向图上使用Dijkstra算法求最短路径,时间复杂度为O(v2),可进一步优化至O(e+vlog(v))。

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

暴力枚举每个点,时间复杂度是O(v2);用优先队列每次找到距离最短的点,优先队列时间复杂度是O(logn),每个点和边都访问一次,所以时间复杂度是O(e+vlogv)。

21. 判断题

在N个元素的二叉排序树中查找一个元素,最差情况的时间复杂度是O(logN)。

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

二叉排序树最坏的情况退化成1条链,时间复杂度是O(n)。

22. 判断题

C++语言中,可以为同一个类定义多个析构函数。

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

析构函数只能有1个。

23. 判断题

使用单链表和使用双向链表,查找元素的时间复杂度相同。

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

查找的时间复杂度不变。都是从某个方向开始一直遍历查找。

24. 判断题

为解决哈希函数冲突,可以使用不同的哈希函数为每个表项各建立一个子哈希表,用来管理该表项的所有冲突元素。这些子哈希表一定不会发生冲突。

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

子哈希表仍然可能产生冲突。

25. 判断题

要判断无向图的连通性,在深度优先搜索和广度优先搜索中选择,深度优先的平均时间复杂度更低。

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

都需要对每个点遍历一次,总时间复杂度不会有差距。可能在其他方面开销有区别,例如辅助空间等方面。

三、简答题

26. 简答题

最远点对

题面描述

小杨有一棵包含n个节点的树,这棵树上的任意一个节点要么是白色,要么是黑色。

小杨想知道相距最远的一对不同颜色节点的距离是多少。

输入格式

第一行包含一个正整数 n,代表树的节点数。

第二行包含n个非负整数a1,a2,...,an(对于所有的1≤i≤n,均有ai等于0或1),其中如果ai=0,则节点i的颜色为白色;如果ai=1,则节点i的颜色为黑色。

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

保证输入的树中存在不同颜色的点。

输出格式

输出一个整数,代表相距最远的一对不同颜色节点的距离。


输入样例

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

输出样例

3

样例解释

相距最远的不同颜色的一对节点为节点 2 和 5。

数据范围

对于全部数据,保证有1≤n≤105,0≤ai≤1。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include&lt;bits/stdc++.h&gt; using namespace std; const int N = 1e5+10; vector&lt;int&gt; g[N]; int col[N]; int n; int dep[N],far[N][2]; int ans; void dfs(int x,int fa){ dep[x]=dep[fa]+1; far[x][col[x]]=dep[x]; for(int i:g[x]){ if(i!=fa){ dfs(i,x); for(int j=0;j&lt;2;j++){ if(far[x][j]!=-1&amp;&amp;far[i][j^1]!=-1){ ans = max(ans,far[x][j]-dep[x]+far[i][j^1]-dep[x]); } } for(int j=0;j&lt;2;j++){ far[x][j]=max(far[x][j],far[i][j]); } } } ans = max(ans,far[x][col[x]^1]-dep[x]); } int main(){ int n; cin&gt;&gt;n; memset(far,-1,sizeof far); for(int i=1;i&lt;=n;i++){ cin&gt;&gt;col[i]; } for(int i=1;i&lt;n;i++){ int u,v; cin&gt;&gt;u&gt;&gt;v; g[u].push_back(v); g[v].push_back(u); } dfs(1,0); cout&lt;&lt;ans&lt;&lt;"\n"; }</pre>
解析:

每个结点要么黑色要么白色,需要保存结点的颜色信息。选2个颜色不同的点,可以先枚举第1个点和第2个点,求他们的距离,再求最大值。任意2点都是连通的,能够相互访问,能求出最大值。根据数据范围,能得到部分分。另一种思路就是根据树的性质,答案的2个点假设是a和b,路径会经过他们的公共祖先,距离=公共祖先到a的距离+公共祖先到b的距离。每个点视为公共祖先的话,有可能是左孩子的黑色和右孩子的白色组合,也可能是左孩子的白色和右孩子的黑色组成,也可能只在左孩子或者右孩子中。所以,每个结点应该保留2种颜色的最远值。一次深搜即可。每个点访问1次,时间复杂度是O(n)。

27. 简答题

空间跳跃

题面描述

小杨在二维空间中有n个水平挡板,并且挡板之间彼此不重叠,其中第i个挡板处于水平高度hi,左右端点分别位于li 与 ri。

小杨可以在挡板上左右移动,当小杨移动到右端点时,如果再向右移动会竖直掉落,从而落到下方第一个挡板上,移动到左端点时同理。小杨在挡板上每移动1个单位长度会耗费 1个单位时间,掉落时每掉落1 个单位高度也会耗费 1个单位时间。

小杨想知道,从第 s个挡板上的左端点出发到第t个挡板需要耗费的最少时间是多少?

注意:可能无法从第 s个挡板到达到第 t个挡板。

输入格式

第一行包含一个正整数n ,代表挡板数量。

第二行包含两个正整数s,t ,含义如题面所示。

之后 n行,每行包含三个正整数li,ri,hi ,代表第 i个挡板的左右端点位置与高度。

输出格式

输出一个整数代表需要耗费的最少时间,如果无法到达则输出 -1。


输入样例

3
3 1
5 6 3
3 5 6
1 4 100000

输出样例

100001

样例范围

耗费时间最少的移动方案为,从第3个挡板左端点移动到右端点,耗费3个单位时间,然后向右移动掉落到第 2个挡板上,耗费 100000-6=99994个单位时间,之后再向右移动1个单位长度,耗费1个单位时间,最后向右移动掉落到第1个挡板上,耗费3个单位时间。共耗费 3+99994+1+3=100001个单位时间。

数据范围

对于全部数据,保证有1≤n≤1000,1≤li≤ri≤105,1≤hi≤105。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include&lt;bits/stdc++.h&gt; using namespace std; const int maxn = 1e4+10; struct edge { int v, w; edge() { } edge(int vv,int ww) { v=vv; w=ww; } }; struct node { int dis, u; node () { } node (int diss,int uu) { dis=diss; u=uu; } bool operator&gt;(const node&amp; a) const { return dis &gt; a.dis; } }; vector&lt;edge&gt; e[maxn]; int dis[maxn], vis[maxn]; priority_queue&lt;node, vector&lt;node&gt;, greater&lt;node&gt; &gt; q; int cnt; void dijkstra(int s) { for (int i=1;i&lt;=cnt;i++)dis[i]=INT_MAX; dis[s] = 0; q.push(node(0, s)); while (!q.empty()) { int u = q.top().u; q.pop(); if (vis[u]) continue; vis[u] = 1; for (auto ed : e[u]) { int v = ed.v, w = ed.w; if (dis[v] &gt; dis[u] + w) { dis[v] = dis[u] + w; q.push(node(dis[v], v)); } } } } map&lt;pair&lt;int,int&gt;,int&gt; mp; vector&lt;int&gt; es[2010]; int l[maxn],r[maxn],h[maxn]; int main() { int n; cin&gt;&gt;n; int s,t; cin&gt;&gt;s&gt;&gt;t; for (int i=1;i&lt;=n;i++) { cin&gt;&gt;l[i]&gt;&gt;r[i]&gt;&gt;h[i]; mp[make_pair(l[i],h[i])]=i; mp[make_pair(r[i],h[i])]=n+i; es[i].push_back(i); es[i].push_back(n+i); e[i].push_back(edge(n+i,r[i]-l[i])); e[n+i].push_back(edge(i,r[i]-l[i])); } cnt=2*n+1; for (int i=1;i&lt;=n;i++) { int hh = -1,idx = i; for (int j=1;j&lt;=n;j++) { if(i==j)continue; if(l[j]&lt;=l[i]&amp;&amp;l[i]&lt;=r[j]&amp;&amp;h[j]&lt;=h[i]) { if(h[j]&gt;hh) { hh=h[j]; idx=j; } } } if(hh!=-1) { if(!mp[make_pair(l[i],hh)]) { mp[make_pair(l[i],hh)]=cnt++; } int v = mp[make_pair(l[i],hh)]; e[i].push_back(edge(v,h[i]-hh)); e[idx].push_back(edge(v,abs(l[i]-l[idx]))); e[n+idx].push_back(edge(v,abs(l[i]-r[idx]))); e[v].push_back(edge(idx,abs(l[i]-l[idx]))); e[v].push_back(edge(n+idx,abs(l[i]-r[idx]))); es[idx].push_back(v); } hh = -1,idx = i; for (int j=1;j&lt;=n;j++) { if(i==j)continue; if(l[j]&lt;=r[i]&amp;&amp;r[i]&lt;=r[j]&amp;&amp;h[j]&lt;=h[i]) { if(h[j]&gt;hh) { hh=h[j]; idx=j; } } } if(hh!=-1) { if(!mp[make_pair(r[i],hh)]) { mp[make_pair(r[i],hh)]=cnt++; } int v = mp[make_pair(r[i],hh)]; e[n+i].push_back(edge(v,h[i]-hh)); e[idx].push_back(edge(v,abs(r[i]-l[idx]))); e[n+idx].push_back(edge(v,abs(r[i]-r[idx]))); e[v].push_back(edge(idx,abs(r[i]-l[idx]))); e[v].push_back(edge(n+idx,abs(r[i]-r[idx]))); es[idx].push_back(v); } } dijkstra(s); int ans = INT_MAX; for (auto i:es[t]) { ans=min(ans,dis[i]); } if(ans!=INT_MAX)cout&lt;&lt;ans&lt;&lt;"\n"; else cout&lt;&lt;"-1\n"; }</pre>
解析:

发现n的数据范围是1000,求的是从1个挡板到另外1个挡板。注意,掉到目标挡板中的某个位置即可。同时1个挡板左端到右端或者右端到左端算距离,其他挡板的2个端点只要能垂直相交到下一个挡板(中间没有其他挡板阻碍),也算相连。将这些端点和相交点看成结点,相连看成边,整个结构就成为一张图的结构。起点是固定的,终点也是固定的(只要是目标挡板的某个点即可),求的就是最短路径。数据都是正整数,可以用dijkstra算法实现。

难点1在于建图。一个挡板左右算2个结点,要连边;一个挡板的左右两端能够垂直到其他挡板,中间不能有间隔,要连边。

难度2就是dijkstra算法的完成。按照优先队列的模板完成即可。