Two City Scheduling - Practice Coding Problems

Two City Scheduling - Problem

A company is planning to interview 2n people. Given the array costs where costs[i] = [aCosti, bCosti], the cost of flying the i-th person to city a is aCosti, and the cost of flying the i-th 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.

Input & Output

Example 1 — Basic Case

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

› Output: 110

💡 Note: First person to city A (cost 10), second to city A (cost 30), third to city B (cost 50), fourth to city B (cost 20). Total: 10+30+50+20 = 110

Example 2 — Different Assignment

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

› Output: 1859

💡 Note: Optimal assignment sends 3 people to each city based on cost differences, minimizing total expense

Example 3 — Equal Costs

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

› Output: 30

💡 Note: When costs are equal for both cities, any assignment gives same total: 10+20 = 30

Constraints

2 * n == costs.length
2 ≤ costs.length ≤ 100
costs.length is even
1 ≤ aCosti, bCosti ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input

2n people with flight costs to cities A and B

Process

Calculate cost differences and sort by savings

Output

Minimum total cost with n people in each city

Key Takeaway

🎯 Key Insight: Sort people by cost difference (A-B) and assign greedily to minimize total expense

Asked in

a Amazon 15 G Google 8 M Microsoft 6

The key insight is to calculate cost differences and assign people greedily. Sort by (costA - costB) and send the first n people (with most negative differences) to city B, and the rest to city A. Time: O(n log n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try All Combinations	O(2^n)	O(n)	Generate all possible ways to assign n people to each city
Greedy - Sort by Cost Difference	O(n log n)	O(n)	Sort people by cost difference and assign greedily

Brute Force - Try All Combinations — Algorithm Steps

Generate all combinations of n people for city A
Assign remaining n people to city B
Calculate total cost for each combination
Return minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all ways to choose n people for city A

Calculate Costs

Sum up flight costs for each assignment

Find Minimum

Return the lowest total cost found

Code -

solution.c — C

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

void generateCombinations(int start, int total, int k, int* current, int currentSize, int*** result, int* resultSize, int* resultCapacity) {
    if (k == 0) {
        if (*resultSize == *resultCapacity) {
            *resultCapacity *= 2;
            *result = realloc(*result, (*resultCapacity) * sizeof(int*));
        }
        (*result)[*resultSize] = malloc(currentSize * sizeof(int));
        memcpy((*result)[*resultSize], current, currentSize * sizeof(int));
        (*resultSize)++;
        return;
    }
    
    for (int i = start; i <= total - k; i++) {
        current[currentSize] = i;
        generateCombinations(i + 1, total, k - 1, current, currentSize + 1, result, resultSize, resultCapacity);
    }
}

int solution(int costs[][2], int costsSize) {
    int n = costsSize / 2;
    int minCost = INT_MAX;
    
    int** combinations;
    int resultSize = 0;
    int resultCapacity = 100;
    combinations = malloc(resultCapacity * sizeof(int*));
    
    int* current = malloc(n * sizeof(int));
    generateCombinations(0, costsSize, n, current, 0, &combinations, &resultSize, &resultCapacity);
    
    for (int c = 0; c < resultSize; c++) {
        int totalCost = 0;
        int* isInCityA = calloc(costsSize, sizeof(int));
        
        for (int j = 0; j < n; j++) {
            isInCityA[combinations[c][j]] = 1;
        }
        
        for (int i = 0; i < costsSize; i++) {
            if (isInCityA[i]) {
                totalCost += costs[i][0];
            } else {
                totalCost += costs[i][1];
            }
        }
        
        if (totalCost < minCost) {
            minCost = totalCost;
        }
        
        free(isInCityA);
        free(combinations[c]);
    }
    
    free(combinations);
    free(current);
    return minCost;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int costs[100][2];
    int costsSize = 0;
    
    char* ptr = line + 1; // Skip opening bracket
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            costs[costsSize][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++; // Skip comma
            costs[costsSize][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            costsSize++;
        }
        ptr++;
    }
    
    printf("%d\n", solution(costs, costsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Need to check C(2n,n) combinations which is exponential

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary storage for combinations

⚡ Linearithmic Space

178.0K Views

Medium Frequency

~15 min Avg. Time

2.8K 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler