Skip to main content
Talentd

Total Cost to Hire K Workers - Solution & Explanation

MediumArrayTwo PointersHeap (Priority Queue)Simulation18 min readAsked at: Microsoft, Bloomberg, Gsa Capital +1
Practice this problem

Problem Statement

You are given a 0-indexed integer array costs where costs[i] is the cost of hiring the ith worker.

You are also given two integers k and candidates. We want to hire exactly k workers according to the following rules:

  • You will run k sessions and hire exactly one worker in each session.
  • In each hiring session, choose the worker with the lowest cost from either the first candidates workers or the last candidates workers. Break the tie by the smallest index.
    • For example, if costs = [3,2,7,7,1,2] and candidates = 2, then in the first hiring session, we will choose the 4th worker because they have the lowest cost [3,2,7,7,1,2].
    • In the second hiring session, we will choose 1st worker because they have the same lowest cost as 4th worker but they have the smallest index [3,2,7,7,2]. Please note that the indexing may be changed in the process.
  • If there are fewer than candidates workers remaining, choose the worker with the lowest cost among them. Break the tie by the smallest index.
  • A worker can only be chosen once.

Return the total cost to hire exactly k workers.

 

Example 1:

Input: costs = [17,12,10,2,7,2,11,20,8], k = 3, candidates = 4
Output: 11
Explanation: 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,7,2,11,20,8]. 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 the worker from [17,12,10,7,2,11,20,8]. The lowest cost is 2 (index 4). The total cost = 2 + 2 = 4.
- In the third hiring round we choose the worker from [17,12,10,7,11,20,8]. The lowest cost is 7 (index 3). The total cost = 4 + 7 = 11. Notice that the worker with index 3 was common in the first and last four workers.
The total hiring cost is 11.

Example 2:

Input: costs = [1,2,4,1], k = 3, candidates = 3
Output: 4
Explanation: We hire 3 workers in total. The total cost is initially 0.
- In the first hiring round we choose the worker from [1,2,4,1]. The lowest cost is 1, and we break the tie by the smallest index, which is 0. The total cost = 0 + 1 = 1. Notice that workers with index 1 and 2 are common in the first and last 3 workers.
- In the second hiring round we choose the worker from [2,4,1]. The lowest cost is 1 (index 2). The total cost = 1 + 1 = 2.
- In the third hiring round there are less than three candidates. We choose the worker from the remaining workers [2,4]. The lowest cost is 2 (index 0). The total cost = 2 + 2 = 4.
The total hiring cost is 4.

 

Constraints:

  • 1 <= costs.length <= 105
  • 1 <= costs[i] <= 105
  • 1 <= k, candidates <= costs.length

Approach Overview

Problem Overview: You are given an array costs where each value represents the cost of hiring a worker. You must hire exactly k workers. At each step, you can only choose from the first candidates workers or the last candidates workers that have not yet been hired. The goal is to minimize the total hiring cost while following this rule.

Approach 1: Min-Heap Simulation (O((k + candidates) log candidates) time, O(candidates) space)

This approach simulates the hiring process using a heap (priority queue). Maintain two candidate pools: one from the left side and one from the right side of the array. Push their costs into a min-heap along with their indices. Each time you hire a worker, pop the smallest cost from the heap and add it to the total. Then expand the same side (left or right) by pushing the next available worker into the heap. The heap always gives the cheapest valid worker while dynamically maintaining the hiring window. This approach works well because the heap guarantees efficient retrieval of the minimum cost worker during each of the k hiring steps.

Approach 2: Two Pointers with Sorted Segments (O(n log n) time, O(n) space)

This method uses two pointers to track the active candidate windows from both ends of the array. First build sorted segments for the first and last candidate pools so the cheapest worker from either side can be selected quickly. After hiring a worker from one side, advance the corresponding pointer and insert the next worker into the sorted structure. The process repeats until k workers are hired. The idea relies on maintaining ordered candidate pools while the pointers gradually move inward through the array. Sorting or maintaining ordered containers makes selecting the smallest cost straightforward.

Recommended for interviews: The min-heap simulation is the approach most interviewers expect. It models the hiring rule directly and demonstrates strong understanding of priority queues and simulation. Explaining the window expansion and how the heap always tracks the cheapest available candidate shows solid algorithmic reasoning. The two-pointer sorted approach also works but is typically less intuitive and involves heavier preprocessing.

Approach 1: Min-Heap Approach

In this approach, we use a min-heap to keep track of the candidate workers with the lowest costs. By maintaining a collection of candidate workers from both ends of the list, the algorithm efficiently selects and removes the minimum worker for each session. This helps follow the hierarchical hiring order by prioritizing the smallest cost and index.

The Python solution uses two heaps to maintain the workers with the lowest costs from both the beginning and the end of the list. By popping the minimum cost worker in each session, it ensures the optimal choice based on cost and then index if there's a tie. The workers are marked as hired so they are not reconsidered in subsequent rounds.

Code

PythonJavaScript

Python

JavaScript

Complexity

Time Complexity: O(k * log(candidates)), where k is the number of workers to hire and candidates the number from both ends considered.
Space Complexity: O(candidates) for maintaining the two heaps.

Try this approach in the editor →

Approach 2: Two Pointers with Sorted Segments

This approach involves sorting segments of the array and using two pointers to dynamically track the smallest available candidate from the start and end. By maintaining sorted sections, it allows for efficient extraction by moving pointers closer as sessions proceed.

The C++ solution sorts two sections of the costs array corresponding to available candidates. Two pointers select the minimum between the two candidate lists in each hiring session, maintaining the principle of hiring the least costly worker first.

Code

C++Java

C++

Java

Complexity

Time Complexity: O(n log candidates) to sort.
Space Complexity: O(candidates) for storing and sorting the two halves.

Try this approach in the editor →

Approach 3: Priority Queue (Min Heap)

First, we check if candidates times 2 is greater than or equal to n. If it is, we directly return the sum of the costs of the first k smallest workers.

Otherwise, we use a min heap pq to maintain the costs of the first candidates workers and the last candidates workers.

We first add the costs and corresponding indices of the first candidates workers to the min heap pq, and then add the costs and corresponding indices of the last candidates workers to the min heap pq. We use two pointers l and r to point to the indices of the front and back candidates, initially l = candidates, r = n - candidates - 1.

Then we perform k iterations, each time taking the worker with the smallest cost from the min heap pq and adding its cost to the answer. If l > r, it means that all the front and back candidates have been selected, and we skip directly. Otherwise, if the index of the current worker is less than l, it means it is a worker from the front, we add the cost and index of the l-th worker to the min heap pq, and then increment l; otherwise, we add the cost and index of the r-th worker to the min heap pq, and then decrement r.

After the loop ends, we return the answer.

The time complexity is O(n times log n), and the space complexity is O(n). Where n is the length of the array costs.

Code

PythonJavaC++GoTypeScript

Python

Java

C++

Go

TypeScript

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Min-Heap Approach

Time Complexity: O(k * log(candidates)), where k is the number of workers to hire and candidates the number from both ends considered.
Space Complexity: O(candidates) for maintaining the two heaps.

Two Pointers with Sorted Segments

Time Complexity: O(n log candidates) to sort.
Space Complexity: O(candidates) for storing and sorting the two halves.

Priority Queue (Min Heap)—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Min-Heap SimulationO((k + candidates) log candidates)O(candidates)General case. Best balance of performance and simplicity when repeatedly selecting the minimum cost worker.
Two Pointers with Sorted SegmentsO(n log n)O(n)Useful when you prefer maintaining ordered candidate pools with pointer expansion from both ends.

Video Solution

Total Cost to Hire K Workers | Using 2 Heap | Dry Run | META | Leetcode-2462 | Live Code • codestorywithMIK • 13,081 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Total Cost to Hire K Workers easy or hard?
Total Cost to Hire K Workers is categorized as a Medium problem. The difficulty comes from managing two candidate windows and dynamically updating them while always selecting the minimum cost worker using a heap.
How to solve Total Cost to Hire K Workers in optimal time?
Use a min-heap to track the cheapest worker among the current left and right candidate pools. Initialize the heap with the first and last 'candidates' workers. After hiring a worker, push the next available worker from that side into the heap. Repeat the process k times to accumulate the minimum total cost.
What is the best approach for Total Cost to Hire K Workers?
The min-heap (priority queue) simulation is the most efficient and commonly used approach. Maintain two candidate pools from the start and end of the array and push their costs into a min-heap. Each hiring step pops the smallest cost and adds a new candidate from the same side. The complexity is O((k + candidates) log candidates) with O(candidates) space.
Is Total Cost to Hire K Workers asked at Google/Amazon/Meta?
Heap-based selection and window simulation problems like this frequently appear in interviews at companies such as Amazon, Google, and Meta. They test understanding of priority queues, greedy decision making, and efficient handling of dynamic candidate sets.
What data structure is used in Total Cost to Hire K Workers?
The primary data structure is a min-heap (priority queue). It efficiently retrieves the lowest cost worker among the current candidates. Two pointers are also used to track the next available workers from the left and right ends of the array.
What is the time complexity of Total Cost to Hire K Workers?
The optimal heap-based solution runs in O((k + candidates) log candidates) time because each hiring operation involves a heap push or pop. The space complexity is O(candidates) for storing the active candidate pool. A sorting-based alternative may take O(n log n) time.
Total Cost to Hire K Workers Python or Java solution approach?
Both Python and Java implementations typically use a priority queue (heap). Python uses the built-in heapq module, while Java uses PriorityQueue. Each step extracts the minimum cost worker and pushes the next candidate from the corresponding side.

Ready to solve this problem?

Practice Total Cost to Hire K Workers with our built-in code editor and test cases.

Practice on FleetCode
Previous

Meeting Rooms II

Next

Time to Cross a Bridge