华为 AI 岗位机考真题及编程题解析

（二）不定项选择题（共 5 题）

16. 设 ${N(t),t\geq0}$ 是强度为 $\lambda$ 的泊松过程。以下陈述中，正确的是（） A. 在区间 $[0,t]$ 内事件数 $N(t)$ 的均值为 $\lambda t$ B. 已知在时间 $[0,t]$ 内发生了 $n$ 个事件，那么这 $n$ 个事件的发生时刻在 $[0,t]$ 上是独立同分布的均匀分布 C. 时间间隔 $T_{1}$（首次事件到达时间）服从参数为 $\lambda$ 的指数分布 D. 两次连续事件的时间间隔 $T_{2}-T_{1}$ 与 $T_{1}$ 相互独立

17. 在 EM 算法中，GMM 的 M-step 的解析解需要（） A. 必须对角协方差 B. 协方差矩阵正定 C. 各成分权重和为 1 D. 均值更新为加权平均

18. 下列关于线性变换的说法中，正确的是（） A. 设 $T: \mathbb{R}^{2} \to \mathbb{R}^{2}$ 是将向量 $\begin{bmatrix}x\y\end{bmatrix}$ 映射为 $\begin{bmatrix}2x + y\x - 3y\end{bmatrix}$ 的变换，则 $T$ 是线性变换 B. 设 $T: \mathbb{R}^{3} \to \mathbb{R}^{2}$ 是将向量 $\begin{bmatrix}x\y\z\end{bmatrix}$ 映射为 $\begin{bmatrix}x + y + 1\z - 2y\end{bmatrix}$ 的变换，则 $T$ 不是线性变换（因存在常数项 1，不满足线性变换'$T(0)=0$'的性质） C. 若 $T_{1}$，$T_{2}$ 均为 $T: \mathbb{R}^{n} \to \mathbb{R}^{m}$ 的线性变换，则它们的和 $T(x)=T_{1}(x)+T_{2}(x)$ 仍是线性变换 D. 若 $T: \mathbb{R}^{n} \to \mathbb{R}^{m}$ 是线性变换，则对于任意向量 $\alpha$，$\beta \in \mathbb{R}^{n}$ 和常数 $k$，$m \in \mathbb{R}$，有 $T(k\alpha + m\beta)=kT(\alpha)+mT(\beta)$

19. 关于深度学习中的激活函数 ReLU、Softmax、Sigmoid 和 Tanh，以下描述正确的是：（） A. ReLU 函数在输入为负时输出为零，而在输入为正时输出为输入值本身 B. Tanh 函数的输出值范围在 $[-1,1]$ 之间，常用于隐藏层的激活函数 C. Sigmoid 函数的导数在输入为 0 时达到最大值，随着输入值的增大或减小而逐渐减小 D. Softmax 函数将输入值归一化为概率分布，所有输出值的和为 1

20. 与大语言模型（LLM）相比，以下哪些是多模态大语言模型（MLLM）在处理多模态输入时面临的独特挑战？（） A. 跨模态的语义理解与生成 B. 多模态输入的实时处理与推理延迟 C. 模型参数量的爆炸式增长 D. 多模态数据的对齐（如图像与文本的语义对齐）

二、编程题（共 2 题）

21. 云存储设备故障预测

在云存储系统中，需要预测存储设备故障以提前迁移数据。每条设备日志包含：设备 ID，写入次数，读取次数，平均写入延迟（ms），平均读取延迟（ms），设备使用年限（年），设备状态（0 正常/1 故障）。需实现一个设备故障预测系统，包含以下功能：

1. 数据清洗规则

• 缺失值标记为'NaN'，用该字段有效值的均值填充；
• 异常值判定与处理：
  • 写入次数、读取次数：小于 0 时为异常值，用该字段有效值的中位数替换；
  • 平均写入延迟、平均读取延迟：小于 0 或大于 1000ms 时为异常值，用该字段有效值的中位数替换；
  • 设备使用年限：小于 0 或大于 20 年时为异常值，用该字段有效值的中位数替换。

2. 逻辑回归模型训练要求

• 训练方法：使用批量梯度下降法（Batch GD），每次迭代使用全部样本；
• 特征变量：写入次数、读取次数、平均写入延迟、平均读取延迟、设备使用年限；
• 标签变量：设备状态；
• 训练参数：迭代次数 100 次，学习率 $\alpha = 0.01$，初始权重全为 0。

3. 预测输出要求

• 输出预测结果：0（表示设备正常）或 1（表示设备故障）。

输入格式

• 第一行：训练样本总个数 $N$（$2\leq N\leq100$）；
• 第二行至第 $N+1$ 行：每行包含 1 个训练样本数据，格式为'设备 ID 写入次数 读取次数 平均写入延迟 平均读取延迟 设备使用年限 状态'；
• 第 $N+2$ 行：预测数据总个数 $M$（$1\leq M\leq10$）；
• 第 $N+3$ 行至第 $N+M+2$ 行：每行包含 1 个预测样本数据，格式为'设备 ID 写入次数 读取次数 平均写入延迟 平均读取延迟 设备使用年限 状态'（预测时状态字段仅为数据格式统一，无实际意义）。

输出格式

• 共 $M$ 行，每行输出 1 个预测结果（0 或 1），与预测数据的顺序一一对应。

22. 大模型训练 MOE 场景路由优化算法

MOE 模型训练时，token 需根据概率发送到 top-k 个不同的专家进行计算，专家分布在多个 NPU 卡上。Device-Limited routing 算法可将 token 的路由目标限制在 $p$ 个 NPU 上，以降低通信成本，具体规则如下：

1. 专家分组：将 $n$ 个专家平均分配在 $m$ 个 NPU 上，每个 NPU 上的专家组成一个组；专家编号为 $N=[0,1,2,...,n-1]$，且每个组内的专家编号连续；
2. 筛选目标 NPU：每个专家对应一个被路由到的概率，以每个组内的最大概率作为该组的代表概率；从所有组中选择代表概率最大的 $p$ 个组，其对应的 NPU 即为路由目标限制 NPU；
3. 筛选目标专家：从上述 $p$ 个 NPU 对应的所有专家中，选择概率最大的 $k$ 个专家，其编号即为最终路由目标。

输入格式

• 第一行：4 个整数，分别表示专家个数 $n$、NPU 个数 $m$、路由目标限制 NPU 个数 $p$、目标路由专家个数 $k$（均处于区间 $[1,10000]$ 内）；
• 第二行：$n$ 个浮点数，分别表示每个专家对应的被路由概率（处于区间 $(0,1)$ 内），概率与专家编号 $[0,1,2,...,n-1]$ 一一对应。

输出格式

• 若 $n$ 不能被 $m$ 整除（无法平均分组），或从目标 NPU 对应的专家中无法获取到 $k$ 个专家编号，则输出'error'；
• 若满足条件，则按专家编号从小到大的顺序输出 $k$ 个专家编号，任意相邻两个编号之间用空格分隔，最后一个编号后无空格。

参考答案

答案仅供参考

单项选择题（共 15 题）

