Minimum Cost to Hire K Workers

Minimum Cost to Hire K Workers - Problem

There are n workers. You are given two integer arrays quality and wage where:

quality[i] is the quality of the i-th worker
wage[i] is the minimum wage expectation for the i-th worker

We want to hire exactly k workers to form a paid group. To hire a group of k workers, we must pay them according to the following rules:

Every worker in the paid group must be paid at least their minimum wage expectation
In the group, each worker's pay must be directly proportional to their quality

This means if a worker's quality is double that of another worker in the group, then they must be paid twice as much as the other worker.

Given the integer k, return the least amount of money needed to form a paid group satisfying the above conditions.

Input & Output

Example 1 — Basic Case

$ Input: quality = [10,20,5], wage = [70,50,30], k = 2

› Output: 105.0

💡 Note: We hire workers at indices 0 and 2. Worker 0 has ratio 70/10=7.0, worker 2 has ratio 30/5=6.0. The captain (highest ratio) is worker 0 with ratio 7.0. Total cost = 7.0 × (10+5) = 105.0

Example 2 — Different k Value

$ Input: quality = [3,1,10,10,1], wage = [4,8,2,2,7], k = 3

› Output: 30.666666666666668

💡 Note: We can hire workers at indices 0, 2, 3. Their ratios are 4/3≈1.33, 2/10=0.2, 2/10=0.2. The captain has ratio 4/3. Total cost = (4/3) × (3+10+10) ≈ 30.67

Example 3 — Minimum Case

$ Input: quality = [10,20], wage = [50,80], k = 2

› Output: 150.0

💡 Note: We must hire both workers. Worker 0 has ratio 50/10=5.0, worker 1 has ratio 80/20=4.0. Since we need both workers and each must get at least their minimum wage, we use the higher ratio of 5.0. Total cost = 5.0 × (10+20) = 150.0

Constraints

n == quality.length == wage.length
1 ≤ k ≤ n ≤ 10⁴
1 ≤ quality[i], wage[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 f Facebook 22 M Microsoft 18

The key insight is that the worker with the highest wage/quality ratio in any group determines the pay rate for everyone. The optimal approach sorts workers by their ratio and uses a max heap to efficiently track the k workers with lowest qualities. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(C(n,k) × k) Space: O(k)

For each combination of k workers, calculate the required pay rate based on the highest wage/quality ratio in the group, then compute total cost.

Greedy with Sorting and Heap

⏱️ Time: O(n log n) Space: O(n)

Sort workers by wage/quality ratio, then iterate through them. For each worker as the 'captain' (highest ratio in group), use a max heap to maintain the k workers with lowest qualities seen so far.

Brute Force - Try All Combinations — Algorithm Steps

Generate all combinations of k workers from n workers
For each combination, find the maximum wage/quality ratio
Calculate total cost using this ratio and sum of qualities
Track minimum cost across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible groups of k workers

Calculate Cost

For each group, find max wage/quality ratio and compute total cost

Find Minimum

Track the lowest cost across all combinations

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>

void generateCombinations(int* quality, int* wage, int n, int k, int start, int* current, int currentSize, double* min_cost) {
    if (currentSize == k) {
        double max_ratio = 0;
        int total_quality = 0;
        
        for (int i = 0; i < k; i++) {
            double ratio = (double)wage[current[i]] / quality[current[i]];
            if (ratio > max_ratio) max_ratio = ratio;
            total_quality += quality[current[i]];
        }
        
        double cost = max_ratio * total_quality;
        if (cost < *min_cost) *min_cost = cost;
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[currentSize] = i;
        generateCombinations(quality, wage, n, k, i + 1, current, currentSize + 1, min_cost);
    }
}

double solution(int* quality, int* wage, int n, int k) {
    double min_cost = DBL_MAX;
    int* current = (int*)malloc(k * sizeof(int));
    generateCombinations(quality, wage, n, k, 0, current, 0, &min_cost);
    free(current);
    return min_cost;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int quality[10000], wage[10000];
    int n = 0;
    
    parseArray(line, quality, &n);
    
    fgets(line, sizeof(line), stdin);
    int m = 0;
    parseArray(line, wage, &m);
    
    int k;
    scanf("%d", &k);
    
    double result = solution(quality, wage, n, k);
    printf("%.10g\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) × k)

C(n,k) combinations, each requiring O(k) work to process

⚡ Linearithmic

Space Complexity

O(k)

Space to store current combination of k workers

⚡ Linearithmic Space

58.0K Views

Medium Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler