Campus Bikes - Practice Coding Problems

Campus Bikes - Problem

Imagine you're managing a bike-sharing program on a university campus! 🚴‍♂️ You have n workers who need bikes and m bikes scattered across campus (where n ≤ m). Your job is to efficiently assign one bike to each worker.

The assignment follows a greedy strategy: always pick the worker-bike pair with the shortest Manhattan distance first. If there's a tie in distance, prioritize by smallest worker index, then by smallest bike index.

Manhattan Distance Formula: |x1 - x2| + |y1 - y2|

Goal: Return an array where result[i] is the index of the bike assigned to the i-th worker.

Input & Output

example_1.py — Basic Assignment

$ Input: workers = [[0,0],[2,1]], bikes = [[1,2],[3,3]]

› Output: [1, 0]

💡 Note: Worker 0 is at (0,0) and Worker 1 is at (2,1). Distances: W0→B0=3, W0→B1=6, W1→B0=2, W1→B1=2. Smallest distance is 2 (tie between W1→B0 and W1→B1). Choose W1→B0 (smaller bike index). Then W0→B1. Result: [1,0].

example_2.py — Tie-breaking by Worker Index

$ Input: workers = [[0,0],[1,1],[2,0]], bikes = [[1,0],[2,2],[2,1]]

› Output: [0, 2, 1]

💡 Note: Multiple pairs have distance 1: W0→B0=1, W1→B2=1. W0 has smaller index, so W0→B0 first. Then W2→B1=1 is smallest remaining. Finally W1→B2. Result: [0,2,1].

example_3.py — Single Worker-Bike Pair

$ Input: workers = [[0,0]], bikes = [[1,1]]

› Output: [0]

💡 Note: Only one worker and one bike available. Worker 0 gets assigned to Bike 0 (the only option). Manhattan distance is |0-1| + |0-1| = 2.

Visualization

Tap to expand

Understanding the Visualization

Calculate Distances

Compute Manhattan distance between every worker-bike pair

Sort by Priority

Order pairs by distance (asc), worker index (asc), bike index (asc)

Greedy Assignment

Pick the best available pair and assign, marking both as used

Repeat Until Complete

Continue until all workers have bikes assigned

Key Takeaway

🎯 Key Insight: The greedy strategy works because we always make the locally optimal choice (shortest distance with proper tie-breaking), which leads to the globally optimal assignment for this problem.

Time & Space Complexity

Time Complexity

⏱️

O(nm log(nm))

Generate nm pairs O(nm), sort them O(nm log(nm)), assign O(nm) - dominated by sorting

⚡ Linearithmic

Space Complexity

O(nm)

Store all worker-bike pairs for sorting

⚡ Linearithmic Space

Constraints

n == workers.length
m == bikes.length
1 ≤ n ≤ m ≤ 1000
workers[i].length == bikes[j].length == 2
0 ≤ workers[i][0], workers[i][1], bikes[j][0], bikes[j][1] < 1000
All worker and bike positions are unique.

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal approach uses a priority queue (min-heap) to efficiently manage worker-bike pairs sorted by Manhattan distance. The heap automatically handles tie-breaking rules: distance → worker index → bike index. We generate all possible pairs O(nm), build a heap O(nm log(nm)), then greedily assign the best available matches until all workers have bikes. Time complexity is O(nm log(nm)), space complexity is O(nm).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Pairs)	O(nm log(nm))	O(nm)	Calculate all worker-bike distances, sort them, and assign greedily
Priority Queue/Heap (Optimal)	O(nm log(nm))	O(nm)	Use a min-heap to efficiently get the next best worker-bike pair

Brute Force (Generate All Pairs) — Algorithm Steps

Generate all (worker, bike) pairs with their Manhattan distances
Sort pairs by: distance (ascending), worker index (ascending), bike index (ascending)
Iterate through sorted pairs and assign bikes to workers
Skip pairs where worker already has a bike or bike is already taken
Continue until all workers are assigned

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Pairs

Create all possible worker-bike combinations with distances

Sort Pairs

Sort by distance, then worker index, then bike index

Assign Greedily

Go through sorted pairs and assign first available matches

Code -

solution.c — C

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

typedef struct {
    int dist, worker, bike;
} Pair;

int compare(const void* a, const void* b) {
    Pair* pa = (Pair*)a;
    Pair* pb = (Pair*)b;
    if (pa->dist != pb->dist) return pa->dist - pb->dist;
    if (pa->worker != pb->worker) return pa->worker - pb->worker;
    return pa->bike - pb->bike;
}

int* assignBikes(int** workers, int workersSize, int** bikes, int bikesSize) {
    // Generate all pairs
    Pair* pairs = malloc(workersSize * bikesSize * sizeof(Pair));
    int pairCount = 0;
    
    for (int i = 0; i < workersSize; i++) {
        for (int j = 0; j < bikesSize; j++) {
            int dist = abs(workers[i][0] - bikes[j][0]) + abs(workers[i][1] - bikes[j][1]);
            pairs[pairCount++] = (Pair){dist, i, j};
        }
    }
    
    // Sort pairs
    qsort(pairs, pairCount, sizeof(Pair), compare);
    
    // Track assignments
    int* result = malloc(workersSize * sizeof(int));
    int* usedBikes = calloc(bikesSize, sizeof(int));
    for (int i = 0; i < workersSize; i++) result[i] = -1;
    
    // Assign bikes greedily
    for (int i = 0; i < pairCount; i++) {
        int workerIdx = pairs[i].worker, bikeIdx = pairs[i].bike;
        if (result[workerIdx] == -1 && !usedBikes[bikeIdx]) {
            result[workerIdx] = bikeIdx;
            usedBikes[bikeIdx] = 1;
        }
    }
    
    free(pairs);
    free(usedBikes);
    return result;
}

int main() {
    // Example usage
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(nm log(nm))

Generate nm pairs O(nm), sort them O(nm log(nm)), assign O(nm) - dominated by sorting

⚡ Linearithmic

Space Complexity

O(nm)

Store all worker-bike pairs for sorting

⚡ Linearithmic Space

Constraints

n == workers.length
m == bikes.length
1 ≤ n ≤ m ≤ 1000
workers[i].length == bikes[j].length == 2
0 ≤ workers[i][0], workers[i][1], bikes[j][0], bikes[j][1] < 1000
All worker and bike positions are unique.

67.0K Views

High Frequency

~25 min Avg. Time

1.9K 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

Brute Force (Generate All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler