【算法刷题-题解】2024_09_18_联想24年春招-人工智能方向试卷(44-100)

# 共45题目：
# 43选择题
# 2算法题目：1.回文字符串重构 2.毛毛虫

涉及知识点：
    卷积核运算
    经典卷积神经网络结构
    OCR技术和图像预处理技术
    隐马尔可夫模型
    遗传算法/粗糙集理论/模糊集理论/主动学习
    
    逻辑斯蒂方程
    SQL
    
    数据库
    数据结构：树/
    

3.SegNet的编码器部分使用的是（A）中的前13层卷积网络，每个编码器层都对应一个解码器层。
AVGG16

BAlexNet

CGooglNet

DVGG19

SegNet：
    发表于CVPR2015，编码器网络由13个卷积层组成，对应于VGG16的前13个卷积层
    丢弃了VGG16的全连接层。将13个卷积层和5个池化层划分为5个编码器。
    单个编码器的组成部分：
        滤波器组
        BN层
        非线性层：ReLU
        最大池化层：2x2
VGG16和VGG19：
    区别在于网络深度不一样
    VGG16：
        16个隐藏层
        采用连续的3x3卷积替代AlexNet中的较大卷积核（11x11，7x7，5x5）
    VGG19：
        19个隐藏层
AlexNet：
   输入为224x224x3的图像，也可填充为227x227x3
    共包含5个卷积层（包含卷积核+偏置层+Relu激活函数+局部相应归一化LRN）+3个全连接层+Softmax输出层
    首个真正意义上的深度卷积神经网络
    局部响应归一化LRN：
        计算每个特征图上每个位置，计算该位置周围像素的平方和
        然后将当前位置的像素除以这个和
        作用：抑制邻近神经元的响应，一定程度上避免过拟合，提高网络泛化能力
    引入了数据增强+Dropout的技术：
        Dropout：在前向传播中，让某个神经元以p概率停止工作
GooglNet：
    引入了Inception结构，可以融合不同尺度的特征信息
    降维功能：在部分分支增加了1x1的卷积层，减小深度，减少计算量
    3个输出层，其中两个是辅助分类层

9.下列关于文字识别技术中图像预处理方法的说法正确的是？B
A
图像灰度化主要用于去除图像的背景信息
B
规范化是为了消除文字点阵位置上的偏差
C
二值化主要目的是去除彩色图像中的干扰信息
D
Huogh变换也是一种最常用的倾斜检测方法，将图像中的前景像素映射到双曲空间

解析：
图像二值化：
    将像素点的灰度值设置为0或者255，
    优势：减少数据维度，排除原图中噪声带来的干扰，凸显有效区域的轮廓结构
倾斜角检测和矫正：
    霍夫变换Hough:
        可以根据给定的图像提取直线
        有助于将图像中的直线定位和提取
    Radon变换：以线积分的形式将图像投影到（s，θ）空间

12.
输⼊图⽚⼤⼩为200×200，
依次经过⼀层卷积（kernel size 5×5，padding 1，stride 2），
pooling（kernel size 3×3，padding0，stride 1），
⼜⼀层卷积（kernel size 3×3，padding 1，stride 1）之后，
输出特征图⼤⼩为：C
A
95
B
96
C
97
D
98

