Task Scheduler II - Practice Coding Problems

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.

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each task exactly once, with O(1) hash table operations

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique task types (at most n)

✓ Linear Space

Constraints

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

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
✓ 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)	O(n²)	O(n)	For each task, scan through all previous days to find when it was last completed

Hash Table Tracking (Optimal) — Algorithm Steps

Initialize a hash table to track last completion day of each task type
Initialize current day counter and task index
For each task, check if it exists in hash table
If task was completed recently (within space days), take a break
Otherwise, complete the task and update its last completion day
Increment day counter and continue until all tasks done
Return total days

Visualization

Tap to expand

Step-by-Step Walkthrough

Task 1

First occurrence - add to hash table, complete immediately

Task 2

New task type - add to hash table, complete immediately

Task 1 Again

Check hash table - last completed too recently, take break

Continue

Keep checking hash table for instant lookups

Code -

solution.c — C

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

#define HASH_SIZE 1001

typedef struct HashNode {
    int task;
    int lastDay;
    struct HashNode* next;
} HashNode;

int hash(int task) {
    return abs(task) % HASH_SIZE;
}

int getLastDay(HashNode** table, int task) {
    int index = hash(task);
    HashNode* current = table[index];
    while (current) {
        if (current->task == task) {
            return current->lastDay;
        }
        current = current->next;
    }
    return -1;
}

void setLastDay(HashNode** table, int task, int day) {
    int index = hash(task);
    HashNode* current = table[index];
    while (current) {
        if (current->task == task) {
            current->lastDay = day;
            return;
        }
        current = current->next;
    }
    HashNode* newNode = malloc(sizeof(HashNode));
    newNode->task = task;
    newNode->lastDay = day;
    newNode->next = table[index];
    table[index] = newNode;
}

int leastInterval(int* tasks, int tasksSize, int space) {
    HashNode* table[HASH_SIZE] = {NULL};
    int day = 0;
    int taskIdx = 0;
    
    while (taskIdx < tasksSize) {
        int currentTask = tasks[taskIdx];
        int lastDay = getLastDay(table, currentTask);
        
        if (lastDay == -1 || day - lastDay > space) {
            setLastDay(table, currentTask, day);
            taskIdx++;
        }
        
        day++;
    }
    
    return day;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each task exactly once, with O(1) hash table operations

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique task types (at most n)

✓ Linear Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Table Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler