0 like 0 dislike
773 views

Given a characters array `tasks`, representing the tasks a CPU needs to do, where each letter represents a different task. Tasks could be done in any order. Each task is done in one unit of time. For each unit of time, the CPU could complete either one task or just be idle.

However, there is a non-negative integer `n` that represents the cooldown period between two same tasks (the same letter in the array), that is that there must be at least `n` units of time between any two same tasks.

Return the least number of units of times that the CPU will take to finish all the given tasks.

Example 1:

```Input: tasks = ["A","A","A","B","B","B"], n = 2
Output: 8
Explanation:
A -> B -> idle -> A -> B -> idle -> A -> B
There is at least 2 units of time between any two same tasks.
```

Example 2:

```Input: tasks = ["A","A","A","B","B","B"], n = 0
Output: 6
Explanation: On this case any permutation of size 6 would work since n = 0.
["A","A","A","B","B","B"]
["A","B","A","B","A","B"]
["B","B","B","A","A","A"]
...
And so on.
```

Example 3:

```Input: tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2
Output: 16
Explanation:
One possible solution is
A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> idle -> idle -> A -> idle -> idle -> A
```

Constraints:

• `1 <= task.length <= 104`
• `tasks[i]` is upper-case English letter.
• The integer `n` is in the range `[0, 100]`.

0 like 0 dislike
by Goeduhub's Expert (2.3k points)

The main idea is to schedule the most frequent tasks as frequently as possible. Begin with scheduling the most frequent task. Then cool-off for n, and in that cool-off period schedule tasks in order of frequency, or if no tasks are available, then be idle.

Exampe: Say we have the following tasks: [A,A,A,B,C,D,E] with n =2

Now if we schedule using the idea of scheduling all unique tasks once and then calculating if a cool-off is required or not, then we have: A,B,C,D,E,A,idle,dile,A i.e. 2 idle slots.

But if we schedule using most frequent first, then we have:

• A,idle,idle,A,idle,idle,A
• A,B,C,A,D,E,A i.e. no idle slots. This is the general intuition of this problem.

The idea in two can be implemented using a heap and temp list. This is illustrated in the code below.

Time complexity is O(N * n) where N is the number of tasks and n is the cool-off period.

Space complexity is O(1) - will not be more than O(26).

from heapq import heappush, heappop

from collections import Counter

class Solution:

"""

:type n: int

:rtype: int

"""

curr_time, h = 0, []

heappush(h, (-1*v, k))

while h:

i, temp = 0, []

while i <= n:

curr_time += 1

if h:

x,y = heappop(h)

if x != -1:

temp.append((x+1,y))

if not h and not temp:

break

else:

i += 1

for item in temp:

heappush(h, item)

return curr_time

n = 2

ans = Solution()