You are given a 0-indexed integer array tasks, where tasks[i] represents the difficulty level of a task. In each round, you can complete either 2 or 3 tasks of the same difficulty level.
Return the minimum rounds required to complete all the tasks, or-1if it is not possible to complete all the tasks.
Input:
tasks =[2,2,3,3,2,4,4,4,4,4]Output:
4Explanation: To complete all the tasks, a possible plan is:- In the first round, you complete 3 tasks of difficulty level 2.- In the second round, you complete 2 tasks of difficulty level 3.- In the third round, you complete 3 tasks of difficulty level 4.- In the fourth round, you complete 2 tasks of difficulty level 4.It can be shown that all the tasks cannot be completed in fewer than 4 rounds, so the answer is4.
Example 2:
1
2
3
4
5
Input:
tasks =[2,3,3]Output:
-1Explanation: There is only 1 task of difficulty level 2, but in each round, you can only complete either 2 or 3 tasks of the same difficulty level. Hence, you cannot complete all the tasks, and the answer is-1.
The key idea is to always group tasks of the same difficulty into as many groups of 3 as possible, since 3 is more efficient than 2. If a count cannot be grouped into 2 or 3, it’s impossible. For example, if there is only 1 task of a difficulty, we cannot form a valid group.
classSolution {
public:int minimumRounds(vector<int>& tasks) {
unordered_map<int, int> cnt;
for (int t : tasks) cnt[t]++;
int ans =0;
for (auto& [k, v] : cnt) {
if (v ==1) return-1;
ans += (v +2) /3;
}
return ans;
}
};
classSolution {
publicintminimumRounds(int[] tasks) {
Map<Integer, Integer> cnt =new HashMap<>();
for (int t : tasks) cnt.put(t, cnt.getOrDefault(t, 0) + 1);
int ans = 0;
for (int v : cnt.values()) {
if (v == 1) return-1;
ans += (v + 2) / 3;
}
return ans;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
classSolution {
funminimumRounds(tasks: IntArray): Int {
val cnt = mutableMapOf<Int, Int>()
for (t in tasks) cnt[t] = cnt.getOrDefault(t, 0) + 1var ans = 0for (v in cnt.values) {
if (v ==1) return -1 ans += (v + 2) / 3 }
return ans
}
}
1
2
3
4
5
6
7
8
9
10
11
classSolution:
defminimumRounds(self, tasks: list[int]) -> int:
cnt: dict[int, int] = {}
for t in tasks:
cnt[t] = cnt.get(t, 0) +1 ans =0for v in cnt.values():
if v ==1:
return-1 ans += (v +2) //3return ans
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
impl Solution {
pubfnminimum_rounds(tasks: Vec<i32>) -> i32 {
use std::collections::HashMap;
letmut cnt = HashMap::new();
for&t in&tasks {
*cnt.entry(t).or_insert(0) +=1;
}
letmut ans =0;
for&v in cnt.values() {
if v ==1 {
return-1;
}
ans += (v +2) /3;
}
ans
}
}