+ problem 621

Author: fruit-in

Problemset/0621-Task Scheduler/README.md

@@ -0,0 +1,81 @@
+# 621. Task Scheduler
+Given a characters array `tasks`, representing the tasks a CPU needs to do, where each letter represents a different task. Tasks could be done in any order. Each task is done in one unit of time. For each unit of time, the CPU could complete either one task or just be idle.
+
+However, there is a non-negative integer `n` that represents the cooldown period between two **same tasks** (the same letter in the array), that is that there must be at least `n` units of time between any two same tasks.
+
+Return *the least number of units of times that the CPU will take to finish all the given tasks*.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> tasks = ["A","A","A","B","B","B"], n = 2
+<strong>Output:</strong> 8
+<strong>Explanation:</strong>
+A -> B -> idle -> A -> B -> idle -> A -> B
+There is at least 2 units of time between any two same tasks.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> tasks = ["A","A","A","B","B","B"], n = 0
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> On this case any permutation of size 6 would work since n = 0.
+["A","A","A","B","B","B"]
+["A","B","A","B","A","B"]
+["B","B","B","A","A","A"]
+...
+And so on.
+</pre>
+
+#### Example 3:
+<pre>
+<strong>Input:</strong> tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2
+<strong>Output:</strong> 16
+<strong>Explanation:</strong>
+One possible solution is
+A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> idle -> idle -> A -> idle -> idle -> A
+</pre>
+
+#### Constraints:
+* <code>1 <= task.length <= 10<sup>4</sup></code>
+* `tasks[i]` is upper-case English letter.
+* The integer `n` is in the range `[0, 100]`.
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+impl Solution {
+    pub fn least_interval(tasks: Vec<char>, n: i32) -> i32 {
+        let mut count = [0; 27];
+        let mut cooldown = [0; 26];
+        let mut time = 0;
+
+        for &task in &tasks {
+            count[(task as usize) - 65] += 1;
+        }
+
+        for _ in 0..tasks.len() {
+            let mut min_cooldown = i32::MAX;
+            let mut next_task = 26;
+
+            for i in 0..26 {
+                if count[i] > 0 {
+                    min_cooldown = min_cooldown.min(cooldown[i]);
+                }
+            }
+            time = time.max(min_cooldown);
+
+            for i in 0..26 {
+                if cooldown[i] <= time && count[i] > count[next_task] {
+                    next_task = i;
+                }
+            }
+            count[next_task] -= 1;
+            time += 1;
+            cooldown[next_task] = time + n;
+        }
+
+        time
+    }
+}
+```

Problemset/0621-Task Scheduler/README_CN.md

@@ -0,0 +1,79 @@
+# 621. 任务调度器
+给你一个用字符数组 `tasks` 表示的 CPU 需要执行的任务列表。其中每个字母表示一种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。在任何一个单位时间，CPU 可以完成一个任务，或者处于待命状态。
+
+然而，两个 **相同种类** 的任务之间必须有长度为整数 `n` 的冷却时间，因此至少有连续 `n` 个单位时间内 CPU 在执行不同的任务，或者在待命状态。
+
+你需要计算完成所有任务所需要的 **最短时间** 。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> tasks = ["A","A","A","B","B","B"], n = 2
+<strong>输出:</strong> 8
+<strong>解释:</strong> A -> B -> (待命) -> A -> B -> (待命) -> A -> B
+     在本示例中，两个相同类型任务之间必须间隔长度为 n = 2 的冷却时间，而执行一个任务只需要一个单位时间，所以中间出现了（待命）状态。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> tasks = ["A","A","A","B","B","B"], n = 0
+<strong>输出:</strong> 6
+<strong>解释:</strong> 在这种情况下，任何大小为 6 的排列都可以满足要求，因为 n = 0
+["A","A","A","B","B","B"]
+["A","B","A","B","A","B"]
+["B","B","B","A","A","A"]
+...
+诸如此类
+</pre>
+
+#### 示例 3:
+<pre>
+<strong>输入:</strong> tasks = ["A","A","A","A","A","A","B","C","D","E","F","G"], n = 2
+<strong>输出:</strong> 16
+<strong>解释:</strong> 一种可能的解决方案是：
+     A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> (待命) -> (待命) -> A -> (待命) -> (待命) -> A
+</pre>
+
+#### 提示:
+* <code>1 <= task.length <= 10<sup>4</sup></code>
+* `tasks[i]` 是大写英文字母
+* `n` 的取值范围为 `[0, 100]`
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+impl Solution {
+    pub fn least_interval(tasks: Vec<char>, n: i32) -> i32 {
+        let mut count = [0; 27];
+        let mut cooldown = [0; 26];
+        let mut time = 0;
+
+        for &task in &tasks {
+            count[(task as usize) - 65] += 1;
+        }
+
+        for _ in 0..tasks.len() {
+            let mut min_cooldown = i32::MAX;
+            let mut next_task = 26;
+
+            for i in 0..26 {
+                if count[i] > 0 {
+                    min_cooldown = min_cooldown.min(cooldown[i]);
+                }
+            }
+            time = time.max(min_cooldown);
+
+            for i in 0..26 {
+                if cooldown[i] <= time && count[i] > count[next_task] {
+                    next_task = i;
+                }
+            }
+            count[next_task] -= 1;
+            time += 1;
+            cooldown[next_task] = time + n;
+        }
+
+        time
+    }
+}
+```

Problemset/0621-Task Scheduler/Solution.rs

@@ -0,0 +1,34 @@
+impl Solution {
+    pub fn least_interval(tasks: Vec<char>, n: i32) -> i32 {
+        let mut count = [0; 27];
+        let mut cooldown = [0; 26];
+        let mut time = 0;
+
+        for &task in &tasks {
+            count[(task as usize) - 65] += 1;
+        }
+
+        for _ in 0..tasks.len() {
+            let mut min_cooldown = i32::MAX;
+            let mut next_task = 26;
+
+            for i in 0..26 {
+                if count[i] > 0 {
+                    min_cooldown = min_cooldown.min(cooldown[i]);
+                }
+            }
+            time = time.max(min_cooldown);
+
+            for i in 0..26 {
+                if cooldown[i] <= time && count[i] > count[next_task] {
+                    next_task = i;
+                }
+            }
+            count[next_task] -= 1;
+            time += 1;
+            cooldown[next_task] = time + n;
+        }
+
+        time
+    }
+}

README.md

@@ -357,6 +357,7 @@
 [609][609l]  |[Find Duplicate File in System][609]                                                  |![rb]
 [611][611l]  |[Valid Triangle Number][611]                                                          |![rs]
 [617][617l]  |[Merge Two Binary Trees][617]                                                         |![py]
+[621][621l]  |[Task Scheduler][621]                                                                 |![rs]
 [622][622l]  |[Design Circular Queue][622]                                                          |![rs]
 [623][623l]  |[Add One Row to Tree][623]                                                            |![py]
 [628][628l]  |[Maximum Product of Three Numbers][628]                                               |![py]
@@ -1683,6 +1684,7 @@
 [609]:Problemset/0609-Find%20Duplicate%20File%20in%20System/README.md#609-find-duplicate-file-in-system
 [611]:Problemset/0611-Valid%20Triangle%20Number/README.md#611-valid-triangle-number
 [617]:Problemset/0617-Merge%20Two%20Binary%20Trees/README.md#617-merge-two-binary-trees
+[621]:Problemset/0621-Task%20Scheduler/README.md#621-task-scheduler
 [622]:Problemset/0622-Design%20Circular%20Queue/README.md#622-design-circular-queue
 [623]:Problemset/0623-Add%20One%20Row%20to%20Tree/README.md#623-add-one-row-to-tree
 [628]:Problemset/0628-Maximum%20Product%20of%20Three%20Numbers/README.md#628-maximum-product-of-three-numbers
@@ -3009,6 +3011,7 @@
 [609l]:https://leetcode.com/problems/find-duplicate-file-in-system/
 [611l]:https://leetcode.com/problems/valid-triangle-number/
 [617l]:https://leetcode.com/problems/merge-two-binary-trees/
+[621l]:https://leetcode.com/problems/task-scheduler/
 [622l]:https://leetcode.com/problems/design-circular-queue/
 [623l]:https://leetcode.com/problems/add-one-row-to-tree/
 [628l]:https://leetcode.com/problems/maximum-product-of-three-numbers/

README_CN.md

@@ -357,6 +357,7 @@
 [609][609l]  |[在系统中查找重复文件][609]                               |![rb]
 [611][611l]  |[有效三角形的个数][611]                                   |![rs]
 [617][617l]  |[合并二叉树][617]                                         |![py]
+[621][621l]  |[任务调度器][621]                                         |![rs]
 [622][622l]  |[设计循环队列][622]                                       |![rs]
 [623][623l]  |[在二叉树中增加一行][623]                                 |![py]
 [628][628l]  |[三个数的最大乘积][628]                                   |![py]
@@ -1683,6 +1684,7 @@
 [609]:Problemset/0609-Find%20Duplicate%20File%20in%20System/README_CN.md#609-在系统中查找重复文件
 [611]:Problemset/0611-Valid%20Triangle%20Number/README_CN.md#611-有效三角形的个数
 [617]:Problemset/0617-Merge%20Two%20Binary%20Trees/README_CN.md#617-合并二叉树
+[621]:Problemset/0621-Task%20Scheduler/README_CN.md#621-任务调度器
 [622]:Problemset/0622-Design%20Circular%20Queue/README_CN.md#622-设计循环队列
 [623]:Problemset/0623-Add%20One%20Row%20to%20Tree/README_CN.md#623-在二叉树中增加一行
 [628]:Problemset/0628-Maximum%20Product%20of%20Three%20Numbers/README_CN.md#628-三个数的最大乘积
@@ -3009,6 +3011,7 @@
 [609l]:https://leetcode.cn/problems/find-duplicate-file-in-system/
 [611l]:https://leetcode.cn/problems/valid-triangle-number/
 [617l]:https://leetcode.cn/problems/merge-two-binary-trees/
+[621l]:https://leetcode.cn/problems/task-scheduler/
 [622l]:https://leetcode.cn/problems/design-circular-queue/
 [623l]:https://leetcode.cn/problems/add-one-row-to-tree/
 [628l]:https://leetcode.cn/problems/maximum-product-of-three-numbers/