LeetCode1834. 单线程 CPU（Java）

题目

给你一个二维数组 tasks ，用于表示 n​​​​​​ 项从 0 到 n - 1 编号的任务。
其中 tasks[i] = [enqueueTimei, processingTimei] 意味着第 i​​​​​​​​​​ 项任务将会于 enqueueTimei 时进入任务队列，需processingTimei 的时长完成执行。

现有一个单线程 CPU ，同一时间只能执行 最多一项 任务，该 CPU 将会按照下述方式运行：
如果 CPU 空闲，且任务队列中没有需要执行的任务，则 CPU 保持空闲状态。
如果 CPU 空闲，但任务队列中有需要执行的任务，则 CPU 将会选择 执行时间最短 的任务开始执行。
如果多个任务具有同样的最短执行时间，则选择下标最小的任务开始执行。

一旦某项任务开始执行，CPU 在 执行完整个任务 前都不会停止。
CPU 可以在完成一项任务后，立即开始执行一项新任务。 返回 CPU 处理任务的顺序。

输入：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 并进入空闲状态

我的思路：
先对二维数组排序——时间先后顺序，若是同一时间则按执行时长升序排序。
小顶堆用于在for循环中找进入队列的待执行的任务

class Solution {
   public int[] getOrder(int[][] tasks) {
		int[] a = new int[tasks.length];// 存答案
		HashMap<int[], Integer> map = new HashMap<>();// 保存下标
		int index = 0;
		for (int[] temp : tasks) {
			map.put(temp, index++);
		}
		// 如何排序
		// 不同一时间，则按照先后顺序。执行完第一个之后，看第一个花费了多长的时间，再在队列中找到执行时间最小的
		Arrays.sort(tasks, new Comparator<int[]>() {
			@Override
			public int compare(int[] o1, int[] o2) {
				// TODO Auto-generated method stub
				if (o1[0] == o2[0]) {// 同一时间进入，按照执行时间长度排序，由少到多
					return o1[1] - o2[1];
				}
				return o1[0] - o2[0];// 不同时间且执行执行时间不等，以进入队列时间排序
			}
		});
		if (tasks.length == 2) {
			for (int i = 0; i < tasks.length; i++) {
				a[i] = i;
			}
			return a;
		}
		PriorityQueue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
			@Override
			public int compare(int[] o1, int[] o2) {
				if (o1[1] == o2[1]) {// 执行时间相等，以下标小的先
					return map.get(o1) - map.get(o2);
				}
				return o1[1] - o2[1];// 执行时间不等，以执行时间长短来
			}
		});
		int time = tasks[0][0] + tasks[0][1];
		index = 0;
		a[index++] = map.get(tasks[0]);
		for (int j = 1; j < tasks.length; j++) {
			boolean isRun = false;
			while (j < tasks.length && tasks[j][0] <= time) {
				isRun = true;
				queue.add(tasks[j]);
				j++;
			}
			j--;
			if (!queue.isEmpty()) {// 队列非空，有要执行的
				int[] arr = queue.poll();
				a[index++] = map.get(arr);
				time += arr[1];
			}
//这步比较细节，题目告诉任务队列中没有需要执行的任务，则 CPU 保持空闲状态,但是时间还是得推着走，去找下一个要进行的。
			if (queue.isEmpty() && !isRun) {
				time++;
			}
		}
//最后，执行时间最短的在前面已经处理完了，剩下来的就算排好序的
		while (!queue.isEmpty()) {
			int[] arr = queue.poll();
			a[index++] = map.get(arr);
		}
		return a;
	}
}

end.