2020-03-15 22:00:39
问题描述：
有 N 名工人。 第 i 名工人的工作质量为 quality[i] ，其最低期望工资为 wage[i] 。
现在我们想雇佣 K 名工人组成一个工资组。在雇佣 一组 K 名工人时，我们必须按照下述规则向他们支付工资：
对工资组中的每名工人，应当按其工作质量与同组其他工人的工作质量的比例来支付工资。
工资组中的每名工人至少应当得到他们的最低期望工资。
返回组成一个满足上述条件的工资组至少需要多少钱。
示例 1：
输入： quality = [10,20,5], wage = [70,50,30], K = 2
输出： 105.00000
解释： 我们向 0 号工人支付 70，向 2 号工人支付 35。
示例 2：
输入： quality = [3,1,10,10,1], wage = [4,8,2,2,7], K = 3
输出： 30.66667
解释： 我们向 0 号工人支付 4，向 2 号和 3 号分别支付 13.33333。
提示：
1 <= K <= N <= 10000，其中 N = quality.length = wage.length
1 <= quality[i] <= 10000
1 <= wage[i] <= 10000
与正确答案误差在 10^-5 之内的答案将被视为正确的。
相似问题：
问题求解：
定义value = wage / quality，即单位质量的价值，那么对于K个人的小组，如果按照最低的value付工资，那么更大value的wage必不能付足够，因此对于K个人的小组需要按照value最大的进行付费。
我们不妨按照value进行升序排序，那么对于其中某一个元素来说，我们只需要得到其左侧K- 1个人的quality最小和，即可得到以当前工人value结算的最大值。最后只需要从中挑选出最大值即可。
时间复杂度：O(nlogn)
public double mincostToHireWorkers(int[] quality, int[] wage, int K) {
double res = Double.MAX_VALUE;
List<double[]> nums = new ArrayList<>();
int n = wage.length;
for (int i = 0; i < n; i++) {
nums.add(new double[]{quality[i], wage[i] * 1.0 / quality[i]});
}
Collections.sort(nums, (double[] o1, double[] o2) -> Double.compare(o1[1], o2[1]));
PriorityQueue<Double> pq = new PriorityQueue<>((Double o1, Double o2) -> Double.compare(o2, o1));
double sum = 0;
for (int i = 0; i < n; i++) {
if (i > K - 1) sum -= pq.poll();
double q = nums.get(i)[0];
double v = nums.get(i)[1];
sum += q;
pq.add(q);
if (i >= K - 1) res = Math.min(res, sum * v);
}
return res;
}
5359. 最大的团队表现值
问题描述：
公司有编号为 1 到 n 的 n 个工程师，给你两个数组 speed 和 efficiency ，其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。请你返回由最多 k 个工程师组成的 最大团队表现值 ，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。
团队表现值 的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。
示例 1：
输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
输出：60
解释：
我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。
示例 2：
输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
输出：68
解释：
此示例与第一个示例相同，除了 k = 3 。我们可以选择工程师 1 ，工程师 2 和工程师 5 得到最大的团队表现值。表现值为 performance = (2 + 10 + 5) * min(5, 4, 7) = 68 。
示例 3：
输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
输出：72
提示：
1 <= n <= 10^5
speed.length == n
efficiency.length == n
1 <= speed[i] <= 10^5
1 <= efficiency[i] <= 10^8
1 <= k <= n
问题求解：
857是value最小 * sum_of_k(quality)，这里是效率最高的。本质上是一样的，思路基本一致。
long res = 0;
int mod = (int)1e9 + 7;
public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
List<int[]> nums = new ArrayList<>();
for (int i = 0; i < n; i++) {
nums.add(new int[]{speed[i], efficiency[i]});
}
Collections.sort(nums, (int[] o1, int[] o2) -> Integer.compare(o2[1], o1[1]));
PriorityQueue<Integer> pq = new PriorityQueue<>();
long sum = 0;
for (int i = 0; i < n; i++) {
if (i >= k) sum -= pq.poll();
sum += nums.get(i)[0];
pq.add(nums.get(i)[0]);
res = Math.max(res, sum * nums.get(i)[1]);
}
return (int)(res % mod);
}