华为OD机试真题——启动多任务排序（2025B卷：200分）Java/python/JavaScript/C/C++/GO最佳实现

2025 B卷 200分 题型

本专栏内全部题目均提供Java、python、JavaScript、C、C++、GO六种语言的最佳实现方式；

并且每种语言均涵盖详细的问题分析、解题思路、代码实现、代码详解、3个测试用例以及综合分析；

本文收录于专栏：《2025华为OD真题目录+全流程解析+备考攻略+经验分享》

华为OD机试真题《启动多任务排序》：

---

文章快捷目录

题目描述及说明

Java

python

JavaScript

C++

C

GO

---

题目名称：启动多任务排序

---

1. 知识点：拓扑排序（贪心策略）、字符串处理、逻辑分析
2. 时间限制：1秒
3. 空间限制：256MB
4. 限定语言：不限

---

题目描述

一个应用启动时，会有多个初始化任务需要执行，且任务之间存在依赖关系。例如，任务A依赖任务B，则必须在B执行完成后才能开始执行A。现给出多条任务依赖规则，要求输出任务的执行顺序序列。规则采用贪婪策略：

1. 若任务无依赖，则立即执行。
2. 若多个任务可同时执行，按任务名称的字母顺序排序。

输入描述

• 输入参数为多个依赖关系，用空格分隔。
• 依赖关系格式为 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

问题分析

我们需要解决任务的执行顺序问题，任务之间存在依赖关系，同时在多个任务可执行时按字母顺序选择。这属于典型的拓扑排序问题，但需要结合贪心策略选择字典序最小的任务。

解题思路

1. 构建依赖图：将所有任务及其依赖关系转化为有向图，边表示依赖方向。
2. 统计入度：记录每个任务的入度（前置依赖的数量）。
3. 优先队列处理：使用优先队列存储当前可执行的任务（入度为0），按字母顺序取出任务。
4. 拓扑排序：依次处理队列中的任务，减少其后继任务的入度，将新的可执行任务加入队列。

代码实现

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));}
}

代码解析

1. 读取输入：使用 Scanner 读取输入行，按空格分割得到多个依赖关系。
2. 数据结构初始化：
   • allNodes：收集所有任务节点。
   • adj：邻接表，记录每个节点的后续任务。
   • inDegree：记录每个任务的入度数。
3. 处理依赖关系：
   • 分割每个依赖关系为X->Y，将X和Y加入节点集合。
   • 构建邻接表，添加边Y→X，确保边不重复，并更新X的入度。
4. 初始化入度：确保每个节点的入度被正确记录，即使没有依赖。
5. 优先队列初始化：将所有入度为0的任务加入队列，按字典序排序。
6. 拓扑排序：依次处理队列中的任务，更新其后继任务的入度，将新的可执行任务加入队列。
7. 输出结果：将拓扑排序结果按空格连接输出。

示例测试

示例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

问题分析

我们需要根据任务的依赖关系确定执行顺序，多个可执行任务时按字母顺序选择。这可以通过拓扑排序结合贪心策略实现，使用优先队列处理当前可执行任务。

解题思路

1. 构建依赖图：将每个任务的依赖关系转化为有向边，记录每个任务的入度（前置依赖的数量）。
2. 优先队列初始化：将入度为0的任务按字母顺序加入优先队列。
3. 拓扑排序：依次执行队列中的任务，减少其后继任务的入度，将新可执行任务加入队列。
4. 处理顺序：按字母顺序选择任务，确保符合题目要求。

代码实现

import sys
import heapq
from collections import defaultdictdef 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:continuex, y = dep.split('->')all_nodes.add(x)all_nodes.add(y)adj[y]