题目描述

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

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

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

返回 CPU 处理任务的顺序。

样例

输入：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 并进入空闲状态

输入：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

算法

(模拟，堆/优先队列) $O(n \log n)$

1. 将任务按照入队时间排序，入队时间相同的，按照处理时间从短到长排序。排序后需要记录原数组的下标。
2. 建立一个小跟堆，记录当前已经入队但尚未处理的任务。
3. 每次从小跟堆的堆顶取出一个任务（如果取不出任务，则将下一个尚未入队的任务插入小跟堆），记录当前任务结束后的时间，将在此时间结束前的所有尚未入队的任务入队。
4. 循环以上过程，直到堆中不存在任务以及不存在尚未入队的任务。

时间复杂度

• 排序需要 $O(n \log n)$ 的时间。
• 每个任务入堆一次，出堆一次，且出入堆的总时间复杂度为 $O(\log n)$。
• 故总时间复杂度为 $O(n \log n)$。

空间复杂度

• 需要 $O(n)$ 的额外空间存储排序后的任务数组、堆和答案。

C++ 代码

#define LL long long

struct Task {
    int idx;
    int enque, proc;
    Task(int idx_, int enque_, int proc_):idx(idx_),enque(enque_),proc(proc_){}

    bool operator < (const Task &t) const {
        if (proc != t.proc)
            return proc > t.proc;
        return idx > t.idx;
    }
};

class Solution {
public:
    vector<int> getOrder(vector<vector<int>>& tasks) {
        const int n = tasks.size();
        vector<Task> qt;

        for (int i = 0; i < n; i++)
            qt.push_back(Task(i, tasks[i][0], tasks[i][1]));

        sort(qt.begin(), qt.end(), [](const Task &a, const Task &b) {
            if (a.enque != b.enque)
                return a.enque < b.enque;
            return a.proc < b.proc;
        });

        priority_queue<Task> heap;

        vector<int> ans;
        int cur_task = 0;
        LL cur_time = 0;
        while (!heap.empty() || cur_task < n) {

            if (heap.empty()) {
                heap.push(qt[cur_task]);
                cur_time = qt[cur_task].enque;
                cur_task++;
            }

            Task top = heap.top();
            heap.pop();
            ans.push_back(top.idx);

            cur_time += top.proc;

            while (cur_task < n) {
                if (qt[cur_task].enque <= cur_time) {
                    heap.push(qt[cur_task]);
                    cur_task++;
                } else {
                    break;
                }
            }
        }

        return ans;
    }
};