CCF编程能力等级认证GESP—C++6级—20241207

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

1、面向对象编程(OOP)是一种特殊的程序设计方法。下面( )不是重要的OOP特性。

A. 抽象
B. 封装
C. 继承
D. 模块化

正确答案：D

2、以下关于C++中类的说法，哪一项是正确的？

A. 类中定义的所有成员变量和成员函数默认是 public 访问权限。
B. 类的构造函数必须显式声明返回类型为 void 。
C. 在C++中，类的数据一般设置为私有，其公有成员函数提供访问私有数据的唯一途径。
D. 同一个类的实例有各自的成员数据和成员函数。

正确答案：C

3、以下C++代码段中存在语法错误或逻辑错误，（ ）是正确的。

#include <iostream>
using namespace std;
class MyClass {
public:
	MyClass() {
		cout << "Constructor called!" << endl;
	}
	void display() {
		cout << "Display function called!" << endl;
	}
};
int main() {
	MyClass* obj = NULL;
	obj->display();
	return 0;
}

A. NULL 在C++中无法用于指针初始化，应使用 nullptr 。
B. obj 的定义应该是 MyClass obj; 而不是指针类型。
C. obj->display() 语句存在空指针访问错误， obj 应该初始化为一个有效的对象。
D. obj->display() 语句会调用 display() 函数，但它没有输出任何内容。

正确答案：C

4、阅读以下代码，下面哪一项是正确的？

void processData() {
	stack<int> s;
	queue<int> q;
	for (int i = 1; i <= 5; ++i) {
		s.push(i);
		q.push(i);
	}
	while (!s.empty()) {
		cout << "Stack pop: " << s.top() << endl;
		s.pop();
	}
	while (!q.empty()) {
		q.pop();
		cout << "Queue pop: " << q.front() << endl;
	}
}

A. 栈 s 的输出顺序是 1 2 3 4 5 ，队列 q 的输出顺序是 5 4 3 2 1 。
B. 栈 s 的输出顺序是 5 4 3 2 1 ，队列 q 的输出顺序是 1 2 3 4 5 。
C. 栈 s 的输出顺序是 1 2 3 4 5 ，队列 q 的输出顺序是 1 2 3 4 5 。
D. 栈 s 的输出顺序是 1 2 3 4 5 ，队列 q 的输出顺序是 1 2 3 4 5 ，程序不会正常执行。

正确答案：B

5、 N个节点的双向循环链，在其中查找某个节点的平均时间复杂度是( )。

A.$O(1)$
B.$O(N)$
C.$O(logN)$
D.$O(N^3)$

正确答案：B

6、以下关于树的说法，（ ）是正确的。

A. 在一棵二叉树中，叶子结点的度一定是2。
B.满二叉树中每一层的结点数等于$O(2^{(层数-1)})$。
C.在一棵树中，所有结点的度之和等于所有叶子结点的度之和。
D.一棵二叉树的先序遍历结果和中序遍历结果一定相同。

正确答案：B

7、已知字符集 {A, B, C, D} 的出现频率如下表所示，根据哈夫曼编码法，下面（ ）是正确的哈夫曼树。

字符	频率
A	8
B	3
C	1
D	6

A.
  ABCD
  /  \
 A   BCD
	 / \
	D	BC
		/ \
	   B   c

B.
  ABCD
  /  \
 A   BCD
	 / \
	B	CD
		/ \
	   C   D

C.
  ABCD
  /  \
 D   ABC
	 / \
	A	BC
		/ \
	   B   c

D.
  ABCD
  /  \
 C   ABD
	 / \
	B	AD
		/ \
	   A   D

正确答案：A

8、上一题中各字符的哈夫曼编码是（ ）。

A. A: 0, B: 10, C: 110, D: 111
B. A: 0, B: 10, C: 11, D: 10
C. A: 0, B: 101, C: 100, D: 11
D. A: 11, B: 10, C: 01, D: 00

正确答案：C

9、( )是3位格雷编码。

A. 000 001 011 010 110 111 101 100
B. 000 001 010 011 100 101 110 111
C. 000 001 100 101 011 010 111 110
D. 000 010 001 011 100 110 101 111

正确答案：A

10、根据下面二叉树和给定的代码，

#include <iostream>
using namespace std;
struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
TreeNode* search(TreeNode* root, int val) {
	cout << root->val << " ";
	if (root == NULL || root->val == val) return root;
	if (val < root->val)
		return search(root->left, val);
	else
		return search(root->right, val);
}

给定以下二叉搜索树，调用函数 search(root,7) 时，输出的结果是（ ）。

    5
   /  \
  3    7
 / \  / \
2   4 6  8

A. 5 3 7
B. 5 7
C. 2 3 4 5 6 7
D. 8 7

正确答案：B

11、阅读以下二叉树的深度优先搜索算法，横线上应填写（ ）。

void dfs(TreeNode* root) {
	if (root == nullptr)
		return;
	stack<TreeNode*> s;
	s.push(root);
	while (!s.empty()) {
		———————————————————————— // 在此处填入代码
		cout << node->value << " ";
		if (node->right) s.push(node->right);
		if (node->left) s.push(node->left);
	}
}

A. TreeNode* node = s.top();
B. TreeNode* node = s.top(); s.pop();
C. TreeNode* node = s.front();
D. TreeNode* node = s.front(); s.pop();

正确答案：B

12、阅读以下二叉树的广度优先搜索的代码，横线上应填写（ ）。

#include <queue>
void bfs(TreeNode* root) {
	if (root == NULL) return;
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty()) {
		———————————————————————— // 在此处填入代码
		cout << node->val << " ";
		if (node->left) {
			q.push(node->left);
		}
		if (node->right) {
			q.push(node->right);
		}
	}
}

A. TreeNode* node = q.top();
B. TreeNode* node = q.top(); q.pop();
C. TreeNode* node = q.front();
D. TreeNode* node = q.front(); q.pop();

正确答案：D

13、使用上题中的宽度优先搜索算法遍历以下这棵树，可能的输出是( )。

      1
    /   \
   2     3
  / \     \
 8   9      6
   / \       \
  4   5       7

A. 1 2 8 9 4 5 3 6 7
B. 1 2 3 4 5 6 7 8 9
C. 1 2 3 8 9 6 4 5 7
D. 8 4 5 9 2 1 3 6 7

正确答案：C

14、以下关于动态规划的描述，（ ）是正确的。

A. 动态规划适用于没有重叠子问题的优化问题。
B. 动态规划要求问题具有最优子结构和无后效性。
C. 动态规划通常通过递归来实现。
D. 动态规划与贪心算法不同，贪心算法不适用于有重叠子问题的问题。

正确答案：B

15、假设背包的最大容量W = 8kg，共有有4个物品可供选择，4个物品的重量分别为weight = [2, 3, 5, 7]，对应的价值分别为values = [30, 40, 60, 80]，则该0/1背包问题中，背包的最大价值为（ ）。

A.70
B.90
C.100
D.120

正确答案：C

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

1、构造函数是一种特殊的类成员函数，构造函数的名称和类名相同。但通过函数重载，可以创建多个同名的构造函数，条件是每个构造函数的参数列表不同。

正确答案：正确

2、类的静态成员函数既能访问类的静态数据成员，也能访问非静态数据成员。

正确答案：错误

3、栈中元素的插入和删除操作都在栈的顶端进行，所以方便用单向链表实现。

正确答案：正确

4、下面代码构建的树一定是完全二叉树：

struct TreeNode {
	int value;
	TreeNode* left;
	TreeNode* right;
};
TreeNode* buildCompleteBinaryTree() {
	TreeNode* root = new TreeNode{1};
	root->left = new TreeNode{2};
	root->right = new TreeNode{3};
	root->left->left = new TreeNode{4};
	root->left->right = new TreeNode{5};
	root->right->left = new TreeNode{6};
	return root;
}

正确答案：正确

5、在二叉排序树中，左子树所有节点的值都大于根节点的值，右子树所有节点的值都小于根节点的值。

正确答案：错误

6、在生成一个派生类的对象时，只调用派生类的构造函数。

正确答案：错误

7、下面的代码实现了二叉树的前序遍历，它通过递归方法访问每个节点并打印节点值。

void preorder(TreeNode* root) {
	if (root == NULL) return;
	cout << root->val << " ";
	preorder(root->left);
	preorder(root->right);
}

正确答案：正确

8、宽度优先搜索算法（BFS）保证了每个节点在最短路径的情况下被访问。

正确答案：正确

9、在解决简单背包问题时，动态规划的状态转移方程如下：

