Total Cost to Hire K Workers - Practice Coding Problems

Total Cost to Hire K Workers - Problem

Imagine you're a hiring manager at a tech company with a limited budget. You have a list of candidates, each with their hiring cost, and you need to hire exactly k workers following a specific strategy.

You're given:

An array costs where costs[i] is the cost to hire the i-th worker
Two integers: k (workers to hire) and candidates (pool size to consider)

Hiring Rules:

Conduct k hiring sessions, selecting one worker per session
In each session, consider only the first candidates workers OR the last candidates workers from the remaining pool
Choose the worker with the lowest cost from these two groups
If there's a tie, prefer the worker with the smaller index
If fewer than candidates workers remain, consider all remaining workers

Goal: Return the minimum total cost to hire exactly k workers.

For example, with costs = [3,2,7,7,1,2] and candidates = 2:
First session: Consider [3,2] and [1,2] → hire worker at index 4 (cost=1)
Second session: Consider [3,2] and [2] → hire worker at index 1 (cost=2)

Input & Output

example_1.py — Basic Case

$ Input: costs = [17,12,10,2,7,2,11,20,8], k = 3, candidates = 4

› Output: 11

💡 Note: We hire 3 workers in total. The total cost is initially 0. In the first hiring round, we choose the worker from [17,12,10,2] (first 4) or [2,11,20,8] (last 4). The lowest cost is 2, and we break the tie by the smallest index, which is 3. The total cost = 0 + 2 = 2. In the second hiring round, we choose from [17,12,10,7] or [11,20,8]. The lowest cost is 7 (index 4). Total cost = 2 + 7 = 9. In the third round, we choose from [17,12,10] or [11,20,8]. The lowest cost is 8 (index 8). Total cost = 9 + 2 = 11. Notice index 7 was not a candidate because the worker from index 3 was hired, shrinking the array to [17,12,10,7,11,20,8].

example_2.py — Small Array

$ Input: costs = [1,2,4,1], k = 3, candidates = 3

› Output: 4

💡 Note: Since candidates (3) * 2 = 6 >= array length (4), we consider all workers in each session. First session: choose worker with cost 1 (index 0). Second session: choose worker with cost 1 (index 3). Third session: choose worker with cost 2 (index 1). Total cost = 1 + 1 + 2 = 4.

example_3.py — Edge Case

$ Input: costs = [31,25,72,79,74,65,84,91,18,59,27,9,81,33,17,58], k = 11, candidates = 2

› Output: 423

💡 Note: Large array with small candidate pool. We need to hire 11 workers considering only 2 from each end initially. This demonstrates the efficiency of the heap approach compared to brute force scanning.

Constraints

1 ≤ costs.length ≤ 10⁵
1 ≤ costs[i] ≤ 10⁵
1 ≤ k, candidates ≤ costs.length
Follow up: Could you solve it in O((k + candidates) log candidates) time?

Visualization

Tap to expand

Understanding the Visualization

Setup Interview Rooms

Create VIP rooms (heaps) for front and back candidates. Each room automatically shows the cheapest available candidate.

Make Hiring Decision

Compare the cheapest candidate from each room. Hire the cheaper one (break ties by experience/index).

Update Candidate Pool

When someone is hired, the next person in their line enters the corresponding interview room.

Repeat Until Done

Continue until you've hired k workers. The VIP rooms ensure you always see the best available candidates instantly!

Key Takeaway

🎯 Key Insight: Priority queues eliminate the need for repeated scanning by automatically maintaining the minimum element at the top, reducing time complexity from O(k × candidates) to O((k + candidates) log candidates).

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses two priority queues (min-heaps) to efficiently track the cheapest workers from both candidate pools. By maintaining two pointers that move inward as workers are hired, we avoid repeatedly scanning the entire array. The key insight is that we only need to consider the cheapest available candidates from each pool, making this problem perfect for heap-based optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(k * candidates)	O(1)	Simulate each hiring session by scanning the candidate pools manually
Two Pointers with Priority Queues (Optimal)	O((k + candidates) log candidates)	O(candidates)	Use two pointers and priority queues to efficiently track candidates from both ends

Brute Force Simulation — Algorithm Steps

For each hiring session (k iterations)
Identify the first 'candidates' workers and last 'candidates' workers
Find the minimum cost among these candidates
Handle ties by choosing smaller index
Remove selected worker and update indices
Add cost to total

Visualization

Tap to expand

Step-by-Step Walkthrough

Session 1

Scan first 2 and last 2 workers, find minimum

Remove Worker

Mark selected worker as hired

Session 2

Repeat scanning process with remaining workers

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

long long totalCost(int* costs, int costsSize, int k, int candidates) {
    long long totalCost = 0;
    bool* hired = (bool*)calloc(costsSize, sizeof(bool));
    
    for (int session = 0; session < k; session++) {
        int minCost = INT_MAX;
        int minIdx = -1;
        
        // Check first 'candidates' workers
        int count = 0;
        for (int i = 0; i < costsSize && count < candidates; i++) {
            if (!hired[i]) {
                if (costs[i] < minCost || (costs[i] == minCost && i < minIdx)) {
                    minCost = costs[i];
                    minIdx = i;
                }
                count++;
            }
        }
        
        // Check last 'candidates' workers
        count = 0;
        for (int i = costsSize - 1; i >= 0 && count < candidates; i--) {
            if (!hired[i]) {
                if (costs[i] < minCost || (costs[i] == minCost && i < minIdx)) {
                    minCost = costs[i];
                    minIdx = i;
                }
                count++;
            }
        }
        
        hired[minIdx] = true;
        totalCost += minCost;
    }
    
    free(hired);
    return totalCost;
}

Time & Space Complexity

Time Complexity

⏱️

O(k * candidates)

For each of k sessions, we scan up to 2*candidates workers

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.7K Views

High Frequency

~25 min Avg. Time

1.3K 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler