Allocate Mailboxes

Allocate Mailboxes - Problem

Given an array houses where houses[i] is the location of the ith house along a street and an integer k, allocate k mailboxes in the street.

Return the minimum total distance between each house and its nearest mailbox.

The test cases are generated so that the answer fits in a 32-bit integer.

Input & Output

Example 1 — Basic Case

$ Input: houses = [1,4,8,10,20], k = 3

› Output: 5

💡 Note: Optimal grouping: [1,4] with mailbox at position 2.5, [8,10] with mailbox at position 9, [20] with mailbox at position 20. Total distances: (1.5+1.5) + (1+1) + 0 = 5.

Example 2 — Two Mailboxes

$ Input: houses = [2,3,5,12,18], k = 2

› Output: 9

💡 Note: Place first mailbox at position 3 for houses [2,3,5] (distances 1+0+2=3) and second mailbox at position 15 for houses [12,18] (distances 3+3=6). Total: 3+6=9.

Example 3 — One Mailbox

$ Input: houses = [7,4,6,1], k = 1

› Output: 8

💡 Note: With only one mailbox, place it at median position. Sorted houses: [1,4,6,7]. Median between positions 1 and 2 is around 5. Place mailbox at 4 or 6. At position 5: distances are 4+1+1+2=8.

Constraints

1 ≤ k ≤ houses.length ≤ 100
1 ≤ houses[i] ≤ 10⁴
All the positions of houses are unique.

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is that for any group of consecutive houses, the optimal mailbox position is at the median to minimize total distance. Best approach uses 2D Dynamic Programming with precomputed cost matrix. Time: O(n²×k), Space: O(n²)

Common Approaches

✓ Optimized

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

2D Dynamic Programming

⏱️ Time: O(n² × k) Space: O(n²)

Use 2D DP table where dp[i][j] represents minimum cost to allocate j mailboxes for first i houses. Precompute cost matrix for placing one mailbox for any range of houses.

Brute Force Recursion

⏱️ Time: O(k^n) Space: O(n)

Recursively try every possible way to place k mailboxes, calculating the cost for each configuration. For each group of houses, place the mailbox at the median position to minimize total distance.

Memoized Recursion

⏱️ Time: O(n² × k) Space: O(n × k)

Same recursive approach as brute force but cache results for overlapping subproblems. Use a memo table to store results of solve(index, remaining_mailboxes).

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int memo[105][105];
static int houses[105];
static int n;

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

int cost(int i, int j) {
    int mid = (i + j) / 2;
    int total = 0;
    for (int idx = i; idx <= j; idx++) {
        total += abs_val(houses[idx] - houses[mid]);
    }
    return total;
}

int solve(int idx, int mailboxes_left) {
    if (mailboxes_left == 1) {
        return cost(idx, n - 1);
    }
    if (idx >= n) {
        return INT_MAX / 2;
    }
    
    if (memo[idx][mailboxes_left] != -1) {
        return memo[idx][mailboxes_left];
    }
    
    int min_cost = INT_MAX / 2;
    for (int end = idx; end <= n - mailboxes_left; end++) {
        int current_cost = cost(idx, end) + solve(end + 1, mailboxes_left - 1);
        if (current_cost < min_cost) {
            min_cost = current_cost;
        }
    }
    
    memo[idx][mailboxes_left] = min_cost;
    return min_cost;
}

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* h, int house_count, int k) {
    for (int i = 0; i < house_count; i++) {
        houses[i] = h[i];
    }
    n = house_count;
    
    qsort(houses, n, sizeof(int), compare);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= k; j++) {
            memo[i][j] = -1;
        }
    }
    
    return solve(0, k);
}

int main() {
    char line1[1000], line2[100];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Parse houses array
    int houses_array[100];
    int house_count = 0;
    
    char* ptr = line1;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']' && house_count < 100) {
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        if (*ptr && *ptr != ']') {
            houses_array[house_count] = (int)strtol(ptr, &ptr, 10);
            house_count++;
        }
    }
    
    int k = (int)strtol(line2, NULL, 10);
    
    int result = solution(houses_array, house_count, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~45 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