2025 B卷 200分 题型
本专栏内全部题目均提供Java、python、JavaScript、C、C++、GO六种语言的最佳实现方式；
并且每种语言均涵盖详细的问题分析、解题思路、代码实现、代码详解、3个测试用例以及综合分析；
本文收录于专栏：《2025华为OD真题目录+全流程解析+备考攻略+经验分享》
华为OD机试真题《启动多任务排序》：
文章快捷目录
题目描述及说明
Java
python
JavaScript
C++
C
GO
题目名称：启动多任务排序
- 知识点：拓扑排序（贪心策略）、字符串处理、逻辑分析
- 时间限制：1秒
- 空间限制：256MB
- 限定语言：不限
题目描述
一个应用启动时，会有多个初始化任务需要执行，且任务之间存在依赖关系。例如，任务A依赖任务B，则必须在B执行完成后才能开始执行A。现给出多条任务依赖规则，要求输出任务的执行顺序序列。规则采用贪婪策略：
- 若任务无依赖，则立即执行。
- 若多个任务可同时执行，按任务名称的字母顺序排序。
输入描述
- 输入参数为多个依赖关系，用空格分隔。
- 依赖关系格式为
X->Y，表示任务X依赖任务Y（即Y需先于X执行）。 - 示例输入：
A->B C->B
输出描述
- 输出排序后的任务列表，用空格分隔。
- 示例输出：
B A C
示例说明
- 输入
A->B C->B表示：- A依赖B，C依赖B → B无依赖，优先执行；A和C均依赖B，但按字母顺序输出A在前。
- 输出顺序为
B A C。
Java
问题分析
我们需要解决任务的执行顺序问题，任务之间存在依赖关系，同时在多个任务可执行时按字母顺序选择。这属于典型的拓扑排序问题，但需要结合贪心策略选择字典序最小的任务。
解题思路
- 构建依赖图：将所有任务及其依赖关系转化为有向图，边表示依赖方向。
- 统计入度：记录每个任务的入度（前置依赖的数量）。
- 优先队列处理：使用优先队列存储当前可执行的任务（入度为0），按字母顺序取出任务。
- 拓扑排序：依次处理队列中的任务，减少其后继任务的入度，将新的可执行任务加入队列。
代码实现
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
String[] dependencies = input.split(" ");
Set<String> allNodes = new HashSet<>();
Map<String, Set<String>> adj = new HashMap<>();
Map<String, Integer> inDegree = new HashMap<>();
for (String dep : dependencies) {
if (dep.isEmpty()) continue;
String[] parts = dep.split("->");
if (parts.length != 2) continue;
String x = parts[0];
String y = parts[1];
allNodes.add(x);
allNodes.add(y);
adj.computeIfAbsent(y, k -> new HashSet<>());
if (adj.get(y).add(x)) {
// 确保边不重复
inDegree.put(x, inDegree.getOrDefault(x, 0) + 1);
}
}
// 初始化入度：确保所有任务的入度被记录
for (String node : allNodes) {
inDegree.putIfAbsent(node, 0);
}
// 优先队列按字母顺序排序
PriorityQueue<String> queue = new PriorityQueue<>();
for (String node : inDegree.keySet()) {
if (inDegree.get(node) == 0) {
queue.offer(node);
}
}
List<String> result = new ArrayList<>();
while (!queue.isEmpty()) {
String curr = queue.poll();
result.add(curr);
if (adj.containsKey(curr)) {
for (String neighbor : adj.get(curr)) {
inDegree.put(neighbor, inDegree.get(neighbor) - 1);
if (inDegree.get(neighbor) == 0) {
queue.offer(neighbor);
}
}
}
}
System.out.println(String.join(" ", result));
}
}
代码解析
- 读取输入：使用
Scanner读取输入行，按空格分割得到多个依赖关系。 - 数据结构初始化：
allNodes：收集所有任务节点。adj：邻接表，记录每个节点的后续任务。inDegree：记录每个任务的入度数。
- 处理依赖关系：
- 分割每个依赖关系为X->Y，将X和Y加入节点集合。
- 构建邻接表，添加边Y→X，确保边不重复，并更新X的入度。
- 初始化入度：确保每个节点的入度被正确记录，即使没有依赖。
- 优先队列初始化：将所有入度为0的任务加入队列，按字典序排序。
- 拓扑排序：依次处理队列中的任务，更新其后继任务的入度，将新的可执行任务加入队列。
- 输出结果：将拓扑排序结果按空格连接输出。
示例测试
示例1输入：
A->B C->B
输出：
B A C
解析：B无依赖先执行，A和C依赖B，按字母顺序执行A后C。
示例2输入：
B->A C->A D->B
输出：
A B D C
解析：A无依赖先执行，B依赖A，执行B后D依赖B，最后执行C。
示例3输入：
X->Y Y->Z
输出：
Z Y X
解析：Z无依赖先执行，Y依赖Z，之后X依赖Y。
综合分析
- 时间复杂度：拓扑排序的时间复杂度为O(N + E)，其中N为任务数，E为边数。优先队列的插入和取出操作为O(log N)，整体复杂度O(N log N + E)。
- 空间复杂度：存储邻接表和入度表的空间复杂度为O(N + E)。
- 正确性：贪心选择字典序最小的任务保证了题目要求的顺序，拓扑排序确保依赖关系正确。
- 适用性：适用于任务调度、编译顺序等需要依赖管理的场景，高效处理数千级别的节点和边。
python
问题分析
我们需要根据任务的依赖关系确定执行顺序，多个可执行任务时按字母顺序选择。这可以通过拓扑排序结合贪心策略实现，使用优先队列处理当前可执行任务。
解题思路
- 构建依赖图：将每个任务的依赖关系转化为有向边，记录每个任务的入度（前置依赖的数量）。
- 优先队列初始化：将入度为0的任务按字母顺序加入优先队列。
- 拓扑排序：依次执行队列中的任务，减少其后继任务的入度，将新可执行任务加入队列。
- 处理顺序：按字母顺序选择任务，确保符合题目要求。
代码实现
import sys
import heapq
from collections import defaultdict
def main():
input_str = sys.stdin.read().strip()
dependencies = input_str.split()
adj = defaultdict(list)
in_degree = defaultdict(int)
all_nodes = set()
for dep in dependencies:
if '->' not in dep:
continue
x, y = dep.split('->')
all_nodes.add(x)
all_nodes.add(y)
adj[y]
