LeetCode 1834. 单线程 CPU(排序 + 优先队列)

文章目录

1. 题目

给你一个二维数组 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

https://leetcode-cn.com/contest/weekly-contest-237/problems/single-threaded-cpu/

2. 解题

  • 先按时间排序任务,将任务加入优先队列
  • 优先队列出列的时候,更新当前时间,然后将到时间了的,需要执行的任务加入优先队列,重复此步骤
typedef pair<int,int> pii;
struct cmp{
    bool operator()(pii& a, pii& b) const
    {                           // 持续时间,下标 piar
        if(a.first == b.first) 
            return a.second > b.second;//下标小的优先
        return a.first > b.first;//持续时间短的优先
    }
};

class Solution {
public:
    vector<int> getOrder(vector<vector<int>>& tasks) {
        int n = tasks.size(), k = 0;
        vector<int> ans(n);
        vector<int> idx(n);
        iota(idx.begin(), idx.end(), 0);
        sort(idx.begin(), idx.end(),[&](auto a, auto b){
            return tasks[a][0] < tasks[b][0];//按开始时间排序
        });
        priority_queue<pii,vector<pii>,cmp> q;
        // 存储 {持续时间,下标}
        int t = 0;
        for(int i = 0; i < n; )
        {
            while(i < n && tasks[idx[i]][0] <= t)
            { 	// 等待执行的任务,加入队列
                q.push({tasks[idx[i]][1], idx[i]});
                i++;
            }
            if(!q.empty())
            {	// 做任务,优先级最高的先
                int delta = q.top().first, id = q.top().second;
                int start = tasks[id][0]; // 任务开始时间
                q.pop();
                ans[k++] = id;
                t = max(t, start);//当前时间
                t += delta;// t 为干完活的时间
            }
            else // 队列为空,时间移到下一个任务
            {
                t = tasks[idx[i]][0];
            }
        }
        while(!q.empty())
        {
            int id = q.top().second;
            q.pop();
            ans[k++] = id;
        }
        return ans;
    }
};

576 ms 112.1 MB C++


我的CSDN博客地址 https://michael.blog.csdn.net/

长按或扫码关注我的公众号(Michael阿明),一起加油、一起学习进步!
Michael阿明

相关推荐
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页