Minimum Cost to Hire K Workers - Practice Coding Problems

Minimum Cost to Hire K Workers - Problem

You're running a company and need to hire exactly k workers from a pool of n candidates. Each worker has a quality rating and a minimum wage expectation.

Here's the challenge: You must follow these strict hiring rules:

📋 Rule 1: Every hired worker must receive at least their minimum wage expectation
⚖️ Rule 2: All workers' pay must be proportional to their quality - if Worker A has twice the quality of Worker B, they must be paid exactly twice as much

Given arrays quality[i] and wage[i] representing each worker's quality and minimum wage expectation, find the minimum total cost to hire exactly k workers while satisfying both rules.

Example: If you hire workers with qualities [3, 1, 2] and they need wages [4, 8, 2], you might pay them [12, 4, 8] respectively (proportional to quality 3:1:2) while meeting everyone's minimum wage.

Input & Output

example_1.py — Basic Case

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

› Output: 105.00000

💡 Note: We hire workers 0 and 2. Worker 0: ratio = 70/10 = 7.0, Worker 2: ratio = 30/5 = 6.0. The max ratio is 7.0, so we pay 7.0 × (10+5) = 105.0 total.

example_2.py — Equal Ratios

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

› Output: 30.66667

💡 Note: We hire workers with qualities [3,1,10] and ratios [4/3, 8/1, 2/10]. The max ratio is 8.0, so total cost is 8.0 × (3+1+10)/3 = 30.67.

example_3.py — Edge Case k=1

$ Input: quality = [2,3,5], wage = [10,15,20], k = 1

› Output: 10.00000

💡 Note: When k=1, we simply choose the worker with minimum wage since there's no proportional constraint with other workers. Worker 0 costs 10.

Constraints

n == quality.length == wage.length
1 ≤ k ≤ n ≤ 10⁴
1 ≤ quality[i], wage[i] ≤ 10⁴
All workers must be paid proportionally to their quality

Visualization

Tap to expand

Understanding the Visualization

Calculate Ratios

For each worker, calculate their wage-to-quality ratio (their 'price per unit of work')

Sort by Efficiency

Sort workers by their ratio - those with lower ratios are more 'cost-efficient'

Sliding Window

Process workers in order, maintaining a group of k workers with lowest total quality

Heap Optimization

Use max heap to efficiently track and remove highest quality workers when needed

Cost Calculation

For each valid group, calculate cost as max_ratio × total_quality

Key Takeaway

🎯 Key Insight: The worker with the highest wage-to-quality ratio in any hired group determines everyone's pay rate. By processing workers in order of increasing ratio and using a heap to maintain the k lowest-quality workers, we efficiently find the optimal hiring combination.

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a greedy approach with heap optimization. Key insight: sort workers by wage-to-quality ratio, then use a sliding window with max heap to efficiently find the k workers with minimum total quality for each possible pay rate. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Heap (Optimal)	O(n log n)	O(n + k)	Sort by wage/quality ratio and use max heap to maintain k lowest quality workers
Brute Force (Try All Combinations)	O(C(n,k) * k)	O(k)	Generate all possible combinations of k workers and calculate minimum cost for each

Greedy with Heap (Optimal) — Algorithm Steps

Create pairs of (wage/quality ratio, quality) and sort by ratio
Use a max heap to track the k workers with lowest total quality
For each worker in sorted order, add their quality to the heap
If heap size exceeds k, remove the worker with highest quality
Calculate cost as current_ratio × total_quality and track minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Ratio

Sort all workers by their wage/quality ratio in ascending order

Sliding Window

Process workers in order, maintaining a window of k workers with lowest total quality

Heap Management

Use max heap to efficiently track and remove highest quality workers

Calculate Cost

For each valid window, calculate cost as current_ratio × total_quality

Code -

solution.c — C

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

typedef struct {
    double ratio;
    int quality;
} Worker;

int compare(const void* a, const void* b) {
    Worker* wa = (Worker*)a;
    Worker* wb = (Worker*)b;
    if (wa->ratio < wb->ratio) return -1;
    if (wa->ratio > wb->ratio) return 1;
    return 0;
}

// Simple max heap implementation
typedef struct {
    int* data;
    int size;
    int capacity;
} MaxHeap;

MaxHeap* createHeap(int capacity) {
    MaxHeap* heap = malloc(sizeof(MaxHeap));
    heap->data = malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MaxHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[parent] >= heap->data[idx]) break;
        int temp = heap->data[parent];
        heap->data[parent] = heap->data[idx];
        heap->data[idx] = temp;
        idx = parent;
    }
}

void heapifyDown(MaxHeap* heap, int idx) {
    while (2 * idx + 1 < heap->size) {
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        int largest = idx;
        
        if (left < heap->size && heap->data[left] > heap->data[largest]) {
            largest = left;
        }
        if (right < heap->size && heap->data[right] > heap->data[largest]) {
            largest = right;
        }
        if (largest == idx) break;
        
        int temp = heap->data[idx];
        heap->data[idx] = heap->data[largest];
        heap->data[largest] = temp;
        idx = largest;
    }
}

void push(MaxHeap* heap, int val) {
    heap->data[heap->size] = val;
    heapifyUp(heap, heap->size);
    heap->size++;
}

int pop(MaxHeap* heap) {
    int result = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return result;
}

double mincostToHireWorkers(int* quality, int* wage, int n, int k) {
    // Create and sort workers by ratio
    Worker* workers = malloc(n * sizeof(Worker));
    for (int i = 0; i < n; i++) {
        workers[i].ratio = (double) wage[i] / quality[i];
        workers[i].quality = quality[i];
    }
    qsort(workers, n, sizeof(Worker), compare);
    
    // Max heap for qualities
    MaxHeap* maxHeap = createHeap(n);
    int totalQuality = 0;
    double minCost = INFINITY;
    
    for (int i = 0; i < n; i++) {
        push(maxHeap, workers[i].quality);
        totalQuality += workers[i].quality;
        
        if (maxHeap->size > k) {
            int removed = pop(maxHeap);
            totalQuality -= removed;
        }
        
        if (maxHeap->size == k) {
            double cost = workers[i].ratio * totalQuality;
            if (cost < minCost) minCost = cost;
        }
    }
    
    free(workers);
    free(maxHeap->data);
    free(maxHeap);
    return minCost;
}

int main() {
    int quality[100], wage[100], k;
    int n = 0;
    char line[1000];
    
    // Read quality array
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL && n < 100) {
        quality[n++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    // Read wage array
    fgets(line, sizeof(line), stdin);
    token = strtok(line, " ");
    int i = 0;
    while (token != NULL && i < n) {
        wage[i++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &k);
    
    printf("%.5f\n", mincostToHireWorkers(quality, wage, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log k) for heap operations = O(n log n) overall

⚡ Linearithmic

Space Complexity

O(n + k)

O(n) for storing worker pairs + O(k) for the heap

⚡ Linearithmic Space

35.2K Views

Medium-High 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

Greedy with Heap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler