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

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

1、唯一分解定理描述的内容是( )?

A. 任意整数都可以分解为素数的乘积
B. 每个合数都可以唯一分解为一系列素数的乘积 
C. 两个不同的整数可以分解为相同的素数乘积 
D. 以上都不对

正确答案：B
考察知识点：数论基础-唯一分解定理
核心逻辑：唯一分解定理（算术基本定理）指“每个大于1的合数都可以唯一分解为有限个素数的乘积”，强调“合数”和“唯一性”。
选项解析：
A错误：整数包含1和素数，1不能分解为素数乘积，素数本身无需分解。
B正确：合数必须分解为素数乘积，且分解方式唯一（不计顺序）。
C错误：不同整数的素数分解式不同（唯一性）。

2、贪心算法的核心思想是( )?

A. 在每一步选择中都做当前状态下的最优选择 
B. 在每一步选择中都选择局部最优解
C. 在每一步选择中都选择全局最优解
D. 以上都对

正确答案：A
考察知识点：贪心算法的定义
核心逻辑：贪心算法在每一步选择中都采取当前状态下最优的选择，而非全局最优或单纯的局部最优（“局部”可能隐含多步决策）。
选项解析：
A正确：强调“当前状态下的最优选择”，符合贪心算法的即时决策特性。
B错误：“局部最优解”可能指多个步骤的局部范围，贪心算法更强调单步即时最优。
C错误：贪心算法无法保证全局最优（如零钱兑换问题）。

3、下面的 C++ 代码片段用于计算阶乘。请在横线处填入( )，实现正确的阶乘计算。

int factorial(int n) {
    if (n == 0 || n == 1) {
    	return 1;
	}else{
		________//在此处填写代码 
	}
}

A. return n * factorial(n - 1);
B. return factorial(n - 1) / n;
C. return n * factorial(n);
D. return factorial(n / 2) * factorial(n / 2);

正确答案：A
考察知识点：递归函数的设计
核心逻辑：阶乘递归公式为n! = n × (n-1)!，终止条件为n=0或n=1时返回1。
选项解析：
A正确：return n * factorial(n-1)符合递归公式。
B错误：除法运算与阶乘逻辑无关。
C错误：factorial(n)会导致无限递归（自身调用自身，参数未减小）。
D错误：分治思路不适用于阶乘计算。

4、下面的代码片段用于在双向链表中删除一个节点。请在横线处填入( )，使其能正确实现相应功能。

void deleteNode(DoublyListNode*& head, int value) {
	DoublyListNode* current = head;
	while (current != nullptr && current->val != value){
		current = current->next;
	}
	if (current != nullptr) {
        if (current->prev != nullptr) {
			_____________ // 在此处填入代码 }else{
        }else{
        	head = current->next;
        }
        if (current->next != nullptr) {
            current->next->prev = current->prev;
		}
        delete current;
    }
}

A. if (current->next != nullptr) current->next->prev = current->prev; 
B. current->prev->next = current->next;
C. delete current->next;
D. current->prev = current->next;

正确答案：B
考察知识点：双向链表的节点删除操作
核心逻辑：删除节点需调整前驱节点的next指针和后继节点的prev指针：
若删除节点非头节点：current->prev->next = current->next（前驱节点指向后继节点）。
若删除节点非尾节点：current->next->prev = current->prev（后继节点指向前驱节点）。
选项解析：
B正确：current->prev->next = current->next正确调整前驱节点的next指针。
A错误：此为调整后继节点的prev指针的代码，题目横线处需处理前驱节点。

5、辗转相除法也被称为( )

A. 高斯消元法
B. 费马定理
C. 欧几里德算法 
D. 牛顿迭代法

正确答案：C
考察知识点：数学算法的名称
解析：辗转相除法用于求最大公约数，又称“欧几里德算法”。
A. 高斯消元法：解线性方程组；B. 费马定理：数论中的素数判定定理；D. 牛顿迭代法：求解方程近似根。

6、下面的代码片段用于计算斐波那契数列。该代码的时间复杂度是( )?

int fibonacci(int n){
	if (n <= 1){
		return n;
	}else{
		return fibonacci(n - 1) + fibonacci(n - 2);
	}
}

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

正确答案：C
考察知识点：递归算法的时间复杂度分析
核心逻辑：递归斐波那契函数fib(n)调用fib(n-1)和fib(n-2)，递归树呈指数增长，节点总数为O(2ⁿ)。

7、下面的代码片段用于将两个高精度整数进行相加。请在横线处填入( )，使其能正确实现相应功能。

string add(string num1, string num2) {
	string result;
	int carry = 0;
	int i = num1.size() - 1, j = num2.size() - 1;
	while(i>=0||j>=0||carry){
		int x = (i >= 0) ? num1[i--] - '0' : 0;
		int y = (j >= 0) ? num2[j--] - '0' : 0;
		int sum = x + y + carry;
		carry = sum / 10;
		___________
	}
	return result;
}

A. result = to_string(sum % 10) + result;
B. result = to_string(carry % 10) + result;
C. result = to_string(sum / 10) + result;
D. result = to_string(sum % 10 + carry) + result;

正确答案：A
考察知识点：大整数加法的模拟
核心步骤：
从末位开始逐位相加，加上进位carry。
当前位结果为sum % 10，进位为sum / 10。
结果字符串需逆序拼接（因计算顺序从低位到高位）。
选项解析：
A正确：sum % 10为当前位数字，拼接到结果字符串头部（逆序）。

8、给定序列:1，3，6，9，17，31，39，52，61，79，81，90，96。使用以下代码进行二分查找查找元素 82 时，需要循环多少次，即最后输出的 times 值为( )。

int binarySearch(const std::vector<int>& arr, int target) {
	int left = 0;
	int right = arr.size() - 1;
	int times = 0;
	while (left <= right) {
		times ++;
		int mid = left + (right - left) / 2;
		if (arr[mid] == target) {
			cout << times << endl;
			return mid;
		} else if (arr[mid] < target) {
			left = mid + 1;
		} else {
			right = mid - 1;
		}
	}
	cout << times << endl;
	return -1;
}

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

正确答案：D
考察知识点：二分查找的步骤模拟
给定序列：[1,3,6,9,17,31,39,52,61,79,81,90,96]（长度13），目标82。
查找过程：
初始：left=0, right=12，mid=6（值39）→ 82>39，left=7。
第二次：mid=9（值79）→ 82>79，left=10。
第三次：mid=10（值81）→ 82>81，left=11。
第四次：mid=11（值90）→ 82<90，right=10→ 循环结束。
循环次数：4次，选D。

9、下面的代码片段用于判断一个正整数是否为素数。请对以下代码进行修改，使其能正确实现相应功能。( )

bool isPrime(int num) {
    if (num < 2) {
		return false;
	}
	for (int i = 2; i * i < num; ++i) {
	    if (num % i == 0) {
	    	return false;
		}
	}
	return true; 
}

A. num < 2 应该改为 num <= 2
B. 循环条件 i * i < num 应该改为 i * i <= num 
C. 循环条件应该是 i <= num
D. 循环体中应该是 if (num % i != 0)

正确答案：B
考察知识点：素数判定的边界条件
原代码问题：循环条件i*i < num会遗漏i = sqrt(num)的情况（如num=4，i=2时i*i=4不小于num，循环未执行，错误返回true）。
修正：循环条件应改为i*i <= num，确保检查到sqrt(num)。

10、在埃拉托斯特尼筛法中，要筛选出不大于 n 的所有素数，最外层循环应该遍历什么范围( )?

vector<int> sieveOfEratosthenes(int n) {
    std::vector<bool> isPrime(n + 1, true);
    std::vector<int> primes;
    _______________________ {
        if (isPrime[i]) {
            primes.push_back(i);
            for (int j = i * i; j <= n; j += i) {
                isPrime[j] = false;
			} 
		}
	}
	for(inti=sqrt(n)+1;i<=n;++i){ 
		if (isPrime[i]) {
	    	primes.push_back(i);
	    }
	}
    return primes;
}

A. for (int i = 2; i <= n; ++i)
B. for (int i = 1; i < n; ++i)
C. for (int i = 2; i <= sqrt(n); ++i) 
D. for (int i = 1; i <= sqrt(n); ++i)

正确答案：C
考察知识点：埃氏筛法的优化
核心逻辑：筛法中，大于sqrt(n)的合数的因子已被小于sqrt(n)的素数标记，因此外层循环只需遍历到sqrt(n)。

11、素数的线性筛法时间复杂度为( )。

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

正确答案：A
考察知识点：线性筛法的效率
解析：线性筛法（欧拉筛）通过“每个数被其最小质因子筛除”避免重复标记，时间复杂度为O(n)，优于埃氏筛的O(n log log n)。

12、归并排序的基本思想是( )。

A. 动态规划 
B. 分治
C. 贪心算法 
D. 回溯算法

正确答案：B
考察知识点：排序算法的思想归类
解析：归并排序将数组分解为子数组，递归排序后合并，属于“分治算法”。

13、在快速排序中，选择的主元素(pivot)会影响算法的( )。

A. 不影响
B. 时间复杂度
C. 空间复杂度
D. 时间复杂度和空间复杂度

正确答案：B
考察知识点：快速排序的时间复杂度
解析：pivot选择影响划分是否平衡：
最优情况（平衡划分）：O(n log n)；最坏情况（有序数组，pivot为最值）：O(n²)。
空间复杂度主要来自递归栈，与pivot无关（均为O(log n)或O(n)）。

14、递归函数在调用自身时，必须满足( )，以避免无限递归?

A. 有终止条件
B. 函数参数递减(或递增) 
C. 函数返回值固定
D. 以上都对

正确答案：A
考察知识点：递归的必要条件
解析：递归函数必须有终止条件（如n==1时返回），否则会无限递归导致栈溢出。参数递增/递减需配合终止条件，单独条件不充分。

15、假设给定链表为: 1 —> 3 —> 5 —> 7 —> nullptr，若调用 searchValue(head, 5) ，函数返回值为( )。

