"""

Here is what I learn from @awice and solution approach 3.

There are two cases: #[0]

if n is small enough for all tasks to run without idle the answer would be len(tasks)

if n is not small enough

it would be like the Figure 2 in https://leetcode.com/problems/task-scheduler/Figures/621_Task_Scheduler_new.PNG

the answer of the case2 is the number of total number of square in the Figure 2

in Figure 2, we can see

n (cooling interval) is 4

max_count is 4, max_count is the max number of each task that is going to be executed

t is 2, t is the number of task with max_count, which is 'A' and 'B', they both have to be executed 4 times

t is the left over of the last row in Figure 2 #[1]

max_count-1 is the height of the Figure 2 except last row #[2]

n+1 is the width of the Figure

so in case2 the answer is (max_count-1)*(n+1)+t

in case2 there would be no way that t is 0

if t is zero, that means the last row don't have idle

if the last row don't have idle, there would be no idle for all the rows

in that case, it is case1

the answer is not possible to be smaller then len(tasks)

if your case2 answer is smaller than len(tasks), it is wrong

the situation would be case1

that is why we take the max out of two cases #[3]

"""

class Solution(object):

def leastInterval(self, tasks, n):

task_count = collections.Counter(tasks).values()

max_count = max(task_count) #[2]

t = task_count.count(max_count) #[1]

return max(len(tasks), (max_count-1)*(n+1)+t) #[3]