There are N
workers. The i
-th worker has a quality[i]
and a minimum wage expectation wage[i]
.
Now we want to hire exactly K
workers to form a paid group. When hiring a group of K workers, we must pay them according to the following rules:
- Every worker in the paid group should be paid in the ratio of their quality compared to other workers in the paid group.
- Every worker in the paid group must be paid at least their minimum wage expectation.
Return the least amount of money needed to form a paid group satisfying the above conditions.
Example 1:
Input: quality = [10,20,5], wage = [70,50,30], K = 2 Output: 105.00000 Explanation: We pay 70 to 0-th worker and 35 to 2-th worker.
Example 2:
Input: quality = [3,1,10,10,1], wage = [4,8,2,2,7], K = 3 Output: 30.66667 Explanation: We pay 4 to 0-th worker, 13.33333 to 2-th and 3-th workers seperately.
Note:
1 <= K <= N <= 10000
, whereN = quality.length = wage.length
1 <= quality[i] <= 10000
1 <= wage[i] <= 10000
- Answers within
10^-5
of the correct answer will be considered correct.
---------------------------------------------------------------------------------------------
First, I wrote a DP codes. However, if using dp[i][j] to stand the picked out i workers ending with j, the dp recursive formula is actually not right.
The key points for this problem is to understand the price-performanceratio. Generally, we use performance-price ratio and the customers pursue higher performance-price ratio. As opposed to performance-price ratio, workers prefer higher price-performance ratio. The highest price-performance ratio is suitable for all workers. So we sort by price-perfermance ratio first and pick out K workers with <= some price-perfermance ratio and the least quality.
import heapq
class Solution:
def mincostToHireWorkers(self, quality, wage, K: int) -> float:
l = len(quality)
ratio_arr = sorted([(wage[i] / quality[i], i) for i in range(l)])
heap, sumq, res = [], 0, float('inf')
for ratio, idx in ratio_arr:
sumq += quality[idx]
heapq.heappush(heap, -quality[idx])
if (len(heap) > K):
sumq += heapq.heappop(heap)
if (len(heap) == K):
res = min(res, sumq * ratio)
return res