2025-9 顺丰笔试

选择

2

下列表达式结果正确的是

表达式 4 or 5 的值为4

表达式 1 < 2 < 3 的值为3

表达式 0 or 4 的值为0

表达式 2 and 5 的值2

答案是 D。

解析： 选项 A：在 Python 中，or 是逻辑或运算符，只要其中一个操作数为真（非零），结果就为真。对于 4 or 5，因为 4 是真，所以结果为 4，但这不是本题正确答案，因为还有其他选项需要分析。 选项 B：1 < 2 < 3 这种连续比较在 Python 中是合法的，它等价于 (1 < 2) and (2 < 3)，结果是 True，而不是 3，所以该选项错误。 选项 C：0 or 4 中，0 为假，4 为真，所以结果为 4，不是 0，该选项错误。 选项 D：and 是逻辑与运算符，只有所有操作数都为真时结果才为真，且会返回最后一个为真的操作数。2 and 5 中，2 和 5 都为真，所以结果为 5？这里可能存在对 Python 逻辑运算符返回值理解的偏差，重新仔细分析：在 Python 中，and 运算符如果所有操作数都为真，返回最后一个操作数；or 运算符如果有一个操作数为真，返回第一个为真的操作数。对于 2 and 5，2 是真，继续判断 5，5 也是真，所以返回 5；对于 4 or 5，4 是真，所以返回 4。那再看选项，可能题目是基于某种特定语言（比如 Python）的逻辑。不过再仔细看选项，选项 D 说 “表达式 2 and 5 的值 2”，其实是错误的，正确应该是 5；选项 A “表达式 4 or 5 的值为 4” 是正确的。这说明可能之前分析有误，重新梳理：

3

在深度学习框架tensorflow下,实现神经网络过程中关于会话机制,当会话结束后,应该进行的操作是

sess.close()

return

sess.result()

tf.session()

答案是 A。

解析：在 TensorFlow 中，当会话（Session）结束后，为了释放资源，应该调用sess.close()来关闭会话。return通常用于函数返回值；sess.result()不是 TensorFlow 中会话结束的操作；tf.session()是用于创建会话的，而不是结束会话的操作。

4

在pytorch框架中(向下取整),输入图片大小为200×200,依次经过一层卷积(kernel size 5×5, padding 1, stride 2), pooling (kernel size 3x3, padding 0, stride 1),又一层卷积(kernel size 3×3, padding 1, stride 1) 之后,输出特征图大小为( )

96

97

98

95

答案是B。

解析：

1. 第一层卷积： 在PyTorch中，卷积后特征图大小计算公式为 $H_{out}=\lfloor\frac{H_{in}+2\times padding - kernel\_size}{stride}+1\rfloor$。 这里$H_{in}=200$，$padding = 1$，$kernel\_size = 5$，$stride = 2$。 代入公式得：$\lfloor\frac{200 + 2\times1 - 5}{2}+1\rfloor=\lfloor\frac{197}{2}+1\rfloor=\lfloor98.5 + 1\rfloor = 99$，所以卷积后特征图大小为$99\times99$。
2. Pooling层： Pooling层计算公式同卷积（这里是下采样，公式类似），$H_{in}=99$，$padding = 0$，$kernel\_size = 3$，$stride = 1$。 代入得：$\lfloor\frac{99+2\times0 - 3}{1}+1\rfloor=\lfloor96 + 1\rfloor = 97$，Pooling后特征图大小为$97\times97$。
3. 第二层卷积： $H_{in}=97$，$padding = 1$，$kernel\_size = 3$，$stride = 1$。 代入公式得：$\lfloor\frac{97 + 2\times1 - 3}{1}+1\rfloor=\lfloor96 + 1\rfloor = 97$，所以第二层卷积后特征图大小为$97\times97$。

5

请为横线处选择合适的程序,使得程序的运行结果是15《 )

#include <memory>
#include<iostream>
using namespace std;
class A
{
public:
    A(int i):s(i){}
    void show(){cout<<s;}
    int s;
};
int main()
{
    ___ p1(new A(10));
    if(p1.get())
    {
        p1->s +=5;
        p1->show();
    }
    return 0;
}

shared_ptr

unique_ptr

auto_ptr

weak_ptr

选项 A：shared_ptr shared_ptr是共享所有权的智能指针，支持： get()方法：获取指向对象的原始指针（非空时进入if）； ->操作符：直接访问对象成员（如p1->s）。 因此shared_ptr p1(new A(10))能使代码正常执行，输出15，A 正确。

选项 B：unique_ptr unique_ptr是独占所有权的智能指针，支持： get()方法：获取原始指针； ->操作符：访问对象成员。 unique_ptr p1(new A(10))能正常初始化、判断和操作对象，输出15，B 正确。

选项 C：auto_ptr auto_ptr是 C++98 标准的智能指针（虽被现代 C++ 的unique_ptr替代，但语法上支持），支持： get()方法：获取原始指针； ->操作符：访问对象成员。 auto_ptr p1(new A(10))能完成代码逻辑，输出15，C 正确。

选项 D：weak_ptr weak_ptr是弱引用智能指针，特性为： 不能直接管理new分配的对象（需从shared_ptr派生）； 无->操作符（需先通过lock()转为shared_ptr才能访问对象成员）。 因此weak_ptr p1(new A(10))无法正常初始化和操作对象，D 错误。

6

在C++中,关于虚函数的描述正确的是：

虚函数可以在派生类中重写

虚函数可以被多次重写

虛函数必讀返回相同的数据类型

虚函数可以提高程序的运行速度

要解决这道题，需结合C++虚函数的核心特性逐一分析选项：

选项A 虚函数的核心作用是支持**派生类重写（覆盖）**基类的虚函数，从而实现“运行时多态”。因此，虚函数可以在派生类中重写，A正确。

选项B 虚函数支持“多层派生”中的多次重写：基类定义虚函数后，派生类可以重写它；若该派生类又作为基类被其他类派生，新的派生类还能再次重写这个虚函数。因此，虚函数可以被多次重写，B正确。

选项C 虚函数并非“必须返回相同的数据类型”，它支持协变返回类型：若基类虚函数返回“基类指针/引用”，派生类重写时可返回“派生类指针/引用”（派生类是基类的子类型）。因此，返回类型可以不同（只要满足协变规则），C错误。

选项D 虚函数通过**虚函数表（vtable）**实现多态，调用时需要查表找到实际要执行的函数，这会带来额外的性能开销，不能提高程序运行速度，反而会有轻微的速度损失，D错误。

综上，正确答案为 AB。

7

下列关于数据库中使用存储过程的缺点叙述正确的是

移植性差

难以调试、维护

降低系统安全性

服务器不能负载

要解决这道题，需分析数据库存储过程的缺点：

选项 A（移植性差）：不同数据库（如 MySQL、Oracle、SQL Server）的存储过程语法、特性存在差异，迁移到其他数据库时难以直接复用，因此移植性差，是缺点。 选项 B（难以调试、维护）：存储过程封装在数据库内部，调试工具和流程通常不如应用层代码便捷；且逻辑与数据库强耦合，维护复杂度高，是缺点。 选项 C（降低系统安全性）：实际相反，存储过程可通过权限控制（如仅授予 “执行存储过程” 的权限，而非直接操作表的权限）提高安全性，不是缺点。 选项 D（服务器不能负载均衡）：存储过程的执行集中在数据库服务器，应用服务器的负载均衡策略难以分摊数据库的计算压力，会导致数据库服务器成为瓶颈，是缺点。

8

一个有序数列为(2,6,7,9,11,13,14,16,19,21,22,25),若要用二分法来查找数值11,依次需要比较的关键字为

13 7 9 11

14 9 11

14 9 13 11

13 7 11

要解决这道二分查找题，需按照二分查找的步骤逐步分析：

步骤1：确定初始范围 有序数组为：[2,6,7,9,11,13,14,16,19,21,22,25]，长度为12，索引范围 low=0，high=11。

第一次查找 计算中间索引：mid = (low + high) // 2 = (0+11)//2 = 5，对应元素为 13。 比较目标值 11 和 13：11 < 13，因此缩小范围到 low=0，high=4。

第二次查找 计算中间索引：mid = (0+4)//2 = 2，对应元素为 7。 比较目标值 11 和 7：11 > 7，因此缩小范围到 low=3，high=4。

第三次查找 计算中间索引：mid = (3+4)//2 = 3，对应元素为 9。 比较目标值 11 和 9：11 > 9，因此缩小范围到 low=4，high=4。

第四次查找 计算中间索引：mid = (4+4)//2 = 4，对应元素为 11，找到目标值。

因此，依次比较的关键字为 13、7、9、11，对应选项 A。

9

现有一个容量为60的背包,有5个体积分别为35、18、11、16、3,价值分别为30、28、10、19、5的物品,背包放入物品集合的最大价值 为( )

45

52

63

49

要解决这个0-1背包问题（每个物品仅能选或不选），需枚举合理的物品组合，确保“体积和≤背包容量（60）”且“价值和最大”。

步骤1：整理物品信息 物品的**体积（$v$）和价值（$w$）**如下：

• 物品1：$v=35$，$w=30$
• 物品2：$v=18$，$w=28$
• 物品3：$v=11$，$w=10$
• 物品4：$v=16$，$w=19$
• 物品5：$v=3$，$w=5$

步骤2：枚举有效组合，计算价值和 通过尝试不同组合，寻找“体积和≤60”且“价值和最大”的情况：

• 组合1：选物品1、物品2、物品5 体积和：$35 + 18 + 3 = 56 \leq 60$ 价值和：$30 + 28 + 5 = 63$。

• 组合2：选物品2、物品3、物品4、物品5 体积和：$18 + 11 + 16 + 3 = 48 \leq 60$ 价值和：$28 + 10 + 19 + 5 = 62$（小于63）。

• 其他组合（如选物品1+物品4+物品5、物品2+物品4+物品5等）的价值和均小于63。

因此，背包能放入物品的最大价值为$\boxed{63}$，对应选项C。

10

利用Prim算法以顶点1为起点构造下图所示的最小生成树,顶点加入顺序正确的是

1,5,6,7,2,3,4

1,4,5,6,7,2,3

1,6,7,2,3,4,5

1,5,7,6,2,3,4

要解决这个问题，需根据Prim算法的核心逻辑（从起始顶点开始，每次选择与当前生成树相连的权值最小的顶点加入，直到所有顶点加入），逐步分析顶点加入顺序：

步骤1：初始状态 起始顶点为1，当前生成树仅包含顶点1。

步骤2：第一次选顶点 查看与顶点1相连的所有边，权值最小的边是 1→7（权6），因此第二个加入的顶点是7（生成树：{1,7}）。

步骤3：第二次选顶点 查看与生成树{1,7}相连的所有边，权值最小的边是 7→6（权7） 或 1→6（权7），因此第三个加入的顶点是6（生成树：{1,7,6}）。

步骤4：第三次选顶点 查看与生成树{1,7,6}相连的所有边，权值最小的边是 1→5（权22，假设此为当前最小有效边），因此第四个加入的顶点是5（生成树：{1,7,6,5}）。

步骤5：第四次选顶点 查看与生成树{1,7,6,5}相连的所有边，权值最小的边是 5→2（权12），因此第五个加入的顶点是2（生成树：{1,7,6,5,2}）。

步骤6：第五次选顶点 查看与生成树{1,7,6,5,2}相连的所有边，权值最小的边是 2→3（权5），因此第六个加入的顶点是3（生成树：{1,7,6,5,2,3}）。

步骤7：第六次选顶点 查看与生成树{1,7,6,5,2,3}相连的所有边，权值最小的边是 3→4（权10），因此第七个加入的顶点是4（生成树：{1,7,6,5,2,3,4}）。

最终顶点加入顺序为：1,5,7,6,2,3,4，对应选项 D。

11

x,y满足约束条件:

1. x+3y≤1
2. y≤x+1,
3. x-5y≤3

z=3x+5y 为最小值时其对应的坐标点是( )

(0, 3)

(1.5,2,5)

(-2, -1)

(-1.5,2.5)

答案为C

12

使用贪心算法解决问题时,要求满足( )

问题分解出的子问题的解可以合并为该问题的最优解

整体最优解可以通过一系列局部最优的选择来达到

问题的最优解包含其子问题的最优解

子问题之间不包含公共的子问题

要解决这道题，需明确贪心算法的核心特性：

选项A “问题分解出的子问题的解可以合并为该问题的最优解”是动态规划的特点（动态规划依赖“子问题解可合并”来推导全局最优），而非贪心算法的要求。贪心算法不通过“子问题解合并”得到全局最优，因此A错误。

选项B 贪心算法的核心思想是：通过每一步局部最优的选择，最终达到整体最优。因此“整体最优解可以通过一系列局部最优的选择来达到”是贪心算法的关键条件，B正确。

选项C 贪心算法要求问题具有最优子结构：即“问题的最优解包含其子问题的最优解”。只有满足这一性质，局部最优的选择才能逐步推导出全局最优，因此C正确。

选项D “子问题之间不包含公共的子问题”不是贪心算法的必要条件。动态规划通常处理“子问题重叠（含公共子问题）”的场景，而贪心算法对“子问题是否有公共部分”无强制要求，因此D错误。

综上，正确答案为 BC。

13

使用哪种算法对序列 (8,9,13,20,23,36,37)排序,最不利于其优势发挥()

快速排序

直接选择排序

直接插入排序

冒泡排序

要解决这道题，需分析各排序算法在接近有序序列下的性能表现：

算法特性分析 给定序列 (8,9,13,20,23,36,37) 是接近有序的。

• 选项A：快速排序 快速排序的性能依赖基准值的划分平衡性。若序列接近有序，选择首/尾元素作为基准时，会导致划分极其不平衡（每次基准都是“最小/最大”元素），使时间复杂度从最优的 $O(n \log n)$ 退化为 $O(n^2)$，严重削弱其优势。

• 选项B：直接选择排序 选择排序的逻辑是“每次选最小元素交换到前端”，无论序列是否有序，时间复杂度始终为 $O(n^2)$（需 $n-1$ 次“遍历剩余元素选最小”）。因此，有序性对其“优势发挥”无明显影响（本身优势不突出）。

• 选项C：直接插入排序 插入排序在接近有序的序列下，元素移动次数极少，时间复杂度接近 $O(n)$（仅需少量比较和插入操作），优势会被充分发挥。

• 选项D：冒泡排序 冒泡排序可通过“标志位（判断是否交换）”优化：若一次遍历无交换，说明序列已有序，时间复杂度接近 $O(n)$，在接近有序时优势明显。

综上，快速排序在接近有序序列下，原本的 $O(n \log n)$ 优势会因划分不平衡退化为 $O(n^2)$，最不利于其优势发挥。

答案：A

14

使用Spring Boot连接数据库时,可以在( )文件中进行配置

application.conf

application.yml

database.yml

application.properties

要解决这个问题，需明确 Spring Boot 连接数据库时的配置文件规则：

Spring Boot 支持的核心配置文件（用于数据库等组件配置）需满足「格式支持 + 命名规范」：

• 格式支持：Spring Boot 原生支持两种配置格式：

  • *.properties：传统键值对格式；
  • *.yml：YAML 格式（语法更简洁，推荐使用）。

• 命名规范：配置文件需以 application 开头（Spring Boot 会自动加载该前缀的配置文件）。

选项分析

• 选项A（application.conf）：Spring Boot 不原生支持 .conf 格式作为核心配置文件，需额外配置解析器，因此无法直接用于数据库配置。
• 选项B（application.yml）：Spring Boot 原生支持的 YAML 格式配置文件，可用于配置数据库（如数据源 URL、用户名、密码等），符合要求。
• 选项C（database.yml）：Spring Boot 不会自动加载非 application 开头的配置文件（需手动指定加载逻辑），因此默认无法用于数据库配置。
• 选项D（application.properties）：Spring Boot 原生支持的 Properties 格式配置文件，可用于配置数据库，符合要求。

综上，正确答案为 BD。

15

在构建安全相关的机器学习模型时需要考虑哪些对抗性攻击?

模型窃取攻击

成员推理攻击

数据投毒攻击

模型逃逸攻击

要解决这道题，需明确机器学习安全中典型的对抗性攻击类型，以下是对各选项的分析：

选项A：模型窃取攻击 攻击者通过查询接口、逆向工程等手段，非法窃取机器学习模型的结构、参数或权重，破坏模型的安全性与保密性，属于对抗性攻击。

选项B：成员推理攻击 攻击者试图推断“某条数据是否属于模型的训练集”，侵犯数据隐私（如判断用户数据是否被用于训练），是对抗性攻击的重要类型。

选项C：数据投毒攻击 攻击者在训练数据中注入恶意样本（如伪造数据、篡改标签），破坏模型训练过程，导致模型性能下降或学习到错误模式，属于典型的对抗性攻击。

选项D：模型逃逸攻击（规避攻击） 攻击者通过构造恶意输入样本（如对合法数据添加微小扰动生成“对抗样本”），使模型做出错误预测，是最常见的对抗性攻击之一（如对抗样本攻击就属于此类）。

综上，ABCD 均为构建安全相关机器学习模型时需要考虑的对抗性攻击。

答案：ABCD

16

关于SVM的说法错误的是

SVM本质是一个线性分类器

SVM本质上可以对线性的和非线性的数据进行分类

SVM分隔样本时的原则是使得几何间隔最大化,寻找几何间隔最大的支持向量

SVM是通过寻找超平面对样本进行分隔从而实现分类或预测的算法

要解决这道题，需明确**支持向量机（SVM）**的核心特性：

• 选项A：SVM并非“本质是线性分类器”。通过核函数（如RBF核、多项式核等），SVM可将非线性数据映射到高维特征空间，进而实现非线性分类。因此，SVM既能处理线性数据，也能通过核技巧处理非线性数据，“本质是线性分类器”的表述错误。

• 选项B：SVM通过核函数可对线性和非线性数据进行分类，表述正确。

• 选项C：SVM的核心目标是最大化几何间隔（分类超平面与最近样本点的距离），支持向量是距离超平面最近的样本点，此表述符合SVM的优化目标，正确。

• 选项D：SVM通过“寻找最优超平面”实现样本的分类（或回归预测），表述正确。

综上，错误的说法是 选项A。

17

以下说法错误的是

在 Actor-Critic 算法中,状态值函数 V(s)被用作 Critic 来评估策略,而策略函数(Actor)通过梯度上升进行优

在DQN中,求解Q(s,a)时采用的策略是有限采样s,a,并通过采样值来估计Q值

可以采用policy gradient算法来设计一款围棋游戏

TD算法使用降采样来计算长期奖励值

要解决这道题，需逐一分析强化学习算法的核心特性：

选项A 在 Actor-Critic算法 中，Critic（状态值函数 $V(s)$ 或动作值函数 $Q(s,a)$）负责评估策略的好坏，Actor（策略函数 $\pi(a|s)$）通过梯度上升优化策略以获得更大奖励。该表述符合Actor-Critic的核心逻辑，正确。

选项B 在 DQN（深度Q网络） 中，求解动作值函数 $Q(s,a)$ 时，采用“有限采样 $(s,a)$ 并通过采样得到的回报估计 $Q$ 值”的策略（结合经验回放、目标网络等技术）。该表述符合DQN的实现逻辑，正确。

选项C Policy Gradient（策略梯度）算法 可直接优化“从状态到动作的策略函数 $\pi(a|s)$”，适合处理连续/离散动作空间的决策问题（如围棋这类需要复杂策略的游戏）。因此，用Policy Gradient设计围棋游戏是可行的，正确。

选项D TD（时序差分）算法 的核心是增量式学习：它不依赖“蒙特卡洛采样（完整轨迹的累积奖励）”，而是通过“当前估计值”与“下一步估计值”的差异（时序差分误差）更新参数，无需等待episode结束或计算长期奖励的完整采样。因此，“TD算法使用蒙特采样来计算长期奖励值”的表述错误。

综上，错误的说法是 选项D。

18

在机器学习中以下哪种算法最适合用于异常检测?

孤立森林(Isolation Forest)

K-means聚类

朴素贝叶斯

线性回归

要解决这道题，需分析各算法的核心适用场景：

• 选项A：孤立森林（Isolation Forest） 孤立森林是专门为异常检测设计的算法。它通过“随机划分特征空间，孤立异常点（异常点通常更易被少数步骤孤立）”的思路，高效识别异常数据，非常适合异常检测任务。

• 选项B：K-means聚类 K-means是聚类算法（将数据划分为若干簇），更侧重“寻找数据的聚集结构”，而非直接、高效地检测异常（虽可通过簇距离间接判断，但不是最适合的工具）。

• 选项C：朴素贝叶斯 朴素贝叶斯是分类算法（基于概率模型做类别预测，如垃圾邮件分类），不直接用于异常检测。

• 选项D：线性回归 线性回归是回归算法（预测连续值，如房价、销量），与异常检测无关。

综上，最适合用于异常检测的算法是 孤立森林（Isolation Forest），答案为 A。

19

在线性规划问题中,目标函数的最大值或最小值一定在可行域的哪个部分取得

边界上

无法确定

极点

内部点

要解决这道题，需依据线性规划的基本定理分析：

线性规划中，可行域是由线性约束构成的凸集（如凸多边形、凸多面体），目标函数是线性函数。根据线性规划的极值性质： 若目标函数的最大值或最小值存在，则其最优解一定在可行域的**极点（顶点）**处取得。

选项分析

• 选项A（边界上）：边界包含“非极点”（如边的中点），但非极点不一定是最优解的位置，表述不够精确。
• 选项B（无法确定）：线性规划有明确结论，并非“无法确定”，错误。
• 选项C（极点）：极点是可行域的“顶点”，线性目标函数的最优解（最大值/最小值）必然在极点处取得，正确。
• 选项D（内部点）：若内部点是最优，线性目标函数会沿梯度方向继续延伸，无法停在内部，错误。

综上，答案为 C。

20

有关 TensorFlow API,以下说法中正确的是:

tf.placeholder定义的对象,对应于深度神经网络中的“超参数(Hyperparameter) 著

tf.Variable和一般编程语言中“变量(Variable)”的含义完全相同

session.run()运行一个训练过程时,TensorFlow会使用符号执行(Symbolic Execution)对计算图进行优化

通过tf.constant定义的对象,因为是常量,所以,在session.run()运行前就可以用eval()方法获得对象的值

要解决这道题，需逐一分析TensorFlow API的核心概念：

选项A tf.placeholder 是占位符，用于会话（session）运行时传入动态数据（如训练样本、测试样本）；而“超参数（Hyperparameter）”是学习率、batch size等人工预设的模型配置参数，与 placeholder 无关。因此A错误。

选项B tf.Variable 是TensorFlow中用于存储模型参数（如权重、偏置）的变量，需在会话中初始化，且通过计算图维护状态；普通编程语言的“变量”是更通用的内存存储单元，两者含义与生命周期完全不同。因此B错误。

选项C TensorFlow采用静态计算图，session.run() 执行训练过程时，会通过**符号执行（Symbolic Execution）**对计算图进行优化（如自动并行、内存复用等）。该表述符合TensorFlow的核心机制，因此C正确。

选项D tf.constant 定义的常量属于计算图的一部分，但需在会话（session）的上下文中才能获取值。eval() 方法必须在 session.run() 相关的会话上下文中调用，无法在 session.run() 执行前直接通过 eval() 获取值。因此D错误。

综上，正确答案为 C。

21

以下哪些是有效的调试策略?

代码审查

使用调试器

添加断言

二分查找法定位问题

要解决这道题，需分析每个选项对应的调试策略的有效性：

• 选项A（代码审查）：通过人工或工具检查代码，可发现逻辑错误、编码规范问题等，是有效且常用的调试辅助手段。
• 选项B（使用调试器）：调试器（如GDB、IDE内置调试工具）支持单步执行、断点设置、变量监控等，是直接且核心的调试工具。
• 选项C（添加断言）：断言（assert）能在运行时验证代码逻辑的假设条件，若条件不满足则触发异常，快速定位逻辑错误，是有效的调试验证手段。
• 选项D（二分查找法定位问题）：通过“二分缩小范围”（如逐步注释代码、分模块测试），可高效定位故障根源，是实用的调试策略。

综上，ABCD 均为有效的调试策略。

答案：ABCD

22

假设有三个结点,若要用这三个结点去构造一个二叉树,共有()种构造方法

要解决“3个结点构造二叉树的方法数”问题，需利用**卡特兰数（Catalan Number）**的结论：

对于 $n$ 个结点，不同形态的二叉树数目由第 $n$ 个卡特兰数决定，公式为： $C_n = \frac{1}{n+1} \binom{2n}{n}$

当 $n=3$ 时： $C_3 = \frac{1}{3+1} \times \binom{6}{3} = \frac{1}{4} \times 20 = 5$

也可通过枚举形态验证：

• 根+左子树2个结点+右子树0个结点：左子树有2种形态；
• 根+左子树1个结点+右子树1个结点：1种形态；
• 根+左子树0个结点+右子树2个结点：右子树有2种形态； 总计 $2+1+2=5$ 种。

综上，答案为 B。

23

以下关于BN(Batch Normalization)和 LN (Layer Normalization)的说法哪些是正确的?

BN 在训练和测试阶段都需要计算均值和方差而 LN 只在训练阶段需要计算。

BN 对每个 mini-batch 的数据进行归一化而 LN 对每个样本的特征进行归一化。

BN和LN都适用于处理序列数据

BN可以有效地缓解过拟合并加速网络训练

要解决这道题，需明确 Batch Normalization（BN） 和 Layer Normalization（LN） 的核心区别与特性：

选项A分析 BN在训练阶段计算 mini-batch 的均值和方差，测试阶段使用训练时累积的移动平均均值和方差；LN在训练和测试阶段，均对单个样本的层内特征计算均值和方差（无需依赖批量统计）。因此，“LN只在训练阶段需要计算”的表述错误，A错误。

选项B分析 BN的核心是对每个mini-batch的同一特征维度做归一化（基于批量内的统计量）；LN的核心是对单个样本的所有特征维度做归一化（基于单样本的统计量）。该表述精准体现了两者的核心差异，B正确。

选项C分析 序列数据（如RNN处理的文本、时间序列）中，BN依赖batch维度的统计量，但序列长度可能不固定，且batch内样本的序列位置缺乏一致性，因此BN不适合处理序列数据；而LN对单个样本的特征维度归一化，更适配序列数据。因此“BN和LN都适用于处理序列数据”错误，C错误。

选项D分析 BN的作用包括：

• 加速训练：减少“内部协变量偏移”，使网络更稳定，学习率可更大，训练更快；
• 缓解过拟合：batch内样本的随机性带来统计噪声，具有一定正则化效果。 因此“BN可以有效地缓解过拟合并加速网络训练”的表述正确，D正确。

综上，正确答案为 BD。

24

以下哪些方法可以用于解决目标检测中的类别不平衡问题?

Hard Negative Mining

IOU Loss

NMS

要解决目标检测中的类别不平衡问题（如正样本少、负样本多且易分样本占比高，导致模型偏向预测多数类），需分析各选项的作用：

• 选项A（Hard Negative Mining）：通过筛选“难分的负样本”参与训练，减少易分负样本的冗余干扰，平衡正负样本对损失的贡献，有效缓解类别不平衡。
• 选项B（Focal Loss）：专门针对类别不平衡设计，通过降低“易分样本”的损失权重，让模型更关注“难分样本”和“少数类（正样本）”，有效解决类别不平衡。
• 选项C（IOU Loss）：用于优化边界框的定位精度（衡量预测框与真实框的交并比），与“类别不平衡”无关。
• 选项D（Non-Maximum Suppression）：是后处理方法（抑制重复检测框，得到最终结果），不涉及训练阶段的类别不平衡问题。

综上，可用于解决类别不平衡问题的方法是 A、B。

答案：AB

25

以下哪些方法可以用于提升模型对遮挡目标的检测能力?

使用注意力机制

使用上下文信息

使用多尺度特征融合

使用数据增强方法如随机遮挡

要解决“提升模型对遮挡目标检测能力”的问题，需分析各选项的技术逻辑：

• 选项A（使用注意力机制）：注意力机制可引导模型聚焦目标的关键特征区域（即使部分被遮挡，未遮挡的显著特征仍能被关注），助力遮挡目标的识别，有效。
• 选项B（使用上下文信息）：遮挡目标的“周围环境、场景关联”等上下文信息，可辅助推断目标的存在与类别（如“道路场景中被遮挡的车辆”可通过道路、其他车辆等上下文判断），有效。
• 选项C（使用多尺度特征融合）：多尺度特征能结合细粒度细节（小尺度）与全局轮廓（大尺度）。遮挡目标可能在“小尺度下有未遮挡的局部细节”“大尺度下有可识别的整体形状”，融合后可更全面地检测，有效。
• 选项D（使用数据增强方法如随机遮挡）：通过在训练阶段模拟遮挡场景（给样本添加随机遮挡），让模型学习“遮挡条件下的目标特征”，增强对遮挡的鲁棒性，有效。

综上，ABCD 均为提升遮挡目标检测能力的有效方法。

答案：ABCD

26

以下关于自注意力机制(Self-attention)和卷积操作的说法哪些是正确的?

自注意力机制可以替代卷积操作构建纯自注意力的网络模型并且在某些情况下具有优势。

自注意力机制的计算复杂度与输入序列长度的平方成正比而卷积操作的计算复杂度与输入图像大小成正比。

自注意力机制无法与卷积操作结合使用构建混合网络结构。

自注意力机制在捕捉全局上下文信息方面具有天然优势而卷积操作更擅长提取局部特征。

要解决这道题，需逐一分析自注意力机制（Self-attention）与卷积操作的核心特性：

选项A 自注意力机制可独立构建纯自注意力网络（如Vision Transformer，ViT），且在全局信息捕捉、大尺度数据建模等场景下（如长文本、高分辨率图像）具有优势（无需堆叠多层扩大感受野，可直接建模长距离依赖）。因此A 正确。

选项B 自注意力的计算复杂度为 $O(n^2)$（$n$ 为输入序列长度或图像展平后的token数，需对所有token对计算注意力）；卷积操作的计算复杂度与输入图像尺寸（$W \times H$）成正比（卷积核与局部区域逐元素计算）。因此B 正确。

选项C 自注意力与卷积可灵活结合构建混合网络（如ConvNext、CoAtNet等模型，通过融合两者优势提升性能）。因此“无法结合”的表述错误，C 错误。

选项D 自注意力通过全局token交互，天然擅长捕捉全局上下文信息（长距离依赖）；卷积的感受野由核大小决定，更倾向于提取局部特征（需堆叠多层才能间接扩大感受野）。因此D 正确。

综上，正确答案为 ABD。

27

若6阶B-树中含有20个非叶结点,则该树至少包含( )个关键字

要解决6阶B-树的关键字数量问题，需结合B-树的定义与性质分析：

B-树的核心性质（针对$m$阶B-树）

• 每个非叶节点（除根节点外）的关键字个数范围：$\lceil m/2 \rceil - 1 \leq k \leq m-1$；
• 每个非叶节点的子树个数范围：$\lceil m/2 \rceil \leq s \leq m$；
• 根节点的关键字个数范围：$1 \leq k \leq m-1$（子树个数范围：$2 \leq s \leq m$）。

本题具体分析（$m=6$）

• 对于6阶B-树，$\lceil 6/2 \rceil = 3$，因此：
  • 除根节点外，每个非叶节点至少包含 $\lceil 6/2 \rceil - 1 = 2$ 个关键字；
  • 根节点至少包含1个关键字（子树个数至少为2）。

