区间调度

这是我参与2022首次更文挑战的第2天，活动详情查看：2022首次更文挑战

题目描述

给你一个二维数组 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 并进入空闲状态

思路

其实学过操作系统的话，就很容易理解题目了，CPU任务在执行期间可以分为两种情况：

1. cpu空闲

即当前任务队列没有需要处理的数据，那么想要获取第一条数据，必先等待时间最近的任务开始，即按照开始时间优先的顺序获取新任务。如果任务开始时间相等，任务执行时长短的优先，这是cpu空闲时的入队规则；

2. cpu不空闲

   就是当前cpu有任务在执行的情况，这时任务队列有多个任务同时存在，没有等待最近时间任务的必要，此时就可以直接以题目要求的规则获取任务。

然后照着上面的思路写代码就OK了。

class Solution {
    class Task {
        //需要新增一个id用来记录序号
        int id;
        int enqueueTime;
        int processingTime;

        public Task(int id, int enqueueTime, int processingTime) {
            this.id = id;
            this.enqueueTime = enqueueTime;
            this.processingTime = processingTime;
        }
    }

    public int[] getOrder(int[][] tasks) {

        //维护一个新的带id的列表
        List<Task> taskList = new ArrayList<>();

        //把原始数据放入这个新的列表中
        for (int i = 0; i < tasks.length; i++) {
            taskList.add(new Task(i, tasks[i][0], tasks[i][1]));
        }

        //按照入队时间排序
        taskList.sort(Comparator.comparingInt(t -> t.enqueueTime));

        //记录当前时间
        long currentTime = 0;

        //使用最小堆来获取下一个要执行的任务
        PriorityQueue<Task> minHeap = new PriorityQueue<>((o1, o2) -> {
            //当执行时间相同的时候,按照id升序排列
            if (o1.processingTime == o2.processingTime)
                return o1.id - o2.id;
            else {
                return o1.processingTime - o2.processingTime;
            }
        });

        int index_taskList = 0;
        int index_ret = 0;
        int[] ret = new int[tasks.length];

        for (int i = 0; i < tasks.length; i++) {

            //如果队列里没有要执行的操作就直接快进
            if (minHeap.isEmpty()) {
                //更新当前时间
                currentTime = Math.max(currentTime, taskList.get(index_taskList).enqueueTime);
            }

            //把小于等于当前时间的任务找出来,加到队列里
            while (index_taskList < tasks.length && taskList.get(index_taskList).enqueueTime <= currentTime) {
                minHeap.offer(taskList.get(index_taskList));
                index_taskList++;
            }

            //从队列里选处理时间最小的任务出来进行处理
            Task task = minHeap.poll();
            ret[index_ret++] = task.id;
            currentTime += task.processingTime;
        }

        return ret;
    }
}