leetcode 1834. 单线程 CPU

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

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

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

返回 CPU 处理任务的顺序。

leetcode 单线程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 <= 105
• 1 <= enqueueTimei, processingTimei <= 1000000000

思路：
1、我们将数组task 中的所有任务按照 ienqueueTime 升序排序，但是要保证数组的下标，所以需要将task[i]的下标存入task[i]中。
2、因为任务的执行有先后顺序，我们将所有分配给 CPU 的任务放入优先队列中，按照题意自定义排序，并且每次取出处理时间 iprocessingTime 最小的任务执行
3、如果队列为空，直接快进时间至下一个将会进入队列的任务的起始时间。
4、将 开始时间<=当前时间 的所有任务加入到优先队列

struct cmp{
    bool operator()(vector<int>& a, vector<int>& b){
        if(a[1] == b[1]){   // 所需时间相同, 下标小的任务排前面
            return a[2] > b[2];
        }
        return a[1] > b[1];  // 所需时间短任务的排前面
    }
};

bool sortcmp(const vector<int> &a, const vector<int> &b) {
    return a[0] < b[0];   // 先来的任务排前面
}
class Solution {
public:
    vector<int> getOrder(vector<vector<int>>& tasks) {
        int n = tasks.size();
        // 将任务的id与任务绑定
        for(int i=0; i<n; i++){
            tasks[i].push_back(i);
        }
        sort(tasks.begin(), tasks.end(), sortcmp); 
        //小根堆，{起始时间，执行时间，id下标}
        priority_queue <vector<int>, vector<vector<int>>, cmp> pq;
        //注意类型，int会溢出
        long long time = 0;
        int k = 0;
        vector<int> res;
        for(int i=0; i<n; i++){
            //如果为空，快进时间
            if(pq.empty()){
                time = max((long long)tasks[k][0], time);//类型
            }
            // 将所有起始时间小于等于时间戳的任务放入优先队列
            while(k < n && tasks[k][0] <= time){
                pq.push(tasks[k]);
                k++;
            }
            //取堆顶
            auto ans = pq.top();
            pq.pop();
            time += ans[1];        //更新时间
            res.push_back(ans[2]); 
        }
        return res;
    }
};