为了更好的阅读体检，可以查看我的算法学习博客阿里巴巴找宝箱(ll)
题目描述
贫如洗的樵夫阿里巴巴在去砍柴的路上，无意中发现了强盗集团的藏宝地，藏宝地有编号从0-N的箱子，每个箱子上面贴有箱子中藏有金币的数量。 从金币数量中选出一个数字集合，并销毁贴有这些数字的每个箱子，如果能销毁一半及以上的箱子，则返回这个数字集合的最小大小
输入描述
一个数字字串，数字之间使用逗号分隔，例如: 6,6,6,6,3,3,3,1,1,5字串中数字的个数为偶数，并且
-
1
字串中数字的个数
-
1
输出描述
这个数字集合的最小大小，例如: 2
样例
输入
1,1,1,1,3,3,3,6,6,8
输出
2
说明
选择集合{1,8}，销毁后的结果数组为[3,3,3,6,6]，长度为5，长度为原数组的一半。
大小为 2 的可行集合还有{1,3},{1,6},{3,6}。
选择{6,8}集合是不可行的，它销后的结果数组为[1,1,1,1,3,3,3]，新数组长度大于原数组的二分之一。
输入
2,2,2,2
输出
1
说明
我们只能选择集合{2}，销毁后的结果数组为空。
Java算法源码
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] nums = Arrays.stream(sc.nextLine().split(",")).mapToInt(Integer::parseInt).toArray();
System.out.println(getResult(nums));
}
public static int getResult(int[] nums) {
// 箱子上贴的数字可以看出 类别
// 统计每一个类别出现的次数，key是类别，value是类别出现次数
HashMap<Integer, Integer> count = new HashMap<>();
for (int num : nums) {
count.put(num, count.getOrDefault(num, 0) + 1);
}
// half是箱子数量的一半，注意向上取整，因为比如箱子有7个，则销毁一半及以上的箱子数量至少是4个，而不是3个
int half = (int) Math.ceil(nums.length / 2.0);
// 按类别出现次数降序 类别
List<Map.Entry<Integer, Integer>> collect =
count.entrySet().stream()
.sorted((a, b) -> b.getValue() - a.getValue())
.collect(Collectors.toList());
// remove记录销毁的箱子数量
int remove = 0;
// numCount记录销毁的类别数量
int numCount = 0;
// 贪心思维,想要销毁最多的箱子数，又要销毁的箱子的类别数最少，则应该尽可能销毁出现次数多的类别，因此前面对按照次数降序了类别
for (Map.Entry<Integer, Integer> entry : collect) {
remove += entry.getValue();
numCount++;
// 一旦达标，则返回销毁的类别数量
if (remove >= half) {
return numCount;
}
}
return -1; // 走不到此行，仅用于代码健壮性
}
}
JS算法源码
/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
rl.on("line", (line) => {
const nums = line.split(",").map(Number);
console.log(getResult(nums));
});
function getResult(nums) {
// 箱子上贴的数字可以看成 类别
// 统计每一个类别出现的次数，key是类别，value是类别出现次数
const count = {};
for (let num of nums) {
count[num] = (count[num] ?? 0) + 1;
}
// half是箱子数量的一半，注意向上取整，因为比如箱子有7个，则销毁一半及以上的箱子数量至少是4个，而不是3个
const half = Math.ceil(nums.length / 2);
// 按类别出现次数降序 类别
const sortedEntery = Object.entries(count).sort((a, b) => b[1] - a[1]);
// remove记录销毁的箱子数量
let remove = 0;
// numCount记录销毁的类别数量
let numCount = 0;
// 贪心思维,想要销毁最多的箱子数，又要销毁的箱子的类别数最少，则应该尽可能销毁出现次数多的类别，因此前面对按照次数降序了类别
for (let entry of sortedEntery) {
remove += entry[1];
numCount++;
// 一旦达标，则返回销毁的类别数量
if (remove >= half) {
return numCount;
}
}
return -1; // 走不到此行，仅用于代码健壮性
}
Python算法源码
# 输入获取
import math
nums = list(map(int, input().split(",")))
# 算法入口
def getResult():
# 箱子上贴的数字可以看成 类别
# 统计每一个类别出现的次数，key是类别，value是类别出现次数
count = {}
for num in nums:
count[num] = count.get(num, 0) + 1
# half是箱子数量的一半，注意向上取整，因为比如箱子有7个，则销毁一半及以上的箱子数量至少是4个，而不是3个
half = int(math.ceil(len(nums) / 2))
# 按类别出现次数降序 类别
entries = list(count.items())
entries.sort(key=lambda x: -x[1])
# remove记录销毁的箱子数量
remove = 0
# numCount记录销毁的类别数量
numCount = 0
# 贪心思维,想要销毁最多的箱子数，又要销毁的箱子的类别数最少，则应该尽可能销毁出现次数多的类别，因此前面对按照次数降序了类别
for entry in entries:
remove += entry[1]
numCount += 1
# 一旦达标，则返回销毁的类别数量
if remove >= half:
return numCount
return -1 # 走不到此行，仅用于代码健壮性
# 算法调用
print(getResult())
