Skip to main content
Talentd

Two City Scheduling - Solution & Explanation

MediumArrayGreedySorting9 min readAsked at: Amazon, Meta, Google +2
Practice this problem

Problem Statement

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.length
  • 2 <= costs.length <= 100
  • costs.length is even.
  • 1 <= aCosti, bCosti <= 1000

Approach Overview

Problem 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.

Approach 1: Greedy Approach with Sorting

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.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

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.

Try this approach in the editor →

Approach 2: Default Approach

Code

PythonJavaC++GoTypeScript

Python

Java

C++

Go

TypeScript

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
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—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Brute Force AssignmentO(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 DifferenceO(n log n)O(1)Optimal solution for interviews and production

Video Solution

Two City Scheduling - Leetcode 1029 - Python • NeetCode • 32,989 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Two City Scheduling easy or hard?
Two City Scheduling is rated Medium difficulty. The implementation is straightforward once you recognize the greedy insight of sorting by cost difference, but identifying that idea quickly is what makes the problem challenging during interviews.
How to solve Two City Scheduling in O(n)?
A strict O(n) solution is not typical because sorting is required to rank cost differences. The standard optimal solution sorts people by (costA - costB) and runs in O(n log n). Without sorting, it is difficult to guarantee the optimal assignment while maintaining the constraint that exactly n people go to each city.
What is the best approach for Two City Scheduling?
The best approach is a greedy strategy combined with sorting. Compute the difference between the cost of flying each person to city A and city B, then sort by this difference. Send the first n people to city A and the rest to city B. This ensures the largest cost savings are applied first and runs in O(n log n) time.
What data structure is used in Two City Scheduling?
The problem primarily uses arrays along with a sorting step. Each element contains the cost of sending a person to city A and city B. The algorithm sorts the array based on the difference between those two costs and then performs a simple iteration.
What is the time complexity of Two City Scheduling?
The optimal greedy solution runs in O(n log n) time because the main operation is sorting the cost differences. After sorting, a single pass assigns the first n people to city A and the remaining n to city B. Space complexity is O(1) if the sort is done in place.
Two City Scheduling Python or Java solution approach?
Both Python and Java implementations follow the same greedy logic. Sort the list of cost pairs using the difference (costA - costB), then sum the first n costs for city A and the remaining n costs for city B. The algorithm runs in O(n log n) time and uses constant extra space.
Is Two City Scheduling asked at Google, Amazon, or Meta?
Two City Scheduling represents a common greedy interview pattern and has appeared in interview preparation sets used by companies like Amazon, Google, and Meta. Variations of the problem test your ability to optimize assignments using sorting and greedy decision making.

Ready to solve this problem?

Practice Two City Scheduling with our built-in code editor and test cases.

Practice on FleetCode
Previous

Rearrange Array to Maximize Prefix Score