目标
给你一个下标从 0 开始的整数数组 tasks ，其中 tasks[i] 表示任务的难度级别。在每一轮中，你可以完成 2 个或者 3 个 相同难度级别 的任务。
返回完成所有任务需要的 最少 轮数，如果无法完成所有任务，返回 -1 。
示例 1：
输入：tasks = [2,2,3,3,2,4,4,4,4,4]
输出：4
解释：要想完成所有任务，一个可能的计划是：
- 第一轮，完成难度级别为 2 的 3 个任务。
- 第二轮，完成难度级别为 3 的 2 个任务。
- 第三轮，完成难度级别为 4 的 3 个任务。
- 第四轮，完成难度级别为 4 的 2 个任务。
可以证明，无法在少于 4 轮的情况下完成所有任务，所以答案为 4 。示例 2：
输入：tasks = [2,3,3]
输出：-1
解释：难度级别为 2 的任务只有 1 个，但每一轮执行中，只能选择完成 2 个或者 3 个相同难度级别的任务。因此，无法完成所有任务，答案为 -1 。说明：
- 1 <= tasks.length <= 10^5
- 1 <= tasks[i] <= 10^9
思路
有一个任务数组，元素值表示任务级别，现在需要我们完成任务，每一轮只能完成2个或3个相同级别的任务，问完成所有任务最少需要多少轮，如果无法完成所有任务返回-1。
首先统计序列中等级相同的任务个数，可以使用哈希表，也可以先排序再在循环的过程中使用滑动窗口统计（这个效率最高，但是容易出错）。然后：
- 如果序列中只有1个同级别任务，那么无法完成，返回-1。
- 如果序列中有2个同级别任务，累加1。
- 如果序列中有3个同级别任务，累加1。
- 如果序列中同级别任务数 n 大于3，累加
(n + 2)/3 向下取整：n % 3 == 1，这时只需将之前3个一组的任务与余下的1个任务组合，然后拆成2组即可：loop = (n - 4)/3 + 2 = (n + 2)/3。n % 3 == 2，多余的两个自成一组：loop = (n -2)/3 + 1 = (n + 1)/3。这时(n+1)刚好可以被3整除，(n+2)/3向下取整不会影响结果。n % 3 == 0，直接整除即可：loop = n/3。道理同上。
以上就是贪心策略，每次取尽可能多的任务。
代码
/**
* @date 2024-05-14 0:11
*/
public class MinimumRounds2244 {
public int minimumRounds(int[] tasks) {
Map<Integer, Integer> map = new HashMap<>();
int res = 0;
for (int t : tasks) {
map.merge(t, 1, Integer::sum);
}
for (Integer cnt : map.values()) {
if (cnt == 1) {
return -1;
} else if (cnt == 2 || cnt == 3) {
res++;
} else if (cnt % 3 == 0) {
res += cnt / 3;
} else if (cnt % 3 == 2) {
res += (cnt - 2) / 3 + 1;
} else if (cnt % 3 == 1) {
res += (cnt - 4) / 3 + 2;
}
}
return res;
}
}性能
