Codestin Search App

Task Scheduler II - Problem

You're managing a project workflow where tasks must be completed in a specific order, but there's a cooldown period between tasks of the same type.

Given an array tasks where tasks[i] represents the type of the i-th task that must be completed, and an integer space representing the minimum number of days that must pass after completing a task before another task of the same type can be performed.

Each day you can either:

Complete the next task from the tasks array (if allowed)
Take a break (if the next task type is still in cooldown)

Goal: Return the minimum number of days needed to complete all tasks while respecting the cooldown constraints.

Example: tasks = [1,2,1,2,3,1], space = 3
Day 1: Complete task 1
Day 2: Complete task 2
Day 3: Break (task 1 still in cooldown)
Day 4: Break (task 1 still in cooldown)
Day 5: Break (task 1 still in cooldown)
Day 6: Complete task 1
...and so on

Input & Output

example_1.py — Basic Case

$ Input: tasks = [1,2,1,2,3,1], space = 3

› Output: 9

💡 Note: Day 0: Task 1, Day 1: Task 2, Day 2-4: Break (Task 1 cooldown), Day 5: Task 1, Day 6-8: Break (Task 2 cooldown), Day 9: Task 2, etc. Total 9 days needed.

example_2.py — No Conflicts

$ Input: tasks = [5,8,8,5], space = 2

› Output: 6

💡 Note: Day 0: Task 5, Day 1: Task 8, Day 2: Break, Day 3: Task 8, Day 4: Break, Day 5: Task 5. The space=2 requirement causes breaks between repeated tasks.

example_3.py — Large Space

$ Input: tasks = [1,1,1], space = 4

› Output: 11

💡 Note: Day 0: Task 1, Days 1-4: Break, Day 5: Task 1, Days 6-9: Break, Day 10: Task 1. With space=4, we need 4 break days between each task 1.

Constraints

1 ≤ tasks.length ≤ 10⁵
1 ≤ tasks[i] ≤ 10⁹
0 ≤ space ≤ tasks.length
Tasks must be completed in the given order

Visualization

Tap to expand

Understanding the Visualization

Machine Usage Tracking

Keep a log of when each machine was last used

Check Availability

Before using a machine, check if enough cooldown time has passed

Decision Making

If machine is ready, use it and update the log. If not, wait one day

Process Completion

Continue until all products in the queue are manufactured

Key Takeaway

🎯 Key Insight: Instead of scanning all previous days, we only need to remember the last usage day of each machine type for O(1) cooldown checks

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a hash table to track the last completion day of each task type. For each task, we check if enough days have passed since its last execution (greater than space days). If not, we take a break; otherwise, we complete the task and update the hash table. This achieves O(n) time complexity with O(k) space where k is the number of unique task types.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Previous Days)	O(n²)	O(n)	For each task, scan through all previous days to find when it was last completed
Hash Table Tracking (Optimal)	O(n)	O(k)	Use hash table to track the last completion day of each task type

Brute Force (Check All Previous Days) — Algorithm Steps

Initialize a list to track what task was completed each day
For each task in the input array, start from the current day
Check if we can complete the task by scanning all previous days
If task type was completed within 'space' days, take a break (increment day)
Otherwise, complete the task and move to next task
Return total days needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Day 1

Check task type 1 - no previous days, can complete

Day 2

Check task type 2 - scan previous days, can complete

Day 3

Check task type 1 - scan back 3 days, find conflict, take break

Continue

Repeat scanning process for each day

Code -

solution.c — C

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

int leastInterval(int* tasks, int tasksSize, int space) {
    int* completed = malloc(10000 * sizeof(int));
    int taskIdx = 0;
    int day = 0;
    
    while (taskIdx < tasksSize) {
        int currentTask = tasks[taskIdx];
        int canComplete = 1;
        
        int start = (day - space > 0) ? day - space : 0;
        for (int i = start; i < day; i++) {
            if (completed[i] == currentTask) {
                canComplete = 0;
                break;
            }
        }
        
        if (canComplete) {
            completed[day] = currentTask;
            taskIdx++;
        } else {
            completed[day] = -1;
        }
        
        day++;
    }
    
    free(completed);
    return day;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n tasks, we potentially scan through all previous days (up to n days)

⚠ Quadratic Growth

Space Complexity

O(n)

We store the task completed each day in an array

⚡ Linearithmic Space

42.8K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Brute Force (Check All Previous Days) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler