Task Scheduler

Intuition

The task that appears the most often is the bottleneck of the whole schedule. If the maximum frequency is f, we must place those f copies at least n apart, which carves the timeline into f - 1 mandatory frames of width n + 1, followed by a final short row. Any task that also reaches the maximum frequency adds one more slot to that final row, giving the length (f - 1) * (n + 1) + maxCount. When there are many distinct tasks, the idle gaps get completely filled and the schedule length is simply the number of tasks. Taking the maximum of the two candidates yields the answer without simulating the timeline. A max-heap simulation would give the same result: at each step you pop the highest-count available task and hold used tasks in a cooldown window of size n + 1.

Algorithm walkthrough

1. 1Count the frequency of every task label using a fixed 26-slot array.
2. 2Scan the counts to find the maximum frequency f.
3. 3Count how many task labels share that maximum frequency (maxCount).
4. 4Compute the mandatory frame length: (f - 1) * (n + 1) + maxCount.
5. 5If the number of tasks exceeds this frame length, the idle slots are all filled, so the answer is the total number of tasks.
6. 6Return the maximum of the frame length and the total task count.

Implementation

from typing import List
from collections import Counter

class Solution:
    def leastInterval(self, tasks: List[str], n: int) -> int:
        counts = Counter(tasks)
        max_freq = max(counts.values())
        max_count = sum(1 for c in counts.values() if c == max_freq)
        frame = (max_freq - 1) * (n + 1) + max_count
        return max(len(tasks), frame)