Allocate Mailboxes - Practice Coding Problems

Allocate Mailboxes - Problem

Strategic Mailbox Placement Challenge

Imagine you're a city planner tasked with optimizing mail delivery efficiency! You have a street with houses at various positions and need to strategically place k mailboxes to minimize the total walking distance for all residents.

Given an array houses where houses[i] represents the position of the i-th house along a street, and an integer k representing the number of mailboxes you can install, your goal is to minimize the total distance between each house and its nearest mailbox.

Example: If houses are at positions [1, 4, 8, 10, 20] and you can place 3 mailboxes, you might place them at positions [1, 8, 20] so each house has a nearby mailbox.

🎯 Goal: Return the minimum possible total distance between all houses and their nearest mailboxes.

Input & Output

example_1.py — Basic Case

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

› Output: 5

💡 Note: Allocate mailboxes in position [3, 9, 20]. Minimum total distance is |1-3| + |4-3| + |8-9| + |10-9| + |20-20| = 2 + 1 + 1 + 1 + 0 = 5

example_2.py — More Mailboxes

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

› Output: 9

💡 Note: Allocate mailboxes in position [3, 14]. Minimum total distance is |2-3| + |3-3| + |5-3| + |12-14| + |18-14| = 1 + 0 + 2 + 2 + 4 = 9

example_3.py — Single Mailbox

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

› Output: 8

💡 Note: With one mailbox at position 5 (median of [1,4,6,7]), total distance is |1-5| + |4-5| + |6-5| + |7-5| = 4 + 1 + 1 + 2 = 8

Visualization

Tap to expand

Understanding the Visualization

Sort Customer Locations

Arrange houses in order along the street for easier processing

Calculate Zone Costs

For any group of customers, the best coffee shop location is at the median

Dynamic Programming

Build optimal solutions: if you know the best way to serve first N customers with K-1 shops, you can find the best way with K shops

Extract Minimum

The final answer gives minimum total walking distance for all customers

Key Takeaway

🎯 Key Insight: The optimal mailbox position for any consecutive group of houses is always at the median house position, and dynamic programming allows us to efficiently find the best way to partition houses into groups.

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

We try all possible ways to assign n houses to k mailboxes, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Only need space for recursion stack and storing current partition

⚡ Linearithmic Space

Constraints

1 ≤ k ≤ houses.length ≤ 100
1 ≤ houses[i] ≤ 10⁴
All houses have different positions
The answer fits in a 32-bit integer

Asked in

G Google 42 a Amazon 38 f Meta 24 ⊞ Microsoft 18

The optimal solution uses Dynamic Programming with precomputed costs. Key insights: median position minimizes distance for any house group, and we can build optimal solutions by combining optimal subproblems. Time complexity: O(n²k), Space: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(k^n)	O(n)	Generate all possible ways to divide houses into k groups and find minimum cost
Dynamic Programming (Optimal)	O(n²k)	O(n² + nk)	Use dynamic programming with precomputed costs for optimal subproblem solutions

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible ways to divide n houses into k groups
For each partition, calculate the cost of each segment
For each segment, place mailbox at median position
Sum distances from all houses to their assigned mailbox
Return the minimum total cost across all partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Create all possible ways to divide houses into k groups

Calculate Costs

For each partition, calculate cost by placing mailbox at median of each group

Find Minimum

Compare all partition costs and return minimum

Code -

solution.c — C

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

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

int calculateCost(int* houses, int start, int end) {
    if (start > end) return INT_MAX;
    int cost = 0;
    int medianIdx = (start + end) / 2;
    int medianPos = houses[medianIdx];
    for (int i = start; i <= end; i++) {
        cost += abs(houses[i] - medianPos);
    }
    return cost;
}

int backtrack(int* houses, int n, int index, int groupsLeft) {
    if (groupsLeft == 0) {
        return index == n ? 0 : INT_MAX;
    }
    if (index >= n) return INT_MAX;
    
    int minCost = INT_MAX;
    for (int end = index; end <= n - groupsLeft; end++) {
        int currentCost = calculateCost(houses, index, end);
        int remainingCost = backtrack(houses, n, end + 1, groupsLeft - 1);
        if (currentCost != INT_MAX && remainingCost != INT_MAX) {
            int totalCost = currentCost + remainingCost;
            if (totalCost < minCost) {
                minCost = totalCost;
            }
        }
    }
    return minCost;
}

int numPointsInRange(int* houses, int housesSize, int k) {
    qsort(houses, housesSize, sizeof(int), compare);
    return backtrack(houses, housesSize, 0, k);
}

int main() {
    printf("Brute force solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

We try all possible ways to assign n houses to k mailboxes, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Only need space for recursion stack and storing current partition

⚡ Linearithmic Space

Constraints

1 ≤ k ≤ houses.length ≤ 100
1 ≤ houses[i] ≤ 10⁴
All houses have different positions
The answer fits in a 32-bit integer

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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler