单线程 CPU

/*
 * Solution Approach (Java Stream API):
 * 1. Create a stream of tasks with indexes and sort by enqueue time.
 * 2. Use a PriorityQueue to manage tasks based on processing time and index.
 * 3. Process tasks by advancing time and adding eligible tasks to the queue.
 * 4. Execute tasks and record the order using a stream.
 * 5. Convert the result list to an array.
 */

import java.util.*;
import java.util.stream.*;

class Solution {
    public int[] getOrder(int[][] tasks) {
        int n = tasks.length;

        // Step 1: Sort tasks by enqueue time
        List<int[]> sortedTasks = IntStream.range(0, n)
                .mapToObj(i -> new int[]{tasks[i][0], tasks[i][1], i})
                .sorted((a, b) -> a[0] - b[0])
                .collect(Collectors.toList());

        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] == b[1] ? a[2] - b[2] : a[1] - b[1]);
        int time = 0, index = 0;

        List<Integer> result = new ArrayList<>();

        while (index < n || !pq.isEmpty()) {
            while (index < n && sortedTasks.get(index)[0] <= time) {
                pq.offer(sortedTasks.get(index++));
            }
            if (pq.isEmpty()) {
                time = sortedTasks.get(index)[0];
                continue;
            }
            int[] current = pq.poll();
            time += current[1];
            result.add(current[2]);
        }

        return result.stream().mapToInt(i -> i).toArray();
    }
}