CCF编程能力等级认证GESP—C++5级—20240629

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

1、下面C++代码用于求斐波那契数列，该数列第1、2项为1，以后各项均是前两项之和。函数fibo()属于( )。

int fibo(int n){
	if (n <= 0)
		return 0;
	if (n == 1 || n == 2)
		return 1;
	
	int a = 1, b = 1, next;
	for(int i = 3; i <= n; i++){
		next = a + b;
		a = b;
		b = next;
	}
	return next;
}

A. 枚举算法 
B. 贪心算法 
C. 迭代算法 
D. 递归算法

正确答案：C

2、下面C++代码用于将输入金额换成最少币种组合方案，其实现算法是( )。

#include <iostream>
using namespace std;
#define N_COINS 7
int coins[N_COINS] = {100, 50, 20, 10, 5, 2, 1}; //货币面值，单位相同
int coins_used[N_COINS];
void find_coins(int money){
	for (int i = 0; i < N_COINS; i++){
		coins_used[i] = money / coins[i];
		money = money % coins[i];
	}
	return;
}
int main(){
	int money;
	cin >> money; // 输入要换算的金额
	find_coins(money);
	for (int i = 0; i < N_COINS; i++)
		cout << coins_used[i] << endl;
	return 0;
}

A. 枚举算法 
B. 贪心算法 
C. 迭代算法 
D. 递归算法

正确答案：B

3、小杨采用如下双链表结构保存他喜欢的歌曲列表:

struct dl_node{
	string song;
	dl_node* next;
	dl_node* prev;
};

小杨想在头指针为 head 的双链表中查找他喜欢的某首歌曲，采用如下查询函数，该操作的时间复杂度为( )。

dl_node* search(dl_node* head, string my_song){
	dl_node* temp = head;
	while (temp != nullptr){
		if (temp->song == my_song)
			return temp;
		temp = temp->next;
	}
	return nullptr;
}

A. $O(1)$
B. $O(n)$
C. $O(logn)$
D. $O(n^2)$

正确答案：B

4、小杨想在如上题所述的双向链表中加入一首新歌曲。为了能快速找到该歌曲，他将其作为链表的第一首歌 曲，则下面横线上应填入的代码为( )。

void insert(dl_node *head, string my_song){
	p = new dl_node;
	p->song = my_song;
	p->prev = nullptr;
	p->next = head;
	if (head != nullptr){
		______// 在此处填入代码
	}
	head = p;
}

A. head->next->prev = p;
B. head->next = p;
C. head->prev = p;
D. 触发异常，不能对空指针进行操作。

正确答案：C

5、下面是根据欧几里得算法编写的函数，它计算的是a与b的( )。

int gcd(int a, int b){
	while (b != 0){
		int temp = b;
		b = a % b;
		a = temp;
	}
	return a;
}

A. 最小公倍数
B. 最大公共质因子 
C. 最大公约数
D. 最小公共质因子

正确答案：C

6、欧几里得算法还可以写成如下形式:

int gcd(int a, int b){
	return b == 0 ? a : gcd(b, a % b);
}

下面有关说法，错误的是( )。

A. 本题的 gcd() 实现为递归方式。
B. 本题的 gcd() 代码量少，更容易理解其辗转相除的思想。
C. 当a较大时，本题的 gcd() 实现会多次调用自身，需要较多额外的辅助空间。 
D. 当a较大时，相比上题中的 gcd() 的实现，本题的 gcd() 执行效率更高。

正确答案：D

7、下述代码实现素数表的线性筛法，筛选出所有小于等于 的素数，则横线上应填的代码是( )。

vector<int> linear_sieve(int n){
	vector<bool> is_prime(n + 1, true);
	vector<int> primes;
	is_prime[0] = is_prime[1] = 0; // 0和1两个数特殊处理
	for (int i = 2; i <= n; ++i){
		if (is_prime[i]){
			primes.push_back(i);
		}
		________{ // 在此处填入代码
			is_prime[i * primes[j]] = 0;
			if (i % primes[j] == 0)
				break;
		}
	}
	return primes;
}