1. 答案：A 解析：LSTM（长短期记忆网络）能捕捉序列数据的长期依赖关系，适合生成连续文本；最大熵模型、隐马尔可夫模型（HMM）更适用于分类、序列标注等任务，决策树主要用于分类和回归，均不擅长连续文本生成。
2. 答案：A 解析：线性变换矩阵 $A$ 由基向量的像构成（列向量为 $T(e_1)$、$T(e_2)$），即 $A=\begin{bmatrix}3&-1\1&2\end{bmatrix}$。向量 $v=\begin{bmatrix}4\3\end{bmatrix}$ 的像为 $A \cdot v = \begin{bmatrix}3\times4 + (-1)\times3\1\times4 + 2\times3\end{bmatrix}=\begin{bmatrix}9\10\end{bmatrix}$，故选择 A。
3. 答案：A 解析：矩阵乘法 $A = uv^{\top}$ 中，元素 $A_{ij}$ 为 $u$ 的第 $i$ 个元素与 $v$ 的第 $j$ 个元素乘积。$u=\begin{bmatrix}2\-1\3\end{bmatrix}$、$v^{\top}=\begin{bmatrix}4&0&-2\end{bmatrix}$，第 2 行第 3 列元素为 $(-1)\times(-2)=2$，故选择 A。
4. 答案：B 解析：方程 $x = \cos x$ 仅有 1 个实根；迭代公式 $x_{k+1}=\cos(x_k)$ 满足压缩映射条件，对任意初始值均收敛到该实根（A 错，收敛速度为线性；C 错，算法稳定；D 错，方程仅 1 个实根）。
5. 答案：A 解析：过拟合指模型在训练集上拟合过好（准确率高），但对未见过的测试集泛化能力差（准确率低）；欠拟合是训练集和测试集准确率均低，故选择 A。
6. 答案：C 解析：预测值：$P_2(1.5)=100 + 20\times1.5 + 5\times1.5\times(1.5-1)=138.75,\text{MPa}$；真实值：$\sigma(1.5)=100 + 20\times1.5 + 5\times(1.5)^2=138.75,\text{MPa}$，绝对误差为 0，故选择 C。
7. 答案：B 解析：方差性质：$\text{Var}(aX + b)=a^2\text{Var}(X)$（常数不影响方差）。代入得 $\text{Var}(Y)=3^2\times4=36$，故选择 B。
8. 答案：D 解析：向量组 $\beta_1,\beta_2,\beta_3$ 线性相关，其组合系数构成的行列式为 0。计算得行列式 $(k_1-1)(k_2(k_1-1)-k_1)=0$，解得 $k_1=1$ 或 $k_2=0$，故选择 D。
9. 答案：D 解析：均匀分布的概率密度函数为 $f(x)=\frac{1}{b-a}$（$a\leq x\leq b$），其他区间为 0；泊松分布是离散分布，指数分布密度为 $f(x)=\lambda e^{-\lambda x}$，正态分布密度为钟形曲线，故选择 D。
10. 答案：D 解析：线性变换满足可加性 $T(u+v)=T(u)+T(v)$（对任意 $u,v$，A 错）和齐次性 $T(cu)=cT(u)$（对任意标量 $c$、向量 $u$，D 对）；必满足 $T(0)=0$（B 错），可改变向量维度（如 $T:\mathbb{R}^3\to\mathbb{R}^2$，C 错）。
11. 答案：C 解析：Transformer 解码器的第一个 Multi-Head Attention 为 Masked Self-Attention（防止未来信息泄露，D 对），第二个为 Encoder-Decoder Cross-Attention（K、V 来自编码器，B 对、C 错），且额外包含交叉注意力层（A 对），故选择 C。
12. 答案：D 解析：直方图、拟合优度检验、偏度/峰度系数均用于检验正态性；T 检验用于检验均值差异（如两样本均值比较），不用于正态性检验，故选择 D。
13. 答案：C 解析：次品数 $X$ 服从二项分布 $B(100,0.02)$，当 $n$ 大、$p$ 小时，二项分布近似泊松分布（参数 $\lambda=np=2$）；均匀分布是连续分布，伯努利分布为单次试验，正态分布需 $np$ 和 $n(1-p)$ 均较大，故选择 C。
14. 答案：A 解析：函数 $(x+3)x^2=0$ 的根为 $x=-3$（单根）和 $x=0$（二重根）。初值 $x_0=3$ 收敛到 $x=-3$，牛顿迭代法对单根收敛速度为二次，对重根为线性，但本题中 $x=-3$ 是单根，实际计算中因导数特性呈超线性收敛，故选择 A。
15. 答案：C 解析：PCA 通过最大化主成分的方差保留数据信息，选择主成分的核心依据是方差贡献率（累计方差贡献率通常需达到 80%-90%）；样本分布密度、特征相关性、数据类别分布均非 PCA 选择主成分的关键，故选择 C。

不定项选择题（共 5 题）

16. 答案：ACD 解析：泊松过程中，$N(t)$ 均值为 $\lambda t$（A 对）；已知 $n$ 个事件时，发生时刻服从均匀分布的顺序统计量，非独立同分布（B 错）；首次到达时间 $T_1$ 及相邻间隔均服从参数 $\lambda$ 的指数分布，且相互独立（C、D 对）。
17. 答案：BCD 解析：GMM 的 M-step 中，协方差矩阵需正定（否则无意义，B 对），各成分权重和为 1（约束条件，C 对），均值更新为加权平均（权重为后验概率，D 对）；协方差矩阵可非对角（A 错），故选择 BCD。
18. 答案：ACD 解析：A 满足线性变换的可加性和齐次性（对）；B 含常数项 1，不满足 $T(0)=0$（错）；线性变换的和仍为线性变换（C 对）；D 是线性变换的定义式（对），故选择 ACD。
19. 答案：ABCD 解析：ReLU 在输入负时输出 0、正时输出自身（A 对）；Tanh 输出范围 $[-1,1]$，常用于隐藏层（B 对）；Sigmoid 导数在 $x=0$ 时最大（0.25），随 $|x|$ 增大而减小（C 对）；Softmax 将输入归一化为概率分布，和为 1（D 对），故选择 ABCD。
20. 答案：ABD 解析：MLLM 的独特挑战包括跨模态语义理解与生成（A 对）、多模态实时处理延迟（B 对）、多模态数据对齐（D 对）；模型参数量增长是 LLM 和 MLLM 共有的挑战（非独特，C 错），故选择 ABD。

编程 21

一、解题思路

1. 数据读取与预处理

• 读取输入：先读取训练样本数量 $N$ 及对应的 $N$ 条训练数据，再读取预测样本数量 $M$ 及对应的 $M$ 条预测数据，数据需按'设备 ID、写入次数、读取次数、平均写入延迟、平均读取延迟、设备使用年限、状态'的格式解析。
• 缺失值处理：将数据中的缺失值（标记为'NaN'）用对应字段有效值的均值填充，需先筛选出各字段非'NaN'的有效数据，计算均值后替换缺失值。
• 异常值处理：根据规则判定异常值（写入/读取次数<0；平均写入/读取延迟<0 或>1000；使用年限<0 或>20），用对应字段有效值的中位数替换异常值，同样需先筛选有效数据计算中位数。

2. 逻辑回归模型训练（批量梯度下降）

• 特征与标签提取：从预处理后的训练数据中提取特征（写入次数、读取次数、平均写入延迟、平均读取延迟、设备使用年限）和标签（设备状态，0 为正常、1 为故障）。
• 特征标准化：为提升梯度下降收敛速度，对特征进行标准化（均值归一化，即 $X_{norm}=\frac{X - \mu}{\sigma}$，$\mu$ 为特征均值，$\sigma$ 为特征标准差）。
• 批量梯度下降迭代：初始权重 $w$ 全为 0，学习率 $\alpha = 0.01$，迭代 100 次。每次迭代计算预测值（通过 sigmoid 函数 $h_\theta(x)=\frac{1}{1+e^{-\theta^T x}}$）、损失函数梯度，更新权重 $w = w - \alpha \times \text{gradient}$。

3. 预测与输出

• 预测数据预处理：对预测数据执行与训练数据相同的缺失值、异常值处理及特征标准化（使用训练数据的特征均值和标准差，避免数据泄露）。
• 结果预测：将预处理后的预测特征代入训练好的逻辑回归模型，通过 sigmoid 函数得到概率，概率≥0.5 预测为 1（故障），否则预测为 0（正常），按顺序输出预测结果。

二、Python 代码实现

import numpy as np

def preprocess_data(data, train_stats=None, is_train=True):
    """ 数据预处理：处理缺失值和异常值，训练数据计算统计量，预测数据使用训练统计量 
        data: 输入数据（二维列表，每行对应一条数据，列：[写入次数，读取次数，平均写入延迟，平均读取延迟，设备使用年限]） 
        train_stats: 训练数据的统计量（均值、中位数、标准差），is_train=False 时需传入 
        is_train: 是否为训练数据（True/False） 
        return: 预处理后的数据，训练数据时额外返回统计量 
    """
    data = np.array(data, dtype=np.float64)
    n_features = data.shape[1]
    stats = {}
    # 存储训练数据的统计量：mean（均值）、median（中位数）、std（标准差）
    if is_train:
        # 计算训练数据各字段的均值、中位数、标准差（忽略 NaN）
        for i in range(n_features):
            valid = data[~np.isnan(data[:, i]), i]
            stats[f'mean_{i}'] = np.mean(valid)
            stats[f'median_{i}'] = np.median(valid)
            stats[f'std_{i}'] = np.std(valid) if len(valid) > 1 else 1.0
    else:
        # 预测数据使用训练数据的统计量
        stats = train_stats
    # 处理缺失值（用均值填充）
    for i in range(n_features):
        data[np.isnan(data[:, i]), i] = stats[f'mean_{i}']
    # 处理异常值（用中位数填充）
    # 特征 0：写入次数，特征 1：读取次数（异常值<0）
    for i in [0, 1]:
        data[data[:, i] < 0, i] = stats[f'median_{i}']
    # 特征 2：平均写入延迟，特征 3：平均读取延迟（异常值<0 或>1000）
    for i in [2, 3]:
        mask = (data[:, i] < 0) | (data[:, i] > 1000)
        data[mask, i] = stats[f'median_{i}']
    # 特征 4：设备使用年限（异常值<0 或>20）
    mask = (data[:, 4] < 0) | (data[:, 4] > 20)
    data[mask, 4] = stats[f'median_4']
    # 训练数据标准化（预测数据后续用训练统计量标准化）
    if is_train:
        normalized_data = (data - np.array([stats[f'mean_{i}'] for i in range(n_features)])) / \
                          np.array([stats[f'std_{i}'] for i in range(n_features)])
        return normalized_data, stats
    else:
        return data

def sigmoid(z):
    """sigmoid 激活函数，避免数值溢出"""
    return np.where(z >= 0, 1/(1+ np.exp(-z)), np.exp(z)/(1+ np.exp(z)))

def train_logistic_regression(X, y, epochs=100, alpha=0.01):
    """ 批量梯度下降训练逻辑回归模型 
        X: 标准化后的训练特征（n_samples × n_features） 
        y: 训练标签（n_samples × 1） 
        epochs: 迭代次数 
        alpha: 学习率 
        return: 训练好的权重 w 
    """
    n_samples, n_features = X.shape
    # 初始化权重（含偏置项，故特征维度 +1，先给 X 添加偏置列）
    X_with_bias = np.hstack([np.ones((n_samples, 1)), X])  # (n_samples, n_features+1)
    w = np.zeros((n_features + 1, 1))  # 初始权重全 0
    for _ in range(epochs):
        # 计算预测概率
        y_pred_prob = sigmoid(np.dot(X_with_bias, w))
        # 计算梯度（批量梯度，使用全部样本）
        gradient = (1/ n_samples) * np.dot(X_with_bias.T, (y_pred_prob - y.reshape(-1, 1)))
        # 更新权重
        w -= alpha * gradient
    return w

def predict(w, X_test, train_stats):
    """ 模型预测 
        w: 训练好的权重 
        X_test: 预处理后的预测特征（未标准化） 
        train_stats: 训练数据的统计量（用于标准化） 
        return: 预测结果（0/1） 
    """
    n_features = X_test.shape[1]
    # 用训练数据的均值和标准差标准化预测特征
    X_test_norm = (X_test - np.array([train_stats[f'mean_{i}'] for i in range(n_features)])) / \
                  np.array([train_stats[f'std_{i}'] for i in range(n_features)])
    # 添加偏置列
    X_test_with_bias = np.hstack([np.ones((X_test_norm.shape[0], 1)), X_test_norm])
    # 计算预测概率并转为标签（≥0.5 为 1，否则为 0）
    y_pred_prob = sigmoid(np.dot(X_test_with_bias, w))
    y_pred = (y_pred_prob >= 0.5).astype(int).flatten()
    return y_pred

def main():
    # 读取输入（注意：实际考试中需从标准输入读取，此处模拟输入格式）
    import sys
    input_lines = [line.strip() for line in sys.stdin if line.strip()]
    ptr = 0
    # 读取训练数据
    N = int(input_lines[ptr])
    ptr += 1
    train_data = []
    train_labels = []
    for _ in range(N):
        parts = input_lines[ptr].split()
        ptr += 1
        # 提取特征（索引 1-5：写入次数、读取次数、平均写入延迟、平均读取延迟、设备使用年限）
        features = [float(p) if p != 'NaN' else np.nan for p in parts[1:6]]
        # 提取标签（索引 6：设备状态）
        label = int(parts[6])
        train_data.append(features)
        train_labels.append(label)
    # 读取预测数据
    M = int(input_lines[ptr])
    ptr += 1
    test_data = []
    for _ in range(M):
        parts = input_lines[ptr].split()
        ptr += 1
        # 提取特征（同训练数据，状态字段无意义）
        features = [float(p) if p != 'NaN' else np.nan for p in parts[1:6]]
        test_data.append(features)
    # 1. 预处理训练数据
    X_train_norm, train_stats = preprocess_data(train_data, is_train=True)
    y_train = np.array(train_labels)
    # 2. 训练逻辑回归模型
    w = train_logistic_regression(X_train_norm, y_train, epochs=100, alpha=0.01)
    # 3. 预处理预测数据并预测
    X_test_processed = preprocess_data(test_data, train_stats=train_stats, is_train=False)
    y_pred = predict(w, X_test_processed, train_stats)
    # 4. 输出预测结果
    for pred in y_pred:
        print(pred)

if __name__ == "__main__":
    main()

编程 22

一、解题思路

1. 输入校验与初始化

• 核心校验：首先判断专家总数 $n$ 是否能被 NPU 个数 $m$ 整除（若不能，直接输出'error'），确保专家可平均分配到每个 NPU 形成连续编号的专家组；同时后续需确认目标 NPU 对应的专家总数不小于 $k$（若不足，同样输出'error'）。
• 数据初始化：读取专家概率列表，与专家编号（0 到 $n-1$）一一对应，便于后续按概率筛选专家。