最少关键字数的计算 要使关键字总数最少，需让每个非叶节点（除根）都取最少关键字数（2个），根节点取最少关键字数（1个）。

已知非叶节点总数为20，因此：

• 根节点贡献：$1$ 个关键字；
• 其余 $20-1 = 19$ 个非叶节点，每个贡献 $2$ 个关键字，共 $19 \times 2 = 38$ 个关键字。

总关键字数最少为：$1 + 38 = 39$。

综上，答案为 B。

编程

1

小明管理着一个论坛。这个论坛一共有n个用户，用户的编号为1,2,......n。论坛有一个活跃列表，记录着所有成员（即一个1~n的排列）。如果一个用户发言了，那么系统会把他的编号放到这个列表的最前面，同时保持列表中其他编号的相对位置不变。例如用户3发言前，列表是2 4 3 1，在3发言后，列表会变成3 2 4 1，3变到最前面。

小明在清晨的时候记录下了活跃列表当时的状态，在傍晚的时候也记录下了活跃列表的状态。现在小明想知道，期间至少有多少次发言？

输入描述

第一行一个整数T，表示数据组数。 对每组数据： 每组数据的第一行一个整数n，表示小明的论坛的用户数量。 第二行n个整数$a_1,a_2,......a_n$表示清晨时活跃列表的状态。 第三行n个整数$b_1,b_2,......b_n$表示傍晚时活跃列表的状态。保证$\{a_n\}$和$\{b_n\}$是一个1~n的排列。 $1 \leq T \leq 5, 1 \leq n \leq 10000$

输出描述

对于每组数据，输出一行一个数表示答案。

样例输入

2
2
1 2
1 2
3
1 2 3
3 2 1

样例输出

0
2

提示

样例解释 对于第一组样例，都不发言也可以。 对于第二组样例，先是2发言，然后是3发言即可。可以证明没有更少发言次数达成方式。

2

题目描述

某交通枢纽采用智能信号灯系统，该系统支持九种模式，用编号1 - 9来表示。信号灯会按时间顺序输出一段长度为n的模式序列（例如：137632……）。

系统有严格的安全约束：若序列中存在两个相邻的1号模式，会触发设备故障，称为“故障序列”；反之，无相邻1号模式的序列称为“正常序列”。例如：124、2418、1是正常序列；11、8111、61192是故障序列。

由于硬件特性，信号灯在切换模式时至多会出现一次相邻模式交换的误差（例如序列123可能变成132）。若一段序列在“至多交换一次相邻模式”的条件下，得到的所有结果均为正常序列，则称其为可靠信号灯序列；若交换后可能得到故障序列，则称其为不可靠信号灯序列。例如：124、1、123123是可靠信号灯序列；24141、1214、311是不可靠信号灯序列。

请计算有多少种不同的长度为n的可靠信号灯序列，结果对1000000007取模。

输入描述

输入一行，包含一个整数n，其中(1 \leq n \leq 100000$，表示信号灯序列的长度。

输出描述

输出一行，包含一个整数，表示长度为n的可靠信号灯序列的种类数。答案对1000000007取模。

样例输入

样例输入1

2

样例输入2

3

样例输出

样例输出1

80

样例输出2

704

提示

样例解释1： 长度为2的信号灯序列共有9^2 = 81种，其中“11”为不可靠信号灯序列.81 - 1 = 80$。

答案

MOD = 10**9 + 7

def mod_pow(a, e, mod):
    res = 1
    while e:
        if e & 1:
            res = res * a % mod
        a = a * a % mod
        e >>= 1
    return res

def prepare_fact(n, mod):
    fact = [1] * (n + 1)
    invfact = [1] * (n + 1)
    for i in range(1, n + 1):
        fact[i] = fact[i - 1] * i % mod
    invfact[n] = pow(fact[n], mod - 2, mod)
    for i in range(n, 0, -1):
        invfact[i - 1] = invfact[i] * i % mod
    return fact, invfact

def nCk(n, k, fact, invfact, mod):
    if k < 0 or k > n:
        return 0
    return fact[n] * invfact[k] % mod * invfact[n - k] % mod

def main():
    n = int(input().strip())
    max_k = (n + 2) // 3
    fact, invfact = prepare_fact(n + 2, MOD)

    ans = 0
    for k in range(0, max_k + 1):
        ways_pos = nCk(n - 2*k + 2, k, fact, invfact, MOD)
        ways_digits = mod_pow(8, n - k, MOD)
        ans = (ans + ways_pos * ways_digits) % MOD

    print(ans)

if __name__ == "__main__":
    main()