A.for (int j = 0; j < primes.size() && i * primes[j] <= n; j++) 
B.for(intj=0; j<=sqrt(n)&&i*primes[j]<=n; j++) 
C.for(intj=0; j<=n; j++)
D.for (int j = 1; j <= sqrt(n); j++)

正确答案：A

8、上题代码的时间复杂度是( )。

A. $O(n^2)$
B. $O(nlogn)$
C. $O(nloglogn)$
D. $O(n)$

正确答案：D

9、为了正确实现快速排序，下面横线上的代码应为( )。

void qsort(vector<int>& arr, int left, int right){
	int i, j, mid;
	int piovt;
	i = left;
	j = right;
	mid = (left + right) / 2; // 计算中间元素的索引
	pivot = arr[mid]; // 选择中间元素作为基准值
	do{
		while (arr[i] < piovt) i++;
		while (arr[j] > pivot) j--;
		if (i <= j){
			swap(arr[i], arr[j]); // 交换两个元素
			i++;j--;
		}
	}________;// 在此处填入代码
	if (left < j) qsort(arr, left, j); // 对左子数组进行快速排序
	if (i < right) qsort(arr, i, right); // 对右子数组进行快速排序
}

A. while (i <= mid)
B. while (i < mid) 
C. while (i < j) 
D. while (i <= j)

正确答案：D

10、关于分治算法，以下哪个说法正确?

A. 分治算法将问题分成子问题，然后分别解决子问题，最后合并结果。 B. 归并排序不是分治算法的应用。
C. 分治算法通常用于解决小规模问题。
D. 分治算法的时间复杂度总是优于O(nlog(n))) 。

正确答案：A

11、根据下述二分查找法，在排好序的数组 1，3，6，9，17，31，39，52，61，79，81，90，96 中查找数值 82，和82比较的数组元素分别是( )。

int binary_search(vector<int>& nums, int target) {
	int left = 0;
	int right = nums.size() - 1;
	while (left <= right) {
		int mid = (left + right) / 2;
		if (nums[mid] == target) {
			return mid;
		} else if (nums[mid] < target) {
			left = mid + 1;
		} else {
			right = mid - 1;
		}
	}
	return -1; // 如果找不到目标元素，返回-1
}

A. 52, 61, 81, 90 
B. 52, 79, 90, 81 
C. 39, 79, 90, 81 
D. 39, 79, 90

正确答案：C

12、要实现一个高精度减法函数，则下面代码中加划线应该填写的代码为( )。

//假设a和b均为正数，且a表示的数比b大
vector<int> minus(vector<int> a, vector<int> b) {
	vector<int> c;
	int len1 = a.size(); 
	int len2 = b.size(); 
	int i, t;
	for (i = 0; i < len2; i++) { 
		if (a[i] < b[i]) { //借位
			_____________ // 在此处填入代码
			a[i] += 10; 
		}
        t = a[i] - b[i];
        c.push_back(t);
    }
    for (; i < len1; i++)
        c.push_back(a[i]);
	len3 = c.size();
	while (c[len3 - 1] == 0) {//去除前导0
        c.pop_back();
		len3--; 
	}
	return c;
}

A. a[i + 1]--; 
B. a[i]--;
C. b[i + 1]--; 
D. b[i]--;

正确答案：A

13、设A和B是两个长度为 的有序数组，现将A和B合并成一个有序数组，归并排序算法在最坏情况下至少要做 ( )次比较。

A. $n^2$
B. $nlogn$
C. $2n-1$
D. $n$

正确答案：C

14、给定如下函数:

int fun(int n){
	if (n == 1) return 1;
	if (n == 2) return 2;
	return fun(n - 2) - fun(n - 1);
}

则当n = 7时, 函数返回值为（ ）。

A. 0 
B. 1 
C. 21 
D. -11

正确答案：D

15、给定如下函数(函数功能同上题，增加输出打印):

