华为OD机试真题——模拟工作队列（2025A卷：200分）Java/python/JavaScript/C/C++/GO最佳实现

2025 A卷 200分 题型

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

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

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

华为OD机试真题《模拟工作队列》：

---

文章快捷目录

题目描述及说明

Java

python

JavaScript

C

GO

---

题目名称：模拟工作队列

---

• 知识点：优先队列（堆）、事件模拟、逻辑处理
• 时间限制：1秒
• 空间限制：256MB
• 限定语言：不限

---

题目描述

模拟一个工作队列的运作，包含一个任务提交者和若干任务执行者（编号从1开始）。提交者在给定时刻向队列提交任务（含执行时间），执行者取出任务的时刻加上执行时间即为完成时刻。任务完成后，执行者从队列中取最老的任务执行；若多个执行者空闲，编号小的优先。

队列规则：

1. 队列有最大长度限制，满时新任务加入会丢弃最老任务。
2. 若队列满且新任务提交时刻与执行者空闲时刻相同，则先取出最老任务执行，再加入新任务。

输入：

• 第一行：2N个正整数，表示N个任务的提交时刻和执行时间（按提交时刻升序排列）。
• 第二行：两个整数，分别为队列最大长度和执行者数量。

输出：

• 最后一个任务完成时刻和被丢弃的任务数量，用空格分隔。

示例1：
输入：

1 3 2 2 3 3  
3 2  

输出：

7 0  

说明：队列未满，无任务丢弃。

示例2：
输入：

1 6 2 4 4 3 6 3  
1 2  

输出：

10 0  

说明：队列满但执行顺序避免丢弃。

---

Java

问题分析

我们需要模拟一个工作队列，处理任务的提交和执行者的调度。队列有最大长度限制，当队列满时新任务会丢弃最老的任务。执行者在空闲时会立即从队列中取出任务执行。输出最后完成时间和被丢弃的任务数。

解题思路

1. 优先队列管理执行者：使用优先队列（最小堆）按执行者的完成时间和编号排序，以快速获取空闲的执行者。
2. 任务队列管理：使用FIFO队列保存待处理的任务。
3. 事件处理顺序：
   • 处理每个任务提交时，先处理所有执行者的完成时间小于等于当前时间的事件。
   • 提交任务，处理队列满时的丢弃逻辑。
   • 再次处理执行者的完成时间小于等于当前时间的事件。
4. 处理剩余任务：在所有任务提交后，处理队列中剩余的任务。

代码实现

import java.util.*;

public class Main {
   

    static class Worker implements Comparable<Worker> {
   
        int time; // 执行者的空闲时间
        int id;

        public Worker(int time, int id) {
   
            this.time = time;
            this.id = id;
        }

        @Override
        public int compareTo(Worker other) {
   
            if (this.time != other.time) {
   
                return Integer.compare(this.time, other.time);
            } else {
   
                return Integer.compare(this.id, other.id);
            }
        }
    }

    public static void main(String[] args) {
   
        Scanner scanner = new Scanner(System.in);
        String[] taskInput = scanner.nextLine().split(" ");
        int n = taskInput.length / 2;

        int[] submitTimes = new int[n];
        int[] durations = new int[n];
        for (int i = 0; i < n; i++) {
   
            submitTimes[i] = Integer.parseInt(taskInput[2 * i]);
            durations[i] = Integer.parseInt(taskInput[2 * i + 1]);
        }

        int maxQueueSize = scanner.nextInt();
        int workerCount = scanner.nextInt();

        PriorityQueue<Worker> workerQueue = new PriorityQueue<>();
        for (int i = 1; i <= workerCount; i++) {
   
            workerQueue.add(new Worker(0, i));
        }

        Queue<Integer> taskQueue = new LinkedList<>();
        int discardCount = 0;
        int[] lastFinishTime = {
   0};

        for (int i = 0; i < n; i++) {
   
            int t = submitTimes[i];
            int d = durations[i];

            processWorkers(workerQueue, taskQueue, t, lastFinishTime);

            if (taskQueue.size() >= maxQueueSize) {
   
                taskQueue.poll();
                discardCount++;
            }

            taskQueue.add(d);
            processWorkers(workerQueue, taskQueue, t, lastFinishTime);
        }

        processRemainingTasks(workerQueue, taskQueue, lastFinishTime);

        System.out.println(lastFinishTime[0] + " " + discardCount);
    }

    private static void processWorkers(PriorityQueue<Worker> workerQueue, Queue<Integer> taskQueue, int currentTime, int[] lastFinishTime) {
   
        while (!workerQueue.isEmpty()) {
   
            Worker worker = workerQueue.peek();
            if (worker.time > currentTime) {
   
                break;
            }
            worker = workerQueue.poll();

            if (taskQueue.isEmpty()) {
   
                workerQueue.add(worker);
                break;
            }

            int duration = taskQueue.poll();
            worker.time += duration;
            if (worker.time > lastFinishTime[0]) {
   
                lastFinishTime[0] = worker.time;
            }
            workerQueue.add(worker);
        }
    }

    private static void processRemainingTasks(PriorityQueue<Worker> workerQueue, Queue<Integer> taskQueue, int[] lastFinishTime) {
   
        while (!taskQueue.isEmpty()) {
   
            Worker worker = workerQueue.poll();
            if (worker == null) break;

            int duration = taskQueue.poll();
            worker.time += duration;
            if (worker.time > lastFinishTime[0]) {
   
                lastFinishTime[0] = worker.time;
            }
            workerQueue.add(worker);
        }
    }
}

代码详解

1. Worker类：表示执行者，包含空闲时间和编号，按完成时间和编号排序。
2. 输入处理：读取任务列表、队列长度和执行者数量。
3. 初始化执行者队列：所有执行者初始空闲时间为0。
4. 处理每个任务提交：
   • processWorkers处理所有执行者完成时间小于等于当前时间的事件，取出任务执行。
   • 检查队列是否满，丢弃旧任务并计数。
   • 将新任务加入队列，再次处理执行者事件。
5. 处理剩余任务：在所有任务提交后，确保队列中的任务被处理完。
6. 输出结果：最后完成时间和丢弃任务数。

示例测试

示例1：
输入：

1 3 2 2 3 3  
3 2  

输出：

7 0  

解析：所有任务被及时处理，无丢弃，最后完成时间为7。

示例2：
输入：

1 6 2 4 4 3 6 3  
1 2  

输出：

10 0  

解析：队列满时丢弃被避免，最后完成时间为10，无丢弃。

示例3：
输入：

2,2  
1 1  

输出：

4 0  

解析：任务在队列中等待，执行者处理完所有任务，最后完成时间4。

综合分析

1. 时间复杂度：每个任务处理两次优先队列操作，O(N log K)，其中K为执行者数量。
2. 空间复杂度：O(K + M)，K为执行者数量，M为队列最大长度。
3. 最优性：优先队列确保每次选择最早空闲的执行者，FIFO队列保证任务顺序，处理逻辑高效。
4. 适用性：适用于任务按时间顺序提交的场景，正确处理队列满和任务丢弃逻辑。

---

python

问题分析

我们需要模拟一个工作队列，处理任务的提交和执行者的调度。队列有最大长度限制，当队列满时新任务会丢弃最老的任务。执行者在空闲时会立即从队列中取出任务执行。输出最后完成时间和被丢弃的任务数。

解题思路

1. 事件驱动模拟：按时间顺序处理任务提交和执行者空闲事件。
2. 优先队列：管理执行者的空闲事件，确保空闲时间早的执行者优先处理任务。
3. 队列管理：使用FIFO队列保存任务，处理队列满时的丢弃逻辑。
4. 完成时间计算：跟踪每个任务的完成时间，更新最大完成时间。

代码实现

import heapq
from collections import deque

def main():
    # 读取输入
    task_input = list(map(int, input().split()))
    queue_size, worker_count = map(int, input().split())
    
    # 解析任务列表，按提交时间排序
    tasks = []
    for i in range(0, len(task_input), 2):
        submit_time = task_input[i]
        duration = task_input[i+1]
        tasks.append((submit_time, duration))
    tasks<