【LeetCode】621. 任务调度器

题目：621. 任务调度器

621. 任务调度器

---

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

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

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

示例 1：

输入：tasks = [“A”,“A”,“A”,“B”,“B”,“B”], n = 2
输出：8
解释：A -> B -> (待命) -> A -> B -> (待命) -> A -> B
在本示例中，两个相同类型任务之间必须间隔长度为 n = 2 的冷却时间，而执行一个任务只需要一个单位时间，所以中间出现了（待命）状态。

示例 2：

输入：tasks = [“A”,“A”,“A”,“B”,“B”,“B”], n = 0
输出：6
解释：在这种情况下，任何大小为 6 的排列都可以满足要求，因为 n = 0
[“A”,“A”,“A”,“B”,“B”,“B”]
[“A”,“B”,“A”,“B”,“A”,“B”]
[“B”,“B”,“B”,“A”,“A”,“A”]
…
诸如此类

示例 3：

输入：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

提示：

• 1 <= task.length <= 104
• tasks[i] 是大写英文字母
• n 的取值范围为[0, 100]

解题思路

思路

建立大小为n+1的桶，个数为任务数量最多的那个任务数。
如：等待时间 n=2，A任务个数为6，建立6个桶，每个容量为3：

A
A
A
A
A
A

1. 现在没有其他任务，完成全部A任务需要的时间为(6 - 1) * 3 + 1 = 16，最后一个桶不需要等待时间。

   A
   A
   A
   A
   A
   A	x	x

2. 添加其他任务,可以看出C没有对总体时间产生影响，只有最后一个B使整体时间+1。(6 - 1) * 3 + 2 = 17

   A	B	C
   A	B	C
   A	B
   A	B
   A	B
   A	B	x

   总结起来：总排队时间 = （桶个数 - 1） （n + 1） + 最后一桶的任务数*

3. 当冷却时间短，任务种类很多时，所需时间还是17.

   A	B	C
   A	B	C
   A	B	D
   A	B	D
   A	B	D
   A	B	x

4. 如果还需要执行两次F

   A	B	C	F
   A	B	C	F
   A	B	D
   A	B	D
   A	B	D
   A	B	x

我们在第一个、第二个桶子里插入了任务F，不难发现无论再继续插入多少任务，我们都可以类似处理，而且新插入元素肯定满足冷却要求
这种情况下其实每个任务之间都不存在空余时间，冷却时间已经被完全填满了。
我们执行任务所需的时间，就是任务的数量

只需要：

1. 记录最大任务数量N，看一下任务数量并列最多的任务有多少个，即最后一个桶子的任务数 X，计算NUM1 = (N - 1) * (n + 1) + x
2. NUM2 = tasks.size()
   输出其中较大值即可
   因为存在空闲时间时肯定是 NUM1 大，不存在空闲时间时肯定是 NUM2 >= NUM1

步骤

1. 设置数组记录字母出现的个数，将数组从大到小排序
2. 计算桶中最后一行的任务个数
3. 根据公式得出结果

代码

class Solution {
public:
// 1. 设置数组记录字母出现的个数，将数组从大到小排序
// 2. 计算桶中最后一行的任务个数
// 3. 根据公式得出结果
    int leastInterval(vector<char>& tasks, int n) {
        int len = tasks.size();
        vector<int> vec(26);
        
        for (char ch:tasks) vec[ch - 'A']++;
        sort(vec.begin(), vec.end(), [](int& x, int& y) {return x > y;});

        int cnt = 1;
        while (cnt < vec.size() && vec[cnt] == vec[0]) cnt++;

        return max(len, (vec[0] - 1) * (n + 1) + cnt);
    }
};