1834. 单线程 CPU #

问题描述#

给你一个二维数组 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 处理任务的顺序。

示例 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⁵

1 <= enqueueTime_i, processingTime_i <= 10⁹

解题思路#

首先需要根据 \([\text{enqueueTime}_i, \text{processingTime}_i, i]\) 排序，得到结果 V。

然后选择 V[0] 执行，并在 V 中移除该任务，得到执行结束时间 end。

然后在 V 中选择 所有入队时间小于等于 end 的任务，放入到最小堆 S 中，从中选择 执行时间最短的任务 作为执行任务，并更新 end。

如果 V 中没有 入队时间小于等于 end 的任务，则选择第一个任务执行。

Python

class Solution:
    def getOrder(self, tasks: List[List[int]]) -> List[int]:
        V = [(e, p, i) for i, (e, p) in enumerate(tasks)]
        V.sort(reverse=True)

        S, ans, begin = [], [], 0

        while V:
            while V and V[-1][0] <= begin:
                heappush(S, (V[-1][1], V[-1][2]))
                V.pop()

            if not S:
                begin = V[-1][0]
                heappush(S, (V[-1][1], V[-1][2]))
                V.pop()

            p, i = heappop(S)
            ans.append(i)
            begin += p

        while S:
            _, i = heappop(S)
            ans.append(i)

        return ans

C++

class Solution {
public:
    vector<int> getOrder(vector<vector<int>>& tasks) {
        int n = tasks.size();
        vector<tuple<int, int, int>> V;

        for (int i = 0; i < n; ++i) {
            V.emplace_back(tasks[i][0], tasks[i][1], i);
        }

        sort(V.begin(), V.end(), greater<>());

        int begin = 0;
        set<pair<int, int>> S;
        vector<int> ans;

        while (!V.empty()) {
            while (!V.empty() && get<0>(V.back()) <= begin) {
                S.emplace(get<1>(V.back()), get<2>(V.back()));
                V.pop_back();
            }

            if (S.empty()) {
                auto &[e, p, i] = V.back();

                begin = e;
                S.emplace(p, i);
                V.pop_back();
            }

            ans.emplace_back(S.begin()->second);
            begin += S.begin()->first;
            S.erase(S.begin());
        }

        while (!S.empty()) {
            ans.emplace_back(S.begin()->second);
            S.erase(S.begin());
        }

        return ans;
    }
};

时间复杂度：\(\mathcal{O}(n\log(n))\)
空间复杂度：\(\mathcal{O}(n)\)

1834. 单线程 CPU#

问题描述#

解题思路#

1834. 单线程 CPU #