Two City Scheduling - Practice Coding Problems

Two City Scheduling - Problem

A global company is organizing a massive recruiting event! They need to interview 2n candidates, but here's the challenge: they have offices in exactly two cities (let's call them City A and City B), and they need to split the candidates evenly between both locations.

You're given an array costs where costs[i] = [aCosti, bCosti] represents:

aCosti: The flight cost to send candidate i to City A
bCosti: The flight cost to send candidate i to City B

Your mission: Find the minimum total cost to fly all candidates such that exactly n candidates end up in each city.

Example: If you have 4 candidates with costs [[10,20],[30,200],[400,50],[30,20]], you need to send 2 to each city. The optimal solution sends candidates 0,1 to City A and candidates 2,3 to City B for a total cost of 10+30+50+20 = 110.

Input & Output

example_1.py — Basic Case

$ Input: costs = [[10,20],[30,200],[400,50],[30,20]]

› Output: 110

💡 Note: First person goes to city A for cost 10. Second person goes to city A for cost 30. Third person goes to city B for cost 50. Fourth person goes to city B for cost 20. Total minimum cost = 10 + 30 + 50 + 20 = 110.

example_2.py — Equal Differences

$ Input: costs = [[259,770],[448,54],[926,667],[184,139],[840,118],[577,469]]

› Output: 1859

💡 Note: With 6 people, we need 3 in each city. After sorting by cost differences and applying greedy assignment, the minimum total cost is 1859.

example_3.py — Minimum Case

$ Input: costs = [[10,20],[30,200]]

› Output: 110

💡 Note: With only 2 people, person 0 goes to city A (cost 10) and person 1 goes to city B (cost 200). Total cost = 10 + 200 = 210. Wait, this should be 10+200=210, but optimal is person 0 to A (10) and person 1 to A (30) = 40... Actually, we need equal split: person 0 to A (10), person 1 to B (200) = 210. But let's check: person 0 to B (20), person 1 to A (30) = 50. So minimum is actually 50 + 60 = 110 with person 1 to A and person 0 to A... No wait, we need exactly 1 in each city: either (A:0,B:1) costs 10+200=210 or (A:1,B:0) costs 30+20=50. So answer is 50.

Visualization

Tap to expand

Understanding the Visualization

Calculate Preference

For each person, calculate how much extra it costs to go to A vs B

Sort by Preference

People who strongly prefer A (negative difference) go first

Assign Optimally

First n people go to A, rest go to B for minimum total cost

Key Takeaway

🎯 Key Insight: Sort by cost difference (A_cost - B_cost) and assign greedily. People with negative differences strongly prefer city A and should go there first!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the array by cost differences

⚡ Linearithmic

Space Complexity

O(n)

Space needed for storing the sorted array with indices

⚡ Linearithmic Space

Constraints

2 * n == costs.length
2 <= costs.length <= 100
costs.length is even
1 <= aCost_i, bCost_i <= 1000

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses a greedy approach based on cost differences. Calculate the difference costA - costB for each person, sort by these differences, and assign the first n people (with smallest differences) to City A. This works because we're minimizing opportunity cost - people with negative differences save money going to A, while people with large positive differences are better suited for B. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n log n)	O(n)	Sort by cost difference and greedily assign people to minimize total cost
Brute Force (Try All Combinations)	O(C(2n,n))	O(n)	Generate all possible ways to split 2n people into two groups of n each

Greedy Approach (Optimal) — Algorithm Steps

Calculate the cost difference (cityA_cost - cityB_cost) for each person
Sort people by their cost difference in ascending order
Send the first n people (with smallest differences) to city A
Send the remaining n people to city B
Sum up all the costs

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Differences

Find cost_A - cost_B for each person

Sort by Difference

Arrange people by their cost differences

Greedy Assignment

Send first n to city A, rest to city B

Code -

solution.c — C

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

typedef struct {
    int diff;
    int idx;
} Person;

int compare(const void *a, const void *b) {
    Person *personA = (Person *)a;
    Person *personB = (Person *)b;
    return personA->diff - personB->diff;
}

int twoCitySchedCost(int costs[][2], int size) {
    Person *people = (Person *)malloc(size * sizeof(Person));
    
    // Calculate cost differences
    for (int i = 0; i < size; i++) {
        people[i].diff = costs[i][0] - costs[i][1];
        people[i].idx = i;
    }
    
    // Sort by cost difference
    qsort(people, size, sizeof(Person), compare);
    
    int totalCost = 0;
    
    // Send first size/2 people to city A
    for (int i = 0; i < size / 2; i++) {
        totalCost += costs[people[i].idx][0];
    }
    
    // Send remaining size/2 people to city B
    for (int i = size / 2; i < size; i++) {
        totalCost += costs[people[i].idx][1];
    }
    
    free(people);
    return totalCost;
}

int main() {
    int size;
    scanf("%d", &size);
    int costs[size][2];
    for (int i = 0; i < size; i++) {
        scanf("%d %d", &costs[i][0], &costs[i][1]);
    }
    printf("%d\n", twoCitySchedCost(costs, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the array by cost differences

⚡ Linearithmic

Space Complexity

O(n)

Space needed for storing the sorted array with indices

⚡ Linearithmic Space

Constraints

2 * n == costs.length
2 <= costs.length <= 100
costs.length is even
1 <= aCost_i, bCost_i <= 1000

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler