这题刚开始还是有点难的。
我刚开始想用贪心法，发现各种test case过不了。
后来看答案才学习到这种做法。
这应该是一种很常见做法吧。
就是做完一个任务把这个任务更新一下timeStamp,等这个timeStamp 到了，就又可以处理了。Web Crawler上经常用这种做法。
然后还有一点就是如果有多个任务同时available,
那我们优先处理剩得最多的。

我在这题里悟到了一点。
为了避免出bug
在写code之前最好列提纲
每一步写code之前写好注释。
这样可以避免很多bug。

class Solution {
    public int leastInterval(char[] tasks, int n) {
        //build HashMap to take count 
        Map<Character, Integer> map = new HashMap<>();
        for (char c : tasks) map.put(c, map.getOrDefault(c, 0) + 1 );
        //build Queue and Heap;
        Queue<Task> maxHeap = new PriorityQueue<>(new Comparator<Task>(){
            public int compare(Task o1, Task o2) {
                return o2.count - o1.count;
            }
        });
        Queue<Task> waitingQueue = new LinkedList<>();
        // generate the task and put to heap;
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            maxHeap.offer(new Task(entry.getKey(), entry.getValue()));
        }
        
        // simulate the process
        int time = 0;
        while (!maxHeap.isEmpty() || !waitingQueue.isEmpty()) {
            //check the waitingQueue and put to heap
            while (!waitingQueue.isEmpty() && waitingQueue.peek().timeStamp + n < time) {
                maxHeap.offer(waitingQueue.poll());
            }
            
            //poll from heap if can
            if(!maxHeap.isEmpty()){
                Task t = maxHeap.poll();
                t.count--;
                t.timeStamp = time;
                if (t.count > 0) waitingQueue.offer(t);
            }
            
            time ++;
        }
        
        //return the result;
        return time;
        
    }
}
class Task {
    char id;
    int count;
    int timeStamp;
    public Task(char id, int count) {
        this.id = id;
        this.count = count;
    }
}