dp[i][w] = max(dp[i-1][w], dp[i-1][w - weights[i-1]] + values[i-1]);

该方程表示：在考虑第 i 个物品时，当前背包容量为 w ，如果不放物品 i ，则最大价值是 dp[i-1][w] ；如果
放入物品 i ，则最大价值是 dp[i-1][w - weights[i-1]] + values[i-1]，其中数组 weights 和 values 分别表示所有物品的重量和价值，数组下标从 0 开始。

正确答案：正确

10、栈中元素的插入和删除操作都在栈的顶端进行，所以方便用双向链表比单向链表更合适表实现。

正确答案：错误

编程题 (每题 25 分，共 50 分)

树上游走

【问题描述】
小杨有一棵包含无穷节点的二叉树（即每个节点都有左儿子节点和右儿子节点；除根节点外，每个节点都有父节点），其中根节点的编号为1，对于节点i，其左儿子的编号为2 * i，右儿子的编号为2 * i + 1。
小杨会从节点s开始在二叉树上移动，每次移动为以下三种移动方式的任意一种：

• 第1种移动方式： 如果当前节点存在父亲节点，向上移动到当前节点的父亲节点，否则不移动；
• 第2种移动方式： 移动到当前节点的左儿子；
• 第3种移动方式： 移动到当前节点的右儿子。

小杨想知道移动n次后自己所处的节点编号。数据保证最后的所处的节点编号不超过$10^{12}$。
【输入格式】
第一行包含一个正整数n, s，代表移动次数和初始节点编号。
第二行包含一个长度为n且仅包含大写字母U, L, R的字符串，代表每次移动的方式，其中U代表第1种移动方式，L代表第2种移动方式，R代表第3种移动方式。
【输出格式】
输出一个正整数，代表最后所处的节点编号。
【样例输入 1】
3 2
URR
【样例输出 1】
7
【样例解释】
小杨的移动路线为2-1-3-7。

子任务编号	数据点占比	n	s
1	20%	$\le 10$	$\le 2$
2	20%	$\le 50$	$\le 10$
3	60%	$\le 10^6$	$\le 10^{12}$

对于全部数据，保证有$1\le n\le 10^6,1\le s\le 10^{12}$。

运送物资

【问题描述】
小杨管理着m辆货车，每辆货车每天需要向 A 市和 B 市运送若干次物资。小杨同时拥有n个运输站点，这些站点位于 A 市和 B 市之间。
每次运送物资时，货车从初始运输站点出发，前往 A 市或 B 市，之后返回初始运输站点。A 市、B 市和运输站点的位置可以视作数轴上的三个点，其中 A 市的坐标为0，B 市的坐标为x，运输站点的坐标为p且有$0<p<x$ ，货车每次去 A 市运送物资的总行驶路程为2p，去 B 市运送物资的总行驶路程为2(x-p)。
对于第i个运输站点，其位置为$p_i$且至多作为$c_i$辆车的初始运输站点。小杨想知道，在最优分配每辆货车的初始运输站点的情况下，所有货车每天的最短总行驶路程是多少。
【输入格式】
第一行包含三个正整数n, m, x，代表运输站点数量，货车数量和两市距离。
之后n行，每行包含两个正整数$p_i,c_i$，代表第i个运输站点的位置和最多容纳车辆数。
之后m行，每行包含两个正整数$a_i,b_i$，代表第i辆货车每天需要向 A 市运送$a_i$次物资，向 B 市运送$b_i$次物资。
【输出格式】
输出一个正整数，代表所有货车每天的最短总行驶路程。
【样例输入 1】
3 4 10
1 1
2 1
8 3
5 3
7 2
9 0
1 10000
【样例输出 1】
40186
【样例解释】
第1辆车的初始运输站点为站点3，第2辆车的初始运输站点为站点2。第3辆车的初始运输站点为站点1，第4辆车的初始运输站点为站点3。此时总行驶路程最短，为 40186。

子任务编号	数据点占比	n	m	$c_i$
1	20%	2	2	1
2	20%	$\le 10^5$	$\le 10^5$	1
3	60%	$\le 10^5$	$\le 10^5$	$\le 10^5$

对于全部数据，保证有$1\le n,m\le 10^5,2\le x\le 10^8,0<p_i<x,1\le c_i\le 10^5,0\le a_i,b_i\le 10^5$。数据保证 $\Sigma c_i\ge m$。