【数据结构-堆】力扣1834. 单线程 CPU

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

小根堆

csharp 复制代码

class Solution {
public:
    vector<int> getOrder(vector<vector<int>>& tasks) {
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
        int n = tasks.size();
        vector<int> indices(n);
        iota(indices.begin(), indices.end(), 0);
        sort(indices.begin(), indices.end(), [&](int i, int j) {
            return tasks[i][0] < tasks[j][0];
        });

        vector<int> ans;
        long long t = 0;
        int p = 0;

        for(int i = 0; i < n; i++){
            if(q.empty()){
                t = max(t, (long long)tasks[indices[p]][0]);
            }

            while(p < n && tasks[indices[p]][0] <= t){
                q.emplace(tasks[indices[p]][1], indices[p]);
                p++;
            }

            auto&& [process, index] = q.top();
            t += process;
            ans.push_back(index);
            q.pop();
        }
        return ans;
    }
};

这道题我们需要理清顺序，我们需要有一个时间轴，然后将时间轴上的任务加到任务列表tasks中。当cpu处理任务的时候，可以认为中间不进行任何操作，当处理完后，时间轴来到了t，那么就要将时间小于t的所有任务加入到q中，然后我们q的队头就是执行时间最短的任务，将它丢到cpu中执行。

由于我们不是每个时间都有任务，所以我们定义一个indices数组，用来对tasks的任务的开始时间进行索引排序，使得indices内tasks任务的索引顺序是根据其开始时间进行升序排序。那么当我们q中没有任务的时候我们需要找到下一个任务的开始时间，那么可以直接使时间轴的时间 t = max(t, (long long)tasks[indices[p]][0]);。因为我们每次循环会使cpu执行一次任务，那么我们最外层循环n次即可。