[路飞]任务调度器

题目描述

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

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

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

分析

输入：
tasks，Array，需要执行的任务列表
n，Number，相同任务的时间间隔

输出：Number, 需要的最少时间

解题思路

这道题我采取的是 模拟 的做法，也就是把整个执行任务的过程，通过代码模拟了一遍。

我们看这个例子，由于每一个时间单位，既可以待命，也可以执行任务，我们需要做的实际上是减少待命的时间，那么减少待命的时间，我们需要做的是优先执行剩余次数最多的任务。

如例子里所示，最后剩余的 A 越少，那么我的待命时间也就最少～

开始模拟之前：根据这个思想，我们首先要统计的是，每种类型有多少任务，然后模拟执行流程。因此我们还需要两个数据结构去记录某种类型的任务下次可执行的时间，以及还剩多少次。

执行任务之前：另外还需要注意一点的是，我们对于执行所需时间的记录，可以让他每次执行任务的时候都跳过待命时间，直接更新到最近可执行的那个任务～

决定执行的任务时：我们找到时间符合要求，且剩余次数最多的任务进行执行

在执行完任务之后：我们更新所执行类型的下次可执行时间，已经剩余次数。

代码

/**
 * @param {character[]} tasks
 * @param {number} n
 * @return {number}
 */
var leastInterval = function (tasks, n) {
  const freq = {}

  tasks.forEach((item) => {
    if (freq[item]) {
      freq[item]++
    } else {
      freq[item] = 1
    }
  })

  const m = Object.keys(freq).length
  const nextValids = new Array(m).fill(1)
  const rests = Object.values(freq)

  let time = 0
  for (let i = 0; i < tasks.length; i++) {
    let minNextValid = Number.MAX_SAFE_INTEGER
    time++
    for (let j = 0; j < nextValids.length; j++) {
      if (rests[j] > 0) {
        minNextValid = Math.min(minNextValid, nextValids[j])
      }
    }
    time = Math.max(time, minNextValid)

    let next = -1
    for (let j = 0; j < m; j++) {
      if (
        rests[j] > 0 &&
        nextValids[j] <= time &&
        (next === -1 || rests[next] < rests[j])
      ) {
        next = j
      }
    }

    rests[next]--
    nextValids[next] = time + n + 1
  }

  return time
}

复杂度

时间：O(N)，执行一个任务就需要更新该任务类型的剩余任务次数和可执行时间
空间：O(N)，存储不同任务类型的时间和次数