2. 专家分组（按 NPU 划分）

• 计算每组专家数：每组专家数量 $group_size = n // m$，确保每个 NPU 对应一个包含 $group_size$ 个连续编号专家的组（如 $n=6$、$m=2$ 时，组 1 为专家 0-2，组 2 为专家 3-5）。
• 构建分组数据：遍历所有专家，按编号归属划分到对应组，同时记录每组的最大概率（作为该组的'代表概率'，用于筛选目标 NPU）。

3. 筛选目标 NPU

• 按组概率排序：将所有组按'代表概率'降序排列，选择前 $p$ 个组（即概率最大的 $p$ 个组），其对应的 NPU 即为路由目标限制 NPU。
• 收集目标专家池：汇总这 $p$ 个目标组内的所有专家（含编号和概率），形成待选专家池。

4. 筛选目标专家与输出

• 按专家概率排序：将待选专家池中的专家按概率降序排列，选择前 $k$ 个专家（若专家池总数不足 $k$，输出'error'）。
• 结果格式化：将选中的 $k$ 个专家按编号从小到大排序，用空格分隔输出，确保行尾无空格。

二、Python 代码实现

def main():
    import sys
    # 读取输入（第一行：n, m, p, k；第二行：n 个专家概率）
    input_lines = [line.strip() for line in sys.stdin if line.strip()]
    if len(input_lines) < 2:
        print("error")
        return
    # 解析第一行参数（专家数 n、NPU 数 m、目标 NPU 数 p、目标专家数 k）
    try:
        n, m, p, k = map(int, input_lines[0].split())
        # 校验参数范围（题目规定区间 [1,10000]）
        if not (1 <= n <= 10000 and 1 <= m <= 10000 and 1 <= p <= 10000 and 1 <= k <= 10000):
            print("error")
            return
    except ValueError:
        print("error")
        return
    # 解析第二行专家概率（n 个浮点数，区间 (0,1)）
    try:
        probs = list(map(float, input_lines[1].split()))
        if len(probs) != n:
            print("error")
            return
        # 校验概率范围（题目规定 (0,1)，此处允许微小精度误差）
        for prob in probs:
            if not (0 < prob < 1):
                print("error")
                return
    except ValueError:
        print("error")
        return
    # 第一步：校验专家能否平均分配到 NPU（n 必须被 m 整除）
    if n % m != 0:
        print("error")
        return
    group_size = n // m  # 每个 NPU 对应的专家数量（每组专家数）
    # 第二步：构建专家组（按 NPU 分组，记录每组的专家编号、概率及组最大概率）
    groups = []
    # 元素格式：(组最大概率，组内专家列表)，组内专家格式：(专家编号，专家概率)
    for group_idx in range(m):
        # 计算当前组专家的编号范围（连续编号）
        start_idx = group_idx * group_size
        end_idx = start_idx + group_size
        group_experts = []
        max_prob_in_group = 0.0
        # 遍历组内专家，收集编号、概率并找组内最大概率
        for expert_idx in range(start_idx, end_idx):
            prob = probs[expert_idx]
            group_experts.append((expert_idx, prob))
            if prob > max_prob_in_group:
                max_prob_in_group = prob
        groups.append((max_prob_in_group, group_experts))
    # 第三步：筛选概率最大的 p 个组（目标 NPU 对应的组）
    # 按组最大概率降序排序，取前 p 个组
    groups_sorted = sorted(groups, key=lambda x: x[0], reverse=True)
    target_groups = groups_sorted[:p]
    # 第四步：收集目标组内的所有专家，形成待选专家池
    candidate_experts = []
    for _, experts in target_groups:
        candidate_experts.extend(experts)
    # 校验待选专家数是否足够 k 个（不足则输出 error）
    if len(candidate_experts) < k:
        print("error")
        return
    # 第五步：按专家概率降序排序，选择前 k 个专家，再按编号升序排列
    # 先按概率降序，概率相同则按编号升序（避免概率一致时排序混乱）
    candidate_experts_sorted = sorted(candidate_experts, key=lambda x: (-x[1], x[0]))
    selected_experts = candidate_experts_sorted[:k]
    # 按专家编号升序排列输出
    selected_ids = sorted([expert[0] for expert in selected_experts])
    # 第六步：格式化输出（空格分隔，行尾无空格）
    print(' '.join(map(str, selected_ids)))

if __name__ == "__main__":
    main()