卷积计算公式：（original_size - kernel_size + 2 * padding）/stride + 1
特征图尺寸减半：723和321
    Conv2d(kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
特征图尺寸不变：110和311
    Conv2d(kernel_size=(1, 1), stride=(1, 1), bias=False)   # k = 1,  s = 1,  p = 0
    Conv2d(kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)  # k = 3, s = 1, p = 1

13.
应用隐马尔可夫模型进行语音识别时，隐含状态是（C ）
A
语音信号
B
文字之间的转移概率
C
文字序列
D
声波信息

隐马尔可夫模型：Hidden_markov_model,HMM
    是关于时序的概率模型，有向图模型，考虑联合概率分布
    描述了：
        由一个隐藏的马尔可夫链随机生成不可观测的状态序列，
        再由各个状态生成观测从而产生观测序列的过程
    简言之：可以看作是一个状态序列和观测序列的生成器
    状态序列：
        隐藏的马尔可夫链随机生成的状态序列，每个状态代表一个可能性
    观测序列:
        每个状态生成一个观测，观测指：对状态的一种表现形式或者输出
    用途：
        自然语言处理：语音识别和机器翻译，HMM常用于处理时序数据和建模状态转换
        生物信息学：基因组测序和蛋白质结构预测领域，用于描述序列的模式和结构变化
        金融市场预测：预测股票价格和趋势分析，描述价格的动态变化
   

14.
以下说法中不正确的是（  B    ）
A
在遗传算法中，规则总体通过交叉和变异操作“进化”，直到总体中所有的规则都满足指定的阈值
B
粗糙集理论可以用来近似地定义类，这些类基于可用的属性是可区分的
C
模糊集方法用隶属度函数替换连续值属性的“脆弱的”阈值
D
主动学习适合数据丰富、但类标号稀缺或难以获得的情况


粗糙集理论（Rough Set）：
    是处理不精确/不确定和不完全数据的有效数学工具
    研究对象是决策表（或信息表），不需要额外的先验知识来分析数据
    研究集合/或决策表/或矩阵
    主要思想：在保持分类能力不变的前提下，通过知识约简，导出问题的决策或分类规则
    错误原因：
    粗糙集理论用于处理不确定性和不完备性信息。
    它通过近似的方式定义类，主要通过上下近似集来区分不可分辨的对象。
    但这些类的可区分性并非基于所有可用属性，而是基于特定的决策属性子集。
    因此“基于可用的属性是可区分的”这一说法过于绝对。

遗传算法：
    通过交叉（crossover）和变异（mutation）操作来使种群进化的，
    但遗传算法不一定保证所有个体都能满足某个特定的阈值。
    遗传算法是基于适应度函数选择最优解，而不是让所有个体都达到相同的阈值。
    
模糊集理论：
    通过隶属度函数对元素进行分类，克服了传统集合的硬边界问题。
    特别是在连续值属性中，
    模糊集提供了一个更灵活的方式来处理阈值的定义，从而避免了“脆弱的”阈值问题。
    
主动学习：
    是一种适用于标注数据稀缺或标注代价较高的情况下的机器学习方法。
    它通过选择最有代表性或最具信息量的样本进行标注，从而降低标注成本。
    该方法特别适用于类标签稀缺或难以获得的情况。

15.
偏差较大，方差较小说明（A）
A
模型欠拟合
B
模型过拟合
C
所选取的交叉验证方法不准确
D
数据中含有大尺度噪声

偏差较大、方差较小的情况通常说明模型的复杂度不足，无法很好地拟合数据的模式。
    偏差较大：模型对训练数据的拟合能力不足，无法准确捕捉数据中的模式，通常表明模型欠拟合。
    方差较小：模型在不同的数据集上表现较为稳定，说明模型不太敏感于数据集的变化。
过拟合的模型通常表现为方差较大
交叉验证方法影响模型性能评估，但不会直接导致偏差大或方差小的问题。
大尺度噪声通常会增加方差

16.
以下关于模型准确率的说法正确的是（C）
A
准确率越高越好
B
准确率是评价模型性能的主要标准
C
训练准确率为100%可能已经发生了过拟合
D
测试准确率达到100%标志着模型训练成功

准确率高并不总是好事，尤其是在不平衡数据集中。
例如，如果90%的样本属于一个类，简单地预测所有样本为该类就能达到90%的准确率，
但模型并没有实际学习到数据的有用模式。因此，准确率并不是唯一的衡量标准。

准确率虽然是常用的指标，但在数据不平衡的情况下，它可能具有误导性。
对于此类问题，常用的评价指标包括精确率（Precision）、召回率（Recall）和F1分数等。

当训练集的准确率达到100%，模型可能记住了训练数据的每个细节，而不是学到了数据的通用模式，
这往往表明模型可能已经过拟合。

测试准确率达到100%有时可能是因为测试集较小或简单，不能充分代表实际数据。因此，
测试准确率达到100%并不一定意味着模型训练成功，可能也表明模型过拟合或数据分布异常。

17.
逻辑斯蒂方程( Logistic Equation) 不适用解决下列哪种问题（  C    ）
A
商品预测销售问题
B
人口限制增长问题
C
商品多分类问题
D
信息传播问题

逻辑斯蒂方程（Logistic Equation）：
    主要用于描述具有增长限制的现象，
    它可以用于处理两类问题（如二元分类），或者用于描述类似人口增长或资源有限的系统。
    它不适合用于多分类问题。
    
    在一定条件下，逻辑斯蒂方程可以用于预测商品销售的增长，
    尤其是当销售受到市场饱和等限制时
    
    逻辑斯蒂方程经典应用之一就是用于描述人口在资源有限情况下的增长，符合其模型特点。
    
    逻辑斯蒂方程（Logistic Equation）通常用于二元分类问题（例如逻辑回归），
    而多分类问题（多个类别）通常需要其他扩展模型，如Softmax回归或多分类逻辑回归。
    
    逻辑斯蒂方程可以用来描述信息传播的过程，
    特别是当传播存在一定限制（如信息接受者的上限）时。

18.
如果希望用CA证书验证证书签名，则需要（  B    ）选项
A
require ssl
B
require x509
C
require issuer
D
require subject

要使用 CA证书验证证书签名，需要验证证书的合法性以及它是否由受信任的证书颁发机构（CA）签发。
验证过程与 X.509 标准证书结构有关，其中包含了证书的签名和其他关键信息。
使用 require x509 是用于检查证书的合法性和签名。

19.
以下语句使用PreparedStatement接口向mysql数据库中插入成功插入数据：
String sql="insert into users(username,password,age) values(?,?,?)";
PreparedStatement ps=conn.prepareStatement
(sql);
ps.setNString(1,"lisi");
ps.setString(2,"123456");
ps.setInt(3,24);
ps.executeUpdate();
试问，执行sql语句ps.executeUpdate()的返回值是：( B )

A
0
B
1
C
true
D
FALSE

在执行 PreparedStatement 的 executeUpdate() 方法时，
返回值表示受影响的行数。当成功插入一条记录时，返回值为 1，表示有一行数据被插入。

20.
以下SQL语句不可能返回null的是：（ C ）
A
select min(col1) from t1
B
select max(col1) from t1
C
select count(col1) from t1
D
select concat('max=', max(col1)) from t1

A. select min(col1) from t1
可能返回 NULL。如果 t1 表中 col1 全部为 NULL 或表为空，min(col1) 会返回 NULL。

B. select max(col1) from t1
可能返回 NULL。与 min(col1) 类似，如果 t1 表中 col1 全部为 NULL 或表为空，max(col1) 会返回 NULL。

C. select count(col1) from t1
不可能返回 NULL。count(col1) 返回的是 col1 中非 NULL 值的数量，即使没有任何非 NULL 数据，它也会返回 0，
而不是 NULL。

D. select concat('max=', max(col1)) from t1
可能返回 NULL。如果 max(col1) 结果为 NULL，那么 concat 函数在遇到 NULL 时也会返回 NULL。

21.
设有职工基本表：职工（职工号，姓名，年龄，月工资，部门号，电话，办公室）。
如果查询每个部门中月工资最高的“职工号”，那么下面SQL语句正确的是：（ A ）
A
select 职工号 from 职工 as a where 月工资=(select max(月工资) from 职工 as b where
a.部门号=b.部门号)
B
select 职工号 from 职工 as a where 月工资=(select max(月工资) from 职工 as b )
C
select 职工号 from 职工 as a where max(月工资)
D
select 职工号 from 职工 as a where max(月工资) from 职工 as b where
a.部门号=b.部门号

题目解析：
要查询每个部门中月工资最高的“职工号”，正确的 SQL 语句应满足以下两个条件：
    按部门号进行分组。
    找到每个部门内月工资最高的职工。

A. select 职工号 from 职工 as a where 月工资 = (select max(月工资) from 职工 as b where a.部门号 = b.部门号)
    正确。这条 SQL 语句是正确的。它通过子查询来查找每个部门内月工资最高的职工，并返回对应的职工号。
    where a.部门号 = b.部门号 用来确保子查询只针对相同部门号的数据。
    
B. select 职工号 from 职工 as a where 月工资 = (select max(月工资) from 职工 as b)
    错误。这条 SQL 会返回全公司月工资最高的职工号，而不是每个部门中的最高工资职工，因为子查询没有按部门号进行过滤。

select 职工号 from 职工 as a where max(月工资)
    错误。max(月工资) 是聚合函数，不能直接在 where 子句中使用。应该在 group by 或子查询中使用。

D. select 职工号 from 职工 as a where max(月工资) from 职工 as b where a.部门号 = b.部门号
    错误。语法不正确，max(月工资) 不能直接放在 where 子句中使用。这个语句在语法结构上是无效的。

22.
下列哪个范式级别最高（ D     ）
A
1NF
B
2NF
C
3NF
D
BCNF

范式是数据库设计中用于减少数据冗余和避免数据异常的一系列规则。
每个范式级别比前一个要求更严格，适用于更优化的设计。
根据范式的定义，级别从低到高的顺序是：1NF、2NF、3NF、BCNF。
BCNF（Boyce-Codd Normal Form）是比第三范式（3NF）更严格的一种范式。

A. 1NF（第一范式）：最低的范式，要求每个字段都是原子的，不可再分。
B. 2NF（第二范式）：在满足 1NF 的基础上，要求非主属性对主键具有完全依赖。
C. 3NF（第三范式）：在满足 2NF 的基础上，要求非主属性不依赖于其他非主属性（消除传递依赖）。
D. BCNF（Boyce-Codd范式）：在满足 3NF 的基础上，要求每个决定因素都是候选键。BCNF 比 3NF 更严格，因此级别更高。

23.
在哪种场景下只需从数据划分角度考虑数据分布问题，即可提高分布式数据库系统的性能（ A      ）
A
一个关系一个站点
B
一个关系多个站点
C
多个关系一个站点
D
多个关系多个站点

在分布式数据库系统中，数据的分布策略对系统性能有重要影响。
考虑数据分布问题的场景取决于如何分配和存储数据到不同的站点上。

A. 一个关系一个站点
    正确。在这种情况下，每个关系（表）只存储在一个站点上。
    这种数据分布方式简化了数据分布问题，因为所有数据操作都在单一的站点上进行，不涉及跨站点的数据传输。
    因此，只需从数据划分角度考虑数据分布问题，即可提高性能。
    
B. 一个关系多个站点
    错误。当一个关系分布到多个站点时，需要考虑如何在多个站点之间协调数据的一致性和查询的效率。
    这不仅涉及数据划分，还需要考虑数据的分布和访问策略，跨站点的数据传输和一致性维护。
    
C. 多个关系一个站点
    错误。多个关系存储在一个站点上可能导致站点负载较重，但这主要是站点的负载问题，而不是数据分布问题。
    
D. 多个关系多个站点
    错误。
    多个关系分布到多个站点涉及复杂的数据分布和访问问题，
    包括如何在多个站点之间有效地管理数据以及如何优化查询性能。

24.
设有一个二维数组A[m][n]，假设A[0][0]存放位置在0x284，A[2][2]存放位置在0x2A4，
每个元素占一个空间，问A[3][3]存放在什么位置（  C    ）
A
2B0
B
2A6
C
2B4
D
不确定

地址差 = 0x2A4 - 0x284 = 0x020 等于十进制32

地址差 = （行偏移量 * 总列数 * 元素大小） + （列偏移量 * 元素大小）
设总列为n  元素大小为M

（2 * n * M）+ (2 * M)
=(2*n + 2)*M=32
(n+1)*M = 16
因为n和M均为整数，且n>3
则n=7，M=2

（3*n*M）+（3*M）
=（3*7*2）+（3*2）
= 42+6=48 等于十六进制0x30

 0x284+0x30 = 0x2B4
    
或是跟A[2][2]计算偏移地址差：
1*7*2+1*2=16 0x10
0x2A4+0x10=0x2B4

25.
以下说法正确的是（   C   ）
A
满二叉树不一定是完全二叉树
B
双亲表示法存储的树优点是找孩子非常容易
C
由森林转换成的二叉树的根节点有右孩子
D
树的后根遍历等于树转换成的二叉树的后序遍历

满二叉树：
    每一层的节点数都达到最大值的二叉树，所有的叶节点都在同一层，且每个节点都有两个或者零个孩子节点
完全二叉树：
    指除了最后一层之外，每一层的节点都达到最大值，最后一层的节点尽可能靠左排列
因此：满二叉树一定是完全二叉树

双亲表示法：
    用数组存储每个节点的双亲索引
    因此找双亲很容易，
    但找一个节点的孩子需要遍历整个数组

森林转换为二叉树的规则:
    1.对于每棵树的根节点，其左孩子为其原本的第一个孩子，右孩子为其兄弟节点
    2.根据这一规则，森林中每棵树的根节点的右孩子是其兄弟，即另一棵树的根
    
一棵树的后根遍历与这棵树所对应的二叉树的中序遍历相同。
    因为树转化为二叉树后是没有右子树的，所以最后访问的是树的根结点。

28.
有以下关键字序列（21,40,52,45,29,12,02,66），H（K）=K%11。
试在0~10的散裂空地址空间中，用线性探测再散列方法处理冲突，
则等概率下查找成功的平均查找长度为（  A    ）
A
3/2
B
2/3
C
3/4
D
4/3


分析：
1. 重新计算每个关键字的哈希值并插入哈希表
关键字序列是 (21, 40, 52, 45, 29, 12, 02, 66)，我们使用哈希函数 H(K) = K % 11，并进行线性探测处理冲突。
依次计算每个关键字的哈希地址，并通过线性探测解决冲突：

    H(21) = 21 % 11 = 10 → 插入位置 10，无冲突，探测 1 次。
    H(40) = 40 % 11 = 7 → 插入位置 7，无冲突，探测 1 次。
    H(52) = 52 % 11 = 8 → 插入位置 8，无冲突，探测 1 次。
    H(45) = 45 % 11 = 1 → 插入位置 1，无冲突，探测 1 次。
    H(29) = 29 % 11 = 7 → 冲突（位置 7 被占用），线性探测，接下来：
    位置 8：已被 52 占用；
    位置 9：空闲 → 插入位置 9，探测 3 次。
    H(12) = 12 % 11 = 1 → 冲突（位置 1 被占用），线性探测，接下来：
    位置 2：空闲 → 插入位置 2，探测 2 次。
    H(02) = 02 % 11 = 2 → 冲突（位置 2 被占用），线性探测，接下来：
    位置 3：空闲 → 插入位置 3，探测 2 次。
    H(66) = 66 % 11 = 0 → 插入位置 0，无冲突，探测 1 次。
2. 探测长度分析
    

30.
关于排序，以下说法正确的是（  A    ）
A
堆排序是不稳定的
B
冒泡排序是不稳定的
C
归并排序是不稳定的
D
直接插入排序是不稳定的

不具备稳定性的排序：
    选择排序/快速排序/堆排序
具备稳定性的排序：
    冒泡排序/插入排序/堆排序/归并排序/一切桶排序

32.
辗转相除法的时间复杂度为（  B    ）
A
O(nlogn)
B
O(logn)
C
O(n^2)
D
O(n)

辗转相除法（即欧几里得算法）的时间复杂度可以通过分析算法的递归步骤来确定
辗转相除法（即欧几里得算法）的时间复杂度可以通过分析算法的递归步骤来确定。

### 辗转相除法简介：
辗转相除法用于计算两个数 \(a\) 和 \(b\) 的最大公约数（GCD）。其基本步骤是不断用较大的数对较小的数取余，直到余数为 0。设 \(a > b\)，其递归公式为：

\[
\text{GCD}(a, b) = \text{GCD}(b, a \% b)
\]

### 时间复杂度分析：

1. **递归的最大深度：**
   辗转相除法每次递归时，问题的规模减少到原来的余数 \(a \% b\)，这小于 \(b\)。
    一个关键的事实是，欧几里得算法的每一步都会使较小数 \(b\) 至少减小到上一步数值的约一半。
    更正式的证明显示，每次迭代后，余数会减小到不超过先前较小数 \(b\) 的一半。因此，余数在对数时间内快速减小。

2. **最坏情况下的迭代次数：**
   最坏的情况下，两个数是连续的斐波那契数。
    例如，如果 \(a\) 和 \(b\) 是斐波那契数 \(F(n)\) 和 \(F(n-1)\)，则计算过程会递归执行 \(n-1\) 次。

   斐波那契数的性质告诉我们，对于 \(F(n)\)，

   \[
   F(n) \approx \frac{1}{\sqrt{5}} \left( \frac{1 + \sqrt{5}}{2} \right)^n
   \]

   因此，对于给定的整数 \(a\) 和 \(b\)，其值 \(a\) 和 \(b\) 之间的比例接近于
斐波那契数的黄金分割比 \( \phi \approx 1.618 \)。

3. **时间复杂度：**
   每次递归的代价是常数 \(O(1)\)，而递归的最大深度大致与两个数的对数成正比。
    因此，时间复杂度是 **\(O(\log \min(a, b))\)**，即随着输入数 \(a\) 和 \(b\) 的大小对数增长。

### 结论：
辗转相除法（欧几里得算法）的时间复杂度为 **\(O(\log \min(a, b))\)**。

33.
对关键字序列{47,61,34(1),76,54,13,34(2),97}，目标是排列成由小到大的关键字集合，
则使用快速排序，枢纽为48，则快速排序一趟后的序列为（ B     ）,其中34(1)代表第一个34，34（2）代表第二个34
A
47,61,34(1),76,54,13,34(2),97
B
34(2),13,34(1),47,54,76,61,97
C
34(1),13,34(2),47,54,76,61,97
D
47,61,34(2),76,54,13,34(1),97

快速排序的核心步骤是 分区（Partition），
即选择一个枢纽（Pivot），将序列分为两部分：左边部分所有元素小于枢纽，右边部分所有元素大于或等于枢纽。
这里，枢纽选择为 48。

分区步骤
    1.初始化指针：
        i 指向序列的起始位置（左边界）。
        j 指向序列的末尾位置（右边界）。
    2.从左向右扫描，找到第一个大于或等于枢纽的元素。
    3.从右向左扫描，找到第一个小于枢纽的元素。
    4.交换这两个元素。
    5.重复步骤2-4，直到 i 和 j 相遇。

34.
下列关于进程和程序的区别描述说法正确的是：（ ABCD  ）
A
进程更能准确刻画并发，而程序不能
B
进程是动态的，程序是静态的
C
进程有生命周期的，有诞生有消亡，是短暂的；而程序是相对长久的
D
进程具有创建其他进程的功能，一个程序可对应多个进程

35.
关于FCFS（先来先服务）算法说法正确的是（  AC    ）
A
利于长作业
B
利于短作业
C
利于CPU繁忙型的作业
D
利于I/O繁忙型的作业

在 FCFS 算法中，作业按到达的顺序依次处理，
因此如果一个长作业先到达，它会先被处理，不会因为后面有短作业而被打断。

FCFS 对短作业并不友好。
短作业可能需要等待较长的时间，特别是在前面有长作业排队时，它们需要等待长作业先完成，无法优先被执行。

FCFS 更有利于 CPU 繁忙型的作业，因为这些作业通常需要较长的计算时间。
由于 FCFS 是先到先处理，不存在抢占行为，
因此 CPU 繁忙型作业可以在获得 CPU 资源后一直运行，不会被 I/O 繁忙型作业频繁中断。

I/O 繁忙型作业通常需要频繁地进行 I/O 操作，
如果它们在 FCFS 队列中，可能会由于等待 CPU 资源而造成长时间的等待，这对 I/O 繁忙型作业是不利的。

36.
在高响应比优先调度算法中，（  ABC    ）
A
在作业要求服务时间相同的情况下，作业的等待时间越长，其优先权越高
B
在作业等待时间相同的情况下，要求服务时间越长，其优先权越高
C
在作业要求服务时间相同的情况下，系统对作业的响应时间越长，其优先权越高
D
在作业的要求服务时间越短，其优先权越高

高响应比优先（Highest Response Ratio Next, HRRN）调度算法是基于响应比的调度策略。
响应比的计算公式为：
相应比=（等待时间+服务时间）/服务时间

当作业的等待时间相同，响应比主要由服务时间决定。
服务时间越长，应比越高，因此优先权越高。
长时间的服务作业相对容易获得高优先权，从而避免了对长作业的不公平对待。

当作业的服务时间相同，响应比依赖于等待时间。
系统对作业的响应时间越长，即等待时间越长，响应比越高。因此，优先权越高，系统会优先处理等待时间较长的作业。

在 HRRN 算法中，服务时间短并不会直接提高优先权。
响应比是由等待时间和服务时间共同决定的，服务时间短并不一定意味着优先权高。
相反，较长的服务时间可以在一定条件下获得更高的响应比，特别是在等待时间较长的情况下

38.
下列事件中会引起创建进程的是（ABCD）
A
系统初始化
B
一个进程在运行过程中开启了子进程
C
用户的交互式请求
D
大型机的批处理系统中一个批处理作业的初始化

39.
下列有关磁盘调度算法的说法中正确的是（ BC     ）
A
SSTF算法可以保证平均寻道长度最短
B
FCFS算法应用在磁盘I/O较少的场合
C
SCAN算法可避免“饥饿”现象
D
CSCAN算法中磁头可以向二个方向移动

磁盘调度算法的主要目标是优化磁盘访问效率，减少寻道时间，并解决可能的“饥饿”现象。
**SSTF（最短寻道时间优先）**算法
    通过选择距离当前磁头位置最近的请求来优化寻道时间，但它不能保证平均寻道长度最短。
    SSTF 在短期内可能减少寻道时间，但长期运行可能会导致某些请求（尤其是磁盘的两端请求）长时间得不到处理，
    即“饥饿”现象，因此不能保证最短的平均寻道长度。

**FCFS（先来先服务）**
    适用于磁盘I/O请求较少的场合。
    在这种情况下，FCFS 的性能比较稳定，不容易产生极端的寻道时间开销。
    然而，在磁盘I/O请求量大时，FCFS 可能导致不必要的寻道开销，
        因为它不考虑请求的顺序和磁头的位置，可能会导致较长的寻道时间。
        
**SCAN（电梯算法）**
    通过磁头在磁盘上来回扫描来处理请求，这样每个请求都会被处理到，
    因此相对于FCFS和SSTF，SCAN 更能避免“饥饿”现象。
    因为SCAN 确保了磁盘上的所有请求都会被处理到，不论它们最初的等待时间有多长。
    
**CSCAN（循环扫描）**算法中，
    磁头在一个方向上移动，直到达到磁盘的一个端点，然后返回到另一端点，但在返回时不会处理请求。
    这意味着磁头在CSCAN中只能在一个方向上移动，而不是在两个方向上移动。

40.
有一棵树广义表形式为A(B(E(K,L),F,G(M)),C(H),D(I,J)), 将其转换为二叉树，
说法正确的是（  ABD    ）
A
二叉树为只有左子树的单支树
B
二叉树中结点D的双亲是C
C
二叉树中结点G的右子树根为M
D
二叉树中结点F只有右子树，右子树的根为G

42.
由于电文中字符的出现频率不同，若电文由5个字符组成，它们出现的频率分别为{4,5,6,7,8}，
以频率作为叶子结点的权值构造赫夫曼树，各结点对应的赫夫曼编码可能为（  ABC    ）
A
4:110,5:111,6:00,7:01,8:10
B
4:111,5:110,6:01,7:00,8:10
C
4:000,5:001,6:10,7:11,8:01
D
4:000,5:001,6:10,7:11,8:00

43.
某培养计划制定系统，其中包括课程为：高数a（无），物理b（a），电路c（b），
C程序设计d（无），数据结构e（d,h），组成原理f（c,b），操作系统g（e,f），离散数学h（d）,
其中小括号内为该课程的先序课程，则以下说法正确的是 （ ABC      ） 
A
第一学期开设a,d课程
B
第二学期开设b,h课程
C
第三学期开设e,c课程
D
第四学期开设f,g课程

45.
毛毛虫树是一张 n 个点 n-1 条边的无向联通图，每两个点都有唯一的一条简单路径。
有根树是指以其中一个点为根节点的树，叶子节点是指除根节点外度数为 1 的节点。
一个点的度数是指与其相连的点的个数。
有根树上，一个点的深度是指其与根节点之间的简单路径的边数。
在某一棵以 1 为根的有根树上，有两个节点 a,b 上各存在一只毛毛虫。
这两只毛毛虫只会往深度更大的点前进，当毛毛虫走到叶子节点时会停下。

设第一只毛毛虫可能走到的节点为p1，第二只毛毛虫可能走到的节点为p2，
你想要知道二元组(p1,p2)的个数（p1可以等于p2）。一共有 Q 次询问。

# 
    第一行两个正整数n,Q（1 <= n,Q <= 50000）。
    第二行 n-1 个正整数f2,f3...fn，(1 <= fi < i)，表示树上节点 i 与 fi 之间有一条边。
    第三行 Q个正整数a1,a2....aQ（1<= ai <=n) ；
    第四行 Q个正整数b1,b2...bQ（1<=bi<=n, ai != bi）。
    第三行和第四行表示 ai,bi 是第i 个查询对应的两只毛毛虫所在的节点。

（简单来说就是实现一个函数，
求每个节点到底有多少个叶子节点。需要一个hashmap来缓存已经求过的叶子结点。）

# 
# 
树的构建：

首先，需要根据给定的边列表构建树，并为每个节点计算其子树的叶子节点数量。
深度优先搜索 (DFS)：

使用 DFS 来遍历树并计算每个节点的叶子节点数量。利用 DFS 的递归性质，可以在遍历时计算每个节点的子树的叶子节点数，并将结果存储起来以便快速查询。
缓存计算结果：

使用哈希表（hashmap）缓存每个节点的叶子节点数量，以避免重复计算。
查询处理：

对于每个查询 (p1, p2)，使用缓存的结果来计算可能的节点组合数量。

from collections import defaultdict, deque

def build_tree(n, parents):
    tree = defaultdict(list)
    for i, p in enumerate(parents, start=2):
        tree[p].append(i)
        tree[i].append(p)
    return tree

def count_leaves(tree, root, parent, leaf_count):
    # Base case: if it's a leaf node
    if len(tree[root]) == 1 and root != parent:
        leaf_count[root] = 1
        return 1
    total_leaves = 0
    for child in tree[root]:
        if child != parent:
            total_leaves += count_leaves(tree, child, root, leaf_count)
    leaf_count[root] = total_leaves
    return total_leaves

def preprocess_tree(n, parents):
    tree = build_tree(n, parents)
    leaf_count = {}
    count_leaves(tree, 1, -1, leaf_count)  # 1 is the root
    return leaf_count

def process_queries(queries_a, queries_b, leaf_count):
    results = []
    for a, b in zip(queries_a, queries_b):
        results.append((leaf_count.get(a, 0), leaf_count.get(b, 0)))
    return results

def main():
    n_Q = input().split()
    n = int(n_Q[0])
    Q = int(n_Q[1])
    
    edge=input().split()
    Qa = input().split()
    Qb = input().split()
    
    
    print(data)
    
    # Reading n and Q
#     n = int(data[0])
#     Q = int(data[1])
    
#     # Reading parent nodes for nodes 2 to n
#     parents = list(map(int, data[2:n+1]))
    
#     # Reading queries
#     queries_start = n + 1
#     queries_a = list(map(int, data[queries_start:queries_start + Q]))
#     queries_b = list(map(int, data[queries_start + Q:queries_start + 2 * Q]))
    
#     # Preprocess the tree to calculate leaf counts
#     leaf_count = preprocess_tree(n, parents)
    
#     # Process queries to get the results
#     results = process_queries(queries_a, queries_b, leaf_count)
    
#     # Output the results
#     for result in results:
#         print(result[0], result[1])


if __name__ == "__main__":
    main()

8 4
['8', '4']

x