【leetcode】621.任务调度器 贪心 + 排序

给你一个用字符数组 tasks 表示的 CPU 需要执行的任务列表。其中每个字母表示一种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。在任何一个单位时间，CPU 可以完成一个任务，或者处于待命状态。

然而，两个 相同种类 的任务之间必须有长度为整数 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。

你需要计算完成所有任务所需要的 最短时间 。

输入：tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2
输出：16
解释：一种可能的解决方案是：
     A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> (待命) -> (待命) -> A -> (待命) -> (待命) -> A

为了让任务处理时间的少，得尽量利用冷却时间，最少处理时间一定是不用等待冷却时间的。

等待的冷却时间和最大任务数有关系，可以把任务数最多的任务种类叫做 A。每个A都相应有 n 的 冷却时间， 同时用其他的任务去填充冷却时间。

这个时候，可能有两种可能，一种可能是其他的任务没有填充满。这种情况，时间是 （A任务的数量 - 1）* （ n + 1） + 最后一个任务 A花费的时间 + 在他冷却时间内处理的任务。

另外一种可能是所有的冷却时间都被塞满了。这种情况下，就没有冷却时间了。处理时间就是所有任务数。

package pro621;

import java.util.*;

public class Solution {

    class P implements Comparable {
        Character c;
        int t;

        P(Character c, int t) {
            this.c = c;
            this.t = t;
        }

        @Override
        public int compareTo(Object o) {
            P p = (P) o;
            return p.t -this.t;
        }
    }

    public int leastInterval(char[] tasks, int n) {
        Map<Character, Integer> map = new HashMap<>();
        PriorityQueue<P> pq = new PriorityQueue<>();
        for(Character c : tasks) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        Set<Map.Entry<Character, Integer>> set = map.entrySet();
        for(Map.Entry<Character, Integer> entry : set) {
            pq.add(new P(entry.getKey(), entry.getValue()));
        }
        P curP = pq.poll();
        int bucket = curP.t;
        int lastBucket = 1;
        while(!pq.isEmpty()) {
            P p = pq.poll();
            if(p.t == bucket) {
                lastBucket++;
            } else {
                break;
            }
        }
        return Math.max(tasks.length, (bucket - 1) * (n + 1)  + lastBucket);
    }

    public static void main(String[] argv) {
        char[] chars = new char[]{'A', 'A', 'A', 'B', 'B', 'B'};
        System.out.println(new Solution().leastInterval(chars, 2));
        chars = new char[] {'A','A','A','A','A','A','B','C','D','E','F','G'};
        System.out.println(new Solution().leastInterval(chars, 2));
    }
}