Task Scheduler

Task Scheduler - Problem

Array Hash Table Greedy Sorting Heap (Priority Queue) Counting Medium

You are given an array of CPU tasks, each represented by letters A-Z, and a number n. Each CPU interval can execute one task or remain idle. Tasks can be completed in any order, but there's a constraint: there must be at least n intervals between two tasks with the same label.

Return the minimum number of CPU intervals required to complete all tasks.

Input & Output

Example 1 — Equal Frequencies

$ Input: tasks = ["A","A","A","B","B","B"], n = 2

› Output: 8

💡 Note: A -> B -> idle -> A -> B -> idle -> A -> B. Need 2 idle intervals between same tasks.

Example 2 — No Cooldown

$ Input: tasks = ["A","A","A","B","B","B"], n = 0

› Output: 6

💡 Note: No cooldown required, so execute all 6 tasks consecutively.

Example 3 — Sufficient Different Tasks

$ Input: tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2

› Output: 12

💡 Note: Enough different tasks to fill gaps: A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> A -> A

Constraints

1 ≤ tasks.length ≤ 10⁴
0 ≤ n ≤ 100
tasks[i] is an uppercase English letter

Visualization

Tap to expand

Asked in

f Facebook 45 a Amazon 38 G Google 32 M Microsoft 28

The key insight is that the most frequent task determines the minimum time structure. The optimal approach uses a mathematical formula to calculate the minimum intervals based on task frequencies and available gaps. Time: O(n), Space: O(1).

Common Approaches

✓ Greedy with Frequency Counting

⏱️ Time: O(n * log k) Space: O(k)

Count frequency of each task, then use a max-heap to always execute the most frequent available task. Use a cooldown queue to track when tasks become available again.

Mathematical Formula

⏱️ Time: O(n) Space: O(1)

The key insight is that the most frequent task determines the minimum time needed. Calculate based on the maximum frequency and available idle slots that can be filled by other tasks.

Simulation with Queue

⏱️ Time: O(tasks.length * n) Space: O(1)

Track each task's next available time and simulate CPU intervals one by one. Use a queue to manage tasks that are ready to execute and another to track tasks in cooldown.

Greedy with Frequency Counting — Algorithm Steps

Count frequency of each task
Use max-heap for available tasks
Track cooldown with queue
Always pick most frequent task

Visualization

Tap to expand

Step-by-Step Walkthrough

Heap Setup

Create max-heap ordered by task frequency

Greedy Choice

Always execute most frequent available task

Cooldown

Track when tasks become available again

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int taskCount[26];

int solution(char* tasks, int taskLen, int n) {
    if (n == 0) {
        return taskLen;
    }
    
    // Count task frequencies
    memset(taskCount, 0, sizeof(taskCount));
    for (int i = 0; i < taskLen; i++) {
        taskCount[tasks[i] - 'A']++;
    }
    
    int maxFreq = 0;
    for (int i = 0; i < 26; i++) {
        if (taskCount[i] > maxFreq) {
            maxFreq = taskCount[i];
        }
    }
    
    // Count how many tasks have the maximum frequency
    int maxCount = 0;
    for (int i = 0; i < 26; i++) {
        if (taskCount[i] == maxFreq) {
            maxCount++;
        }
    }
    
    // The minimum time is either:
    // 1. Just the total number of tasks (if we have enough variety)
    // 2. The time needed for the most frequent tasks with required gaps
    int option2 = (maxFreq - 1) * (n + 1) + maxCount;
    return taskLen > option2 ? taskLen : option2;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char tasks[1000];
    int taskLen = 0;
    
    // Parse JSON array
    for (int i = 0; line[i]; i++) {
        if (line[i] >= 'A' && line[i] <= 'Z') {
            tasks[taskLen++] = line[i];
        }
    }
    
    int n;
    scanf("%d", &n);
    
    int result = solution(tasks, taskLen, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log k)

Each of n intervals requires heap operations on at most k unique tasks

✓ Linear Growth

Space Complexity

O(k)

Heap and queue store at most k unique task types

✓ Linear Space

187.0K Views

High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy with Frequency Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler