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
考察知识点：迭代算法的判定
解析：
代码通过for循环计算斐波那契数列：
初始a=1（第1项）、b=1（第2项），从第3项开始，通过next = a + b迭代更新a和b（a = b，b = next）。
为什么是迭代而非递归：
递归实现（fibo(n) = fibo(n-1) + fibo(n-2)）会产生大量重复计算（如fibo(5)需计算fibo(4)和fibo(3)，而fibo(4)又需fibo(3)和fibo(2)，导致fibo(3)被计算2次），时间复杂度O(2ⁿ)。
迭代通过循环直接更新变量，时间复杂度O(n)，空间复杂度O(1)，效率远高于递归。
排除其他选项：
枚举算法需遍历所有可能解（如暴力破解），代码无枚举逻辑；
贪心算法需每步选择局部最优（如币种兑换），此处无“选择”过程；
递归算法需函数调用自身，代码中无递归调用。

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
考察知识点：贪心算法的应用
解析：
代码逻辑：按面值从大到小（100→50→20→…→1）计算每种币种的使用数量，即coins_used[i] = money / coins[i]，剩余金额money = money % coins[i]。
为什么是贪心算法：
贪心算法的核心是“每步选择当前最优解”，此处优先使用最大面值币种，减少剩余金额，从而最小化总币数。
适用性条件：当币种为“100,50,20,10,5,2,1”时，大面值是小面值的倍数，贪心可得到最优解。例如145元：100*1 + 20*2 + 5*1（共4枚），无需考虑其他组合。
反例：若币种为“25,10,1”且目标30元，贪心会选25*1+1*5（6枚），但最优解是10*3（3枚），此时贪心失效。
排除其他选项：
迭代算法是重复执行某段代码（如循环），但迭代是实现方式，不是算法思想；
枚举算法需遍历所有可能组合（如100x +50y+…=money），复杂度极高，不符代码逻辑。

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
考察知识点：链表查找的时间复杂度
解析：
代码逻辑：从head开始，通过temp = temp->next遍历链表，直到找到目标歌曲或temp为nullptr。
为什么时间复杂度是O(n)：
链表的存储特点：节点通过指针连接，物理地址不连续，无法像数组那样通过索引随机访问（O(1)），必须从头节点顺序遍历。
最坏情况：目标歌曲在链表末尾（需遍历n个节点）或不存在（遍历所有n个节点），因此时间复杂度为O(n)。
选项对比：
O(1)：仅可能是数组随机访问或哈希表查找；
O(logn)：需有序结构（如二分查找），链表无序；
O(n²)：需嵌套循环（如冒泡排序），此处仅单循环。

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
考察知识点：双向链表头部插入操作
解析：
双向链表节点结构：每个节点包含prev（前驱指针）和next（后继指针），头节点head的prev为nullptr。
插入步骤详解：
创建新节点p：p->song = my_song，p->prev = nullptr（新节点为头节点，无前驱），p->next = head（新节点的后继指向原头节点）。
若原链表非空（head != nullptr）：需将原头节点的prev指针指向新节点p，即head->prev = p（否则原头节点的前驱仍为nullptr，双向链表关系不完整）。
更新头节点：head = p（新节点成为新的头节点）。
选项分析：
A错误：head->next->prev = p修改的是原头节点的下一个节点的前驱，插入头部时原头节点的next可能为nullptr（链表为空时），会导致空指针访问错误。
B错误：head->next = p是原头节点的后继指向新节点，但新节点的next已指向原头节点（p->next = head），此步重复且逻辑错误。
D错误：head != nullptr时，原头节点存在，可安全修改其prev指针，无需触发异常。

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
考察知识点：欧几里得算法的功能
解析：
代码逻辑：通过while (b != 0)循环，反复计算temp = b，b = a % b，a = temp，直到b=0，此时a为最大公约数（GCD）。
为什么是最大公约数：
欧几里得算法（辗转相除法）基于定理：gcd(a,b) = gcd(b,a%b)。
举例：计算gcd(48,18)：
初始a=48，b=18 → a%b=12 → a=18，b=12；
a%b=6 → a=12，b=6；
a%b=0 → 循环结束，a=6即GCD。
排除其他选项：
最小公倍数（LCM）需公式LCM(a,b) = a*b / GCD(a,b)，代码未计算；
最大公共质因子/最小公共质因子：GCD可能包含非质因子（如gcd(8,12)=4，4不是质因子）。

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
考察知识点：递归与迭代的效率对比
解析：
递归实现的gcd(a,b)：通过return b == 0 ? a : gcd(b, a%b)调用自身，直到b=0。
为什么递归效率更低：
空间开销：递归需在栈内存中保存每次调用的参数（a,b）、返回地址等，递归深度越大，栈空间占用越多。例如gcd(1e9, 1e9-1)需递归约log₂(1e9)≈30次，栈空间开销不可忽视。
时间开销：函数调用和返回需额外指令，效率低于迭代的纯循环操作。
选项D错误的原因：
迭代实现仅用3个变量（a,b,temp），空间复杂度O(1)，无函数调用开销，执行效率更高。递归实现代码更简洁，但效率更低。

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

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(int j = 0; j <=sqrt(n) && i*primes[j]<=n; j++) 
C.for(int j = 0; j<=n; j++)
D.for (int j = 1; j <= sqrt(n); j++)