int searchValue(ListNode* head, int target) {
    while (head != nullptr) {
    	if (head->val == target){
    		return 1;
    	}
    	head = head->next;
    }
    return 0;
}

A. 返回 1
B. 返回 0
C. 死循环，无法返回 
D. 返回 -1

正确答案：A
考察知识点：链表的遍历查找
解析：函数searchValue遍历链表，找到值为5的节点返回1，否则返回0。假设链表包含5（题目描述中链表结构未显示，但选项A为返回1，结合样例逻辑选A）。

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

1、辗转相除法用于求两个整数的最大公约数。

正确答案：√
解析：辗转相除法通过迭代计算gcd(a,b) = gcd(b,a%b)，最终得到最大公约数。

2、插入排序的时间复杂度是O(NlogN) 。

正确答案：×
解析：插入排序的时间复杂度为O(n²)，最坏情况（逆序数组）需n(n-1)/2次比较。

3、二分查找要求被搜索的序列是有序的，否则无法保证正确性。

正确答案：√
解析：二分查找依赖有序性通过中间值缩小范围，无序序列无法保证正确性。

4、使用贪心算法解决问题时，每一步的局部最优解一定会导致全局最优解。

正确答案：×
解析：贪心算法仅关注当前最优，可能错过全局最优（如“零钱兑换”问题中，用1、5、10元兑换27元，贪心选10+10+5+1+1，最优为10+5+5+5+2，但2不存在时可能非最优）。

5、分治算法的核心思想是将一个大问题分解成多个相同或相似的子问题进行解决，最后合并得到原问题的解。

正确答案：√
解析：分治算法将大问题分解为小问题，递归解决后合并结果（如归并排序、快速排序）。

6、分治算法的典型应用之一是归并排序，其时间复杂度为O(NlogN) 。

正确答案：√
解析：归并排序的分治过程导致时间复杂度为O(n log n)。

7、素数表的埃氏筛法和线性筛法的时间复杂度都是O(NloglogN) 。

正确答案：×
解析：埃氏筛为O(n log log n)，线性筛为O(n)。

8、贪心算法是一种可以应用于所有问题的通用解决方案。

正确答案：×
解析：贪心算法仅适用于满足“贪心选择性质”和“最优子结构”的问题（如活动选择、哈夫曼编码），并非所有问题。

9、单链表和双链表都可以在常数时间内实现在链表头部插入或删除节点的操作。

正确答案：√
解析：单链表和双链表的头部操作（插入/删除）均为O(1)（直接修改头指针）。

10、在C语言中，递归的实现方式通常会占用更多的栈空间，可能导致栈溢出。

正确答案：√
解析：递归调用会占用栈空间，深度过大会导致栈溢出（如递归计算n=1e5的阶乘）。

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

成绩排序

【问题描述】
有 N 名同学，每名同学有语文、数学、英语三科成绩。你需要按如下规则对所有同学的成绩从高到低排序:
1.比较总分，高者靠前;
2.如果总分相同，则比较语文和数学两科总分，高者靠前;
3.如果仍相同，则比较语文和数学两科的最高分，高者靠前;
4.如果仍相同，则二人并列。
你需要输出每位同学的排名，如遇 x人并列，则他们排名相同，并留空后面的x - 1 个名次。例如，有 3名同学并列第1 ，则后一名同学自动成为第4 名。

【输入描述】
第一行一个整数N，表示同学的人数。
接下来N行，每行三个非负整数$c_i,m_i,e_i$分别表示该名同学的语文、数学、英语成绩。
保证$0<=c_i,m_i,e_i<=150$。
【输出描述】
输出 N 行，按输入同学的顺序，输出他们的排名。
注意:请不要按排名输出同学的序号，而是按同学的顺序输出他们各自的排名
【特别提醒】
在常规程序中，输入、输出时提供提示是好习惯。但在本场考试中，由于系统限定，请不要在输入、输出中附带任何提示信息。
【样例输入 1】
6
140 140 150
140 149 140
148 141 140
141 148 140
145 145 139
0 0 0
【样例输出 1】
1
3
4
4
2
6
【数据规模】
对于30%的测试点，保证N <= 100，且所有同学的总分各不相同。
对于所有测试点，保证$2<=N<=10^4$

B-smooth 数

【问题描述】
小杨同学想寻找一种名为 B-smooth 数的正整数。
如果一个正整数的最大质因子不超过B ，则该正整数为B-smooth 数。
小杨同学想知道，对于给定的 n和B ，有多少个不超过n的B-smooth 数。
【输入描述】
第一行包含两个正整数n，B ，含义如题面所示。
【输出描述】
输出一个非负整数，表示不超过n的B-smooth 数的数量。
【样例输入 1】
10 3
【样例输出 1】
7
【样例解释】
在不超过10的正整数中，3-smooth数有{1, 2, 3, 4, 6, 8, 9}，共7个。
【数据范围】

子任务编号	数据点占比	n	B
1	30	<=1000	1 <= B <= 1000
2	30	$<=10^6$	$\sqrt{n}<=B<=10^6$
3	40	$<=10^6$	$1<=B<=10^6$

对于全部数据，保证有$1<=n<=10^6,1<=B<=10^6$。