Single-Threaded CPU

Brute Force — Scanning All Tasks at Each Step — Watch how the CPU scans all unprocessed tasks each time it becomes idle, picking the shortest-processing-time task among available ones.

class Solution {
public:
    vector<int> getOrder(vector<vector<int>>& tasks) {
        int n = tasks.size();
        vector<int> result;
        vector<bool> processed(n, false);
        long long currentTime = 0;
        
        for (int count = 0; count < n; count++) {
            // Find available tasks
            int bestIdx = -1;
            int bestProc = INT_MAX;
            long long minEnqueue = LLONG_MAX;
            
            for (int i = 0; i < n; i++) {
                if (processed[i]) continue;
                minEnqueue = min(minEnqueue, (long long)tasks[i][0]);
                if (tasks[i][0] <= currentTime) {
                    if (tasks[i][1] < bestProc || 
                        (tasks[i][1] == bestProc && i < bestIdx)) {
                        bestProc = tasks[i][1];
                        bestIdx = i;
                    }
                }
            }
            
            // If no task available, jump time forward
            if (bestIdx == -1) {
                currentTime = minEnqueue;
                count--; // Re-scan with updated time
                continue;
            }
            
            processed[bestIdx] = true;
            currentTime += bestProc;
            result.push_back(bestIdx);
        }
        
        return result;
    }
};

class Solution:
    def getOrder(self, tasks: list[list[int]]) -> list[int]:
        n = len(tasks)
        result = []
        processed = [False] * n
        current_time = 0
        
        while len(result) < n:
            best_idx = -1
            best_proc = float('inf')
            min_enqueue = float('inf')
            
            for i in range(n):
                if processed[i]:
                    continue
                min_enqueue = min(min_enqueue, tasks[i][0])
                if tasks[i][0] <= current_time:
                    if (tasks[i][1] < best_proc or 
                        (tasks[i][1] == best_proc and i < best_idx)):
                        best_proc = tasks[i][1]
                        best_idx = i
            
            if best_idx == -1:
                current_time = min_enqueue
                continue
            
            processed[best_idx] = True
            current_time += best_proc
            result.append(best_idx)
        
        return result

class Solution {
    public int[] getOrder(int[][] tasks) {
        int n = tasks.length;
        int[] result = new int[n];
        boolean[] processed = new boolean[n];
        long currentTime = 0;
        int resultIdx = 0;
        
        while (resultIdx < n) {
            int bestIdx = -1;
            int bestProc = Integer.MAX_VALUE;
            long minEnqueue = Long.MAX_VALUE;
            
            for (int i = 0; i < n; i++) {
                if (processed[i]) continue;
                minEnqueue = Math.min(minEnqueue, tasks[i][0]);
                if (tasks[i][0] <= currentTime) {
                    if (tasks[i][1] < bestProc ||
                        (tasks[i][1] == bestProc && i < bestIdx)) {
                        bestProc = tasks[i][1];
                        bestIdx = i;
                    }
                }
            }
            
            if (bestIdx == -1) {
                currentTime = minEnqueue;
                continue;
            }
            
            processed[bestIdx] = true;
            currentTime += bestProc;
            result[resultIdx++] = bestIdx;
        }
        
        return result;
    }
}

Sorting + Min-Heap — Efficient Task Scheduling — Watch how sorting tasks by enqueue time and using a min-heap (keyed on processing time, then index) lets us efficiently pick the best task at each step without scanning all tasks.

class Solution {
public:
    vector<int> getOrder(vector<vector<int>>& tasks) {
        int n = tasks.size();
        // Pair each task with its original index
        vector<array<long long, 3>> sortedTasks(n);
        for (int i = 0; i < n; i++) {
            sortedTasks[i] = {tasks[i][0], tasks[i][1], i};
        }
        // Sort by enqueue time
        sort(sortedTasks.begin(), sortedTasks.end());
        
        // Min-heap: (processingTime, originalIndex)
        priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<>> minHeap;
        
        vector<int> result;
        long long currentTime = 0;
        int ptr = 0;
        
        while (result.size() < n) {
            // Add all tasks that have arrived by currentTime
            while (ptr < n && sortedTasks[ptr][0] <= currentTime) {
                minHeap.push({sortedTasks[ptr][1], (int)sortedTasks[ptr][2]});
                ptr++;
            }
            
            if (minHeap.empty()) {
                // No available tasks — jump to next enqueue time
                currentTime = sortedTasks[ptr][0];
                continue;
            }
            
            auto [procTime, idx] = minHeap.top();
            minHeap.pop();
            currentTime += procTime;
            result.push_back(idx);
        }
        
        return result;
    }
};

import heapq

class Solution:
    def getOrder(self, tasks: list[list[int]]) -> list[int]:
        n = len(tasks)
        # Pair each task with its original index and sort by enqueue time
        sorted_tasks = sorted(
            [(enqueue, proc, idx) for idx, (enqueue, proc) in enumerate(tasks)]
        )
        
        result = []
        min_heap = []  # (processingTime, originalIndex)
        current_time = 0
        ptr = 0
        
        while len(result) < n:
            # Add all tasks that have arrived by current_time
            while ptr < n and sorted_tasks[ptr][0] <= current_time:
                heapq.heappush(min_heap, (sorted_tasks[ptr][1], sorted_tasks[ptr][2]))
                ptr += 1
            
            if not min_heap:
                # No available tasks — jump to next enqueue time
                current_time = sorted_tasks[ptr][0]
                continue
            
            proc_time, idx = heapq.heappop(min_heap)
            current_time += proc_time
            result.append(idx)
        
        return result

class Solution {
    public int[] getOrder(int[][] tasks) {
        int n = tasks.length;
        // Pair each task with its original index
        int[][] sortedTasks = new int[n][3];
        for (int i = 0; i < n; i++) {
            sortedTasks[i][0] = tasks[i][0]; // enqueueTime
            sortedTasks[i][1] = tasks[i][1]; // processingTime
            sortedTasks[i][2] = i;            // originalIndex
        }
        // Sort by enqueue time
        Arrays.sort(sortedTasks, (a, b) -> Integer.compare(a[0], b[0]));
        
        // Min-heap: (processingTime, originalIndex)
        PriorityQueue<int[]> minHeap = new PriorityQueue<>((a, b) -> {
            if (a[0] != b[0]) return Integer.compare(a[0], b[0]);
            return Integer.compare(a[1], b[1]);
        });
        
        int[] result = new int[n];
        long currentTime = 0;
        int ptr = 0, resultIdx = 0;
        
        while (resultIdx < n) {
            // Add all tasks that have arrived by currentTime
            while (ptr < n && sortedTasks[ptr][0] <= currentTime) {
                minHeap.offer(new int[]{sortedTasks[ptr][1], sortedTasks[ptr][2]});
                ptr++;
            }
            
            if (minHeap.isEmpty()) {
                // No available tasks — jump to next enqueue time
                currentTime = sortedTasks[ptr][0];
                continue;
            }
            
            int[] task = minHeap.poll();
            currentTime += task[0];
            result[resultIdx++] = task[1];
        }
        
        return result;
    }
}