欢迎大家订阅我的专栏：算法题解：C++与Python实现！ 本专栏旨在帮助大家从基础到进阶 ，逐步提升编程能力，助力信息学竞赛备战！
专栏特色 1.经典算法练习：根据信息学竞赛大纲，精心挑选经典算法题目，提供清晰的代码实现与详细指导，帮助您夯实算法基础。 2.系统化学习路径：按照算法类别和难度分级，从基础到进阶，循序渐进，帮助您全面提升编程能力与算法思维。
适合人群：
- 准备参加蓝桥杯、GESP、CSP-J、CSP-S等信息学竞赛的学生
- 希望系统学习C++/Python编程的初学者
- 想要提升算法与编程能力的编程爱好者
附上汇总帖：GESP认证C++编程真题解析 | 汇总
单选题
第1题
一间的机房要安排6名同学进行上机考试，座位共2行3列。考虑到在座位上很容易看到同一行的左右两侧的 屏幕，安排中间一列的同学做A卷，左右两列的同学做B卷。请问共有多少种排座位的方案？（ ）。
A.720
B.90
C.48
D.15
【答案】：A
【解析】
6个同学是不同的个体，因此将他们以全排列的方式分配到6个座位上即可。即6! = 6 * 5 * 4 * 3 * 2 * 1 = 720。
第2题
又到了毕业季，学长学姐们都在开心地拍毕业照。现在有3位学长、3位学姐希望排成一排拍照，要求男生不 相邻、女生不相邻。请问共有多少种拍照方案？（ ）。
A.720
B.72
C.36
D.2
【答案】：B
【解析】
男女交替排列，有两种情况：①男女男...②女男女...。对于任何一种情况，男女3人内部可以进行全排列，即3! = 3 * 2 * 1 = 6种方式。那么对于其中一种情况有6 * 6 = 36种方法，两种情况的方法总数就是2 * 36 = 72种。
第3题
下列关于C++类和对象的说法，错误的是（ ）。
A.通过语句 const int x = 5; 定义了一个对象 x 。
B.通过语句 std::string t = "12345"; 定义了一个对象 t 。
C.通过语句 void (*fp)() = NULL; 定义了一个对象 fp 。
D.通过语句 class MyClass; 定义了一个类 MyClass 。
【答案】：D
【解析】
混淆了声明和定义， class MyClass; 只是声明了一个类，而非定义了一个类。
第4题
关于生成树的说法，错误的是（ ）。
A.一个无向连通图，一定有生成树。
B.n 个顶点的无向图，其生成树要么不存在，要么一定包含 n-1 条边。
C.n 个顶点、n-1 条边的无向图，不可能有多颗生成树。
D.n 个顶点、n-1 条边的无向图，它本身就是自己的生成树。
【答案】：D
【解析】
一个无向图拥有生成树的一个必要条件是连通，D选项并没有说明图是连通的，因此不一定存在生成树。
第5题
一对夫妻生男生女的概率相同。这对夫妻希望儿女双全。请问这对夫妻生下两个孩子时，实现儿女双全的概 率是多少？（ ）。
A.
B.
C.
D.
【答案】：C
【解析】
共有4种情况：①男女②女男；③男男；④女女。其中儿女双全的情况占一半，因此答案是1/2。
第6题
已定义变量 double a, b; ，下列哪个表达式可以用来判断一元二次方程 是否有实根？（ ）。
A.4 * b - a * a < 0
B.4 * b <= a * a
C.a * a - 4 * b
D.b * 4 - a * a
【答案】：B
【解析】
方程的判别式为 △ = a * a - 4b，当它>=0时，说明有实根。
第7题
n 个结点的二叉树，执行广度优先搜索的平均时间复杂度是（ ）。
A.
B.
C.
D.
【答案】：C
【解析】
广度优先搜索会将二叉树的n个结点恰好遍历一次，因此时间复杂度是。
第8题
以下关于动态规划的说法中，错误的是（ ）。
A.动态规划方法通常能够列出递推公式。
B.动态规划方法的时间复杂度通常为状态的个数。
C.动态规划方法有递推和递归两种实现形式。
D.对很多问题，递推实现和递归实现动态规划方法的时间复杂度相当。
【答案】：B
【解析】
动态规划的时间复杂度通常由状态数量和每个状态的转移复杂度共同决定。例如，时间复杂度做法的最长上升子序列，状态数只有种。
第9题
下面的 sum_digit 函数试图求出从 1 到 n （包含 1 和 n ）的数中，包含数字 d 的个数。该函数的时间复杂度为（ ）。
#include <string>
int count_digit(int n, char d) {
int cnt = 0;
std::string s = std::to_string(n);
for (int i = 0; i < s.length(); i++)
if (s[i] == d)
cnt++;
return cnt;
}
int sum_digit(int n, char d) {
int sum = 0;
for (int i = 1; i <= n; i++)
sum += count_digit(i, d);
return sum;
}
A.
B.
C.
D.
【答案】：A
【解析】
count_digit()函数中将整数n转换为字符串，并枚举每一位，时间复杂度与n的位数有关，是O(logn)。sum_digit()函数中枚举1~n的每个数字去调用count_digit()函数，因此时间复杂度是O(log(1)+log(2)+...+log(n))=O(log(n!))， 近似于 O(nlogn)。
第10题
下面程序的输出为（ ）。
#include <iostream>
const int N = 10;
int ch[N][N][N];
int main() {
for (int x = 0; x < N; x++)
for (int y = 0; y < N; y++)
for (int z = 0; z < N; z++)
if (x == 0 && y == 0 && z == 0)
ch[x][y][z] = 1;
else {
if (x > 0)
ch[x][y][z] += ch[x - 1][y][z];
if (y > 0)
ch[x][y][z] += ch[x][y - 1][z];
if (z > 0)
ch[x][y][z] += ch[x][y][z - 1];
}
std::cout << ch[1][2][3] << std::endl;
return 0;
}
A.60
B.20
C.15
D.10
【答案】：A
【解析】
递推式ch[x][y][z]=ch[x-1][y][z]+ch[x][y-1][z]+ch[x][y][z-1]，本质上是在计算从坐标(0，0，0)到达坐标(x，y，z)有多少种不同的方式。到达(1，2，3)一共需要6次移动，分别需要在x，y，z的方向上走1，2，3步，移动方式有C(6,1) * C(5,2) * C(3,3)=6 * 10 * 1 种方式。其中C(5,2)表示从5个里面选出2个的组合数。
第11题
下面 count_triple 函数的时间复杂度为（ ）。
int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
int count_triple(int n) {
int cnt = 0;
for (int v = 1; v * v * 4 <= n; v++)
for (int u = v + 1; u * (u + v) * 2 <= n; u += 2)
if (gcd(u, v) == 1) {
int a = u * u - v * v;
int b = u * v * 2;
int c = u * u + v * v;
cnt += n / (a + b + c);
}
return cnt;
}
A.
B.
C.
D.
【答案】：C
【解析】
第1层循环v的增量是常数，且v*v<=n保证了循环次数是O(sqrt(n))，第2层循环u与v同数量级，增量也是常数，u*(u+v)<=n的条件也保证了循环次数是 O(sqrt(n))。循环内部每次调用复杂度为 O(logn)的最大公约数函数，因此总时间复杂度为 O(sqrt(n) * sqrt(n) * logn)=O(nlogn)。
第12题
下面 quick_sort 函数试图实现快速排序算法，两处横线处分别应该填入的是（ ）。
void swap(int & a, int & b) {
int temp = a; a = b; b = temp;
}
int partition(int a[], int l, int r) {
int pivot = a[l], i = l + 1, j = r;
while (i <= j) {
while (i <= j && a[j] >= pivot)
j--;
while (i <= j && a[i] <= pivot)
i++;
if (i < j)
swap(a[i], a[j]);
}
________; // 在此处填入选项
return ________; // 在此处填入选项
}
void quick_sort(int a[], int l, int r) {
if (l < r) {
int pivot = partition(a, l, r);
quick_sort(a, l, pivot - 1);
quick_sort(a, pivot + 1, r);
}
}
A.
swap(a[l], a[i])
i
B.
swap(a[l], a[j])
i
C.
swap(a[l], a[i])
j
D.
swap(a[l], a[j])
j
【答案】：D
【解析】
考察快速排序中的划分区间时的细节。可以发现区间[l, r]会递归到[l, pivot-1]和[pivot+1, r]，而在 partition 函数中， 通过 while(i<=j) 我们可以知道，循环结束后必然存在 i>j。考虑最坏情况 j=r 自始至终没有变化过，那么最终 i = r + 1，如果我们返回 i，那么区间 [l, r] 会递归到 [1, (r+1)-1]，造成无限递归，因此排除A，B选项。
接下来考虑C，D该如何选择，可以发现 partition 函数最终返回的应当是基准值的下标，如果要返回 j，那么就需要将基准值 a[l] 与a[j]交换，因此选D。
第13题
下面 LIS 函数试图求出最长上升子序列的长度，横线处应该填入的是（ ）。
int max(int a, int b) {
return (a > b) ? a : b;
}
int LIS(vector<int> & nums) {
int n = nums.size();
if (n == 0)
return 0;
vector<int> dp(n, 1);
int maxLen = 1;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++)
if (nums[j] < nums[i])
________; // 在此处填入选项
maxLen = max(maxLen, dp[i]);
}
return maxLen;
}
A.dp[j] = max(dp[j] + 1, dp[i])
B.dp[j] = max(dp[j], dp[i] + 1)
C.dp[i] = max(dp[i] + 1, dp[j])
D.dp[i] = max(dp[i], dp[j] + 1)
【答案】：D
【解析】
dp[i]表示以位置i结尾的最长上升子序列长度，枚举上一个结尾位置是j，那么转移方程就是 dp[i]=max(dp[i], dp[j]+1)。
第14题
下面 LIS 函数试图求出最长上升子序列的长度，其时间复杂度为（ ）。
#define INT_MIN (-1000)
int LIS(vector<int> & nums) {
int n = nums.size();
vector<int> tail;
tail.push_back(INT_MIN);
for (int i = 0; i < n; i++) {
int x = nums[i], l = 0, r = tail.size();
while (l < r) {
int mid = (l + r) / 2;
if (tail[mid] < x)
l = mid + 1;
else
r = mid;
}
if (r == tail.size())
tail.push_back(x);
else
tail[r] = x;
}
return tail.size() - 1;
}
A.
B.
C.
D.
【答案】：C
【解析】
循环执行了n次，每次都进行了时间复杂度为 O(logn) 的二分，因此总的时间复杂度为O(nlogn)。
第15题
下面的程序使用邻接矩阵表达的带权无向图，则从顶点0到顶点3的最短距离为（ ）。
int weight[4][4] = {
{ 0, 5, 8, 10},
{ 5, 0, 1, 7},
{ 8, 1, 0, 3},
{10, 7, 3, 0}};
A.9
B.10
C.11
D.12
【答案】：A
【解析】
计算从起点 0 到终点 3 的最短路，可以使用 dijkstra 或者是 floyd 算法。但由于起点和终点已经确定，因此中间经过的点数至多只有 2 个，完全可以直接暴力搜索去枚举所有情况去计算答案。一共只有以下 5 种情况：
- 0->3，距离为10；
- 0->1->3，距离为5+7=12；
- 0->2->3，距离为8+3=11；
- 0->1->2->3，距离为5+1+3=9；
- 0->2->1->3，距离为8+1+7=16；
其中最短的距离为9。
判断题
第16题
C++语言中，表达式 9 | 12 的结果类型为 int 、值为 13 。
A.正确
B.错误
【答案】：A
【解析】
9的二进制为1001，12的二进制为1100，进行按位或计算之后结果为1101，值为13。
第17题
C++语言中，访问数据发生下标越界时，总是会产生运行时错误，从而使程序异常退出。
A.正确
B.错误
【答案】：B
【解析】
C++标准明确指出，数组下标越界是未定义行为，而未定义行为≠运行时错误。编译器或系统可能不强制检查越界，因此程序可能不会立即崩溃，而是继续运行并产生错误结果。
常见的未定义行为有数组边界外的内存访问、有符号整数溢出、空指针解引用、通过不同类型的指针访问对象等等。
第18题
对 n 个元素的数组进行归并排序，最差情况的时间复杂度为 。
A.正确
B.错误
【答案】：A
【解析】
归并排序每次将要排序的区间进行分半递归，n个元素至多进行 logn 层分半，每一层都会将n 个元素都遍历一次，因此最坏时间复杂度为 O(nlogn)。
第19题
5个相同的红球和4个相同的蓝球排成一排，要求每个蓝球的两侧都必须至少有一个红球，则一共有15种排列 方案。
A.正确
B.错误
【答案】：B
【解析】
相当于蓝球不能出现3个连在一起的情况，那么考虑将蓝球按个数进行分组，有如下几种情况：[1，1，1，1]，[2，1，1]，[1，2，1]，[1，1，2]，[2，2]，即，3，3，3，2组这几种情况。对于每一种情况，要把所有组放入到5个红球形成的6个部分中(每部分可以为空)。可以得到有C(6，4)+3*C(6，3)+C(6，2)种排列方式，显然不等于15。
第20题
使用 math.h 或 cmath 头文件中的函数，表达式 log(8) 的结果类型为 double 、值约为 3 。
A.正确
B.错误
【答案】：B
【解析】
log函数是以e为底的，计算的是一个数的自然对数。log(8)的值为2.079，而log2(8)的值才约为3。
第21题
C++是一种面向对象编程语言，C则不是。继承是面向对象三大特性之一，因此，使用C语言无法实现继承。
A.正确
B.错误
【答案】：B
【解析】
c语言确实没有直接实现继承的语法，但是可以通过结构体嵌套的方式来模拟继承的效果。
第22题
n 个顶点的无向完全图，有 棵生成树。
A.正确
B.错误
【答案】：A
【解析】
根据Cayley(凯莱)公式可以知道n个点的生成树个数为
第23题
已知三个 double 类型的变量 a 、 b 和 theta 分别表示一个三角形的两条边长及二者的夹角（弧度），则三角形的周长可以通过表达式 sqrt(a * a + b * b - 2 * a * b * cos(theta)) 求得。
A.正确
B.错误
【答案】：B
【解析】
题目的式子是根据两边长以及夹角，通过余弦定理来计算第三边c的长度，而非三角形的周长。若要计算周长，还需要加上a和b。
第24题
有 V 个顶点、E 条边的图的深度优先搜索遍历时间复杂度为 。
A.正确
B.错误
【答案】：A
【解析】
在深度优先遍历的过程中，对于当前点u，我们会枚举它的出边来到达它的相邻点，那么最终每个点都会被遍历，并且每条边都会被枚举到，因此时间复杂度是 O(V +E)，即点数+边数。
第25题
从32名学生中选出4人分别担任班长、副班长、学习委员和组织委员，老师要求班级综合成绩排名最后的4 名学生不得参选班长或学习委员（仍可以参选副班长和组织委员），则共有 P(30,4) 种不同的选法。
A.正确
B.错误
【答案】：A
【解析】
先考虑从剩余的28人中选出班长和学习委员，那么有28 * 27种选法。还剩下26人，接下来要选副班长和组织委员。此时原本被排除的4人可以参与选举了，因此有30人，那么有30 * 29种方法选出副班长和组织委员。一共有30 * 29 * 29 * 27 种选择方式，即P(30，4)。
