[前端]_一起刷leetcode 621. 任务调度器

喜欢当热心市民的小学生
317 阅读6分钟

「这是我参与11月更文挑战的第15天，活动详情查看：2021最后一次更文挑战」

题目

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]

暴力解法

思路

  1. 首先判断n, 如果n为0，直接返回当前数组的长度即可，因为没间隔，每个任务1个单位时间；
  2. 新增数组arr记录每个元素出现的次数，并把记录从大到小做一轮排序，这道题目我们要做一个思维上的转换，用贪心的算法，每次把arr数组中最大的n项做一个减一的操作；
  3. 分类讨论， 如果n大于或者等于数组arr的长度，那么说明arr所有的元素都可以直接减一，那么我们只需要判断n - 1轮过后还有多少个剩余元素即可；
  4. 如果n小于arr的长度，那么我们只需要把arr中前n大的元素做一个减一即可，然后重新排序，确保每次我们减掉的都是最大的那几个值；
  5. 一直减到所有元素都为0即可。

实现

/**
 * @param {character[]} tasks
 * @param {number} n
 * @return {number}
 */
var leastInterval = function(tasks, n) {
    // 如果技能无cd，我们只需要判断需要释放多少次即可
    if (n === 0) {
        return tasks.length;
    }

    // 记录每个元素出现的次数
    let map = new Map();
    const len = tasks.length;
    
    for (let i = 0; i < len; i++) {
        map.set(tasks[i], (map.get(tasks[i]) || 0) + 1);
    }

    // 把记录转成数组并做排序
    let arr = [];
    for (let [ key, value ] of map) {
        arr.unshift(value);
        for (let i = 0; i < arr.length; i++) {
            if (arr[i] < arr[i + 1]) {
                [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
            } else {
                break;
            }
        }
    };

    let len2 = arr.length;
    let res = 0;

    // 分类讨论， 当n比数组大，说明每次数组中的每个元素都有的减，只需要判断n-1轮后有多少个残留即可
    if (n >= len2) {
        res = (n + 1) * (arr[0] - 1);

        for (let i = 0; i < len2; i++) {
            if (arr[i] === arr[0]) {
                res++;
            } else {
                break
            }
        }
        return res;
    }

    // 如果不是每次都有的减，那我们每次确保减掉最大的值即可
    while (arr.length) {
        // 如果最大值为1，说明是最后一轮进行减一了
        if (arr[0] === 1) {
            res += arr.length;
            return res;
        } else {
            res += n + 1;

            // 数组长度够的话，前n大的元素都减一
            let max = Math.min(n, arr.length - 1);
            for (let i = max; i >= 0; i--) {
                arr[i]--;
                if (arr[i] === 0) {
                    arr.splice(i, 1);
                }
            }

            // 减完后后面的元素冒泡上来，确保每次减的都是最大的
            for (let i = max + 1; i < len2; i++) {
                for (let j = i; j > 0; j--) {
                    if (arr[j] > arr[j - 1]) {
                        [arr[j], arr[j - 1]] = [arr[j - 1], arr[j]];
                    } else {
                        break;
                    }
                }
            }
        }
    }

    return res;
};

优化

暴力解法解完了之后，发现性能并不好，被85%的人击败了。于是来做个优化。想了半天发现只有前面构建arr排序列表那里可以做优化，因为题目是指定了大写字母，说明数量不超过26， 可以用计数排序。优化完发现还是被百分之五十的人打败了。

这部分代码替换上面构建arr的代码。

    let arr = new Array(26).fill(0);
    const len = tasks.length;
    
    for (let i = 0; i < len; i++) {
        arr[tasks[i].charCodeAt() - 65]++;
    }

    arr = arr.filter(v => v);
    arr.sort((a, b) => b - a);

这使我意识到了这道题没有那么简单。于是我只能放大招 -- 偷看答案。哎， 做了一个月题就看了两次答案，心虚啊。。。上一次看答案还是在上一次。

看完答案我发现我自己傻逼了。。。

人家题目说最少间隔n个，那么意味着我刚刚反复删除后排序保持arr的数据太多余了。。。。 你又不是只能排n个。找到了方向，顺着方向去捋思路。

思路

image.png

  1. 老规矩，我们计算每个元素出现的数量，这一步是没错的；
  2. 找到出现最多的元素，构造出上图这样子的矩形，有没有觉得很眼熟；

image.png

  1. 首先解释一下： 为什么是n+1， 因为执行一轮，自己要花1个时间，还要等n个单位时间，所以一轮总共是n + 1的时间；

  2. 然后解释一下，为什么要用arr[0]减一， 因为最后一轮执行完残留的元素，不用等cd了；

  3. 最后解释一下，res++是为了加上残留的那几个元素的执行时间；

  4. 但是这只是第一种情况， n比arr.length大，意味着每次必须等够n才能开始下一轮；

  5. 当n比arr.length小，说明什么？

    7.1 摆满矩形后，拿后面的数量去填空位，如果填不满，答案跟上一轮一样,用arr[0]也就是数组中元素出现最多次数maxValue, maxValue的个数maxCount表示的公式为： (n + 1) * (maxValue - 1) + maxCount)；

    7.2 如果填满了，还有剩余，说明我们需要cd的时间全被占用了，相当于无cd。

    7.3 填的满填不满如何判断呢，很简单，判断填满所需的长度和tasks的长度哪个大即可，那我们可以转换为： tasks.length > 7.1的公式 ? tasks.length : 7.1的公式, 又可以转换为： Math.max(tasks.length, 7.1的公式)

  6. 总结完，发现6和7.1 一样， 7.2和cd为0一样，那这道题又变成规律题了。。。上代码

优化代码

/**
 * @param {character[]} tasks
 * @param {number} n
 * @return {number}
 */
var leastInterval = function(tasks, n) {
    let arr = new Array(26).fill(0), // 记录出现的次数
        maxValue = Number.MIN_VALUE, // 找最大值
        maxCount = 0; // 最大值出现的次数
    
    const len = tasks.length;

    // 这次我们只记录最大值和最大值出现的次数
    for (let i = 0; i < len; i++) {
        const curIndex = tasks[i].charCodeAt() - "A".charCodeAt();
        arr[curIndex]++;
        if (arr[curIndex] > maxValue) {
            maxValue = arr[curIndex];
            maxCount = 1;
        } else if (arr[curIndex] === maxValue) {
            maxCount++;
        }
    }

    // 无cd的话结果为tasks.length， 有cd的话结果为(n + 1) * (maxValue - 1) + maxCount
    return Math.max(tasks.length, (n + 1) * (maxValue - 1) + maxCount);
};

结果

image.png

看懂了的小伙伴可以点个关注、咱们下道题目见。如无意外以后文章都会以这种形式，有好的建议欢迎评论区留言。

avatar
文章
阅读
粉丝