LeetCode——1834. 单线程 CPU(Single-Threaded CPU)[中等]——分析及代码（Java）

一、题目

给你一个二维数组 tasks ，用于表示 n 项从 0 到 n - 1 编号的任务。其中 tasks[i] = [enqueueTimei, processingTimei] 意味着第 i 项任务将会于 enqueueTimei 时进入任务队列，需要 processingTimei 的时长完成执行。

现有一个单线程 CPU ，同一时间只能执行 最多一项 任务，该 CPU 将会按照下述方式运行：

• 如果 CPU 空闲，且任务队列中没有需要执行的任务，则 CPU 保持空闲状态。
• 如果 CPU 空闲，但任务队列中有需要执行的任务，则 CPU 将会选择 执行时间最短 的任务开始执行。如果多个任务具有同样的最短执行时间，则选择下标最小的任务开始执行。
• 一旦某项任务开始执行，CPU 在 执行完整个任务 前都不会停止。
• CPU 可以在完成一项任务后，立即开始执行一项新任务。

返回 CPU 处理任务的顺序。

示例 1：

输入：tasks = [[1,2],[2,4],[3,2],[4,1]]
输出：[0,2,3,1]
解释：事件按下述流程运行： 
- time = 1 ，任务 0 进入任务队列，可执行任务项 = {0}
- 同样在 time = 1 ，空闲状态的 CPU 开始执行任务 0 ，可执行任务项 = {}
- time = 2 ，任务 1 进入任务队列，可执行任务项 = {1}
- time = 3 ，任务 2 进入任务队列，可执行任务项 = {1, 2}
- 同样在 time = 3 ，CPU 完成任务 0 并开始执行队列中用时最短的任务 2 ，可执行任务项 = {1}
- time = 4 ，任务 3 进入任务队列，可执行任务项 = {1, 3}
- time = 5 ，CPU 完成任务 2 并开始执行队列中用时最短的任务 3 ，可执行任务项 = {1}
- time = 6 ，CPU 完成任务 3 并开始执行任务 1 ，可执行任务项 = {}
- time = 10 ，CPU 完成任务 1 并进入空闲状态

示例 2：

输入：tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]
输出：[4,3,2,0,1]
解释：事件按下述流程运行： 
- time = 7 ，所有任务同时进入任务队列，可执行任务项  = {0,1,2,3,4}
- 同样在 time = 7 ，空闲状态的 CPU 开始执行任务 4 ，可执行任务项 = {0,1,2,3}
- time = 9 ，CPU 完成任务 4 并开始执行任务 3 ，可执行任务项 = {0,1,2}
- time = 13 ，CPU 完成任务 3 并开始执行任务 2 ，可执行任务项 = {0,1}
- time = 18 ，CPU 完成任务 2 并开始执行任务 0 ，可执行任务项 = {1}
- time = 28 ，CPU 完成任务 0 并开始执行任务 1 ，可执行任务项 = {}
- time = 40 ，CPU 完成任务 1 并进入空闲状态

提示：

• tasks.length == n
• 1 <= n <= 10^5
• 1 <= enqueueTimei, processingTimei <= 10^9

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/single-threaded-cpu
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析及代码

1. 优先队列

（1）思路

设计一个优先队列（堆），将任务按起始时间排序后，根据当前时间线依次入队，再从队列中根据题目要求取出优先级最高的任务执行，直至完成全部任务。

（2）代码

class Solution {
    public int[] getOrder(int[][] tasks) {
        int n = tasks.length;
        int[] ans = new int[n];//待求的任务处理顺序
        PriorityQueue<int[]> toDo = new PriorityQueue<int[]>(new Comparator<int[]>() {
            public int compare(int[] a, int[] b) {
                if (a[1] != b[1])//注意Integer比较用equals和compareTo
                    return a[1] - b[1];
                return a[2] - b[2];
            }
        });
        int[][] newTasks = new int[n][3];//添加任务序号信息
        for (int i = 0; i < n; i++) {
            newTasks[i][0] = tasks[i][0];
            newTasks[i][1] = tasks[i][1];
            newTasks[i][2] = i;
        }
        Arrays.sort(newTasks, (t1, t2) -> t1[0] - t2[0]);//将任务按时间排序
        
        int t = 0, index = 0, i = 0;//当前时间，已执行任务数，已入队任务数
        while (index < n) {
            if (toDo.isEmpty())//若队列为空且当前时间小于下一任务起始时间，直接跳到该起始时间
                t = Math.max(t, newTasks[i][0]);
            while (i < n && newTasks[i][0] <= t)//将起始时间不超过当前时间的任务都入队
                toDo.offer(newTasks[i++]);
            int[] task = toDo.poll();//选取优先执行的任务
            ans[index++] = task[2];
            t += task[1];
        }
        return ans;
    }
}

（3）结果

执行用时 ：133 ms，在所有 Java 提交中击败了 76.52% 的用户；
内存消耗 ：94.9 MB，在所有 Java 提交中击败了 26.82% 的用户。

三、其他

暂无。