学习记录：js算法（六十七）：任务调度器

文章目录

- 任务调度器
- - 思路一
  - 思路二

任务调度器

给你一个用字符数组 tasks 表示的 CPU 需要执行的任务列表，用字母 A 到 Z 表示，以及一个冷却时间 n 。每个周期或时间间隔允许完成一项任务。任务可以按任何顺序完成，但有一个限制：两个相同种类的任务之间必须有长度为 n 的冷却时间。

返回完成所有任务所需要的最短时间间隔。

bash 复制代码

示例 1：
输入：tasks = ["A","A","A","B","B","B"], n = 2
输出：8
解释：
在完成任务 A 之后，你必须等待两个间隔。对任务 B 来说也是一样。在第 3 个间隔，A 和 B 都不能完成，所以你需要待命。在第 4 个间隔，由于已经经过了 2 个间隔，你可以再次执行 A 任务。
 
示例 2：
输入：tasks = ["A","C","A","B","D","B"], n = 1
输出：6
解释：一种可能的序列是：A -> B -> C -> D -> A -> B。
由于冷却间隔为 1，你可以在完成另一个任务后重复执行这个任务。

示例 3：
输入：tasks = ["A","A","A","B","B","B"], n = 3
输出：10
解释：一种可能的序列为：A -> B -> idle -> idle -> A -> B -> idle -> idle -> A -> B。
只有两种任务类型，A 和 B，需要被 3 个间隔分割。这导致重复执行这些任务的间隔当中有两次待命状态。

思路一

js 复制代码

function leastInterval(tasks, n) {
    // 初始化一个大小为26的数组，用来统计每个字母任务出现的次数。
    const taskCounts = new Array(26).fill(0);
    
    // 遍历任务列表，统计每个任务的出现次数。
    for (const task of tasks) {
        taskCounts[task.charCodeAt(0) - 'A'.charCodeAt(0)]++;
    }

    // 找出频率最高的任务的频率。
    let maxCount = Math.max(...taskCounts);
    
    // 计算频率最高任务的数量。
    let maxTaskCount = taskCounts.filter(count => count === maxCount).length;

    // 计算除了最后一个周期外，其他周期中最大频率任务的个数。
    let partCount = maxCount - 1;
    
    // 计算除了最大频率任务之外，每个周期中需要的其他任务或空闲插槽数量。
    let partLength = n - (maxTaskCount - 1);
    
    // 计算所有周期中空闲插槽的总数。
    let emptySlots = partCount * partLength;
    
    // 计算除了最大频率任务之外的所有任务的总数。
    let availableTasks = tasks.length - maxCount * maxTaskCount;
    
    // 计算实际需要的空闲插槽数量，如果emptySlots大于availableTasks，则实际需要的空闲插槽数量为emptySlots - availableTasks。
    let idles = Math.max(0, emptySlots - availableTasks);

    // 返回完成所有任务所需的最少时间，等于所有任务的执行时间加上必要空闲插槽数量。
    return tasks.length + idles;
}

讲解

统计任务频率：
○ 创建一个大小为 26 的数组 taskCounts ，统计每个任务出现的次数。这是因为任务是由大写字母 A 到 Z 表示的，所以数组的长度为 26。

确定最高频率任务：
○ 通过遍历 taskCounts ，找到出现次数最多的任务频率 maxCount，即任务的最高频率。

计算最高频率任务的数量：
○ 再次遍历 taskCounts ，计算有多少个任务具有 maxCount 这样的最高频率。

计算理论上的空闲插槽数量：
○ 根据 maxCount 和 n ，计算理论上在最高频率任务之间的空闲插槽数量。这是因为除了最后一个周期外，每个最高频率任务前都应该有n个空闲插槽。

计算实际需要的空闲插槽数量：
○ 这一步非常重要，因为实际的空闲插槽数量取决于剩余任务的数量和最高频率任务的数量。如果剩余任务不足以填满所有理论上的空闲插槽，那么实际的空闲插槽数量将少于理论值。

计算所需最少时间：
○ 结果是所有任务的执行时间加上必要的空闲插槽数量，确保任何两个相同任务之间至少有 n 个不同的任务。

思路二

js 复制代码

function leastInterval(tasks, n) {
    const taskCount = Array(26).fill(0);

    // 统计每个任务的频率
    for (const task of tasks) {
        taskCount[task.charCodeAt(0) - 'A'.charCodeAt(0)]++;
    }

    const maxCount = Math.max(...taskCount);
    const maxCountTasks = taskCount.filter(count => count === maxCount).length;

    // 计算所需的时间
    const intervals = (maxCount - 1) * (n + 1) + maxCountTasks;

    // 返回最大值和任务数量的较大者
    return Math.max(intervals, tasks.length);
}

讲解

计数排序的基本思想：

统计频率：创建一个数组来统计每个元素出现的次数。

计算位置：根据频率数组计算每个元素在排序后数组中的位置。

构建输出数组：根据位置将元素放入输出数组中。

在任务调度问题中的应用：

统计每个任务的频率：维护一个数组 taskCount ，其中每个索引对应一个任务（例如，A 对应 0，B 对应 1，依此类推），并统计每个任务的出现次数。

找出最大频率：找到出现次数最多的任务（即最大频率）和有多少个任务具有这个最大频率。

计算所需时间：

设最大频率为 maxCount，具有该频率的任务数量为 maxCountTasks。

最小时间间隔的计算公式为：intervals(maxCount−1)×(n+1)+maxCountTasks
这里，maxCount - 1 是因为最后一个任务不需要冷却时间。

返回结果：返回 intervals 和任务总数的较大者，以确保不会少于任务总数。

代码解析：

任务频率统计：使用 taskCount 数组来记录每种任务的出现频率。

最大频率与任务数量：使用 Math.max 找到最大频率，并通过 filter 统计有多少个任务具有该频率。

计算最小时间：使用前面提到的公式计算所需的时间间隔。

返回结果：返回计算出的时间和任务总数中的较大值，以确保返回的时间不小于任务总数。