int fun(int n){
	cout << n << " ";
	if (n == 1) return 1;
	if (n == 2) return 2;
	return fun(n - 2) - fun(n - 1);
}

则当n = 4时，屏幕上输出序列为（ ）。

A. 4 3 2 1 
B. 1 2 3 4 
C. 4 2 3 1 2 
D. 4 2 3 2 1

正确答案：C

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

1、如果将双向链表的最后一个结点的下一项指针指向第一个结点，第一个结点的前一项指针指向最后一个结 点，则该双向链表构成循环链表。

正确答案：正确

2、数组和链表都是线性表，链表的优点是插入删除不需要移动元素，并且能随机查找。

正确答案：错误

3、链表的存储空间物理上可以连续，也可以不连续。

正确答案：正确

4、找出自然数n以内的所有质数，常用算法有埃拉托斯特尼(埃氏)筛法和线性筛法，其中埃氏筛法效率更 高。

正确答案：错误

5、唯一分解定理表明任何一个大于1的整数都可以唯一地表示为一系列质数的乘积，即质因数分解是唯一的。

正确答案：正确

6、贪心算法通过每一步选择局部最优解来获得全局最优解，但并不一定能找到最优解。

正确答案：正确

7、归并排序和快速排序都采用递归实现，也都是不稳定排序。( )

正确答案：错误

8、插入排序有时比快速排序时间复杂度更低。

正确答案：正确

9、在进行全国人口普查时，将其分解为对每个省市县乡来进行普查和统计。这是典型的分治策略。

正确答案：正确

10、在下面C++代码中，由于删除了变量 ptr ，因此 ptr 所对应的数据也随之删除，故执行下述代码时，将报 错。

int* ptr = new int(10);
cout << *ptr << endl;
delete ptr;
cout << ptr << endl;

正确答案：错误

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

黑白格

【问题描述】
小杨有一个n行m列的网格图，其中每个格子要么是白色，要么是黑色。
小杨想知道至少包含k个黑色格子的最小子矩形包含了多少个格子。
【输入描述】
第一行包含三个正整数n,m,k,含义如题面所示。
之后n行，每行一个长度为m的01串，代表网格图第i行格子的颜色，如果为0，则对应格子为白色，否则为黑色。
【输出描述】
输出一个整数，代表至少包含k个黑色格子的最小子矩形包含格子的数量，如果不存在则输出0。
【样例输入 1】
4 5 5
0000
01111
00011
00011
【样例输出 1】
6
【样例解释】
对于样例1，假设(i, j)代表第i行第j列，至少包含5个黑色格子的最小子矩形的四个顶点为（2，4），（2，5），（4，4），4，5），共包含六个格子。
【数据范围】

子任务编号	数据点占比	n, m
1	20%	<= 10
2	40%	n = 1, 1 <= m <= 100
3	40%	<= 100

对于全部数据，保证有1 <= n, m <= 100, 1 <= k <= n * m。

小杨的幸运数字

【问题描述】
小杨认为他的幸运数字应该恰好有两种不同的质因子，例如，$12=2\ast 2\ast 3$ 的质因子有2, 3 ，恰好为两种不同的质
因子，因此12是幸运数字，而$30=2\ast 3\ast 5$的质因子有2, 3, 5，不符合要求，不为幸运数字。
小杨现在有n个正整数，他想知道每个正整数是否是他的幸运数字。
【输入描述】
第一行包含一个正整数n，代表正整数个数。
之后n行，每行一个正整数。
【输出描述】
输出n行，对于每个正整数，如果是幸运数字，输出1，否则输出0。
【样例输入 1】
3
7
12
30
【样例输出 1】
0
1
0
【样例解释】
7的质因子有7，只有一种。
12的质因子有2，3，恰好有两种。
30的质因子有2，3，5，有三种。
【数据范围】

子任务编号	数据点占比	n	正整数值域
1	40%	$<=100$	$<=10^5$
2	60%	$<=10^4$	$<=10^6$

对于全部数据，保证有$1<=n,<=10^4$, 每个正整数$a_i$满足$2<=a_i<=10^6$。