1834 单线程 CPU（lambda表达式排序 + 优先队列）

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 <= 105
• 1 <= enqueueTime, processingTime<= 109

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/single-threaded-cpu

2. 思路分析：

分析题目可以知道需要根据任务的入队时间对任务进行入队，在队列中如果含有多个任务时选择执行时间较短的任务执行，根据这个过程知道可以使用优先队列（小根堆）解决。优先队列可以赋予元素优先级，这样就可以根据队列中元素的优先级高低来处理对应的元素。因为使用的是python语言，所以可以使用python标准库中的heapq模块中的方法进行优先队列的相关操作，heapq可以将一个列表初始化为一个小根堆。首先我们需要根据入队时间较早的任务进行入队，可以对所有的任务按照入队时间进行排序，但是这里有一个问题就是通过排序之后任务的编号信息就丢失了，这里可以采用先声明一个元素值为[0, n）的列表numbers，其中n表示任务的数目，然后使用lambda表达式定义按照任务的入队时间进行排序，这样排序之后就不会丢失任务的编号信息，列表中排列在前面的元素就是入队时间较早的任务编号。其次是对任务进行入队，这里需要维护一个int类型的变量timestamp用来记录当前任务的完成时间，这样就可以将所有入队时间小于等于timestamp的任务都进行入队，使用heapq.heappush()方法对其入队，这样在入队的时候就可以维护一个小根堆，队列中的元素为元组类型，第一个值为当前任务的执行时间，第二个值为当前任务的编号，执行时间越短那么在进入队列的时候就会被放在队首（heapq.heappush()方法在加入元素的时候会维持堆的不变性，当加入队列的中元素为元组类型的时候按照元组的第一个值来维护小根堆），当所有入队时间小于等于timestamp的任务都入队之后那么执行队列中执行时间最短的那个任务，也即弹出队首元素并将任务编号结果加入到结果集中，更新当前任务的完成时间这样每一次都是执行一个任务，最后返回结果即可

3. 代码如下：

from typing import List
import heapq


class Solution:
    def getOrder(self, tasks: List[List[int]]) -> List[int]:
        timestamp = 0
        # 因为对task排序之后会丢失掉任务的编号信息所以需要一个额外的变量numbers记录任务的编号
        n = len(tasks)
        numbers = list(range(n))
        # 按照入队时间的先后顺序对任务的编号进行排序
        numbers.sort(key=lambda x: tasks[x][0])
        pos = 0
        q, res = list(), list()
        for i in range(n):
            if not q:
                timestamp = max(timestamp, tasks[numbers[pos]][0])
            # 将符合条件的多个任务入队
            while pos < n and tasks[numbers[pos]][0] <= timestamp:
                heapq.heappush(q, (tasks[numbers[pos]][1], numbers[pos]))
                pos += 1
            # 每一次执行一个任务
            processTime, index = heapq.heappop(q)
            # 更新任务的完成时间
            timestamp += processTime
            res.append(index)
        return res