## Description

You are given n​​​​​​ tasks labeled from 0 to n - 1 represented by a 2D integer array tasks, where tasks[i] = [enqueueTimei, processingTimei] means that the i​​​​​​th​​​​ task will be available to process at enqueueTimei and will take processingTimei to finish processing.

You have a single-threaded CPU that can process at most one task at a time and will act in the following way:

• If the CPU is idle and there are no available tasks to process, the CPU remains idle.
• If the CPU is idle and there are available tasks, the CPU will choose the one with the shortest processing time. If multiple tasks have the same shortest processing time, it will choose the task with the smallest index.
• Once a task is started, the CPU will process the entire task without stopping.
• The CPU can finish a task then start a new one instantly.

Return the order in which the CPU will process the tasks.

Example 1:

Input: tasks = [[1,2],[2,4],[3,2],[4,1]]
Output: [0,2,3,1]
Explanation: The events go as follows:
- At time = 1, task 0 is available to process. Available tasks = {0}.
- Also at time = 1, the idle CPU starts processing task 0. Available tasks = {}.
- At time = 2, task 1 is available to process. Available tasks = {1}.
- At time = 3, task 2 is available to process. Available tasks = {1, 2}.
- Also at time = 3, the CPU finishes task 0 and starts processing task 2 as it is the shortest. Available tasks = {1}.
- At time = 4, task 3 is available to process. Available tasks = {1, 3}.
- At time = 5, the CPU finishes task 2 and starts processing task 3 as it is the shortest. Available tasks = {1}.
- At time = 6, the CPU finishes task 3 and starts processing task 1. Available tasks = {}.
- At time = 10, the CPU finishes task 1 and becomes idle.


Example 2:

Input: tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]
Output: [4,3,2,0,1]
Explanation: The events go as follows:
- At time = 7, all the tasks become available. Available tasks = {0,1,2,3,4}.
- Also at time = 7, the idle CPU starts processing task 4. Available tasks = {0,1,2,3}.
- At time = 9, the CPU finishes task 4 and starts processing task 3. Available tasks = {0,1,2}.
- At time = 13, the CPU finishes task 3 and starts processing task 2. Available tasks = {0,1}.
- At time = 18, the CPU finishes task 2 and starts processing task 0. Available tasks = {1}.
- At time = 28, the CPU finishes task 0 and starts processing task 1. Available tasks = {}.
- At time = 40, the CPU finishes task 1 and becomes idle.


Constraints:

• tasks.length == n
• 1 <= n <= 105
• 1 <= enqueueTimei, processingTimei <= 109

## Solutions

Solution 1: Sorting + Priority Queue (Min Heap)

First, we sort the tasks by enqueueTime in ascending order. Next, we use a priority queue (min heap) to maintain the currently executable tasks. The elements in the queue are (processingTime, index), which represent the execution time and the index of the task. We also use a variable $t$ to represent the current time, initially set to $0$.

Next, we simulate the execution process of the tasks.

If the current queue is empty, it means there are no executable tasks at the moment. We update $t$ to the larger value between the enqueueTime of the next task and the current time $t$. Then, we add all tasks with enqueueTime less than or equal to $t$ to the queue.

Then, we take out a task from the queue, add its index to the answer array, and update $t$ to the sum of the current time $t$ and the execution time of the current task.

We repeat the above process until the queue is empty and all tasks have been added to the queue.

The time complexity is $O(n \times \log n)$, where $n$ is the number of tasks.

• class Solution {
int[][] ts = new int[n][3];
for (int i = 0; i < n; ++i) {
}
Arrays.sort(ts, (a, b) -> a[0] - b[0]);
int[] ans = new int[n];
PriorityQueue<int[]> q
= new PriorityQueue<>((a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
int i = 0, t = 0, k = 0;
while (!q.isEmpty() || i < n) {
if (q.isEmpty()) {
t = Math.max(t, ts[i][0]);
}
while (i < n && ts[i][0] <= t) {
q.offer(new int[] {ts[i][1], ts[i][2]});
++i;
}
var p = q.poll();
ans[k++] = p[1];
t += p[0];
}
return ans;
}
}

• class Solution {
public:
int n = 0;
using pii = pair<int, int>;
priority_queue<pii, vector<pii>, greater<pii>> q;
int i = 0;
long long t = 0;
vector<int> ans;
while (!q.empty() || i < n) {
if (q.empty()) t = max(t, (long long) tasks[i][0]);
while (i < n && tasks[i][0] <= t) {
++i;
}
auto [pt, j] = q.top();
q.pop();
ans.push_back(j);
t += pt;
}
return ans;
}
};

• class Solution:
def getOrder(self, tasks: List[List[int]]) -> List[int]:
ans = []
q = []
i = t = 0
while q or i < n:
if not q:
while i < n and tasks[i][0] <= t:
i += 1
pt, j = heappop(q)
ans.append(j)
t += pt
return ans


• func getOrder(tasks [][]int) (ans []int) {
for i := range tasks {
}
q := hp{}
i, t, n := 0, 0, len(tasks)
for len(q) > 0 || i < n {
if len(q) == 0 {
}
for i < n && tasks[i][0] <= t {
i++
}
p := heap.Pop(&q).(pair)
ans = append(ans, p.i)
t += p.t
}
return
}

type pair struct{ t, i int }
type hp []pair

func (h hp) Len() int           { return len(h) }
func (h hp) Less(i, j int) bool { return h[i].t < h[j].t || (h[i].t == h[j].t && h[i].i < h[j].i) }
func (h hp) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *hp) Push(v any)        { *h = append(*h, v.(pair)) }
func (h *hp) Pop() any          { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }