Campus Bikes II

Campus Bikes II - Problem

On a campus represented as a 2D grid, there are n workers and m bikes, with n ≤ m. Each worker and bike is a 2D coordinate on this grid.

We need to assign one unique bike to each worker such that the sum of the Manhattan distances between each worker and their assigned bike is minimized.

Return the minimum possible sum of Manhattan distances between each worker and their assigned bike.

The Manhattan distance between two points p1 and p2 is: |p1.x - p2.x| + |p1.y - p2.y|

Input & Output

Example 1 — Basic Case

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

› Output: 6

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

Example 2 — Multiple Options

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

› Output: 4

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

Example 3 — Same Position

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

› Output: 0

💡 Note: Worker at (0,0) gets assigned to bike at (0,0) with Manhattan distance 0.

Constraints

1 ≤ workers.length ≤ bikes.length ≤ 12
workers[i].length == bikes[j].length == 2
0 ≤ workers[i][0], workers[i][1], bikes[j][0], bikes[j][1] < 1000

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 U Uber 8

The key insight is to use bitmasks to represent which bikes are already assigned and apply dynamic programming with memoization to avoid recomputing subproblems. The optimal approach uses DP with bitmask: Time: O(n × 2^m × m), Space: O(n × 2^m).

Common Approaches

✓ Prefix Sum

⏱️ Time: N/A Space: N/A

Backtracking with Pruning

⏱️ Time: O(m!/(m-n)!) Space: O(n)

Same as brute force but keeps track of current best solution and prunes branches that already exceed this minimum.

Brute Force - Try All Permutations

⏱️ Time: O(m!/(m-n)!) Space: O(n)

For each worker, try assigning each available bike and recursively solve for remaining workers. This explores all possible assignments.

Dynamic Programming with Bitmask

⏱️ Time: O(n × 2^m × m) Space: O(n × 2^m)

Represent the set of used bikes as a bitmask and use dynamic programming to store results of subproblems. Each state is defined by (current worker index, bitmask of used bikes).

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool* solution(int* candiesCount, int candiesSize, int** queries, int queriesSize, int* returnSize) {
    // Build prefix sums
    long long* prefixSum = (long long*)malloc((candiesSize + 1) * sizeof(long long));
    prefixSum[0] = 0;
    for (int i = 0; i < candiesSize; i++) {
        prefixSum[i + 1] = prefixSum[i] + candiesCount[i];
    }
    
    bool* result = (bool*)malloc(queriesSize * sizeof(bool));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int favoriteType = queries[i][0];
        long long favoriteDay = queries[i][1];
        long long dailyCap = queries[i][2];
        
        // Candies needed before favorite type
        long long candiesBeforeFavorite = prefixSum[favoriteType];
        
        // Earliest day to start eating favorite type
        long long earliestDay = (candiesBeforeFavorite + dailyCap - 1) / dailyCap;
        
        // Latest day to still be eating favorite type
        long long candiesUpToFavorite = prefixSum[favoriteType + 1];
        long long latestDay = candiesUpToFavorite - 1;
        
        // Check if favorite day is within valid range
        bool possible = earliestDay <= favoriteDay && favoriteDay <= latestDay;
        result[i] = possible;
    }
    
    free(prefixSum);
    return result;
}

int main() {
    int candiesSize;
    scanf("%d", &candiesSize);
    
    int* candiesCount = (int*)malloc(candiesSize * sizeof(int));
    for (int i = 0; i < candiesSize; i++) {
        scanf("%d", &candiesCount[i]);
    }
    
    int queriesSize;
    scanf("%d", &queriesSize);
    
    int** queries = (int**)malloc(queriesSize * sizeof(int*));
    for (int i = 0; i < queriesSize; i++) {
        queries[i] = (int*)malloc(3 * sizeof(int));
        scanf("%d %d %d", &queries[i][0], &queries[i][1], &queries[i][2]);
    }
    
    int returnSize;
    bool* result = solution(candiesCount, candiesSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf(result[i] ? "true" : "false");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(candiesCount);
    for (int i = 0; i < queriesSize; i++) {
        free(queries[i]);
    }
    free(queries);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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