A company is planning to interview 2n people. Given the array costs where costs[i] = [aCosti, bCosti], the cost of flying the ith person to city a is aCosti, and the cost of flying the ith person to city b is bCosti.
Return the minimum cost to fly every person to a city such that exactly n people arrive in each city.
Example 1:
Input: costs = [[10,20],[30,200],[400,50],[30,20]] Output: 110 Explanation: The first person goes to city A for a cost of 10. The second person goes to city A for a cost of 30. The third person goes to city B for a cost of 50. The fourth person goes to city B for a cost of 20. The total minimum cost is 10 + 30 + 50 + 20 = 110 to have half the people interviewing in each city.
Example 2:
Input: costs = [[259,770],[448,54],[926,667],[184,139],[840,118],[577,469]] Output: 1859
Example 3:
Input: costs = [[515,563],[451,713],[537,709],[343,819],[855,779],[457,60],[650,359],[631,42]] Output: 3086
Constraints:
2 * n == costs.length2 <= costs.length <= 100costs.length is even.1 <= aCosti, bCosti <= 1000Problem Overview: You are given 2n people and the cost of flying each person to city A or city B. Exactly n people must go to each city. The goal is to minimize the total travel cost.
Approach 1: Brute Force Assignment (Exponential Time)
The most direct idea is to try every valid assignment where exactly half of the people go to city A and the rest go to city B. For each person you choose either city, track the number already assigned to each city, and compute the total cost. This can be implemented using recursion or backtracking. The approach explores all valid combinations and keeps the minimum total cost.
This method quickly becomes infeasible because the number of combinations grows exponentially. With 2n people, the number of valid assignments is roughly C(2n, n). Time complexity is O(2^n) in practice, and space complexity is O(n) due to recursion depth. It helps build intuition but is not practical for large inputs.
Approach 2: Greedy Approach with Sorting (O(n log n))
The optimal strategy relies on the difference between sending a person to city A versus city B. For each person compute costA - costB. This value tells you how much cheaper (or more expensive) city A is compared to city B. If the difference is very negative, sending that person to A saves a lot of money. If it is very positive, city B is cheaper.
Sort the people based on this difference. After sorting, send the first n people (those who benefit most from going to A) to city A, and the remaining n people to city B. Sorting guarantees the largest savings decisions happen first. The final cost is simply the sum of the chosen city cost for each person.
This greedy rule works because each decision is based on relative savings, which remains optimal after sorting. The algorithm performs one sort and one pass through the array. Time complexity is O(n log n) due to sorting, and space complexity is O(1) if sorting is in-place.
This problem is a classic example of combining Greedy decision making with Sorting to optimize assignments in an Array-based problem.
Recommended for interviews: The greedy sorting approach is what interviewers expect. Mentioning the brute force idea shows you understand the constraints of the problem space, but implementing the difference-based sorting demonstrates strong algorithmic intuition and the ability to recognize greedy optimization patterns.
This approach relies on sorting the people by the difference between the cost of flying them to city A and city B. By doing so, we can initially assume that flying every person to city A is optimal, and then we adjust half of the people to go to city B based on minimal added cost.
In this solution, we first sort the list of costs based on the difference between the cost of city A and city B for each person. The comparison function is used with qsort. Then, we add the cost for city A for the first half of people and the cost for city B for the second half of people, returning the total minimized cost.
The time complexity of this solution is O(n log n) due to the sorting step, and the space complexity is O(1) since we are sorting in place.
Python
Java
C++
Go
TypeScript
| Approach | Complexity |
|---|---|
| Greedy Approach with Sorting | The time complexity of this solution is O(n log n) due to the sorting step, and the space complexity is O(1) since we are sorting in place. |
| Default Approach | — |
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Brute Force Assignment | O(2^n) | O(n) | Conceptual understanding or very small inputs |
| Dynamic Programming (Balanced Assignment) | O(n^2) | O(n^2) | When exploring state transitions or learning DP modeling |
| Greedy with Sorting by Cost Difference | O(n log n) | O(1) | Optimal solution for interviews and production |
Two City Scheduling - Leetcode 1029 - Python • NeetCode • 32,365 views views
Watch 9 more video solutions →Practice Two City Scheduling with our built-in code editor and test cases.
Practice on FleetCode