Campus Bikes II - Practice Coding Problems

Campus Bikes II - Problem

Imagine you're managing a bike-sharing program on a university campus! 🚲

You have a 2D grid representing the campus with n workers who need bikes and m available bikes scattered across different locations, where n ≤ m. Each worker and bike has specific coordinates (x, y) on this grid.

Your mission: assign exactly one unique bike to each worker such that the total walking distance is minimized. The distance is measured using Manhattan distance: |x₁ - x₂| + |y₁ - y₂| (think city blocks!).

Return the minimum possible sum of Manhattan distances between all workers and their assigned bikes.

Key Challenge: Unlike the simpler Campus Bikes I problem, here we want the globally optimal assignment, not just a greedy one!

Input & Output

example_1.py — Basic Assignment

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

› Output: 6

💡 Note: Assign bike 0 to worker 0 (distance = |0-1| + |0-2| = 3) and bike 1 to worker 1 (distance = |2-3| + |1-3| = 3). Total distance = 3 + 3 = 6.

example_2.py — Multiple Options

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

› Output: 4

💡 Note: Optimal assignment: worker 0 gets bike 0 (distance=1), worker 1 gets bike 2 (distance=1), worker 2 gets bike 1 (distance=2). Total = 4.

example_3.py — Edge Case

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

› Output: 0

💡 Note: Only one worker needs assignment. Choose the closest bike at position [0,0] with distance 0.

Visualization

Tap to expand

Understanding the Visualization

Map the Campus

Plot all worker and bike locations on the campus grid

Calculate Distances

Compute Manhattan distance between each worker-bike pair

Use Smart States

Use bitmasks to efficiently represent which bikes are assigned

Memoize Results

Cache results for each state to avoid redundant calculations

Find Optimal Assignment

Return the minimum total distance across all possible assignments

Key Takeaway

🎯 Key Insight: Using bitmask DP allows us to efficiently represent assignment states and use memoization to avoid recalculating identical subproblems, achieving optimal performance for this combinatorial optimization problem.

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^m)

We have n workers and 2^m possible bike assignment states. Each state is computed once due to memoization.

✓ Linear Growth

Space Complexity

O(2^m)

We store memoization results for each possible bike assignment bitmask, plus recursion stack space

✓ Linear Space

Constraints

1 ≤ workers.length ≤ 10
workers.length ≤ bikes.length ≤ 10
workers[i].length == bikes[j].length == 2
0 ≤ workers[i][0], workers[i][1], bikes[j][0], bikes[j][1] < 1000
Note: Small constraints allow for exponential solutions

Asked in

G Google 45 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution uses Dynamic Programming with Bitmasks to efficiently explore all possible bike assignments. The key insight is using a bitmask to represent which bikes are taken and memoization to avoid recalculating the same subproblems. This achieves O(n × 2^m) time complexity, which is optimal for this assignment problem.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(n × 2^m)	O(2^m)	Use bitmask DP to efficiently explore all assignments with memoization

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Use a bitmask to represent which bikes are currently taken
For each worker, try assigning each available bike
Use memoization to store results for each (worker_index, bike_mask) state
Recursively solve for next worker with updated bike mask
Return minimum cost from memoized results

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize state

Start with worker 0, no bikes assigned (mask = 000)

Try bike assignments

For each available bike, set corresponding bit in mask

Memoize results

Store result for each (worker, mask) combination

Reuse cached results

When same state encountered again, return cached result

Code -

solution.c — C

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

#define MAX_MEMO 100000

typedef struct {
    int workerIdx;
    int bikeMask;
    int cost;
} MemoEntry;

MemoEntry memo[MAX_MEMO];
int memoSize = 0;

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int findMemo(int workerIdx, int bikeMask) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].workerIdx == workerIdx && memo[i].bikeMask == bikeMask) {
            return memo[i].cost;
        }
    }
    return -1;
}

void addMemo(int workerIdx, int bikeMask, int cost) {
    if (memoSize < MAX_MEMO) {
        memo[memoSize].workerIdx = workerIdx;
        memo[memoSize].bikeMask = bikeMask;
        memo[memoSize].cost = cost;
        memoSize++;
    }
}

int dp(int workers[][2], int bikes[][2], int numWorkers, int numBikes, int workerIdx, int bikeMask) {
    if (workerIdx == numWorkers) {
        return 0;
    }
    
    int cached = findMemo(workerIdx, bikeMask);
    if (cached != -1) {
        return cached;
    }
    
    int minCost = INT_MAX;
    for (int bikeIdx = 0; bikeIdx < numBikes; bikeIdx++) {
        if (!(bikeMask & (1 << bikeIdx))) {
            int distance = abs_val(workers[workerIdx][0] - bikes[bikeIdx][0]) + 
                          abs_val(workers[workerIdx][1] - bikes[bikeIdx][1]);
            int cost = distance + dp(workers, bikes, numWorkers, numBikes, workerIdx + 1, bikeMask | (1 << bikeIdx));
            if (cost < minCost) {
                minCost = cost;
            }
        }
    }
    
    addMemo(workerIdx, bikeMask, minCost);
    return minCost;
}

int assignBikes(int workers[][2], int bikes[][2], int numWorkers, int numBikes) {
    memoSize = 0;
    return dp(workers, bikes, numWorkers, numBikes, 0, 0);
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^m)

We have n workers and 2^m possible bike assignment states. Each state is computed once due to memoization.

✓ Linear Growth

Space Complexity

O(2^m)

We store memoization results for each possible bike assignment bitmask, plus recursion stack space

✓ Linear Space

Constraints

1 ≤ workers.length ≤ 10
workers.length ≤ bikes.length ≤ 10
workers[i].length == bikes[j].length == 2
0 ≤ workers[i][0], workers[i][1], bikes[j][0], bikes[j][1] < 1000
Note: Small constraints allow for exponential solutions

28.4K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler