1834. 单线程 CPU#

1
给你一个二维数组 tasks ，用于表示 n 项从 0 到 n - 1 编号的任务。
2

3
其中 tasks[i] = [enqueueTimei, processingTimei]
4

5
意味着第 i 项任务将会于 enqueueTimei 时进入任务队列
6

7
需要 processingTimei 的时长完成执行。
8

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

11
如果 CPU 空闲，且任务队列中没有需要执行的任务，则 CPU 保持空闲状态。
12

13
如果 CPU 空闲，但任务队列中有需要执行的任务，则 CPU 将会选择 执行时间最短 的任务开始执行。
14

15
如果多个任务具有同样的最短执行时间，则选择下标最小的任务开始执行。
16
一旦某项任务开始执行，CPU 在 执行完整个任务 前都不会停止。
17
CPU 可以在完成一项任务后，立即开始执行一项新任务。
18
返回 CPU 处理任务的顺序。
19

20

21

22
示例 1：
23

24
输入：tasks = [[1,2],[2,4],[3,2],[4,1]]
25
输出：[0,2,3,1]
26
解释：事件按下述流程运行：
27
- time = 1 ，任务 0 进入任务队列，可执行任务项 = {0}
28
- 同样在 time = 1 ，空闲状态的 CPU 开始执行任务 0 ，可执行任务项 = {}
29
- time = 2 ，任务 1 进入任务队列，可执行任务项 = {1}
30
- time = 3 ，任务 2 进入任务队列，可执行任务项 = {1, 2}
31
- 同样在 time = 3 ，CPU 完成任务 0 并开始执行队列中用时最短的任务 2 ，可执行任务项 = {1}
32
- time = 4 ，任务 3 进入任务队列，可执行任务项 = {1, 3}
33
- time = 5 ，CPU 完成任务 2 并开始执行队列中用时最短的任务 3 ，可执行任务项 = {1}
34
- time = 6 ，CPU 完成任务 3 并开始执行任务 1 ，可执行任务项 = {}
35
- time = 10 ，CPU 完成任务 1 并进入空闲状态
36
示例 2：
37

38
输入：tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]
39
输出：[4,3,2,0,1]
40
解释：事件按下述流程运行：
41
- time = 7 ，所有任务同时进入任务队列，可执行任务项  = {0,1,2,3,4}
42
- 同样在 time = 7 ，空闲状态的 CPU 开始执行任务 4 ，可执行任务项 = {0,1,2,3}
43
- time = 9 ，CPU 完成任务 4 并开始执行任务 3 ，可执行任务项 = {0,1,2}
44
- time = 13 ，CPU 完成任务 3 并开始执行任务 2 ，可执行任务项 = {0,1}
45
- time = 18 ，CPU 完成任务 2 并开始执行任务 0 ，可执行任务项 = {1}
46
- time = 28 ，CPU 完成任务 0 并开始执行任务 1 ，可执行任务项 = {}
47
- time = 40 ，CPU 完成任务 1 并进入空闲状态
48

49

50
提示：
51

52
tasks.length == n
53
1 <= n <= 105
54
1 <= enqueueTimei, processingTimei <= 109

1
//task index序列号 start为进入队列时间 times为完成时间
2
class task {
3
public:
4
    int index;
5
    int start;
6
    int times;
7
    task(int index, int start, int times) : index(index), start(start), times(times) {}
8
    task() = default;
9
};
10

11
class Solution {
12
public:
13
    vector<int> getOrder(vector<vector<int>> &tasks)
14
    {
15
        vector<int> ans;
16
        auto cmptimes = [](task a, task b)
17
        {
18
            if (a.times == b.times) return a.index > b.index;
19
            else return a.times > b.times;
20
        };
21

22
        auto cmpstart = [](task a, task b)
23
        {
24
            return a.start > b.start;
25
        };
26

27
        priority_queue<task, vector<task>, decltype(cmptimes)> qtimes(cmptimes);
28
        priority_queue<task, vector<task>, decltype(cmpstart)> qstart(cmpstart);
29
        int n = tasks.size();
30

31
        for(int i = 0; i < n; ++i)
32
        {
33
            qstart.push({i, tasks[i][0], tasks[i][1]});
34
        }
35

36
        int now = qstart.top().start;
37
        while(qstart.size() > 0)
38
        {
39

40
            while (qstart.size() > 0 && qstart.top().start <= now)
41
            {
42
                qtimes.push(qstart.top());
43
                qstart.pop();
44
            }
45
            if (qtimes.size() > 0)
46
            {
47
                task x = qtimes.top();
48
                qtimes.pop();
49
                ans.push_back(x.index);
50
                now += x.times;
51
            }
52
            else
53
            {
54
                now = qstart.top().start;
55
            }
56
        }
57

58
        while (qtimes.size() > 0)
59
        {
60
            task x = qtimes.top();
61
            qtimes.pop();
62
            ans.push_back(x.index);
63
        }
64
        return ans;
65
    }
66
};