正确答案：A
考察知识点：线性筛法的内层循环条件
解析：
线性筛法核心目标：每个合数仅被其最小质因子标记一次，避免埃氏筛的重复标记（如12在埃氏筛中被2和3标记，线性筛中仅被2标记）。
内层循环逻辑：
for (j=0; j < primes.size() && i * primes[j] <=n; j++)：
j < primes.size()：遍历已找到的素数（primes数组存储已筛出的素数）；
i*primes[j] <=n：确保标记的合数不超过n；
if (i % primes[j] == 0) break：若primes[j]是i的质因子，则primes[j]是i * primes[j]的最小质因子，后续素数会导致重复标记（如i=4，primes[j]=2时，4 * 2=8（最小质因子2），若继续j=1（primes[1]=3），4 * 3=12的最小质因子是2，已被标记，故需中断）。
选项A正确的原因：
B错误：j <= sqrt(n)会限制素数范围，遗漏部分合数（如i=5，primes[j]=3时，5 * 3=15需标记）；
C错误：j <=n会导致i * primes[j]远超过n，且primes.size()远小于n；
D错误：j=1会跳过第一个素数（2），导致偶数未被标记。

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

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

正确答案：D
考察知识点：线性筛法的时间复杂度
解析：

线性筛法效率：每个合数仅被其最小质因子标记一次，因此每个数最多被标记一次。例如：
4（2 * 2）、6（2 * 3）、8（2 * 4）、9（3 * 3）、10（2 * 5）等，均只被标记一次。
为什么是O(n)：
总操作次数 = 素数个数 * 每个素数标记的合数个数，最终趋近于n，时间复杂度严格为O(n)。
埃氏筛对比：
埃氏筛法中，素数p会标记p,2p,3p…，总操作次数为n/2 + n/3 + n/5 + … ≈ n log log n，当n=1e6时，log log n≈3，线性筛（O(n)）比埃氏筛（O(n log log n)）快约3倍。

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
考察知识点：快速排序的循环条件
解析：
快速排序分区逻辑：
选中间元素为基准值pivot = arr[mid]；
i从左向右找> pivot的元素，j从右向左找< pivot的元素，交换arr[i]和arr[j]；
重复步骤2，直到i > j（所有小于pivot的元素在左，大于的在右）。
do-while循环条件：
代码中do { … } while(条件)，先执行循环体（查找并交换），再判断是否继续。
循环终止条件应为i > j，因此循环条件是while (i <= j)（当i <= j时继续循环，i > j时终止）。
举例：初始i=left=0，j=right=12，经过几次交换后i=11，j=10，此时i > j，循环终止。
选项D正确的原因：
A错误：mid是基准值索引，与i,j的位置无关；
B错误：i < j会遗漏i == j的情况（如数组长度为1时）；
C错误：同B，i < j未包含i == j。

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

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

正确答案：A
考察知识点：分治算法的定义
解析：
分治算法三步骤：
分解（Divide）：将原问题分解为规模更小的子问题；
解决（Conquer）：递归解决子问题；
合并（Combine）：合并子问题的解得到原问题的解。
选项A正确的原因：直接符合分治算法的定义。
其他选项错误的原因：
B错误：归并排序是典型分治算法（分解为左右两半→递归排序→合并有序数组）；
C错误：分治算法通常用于解决大规模问题（通过分解为小问题），小规模问题直接解决；
D错误：分治算法的时间复杂度取决于合并步骤，如归并排序是O(n log n)，快速排序平均O(n log n)，最坏O(n²)，并非“总是优于O(n log n)”。

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
考察知识点：二分查找的步骤模拟
解析：
数组：[1,3,6,9,17,31,39,52,61,79,81,90,96]（长度13，索引0-12），目标82。
二分查找步骤：

步骤	left	right	mid = (left+right)/2	nums[mid]	比较结果	调整范围
1	0	12	6	39	39 < 82	left = mid+1=7
2	7	12	9	79	79 < 82	left = mid+1=10
3	10	12	11	90	90 > 82	right = mid-1=10
4	10	10	10	81	81 < 82	left = mid+1=11
5	11	10	-	-	left > right	循环结束

比较的元素序列：39（步骤1）→79（步骤2）→90（步骤3）→81（步骤4），共4次比较。

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
考察知识点：高精度减法的借位逻辑
解析：
高精度减法背景：当数字过大（如100位）无法用int或long long存储时，用数组存储每位数字（通常低位在前，如a = [3,1]表示13，b = [5,0]表示5，计算13-5=8）。
借位场景：当a[i] < b[i]（如a[0]=3 < b[0]=5），需从a[i+1]（高位）借1，即：
a[i+1]–（高位减1）；
a[i] += 10（当前位加10，如3+10=13，13-5=8）。
代码示例：
a = [3,1]（13），b = [5,0]（5）：
i=0时，a[0]=3 < b[0]=5，执行a[i+1]–（a[1]从1变为0），a[0] +=10（3+10=13）；
t = 13 -5=8，c = [8]，结果为8。
选项A正确的原因：
B错误：a[i]–会使当前位更小（3-1=2，2-5更无法计算）；
C/D错误：借位是从被减数a的高位借，与b无关。

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

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

正确答案：C
考察知识点：归并排序的比较次数
解析：
归并排序合并步骤：将两个有序数组A和B（长度均为n）合并为一个有序数组C（长度2n），比较次数取决于元素大小关系。
最坏情况场景：当一个数组的所有元素均小于另一个数组的所有元素时，每次比较只能确定一个元素的位置，需比较2n-1次。
举例：A=[1,3,5]（升序），B=[2,4,6]（升序），合并过程：
1 vs 2 → 取1（比较1次）
3 vs 2 → 取2（比较2次）
3 vs 4 → 取3（比较3次）
5 vs 4 → 取4（比较4次）
5 vs 6 → 取5（比较5次）
剩余6 → 直接取（无需比较）
总比较次数=5=2 * 3 - 1 = 2n - 1（n=3时）。
选项排除：
A错误：n²是冒泡排序的时间复杂度，与归并合并无关；
B错误：nlogn是归并排序整体的时间复杂度，非单次合并比较次数；
D错误：n次比较仅适用于一个数组完全包含于另一个数组的情况（如A=[1,2,3]，B=[4,5,6]，比较3次）。

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
考察知识点：递归函数的返回值计算
解析：
函数定义：fun(n) = fun(n-2) - fun(n-1)，边界条件fun(1)=1，fun(2)=2。
递归展开计算（从n=1逐步推导至n=7）：

fun(1) = 1  
fun(2) = 2  
fun(3) = fun(1) - fun(2) = 1 - 2 = -1  
fun(4) = fun(2) - fun(3) = 2 - (-1) = 3  
fun(5) = fun(3) - fun(4) = -1 - 3 = -4  
fun(6) = fun(4) - fun(5) = 3 - (-4) = 7  
fun(7) = fun(5) - fun(6) = -4 - 7 = -11

关键注意点：
递归顺序是自底向上（先计算小n的值，再推导大n），避免重复计算；
符号处理：减法可能导致负数，需严格按公式展开，避免符号错误（如fun(3)结果为-1，而非1）。

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
考察知识点：递归调用的输出顺序
解析：

函数逻辑：调用fun(n)时，先输出n，再递归调用fun(n-2)和fun(n-1)。
调用链与输出顺序（以fun(4)为例）：

fun(4) → 输出4 → 先调用fun(2)，再调用fun(3)  
  ├─ fun(2) → 输出2 → 触发边界条件（n=2），无递归调用  
  └─ fun(3) → 输出3 → 先调用fun(1)，再调用fun(2)  
       ├─ fun(1) → 输出1 → 触发边界条件（n=1）  
       └─ fun(2) → 输出2 → 触发边界条件（n=2）

输出序列：4（fun(4)）→2（fun(2)）→3（fun(3)）→1（fun(1)）→2（fun(2)），即4 2 3 1 2。
常见误区：
误认为递归顺序是fun(4)→fun(3)→fun(1)→fun(2)→fun(2)，导致输出4 3 1 2 2，忽略了fun(4)先调用fun(2)再调用fun(3)的顺序。

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

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

正确答案：正确
考察知识点：循环链表的定义
解析：
双向链表的循环化：若最后一个节点的next指向头节点，且头节点的prev指向最后一个节点，则链表形成闭合环，称为双向循环链表。

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

正确答案：错误
考察知识点：链表的特性
解析：
链表的存储特点：节点通过指针/引用连接，物理地址不连续，无法通过索引直接访问（随机查找），必须从头节点顺序遍历（时间复杂度O(n)）。
错误点：“能随机查找”表述错误，随机查找是数组的特性（O(1)时间复杂度）。

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

正确答案：正确
考察知识点：链表的存储空间
解析：
链表节点的内存分配：通常通过new或malloc动态分配，节点的物理地址可以连续（如内存池分配）或不连续（如碎片化内存），逻辑顺序由指针维护。

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

正确答案：错误
考察知识点：筛法效率对比
解析：
埃氏筛法：每个素数p会标记其倍数（p,2p,3p…），导致合数可能被多个素数标记（如12被2和3标记），时间复杂度O(n log log n)。
线性筛法：每个合数仅被其最小质因子标记（如12仅被2标记），时间复杂度O(n)，效率高于埃氏筛法。
错误点：“埃氏筛法效率更高”与事实相反。

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

正确答案：正确
考察知识点：唯一分解定理
解析：
唯一分解定理（算术基本定理）：任何大于1的整数都可以唯一地表示为有限个质数的乘积，且不计次序时表示方式唯一（如12=2²×3=3×2²，视为同一种分解）。

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

正确答案：正确
考察知识点：贪心算法的局限性
解析：
贪心算法的核心：每步选择局部最优解，期望得到全局最优解。

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

正确答案：错误
一、关于“都采用递归实现”：部分正确，但存在例外
归并排序和快速排序的经典实现确实依赖递归，但并非必须使用递归，也存在非递归（迭代）实现方式：
归并排序：
递归实现：将数组二分至子数组长度为1，再合并排序，逻辑清晰（时间复杂度 O(n\log n)O(nlogn)）。
非递归实现：通过迭代控制子数组长度（从1→2→4…），逐步合并相邻子数组（如“自底向上归并”），无需递归栈。
快速排序：
递归实现：选择基准元素分区，递归处理左右子数组（平均时间复杂度 O(n\log n)O(nlogn)）。
非递归实现：用栈/队列保存待排序区间的起止索引，手动模拟递归过程，避免递归栈溢出风险。
结论：两种排序的“主流实现”是递归，但存在非递归方式，因此“都采用递归实现”的表述不够严谨（忽略了迭代实现的可能性）。
二、关于“都是不稳定排序”：错误，归并排序是稳定的
稳定性定义：排序后，相等元素的相对顺序保持不变。
归并排序：稳定排序。
合并阶段中，当左右子数组元素相等时，优先选择左子数组元素，可确保相等元素的相对顺序不变。例如：
原序列 [2, 1, 1]，归并排序后仍为 [1, 1, 2]，两个1的相对顺序与原序列一致。
快速排序：不稳定排序。
分区阶段中，基准元素的交换可能破坏相等元素的顺序。例如：
原序列 [2, 1, 1]，若选择第一个1为基准，可能将右侧的1交换至左侧，导致两个1的相对顺序反转。
结论：归并排序是稳定的，快速排序是不稳定的，因此“都是不稳定排序”的表述错误。

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

正确答案：正确
数据接近完全有序（插入排序最好情况 vs 快速排序最坏情况）
插入排序最好情况：
当输入数据已排序或接近排序（如 [1, 2, 3, 4, 5]），插入排序的时间复杂度降至 O(n)（仅需遍历一次，无需移动元素）。
快速排序最坏情况：
若快速排序选择固定基准（如第一个元素），且输入数据已排序，则每次分区会将数组分为 [0] 和 [n-1] 两部分，时间复杂度退化为 O(n^2)。
例如：对 [1, 2, 3, 4, 5] 排序，快速排序会进行 n-1次递归，每层比较 O(n)次，总复杂度 O(n^2)。
对比结论：此时插入排序的 O(n)远优于快速排序的 O(n^2)。

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

正确答案：正确
考察知识点：分治策略的实际应用
解析：
分治策略的核心：将大规模问题分解为若干小规模子问题，分别解决后合并结果。
人口普查的分治思想：全国人口普查→省市普查→县区普查→乡镇普查，逐层分解，符合分治策略。

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

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

正确答案：错误
考察知识点：delete操作的影响
解析：
delete ptr的作用：释放ptr指向的内存空间，但不会修改ptr本身的值（ptr仍指向原内存地址，成为“野指针”）。
访问野指针的行为：C++标准未定义，可能导致程序崩溃、输出垃圾值或“看似正常”，但不一定报错（编译时无法检测，运行时行为不确定）。

编程题 (每题 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$。