CCF编程能力等级认证GESP---C++6级---20240629
- [单选题（每题 2 分，共 30 分）](#单选题（每题 2 分，共 30 分）)
- [判断题（每题 2 分，共 20 分）](#判断题（每题 2 分，共 20 分）)
- 编程题 (每题 25 分，共 50 分)
单选题（每题 2 分，共 30 分）
1、面向对象的编程思想主要包括( )原则。
cpp
A. 贪心、动态规划、回溯
B. 并发、并行、异步
C. 递归、循环、分治
D. 封装、继承、多态正确答案：D
2、运行下列代码，屏幕上输出( )。
cpp
#include <iostream>
using namespace std;
class my_class {
public:
static int count;
my_class(){
count++;
}
~my_class(){
count--;
}
static void print_count(){
cout << count << " ";
}
};
int my_class::count = 0;
int main(){
my_class obj1;
my_class::print_count();
my_class obj2;
obj2.print_count();
my_class obj3;
obj3.print_count();
return 0;
}
cpp
A. 1 1 1
B. 1 2 3
C. 1 1 2
D. 1 2 2正确答案：B
3、运行下列代码，屏幕上输出( )。
cpp
#include <iostream>
using namespace std;
class shape{
protected:
int width, height;
public:
shape(int a = 0, int b = 0){
width = a;
height = b;
}
virtual int area(){
cout << "parent class area: " << endl;
return 0;
}
};
class rectangle: public shape{
public:
rectangle(int a = 0, int b = 0):shape(a, b){ }
int area(){
cout << "rectangle area: ";
return (width * height);
}
};
class triangle: public shape{
public:
triangle(int a = 0, int b = 0) : shape(a, b){ }
int area(){
cout << "triangle area: ";
return (width * height / 2);
}
};
int main(){
shape *pshape;
rectangle rec(10, 7);
triangle tri(10, 5);
pshape = &rec;
pshape->area();
pshape = &tri;
pshape->area();
return 0;
}
cpp
A. rectangle area: triangle area:
B. parent class area: parent class area:
C. 运行时报错
D. 编译时报错正确答案：A
4、向一个栈顶为hs的链式栈中插入一个指针为s的结点时，应执行( )。
cpp
A. hs->next = s;
B. s->next = hs; hs = s;
C. s->next = hs->next; hs->next = s;
D. s->next = hs; hs = hs->next;正确答案：B
5、在栈数据结构中，元素的添加和删除是按照什么原则进行的?
cpp
A. 先进先出
B. 先进后出
C. 最小值先出
D. 随机顺序正确答案：B
6、要实现将一个输入的十进制正整数转化为二进制表示，下面横线上应填入的代码为( )。
cpp
#include <iostream>
using namespace std;
stack<int> ten2bin(int n) {
stack<int> st;
int r, m;
r = n % 2;
m = n / 2;
st.push(r);
while (m != 1) {
r = m % 2;
st.push(r);
m = m / 2;
}
st.push(m);
return st;
}
int main() {
int n;
cin >> n;
stack<int> bin;
bin = ten2bin(n);
while (!bin.empty()) {
________ // 在此处填入代码
}
return 0;
}正确答案：A
7、下面定义了一个循环队列的类，请补全判断队列是否满的函数，横向上应填写( )。
cpp
#include <iostream>
using namespace std;
class circular_queue {
private:
int *arr; // 数组用于存储队列元素
int capacity; // 队列容量
int front; // 队头指针
int rear; // 队尾指针
public:
circular_queue(int size) {
capacity = size + 1; // 为了避免队列满时与队列空时指针相等的情况，多预留一个空间 arr = new int[capacity];
front = 0;
rear = 0;
}
~circular_queue() {
delete[] arr;
}
bool is_empty() {
return front == rear;
}
bool is_full() {
________________ // 在此处填入代码
}
void en_queue(int data) {
if (is_full()) {
cout << "队列已满，无法入队!" << endl;
return -1;
}
arr[rear] = data;
rear = (rear + 1) % capacity;
return 1;
}
int de_queue() {
if (is_empty()) {
cout << "队列为空，无法出队!" << endl;
return -1; // 出队失败，返回一个特殊值
}
int data = arr[front];
front = (front + 1) % capacity;
return data;
}
};
cpp
A. return (rear + 1) % capacity == front;
B. return rear % capacity == front;
C. return rear == front;
D. return (rear + 1) == front;正确答案：A
8、对"classmycls"使用哈夫曼(Huffman)编码，最少需要( )比特。
cpp
A. 10
B. 20
C. 25
D. 30正确答案：C
9、二叉树的( )第一个访问的节点是根节点。
cpp
A. 先序遍历
B. 中序遍历
C. 后序遍历
D. 以上都是正确答案：A
10、一棵5层的满二叉树中节点数为( )。
cpp
A. 31
B. 32
C. 33
D. 16正确答案：A
11、在求解最优化问题时，动态规划常常涉及到两个重要性质，即最优子结构和( )。
cpp
A. 重叠子问题
B. 分治法
C. 贪心策略
D. 回溯算法正确答案：A
12、青蛙每次能跳1或2步，下面代码计算青蛙跳到第n步台阶有多少种不同跳法。则下列说法，错误的是( )。
cpp
int jump_recur(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
return jump_recur(n - 1) + jump_recur(n - 2);
}
int jump_dp(int n) {
vector<int> dp(n + 1); // 创建一个动态规划数组，用于保存已计算的值
// 初始化前两个数
dp[1] = 1;
dp[2] = 2;
// 从第三个数开始计算斐波那契数列
for(inti=3;i<=n;++i){
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
cpp
A. 函数jump_recur()采用递归方式。
B. 函数jump_dp()采用动态规划方法。
C. 当n较大时，函数jump_recur()存在大量重复计算，执行效率低。
D. 函数jump_recur()代码量小，执行效率高。正确答案：D
13、阅读以下二叉树的广度优先搜索代码:
cpp
#include <iostream>
#include <queue>
using namespace std;
// 二叉树节点的定义
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
// 宽度优先搜索(BFS)迭代实现
TreeNode* bfs(TreeNode* root, int a) {
if (root == nullptr) return nullptr;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
TreeNode* node = q.front();
q.pop();
if (node->val == a)
return node;
cout << node->val << " "; // 先访问当前节点
if (node->left) q.push(node->left); // 将左子节点入队
if (node->right) q.push(node->right); // 将右子节点入队 }
return nullptr;
}使用以上算法，在以下这棵树搜索数值20时，可能的输出是( )。
cpp
A. 5 2 -4 3 17 9
B. -4 2 3 5 9 17
C. 5 2 17 -4 3 9
D. 以上都不对正确答案：C
14、同上题中的二叉树，阅读以下二叉树的深度优先搜索代码:
cpp
#include <iostream>
#include <stack>
using namespace std;
// 非递归深度优先搜索(DFS)
TreeNode* dfs(TreeNode* root, int a) {
if (root == nullptr) return nullptr;
stack<TreeNode*> stk;
stk.push(root);
while (!stk.empty()) {
TreeNode* node = stk.top();
stk.pop();
if (node->val == a)
return node;
cout << node->val << " "; // 访问当前节点
if (node->right) stk.push(node->right); // 先压入右子节点
if (node->left) stk.push(node->left); // 再压入左子节点
}
return nullptr;
}使用以上算法，在二叉树搜索数值20时，可能的输出是( )。
cpp
A. 5 2 -4 3 17 9
B. -4 2 3 5 9 17
C. 5 2 17 -4 3 9
D. 以上都不对正确答案：A
15、在上题的树中搜索数值3时，采用深度优先搜索一共比较的节点数为( )。
cpp
A. 2
B. 3
C. 4
D. 5正确答案：C
判断题（每题 2 分，共 20 分）
1、哈夫曼编码本质上是一种贪心策略。
正确答案：正确
2、创建一个对象时，会自动调用该对象所属类的构造函数。如果没有定义构造函数，编译器会自动生成一个默 认的构造函数。
正确答案：正确
3、定义一个类时，必须手动定义一个析构函数，用于释放对象所占用的资源。
正确答案：错误
4、C++中类内部可以嵌套定义类。
正确答案：正确
5、000, 001, 011, 010, 110, 111, 101, 100是一组格雷码。
正确答案：正确
6、n个节点的双向循环链表，在其中查找某个节点的平均时间复杂度是 O ( l o g n ) O(logn) O(logn)。
正确答案：错误
7、完全二叉树可以用数组存储数据。
正确答案：正确
8、在C++中，静态成员函数只能访问静态成员变量。
正确答案：正确
9、在深度优先搜索中，通常使用队列来辅助实现。
正确答案：错误
10、对0-1背包问题，贪心算法一定能获得最优解。
正确答案：错误
编程题 (每题 25 分，共 50 分)
计算得分
【问题描述】
小杨想要计算由m个小写字母组成的字符串的得分。
小杨设置了一个包含n个正整数的计分序列 A = [ a 1 , a 2 , . . . , a n ] A = [a_1, a_2, ..., a_n] A=[a1,a2,...,an]，如果字符串的一个子串由 k ( 1 < = k < = n ) k(1 <= k <= n) k(1<=k<=n) 个abc首尾相接组成，那么能够得到分数 a k a_k ak，并且字符串包含的字符不能够重复计算得分，整个字符串的得分是计分子串的总和。
例如，假设n = 3，字符串dabcabcabcabzabc 的所有可能计分方式如下:
d+abc+abcabc+abz+abc 或者 d+abcabc+abc+abz+abc，其中 d 和 abz 不计算得分，总得分为 a 1 + a 2 + a 1 a_1 + a_2 + a_1 a1+a2+a1
d+abc+abc+abc+abz+abc，总得分为 a 1 + a 1 + a 1 + a 1 a_1 + a_1 + a_1 + a_1 a1+a1+a1+a1
d+abcabcabc+abz+abc，总得分为 a 3 + a 1 a_3 + a_1 a3+a1
小杨想知道对于给定的字符串，最大总得分是多少。
【输入描述】
第一行包含一个正整数n，代表计分序列A的长度。
第二行包含n个正整数，代表计分序列A。
第三行包含一个正整数m，代表字符串的长度。
第四行包含一个由m个小写字母组成的字符串。
【输出描述】
输出一个整数，代表给定字符串的最大总得分。
【样例输入 1】
3
3 1 2
13
dabcabcabcabz
【样例输出 1】
9
【样例解释】
最优的计分方式为 d+abc+abc+abc+abz，总得分为 a 1 + a 1 + a 1 a_1 + a_1 + a_1 a1+a1+a1, 共9分。
【数据范围】
| 子任务编号 | 数据点占比 | n | m | a i a_i ai | 特殊条件 |
|---|---|---|---|---|---|
| 1 | 20% | <=20 | < = 1 0 5 <= 10^5 <=105 | <= 1000 | 对于所有的i(1 <= i < n),存在 a i > = a i + 1 a_i >= a_{i+1} ai>=ai+1 |
| 2 | 40% | <= 3 | < = 1 0 5 <= 10^5 <=105 | <= 1000 | |
| 3 | 40% | <=20 | < = 1 0 5 <= 10^5 <=105 | <= 1000 |
对于全部数据，保证有 1 < = n < = 20 , 1 < = m < = 1 0 5 , 1 < = a i < = 1000 1 <= n <= 20, 1 <= m <= 10^5, 1 <= a_i <= 1000 1<=n<=20,1<=m<=105,1<=ai<=1000。
二叉树
【问题描述】
小杨有一棵包含n个节点的二叉树，且根节点的编号为1。这棵二叉树任意一个节点要么是白色，要么是黑色。之后小杨会对这棵二叉树进行q次操作，每次小杨会选择一个节点，将以这个节点为根的子树内所有节点的颜色反转， 即黑色变成白色，白色变成黑色。
小杨想知道q次操作全部完成之后每个节点的颜色。
【输入描述】
第一行一个正整数n，表示二叉树的节点数量。
第二行n - 1个正整数，第 i ( 1 < = i < = n − 1 ) i(1 <= i <= n - 1) i(1<=i<=n−1)个数表示编号为i + 1的节点的父亲节点编号，数据保证是一棵二叉 树。
第三行一个长度为n的01串，从左到右第 i ( 1 < = i < = n ) i(1 <= i <= n) i(1<=i<=n)位如果为0，表示编号为i的节点颜色为白色，否则为黑 色。
第四行一个正整数q，表示操作次数。
接下来q行每行一个正整数 a i ( 1 < = a i < = n ) a_i(1 <= a_i <= n) ai(1<=ai<=n)，表示第i次操作选择的节点编号。
【输出描述】
输出一行一个长度为n的01串，表示q次操作全部完成之后每个节点的颜色。从左到右第 i ( 1 < = i < = n ) i(1 <= i <= n) i(1<=i<=n)位如果为0，表示编号为i的节点颜色为白色，否则为黑色。
【样例输入 1】
6
3 1 1 3 4
100101
3
1
3
2
【样例输出 1】
010000
【样例解释】
第一次操作后，节点颜色为:011010
第二次操作后，节点颜色为:000000
第三次操作后，节点颜色为:010000
【数据范围】
| 子任务编号 | 数据点占比 | n | q | 特殊条件 |
|---|---|---|---|---|
| 1 | 20% | < = 1 0 5 <= 10^5 <=105 | < = 1 0 5 <= 10^5 <=105 | 对于所有i>=2,节点i的父亲节点编号为i - 1 |
| 2 | 40% | < = 1000 <= 1000 <=1000 | <= 1000 | |
| 3 | 40% | < = 1 0 5 <= 10^5 <=105 | < = 1 0 5 <= 10^5 <=105 |
对于全部数据，保证有 1 < = n , q < = 1 0 5 1 <= n , q <= 10^5 1<=n,q<=105。