Shortest Distance from All Buildings

Shortest Distance from All Buildings - Problem

Imagine you're a city planner tasked with finding the perfect location for a new house that minimizes travel time to all existing buildings in the city!

You're given an m × n grid representing a city map where:

0 represents empty land where you can build and walk freely
1 represents an existing building (impassable)
2 represents an obstacle like a lake or mountain (impassable)

Your goal is to find an empty land spot that has the shortest total walking distance to all buildings. You can only move up, down, left, or right (no diagonal movement).

Return the minimum total travel distance, or -1 if it's impossible to reach all buildings from any empty land.

Input & Output

example_1.py — Basic Case

$ Input: grid = [[1,0,2,0,1],[0,0,0,0,0],[0,0,1,0,0]]

› Output: 7

💡 Note: The optimal house location is at (1,2). From this position: distance to building at (0,0) = 3, distance to building at (0,4) = 3, distance to building at (2,2) = 1. Total distance = 3 + 3 + 1 = 7.

example_2.py — Impossible Case

$ Input: grid = [[1,0,1],[0,2,0],[1,0,1]]

› Output: -1

💡 Note: The building at (1,1) is blocked by obstacle (2), so no empty land can reach all buildings. Return -1.

example_3.py — Single Building

$ Input: grid = [[1,0,0],[0,0,0],[0,0,0]]

› Output: 1

💡 Note: Only one building exists at (0,0). The optimal empty cell locations are the adjacent cells (0,1) and (1,0), each with distance 1 from the building. The minimum total distance is 1.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 50
grid[i][j] is either 0, 1, or 2
There will be at least one building in the grid

Visualization

Tap to expand

Asked in

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

The optimal solution uses Multi-Source BFS starting from each building instead of each empty cell. This approach runs BFS from each building to calculate distances to all reachable empty cells, accumulating total distances. The key insight is to reverse the search direction to avoid redundant calculations, achieving O(k·mn) time complexity where k is the number of buildings.

Common Approaches

✓ Brute Force (BFS from Each Empty Land)

⏱️ Time: O(m²n²) Space: O(mn)

Try each empty land cell as a potential house location. For each empty cell, perform BFS to find distances to all buildings and sum them up. Keep track of the minimum total distance found.

Multi-Source BFS (Optimal)

⏱️ Time: O(k·mn) Space: O(mn)

Instead of starting from each empty cell, we reverse the approach: start BFS from all buildings simultaneously. For each building, we calculate distances to all reachable empty cells and accumulate the total distance. This avoids redundant calculations and provides the optimal solution.

Brute Force (BFS from Each Empty Land) — Algorithm Steps

Iterate through each cell in the grid
If cell is empty land (0), start BFS from this cell
Use BFS to find shortest distance to each building (1)
Sum all distances to buildings
Keep track of minimum total distance across all empty lands

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Empty Cell (0,0)

Start BFS from first empty cell to find distances to all buildings

BFS Expansion

Expand level by level until all buildings are reached

Calculate Total Distance

Sum up distances to all buildings found

Try Next Empty Cell

Repeat process for every empty cell in the grid

Code -

solution.c — C

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

#define MAX_SIZE 1000

typedef struct {
    int row, col, dist;
} Point;

typedef struct {
    Point data[MAX_SIZE * MAX_SIZE];
    int front, rear;
} Queue;

void initQueue(Queue* q) {
    q->front = 0;
    q->rear = 0;
}

bool isEmpty(Queue* q) {
    return q->front == q->rear;
}

void enqueue(Queue* q, Point p) {
    q->data[q->rear++] = p;
}

Point dequeue(Queue* q) {
    return q->data[q->front++];
}

static bool visited[MAX_SIZE][MAX_SIZE];

int bfsFromEmpty(int** grid, int m, int n, int startRow, int startCol, int buildingCount) {
    Queue q;
    initQueue(&q);
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            visited[i][j] = false;
        }
    }
    
    Point start = {startRow, startCol, 0};
    enqueue(&q, start);
    visited[startRow][startCol] = true;
    
    int totalDist = 0;
    int buildingsReached = 0;
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    while (!isEmpty(&q)) {
        Point curr = dequeue(&q);
        
        if (grid[curr.row][curr.col] == 1) {
            totalDist += curr.dist;
            buildingsReached++;
            continue;
        }
        
        for (int i = 0; i < 4; i++) {
            int newRow = curr.row + directions[i][0];
            int newCol = curr.col + directions[i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n &&
                !visited[newRow][newCol] && grid[newRow][newCol] != 2) {
                visited[newRow][newCol] = true;
                Point next = {newRow, newCol, curr.dist + 1};
                enqueue(&q, next);
            }
        }
    }
    
    return buildingsReached == buildingCount ? totalDist : INT_MAX;
}

int shortestDistance(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        return -1;
    }
    
    int m = gridSize, n = gridColSize[0];
    int buildingCount = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                buildingCount++;
            }
        }
    }
    
    if (buildingCount == 0) {
        return -1;
    }
    
    int minDist = INT_MAX;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 0) {
                int dist = bfsFromEmpty(grid, m, n, i, j, buildingCount);
                if (dist < minDist) {
                    minDist = dist;
                }
            }
        }
    }
    
    return minDist == INT_MAX ? -1 : minDist;
}

static int grid_data[MAX_SIZE][MAX_SIZE];
static int* grid_ptrs[MAX_SIZE];
static int col_sizes[MAX_SIZE];

int** parseGrid(char* input, int* gridSize, int** gridColSize) {
    *gridSize = 0;
    
    if (strcmp(input, "[]") == 0) {
        *gridColSize = col_sizes;
        return grid_ptrs;
    }
    
    int i = 1; // skip first '['
    int row_count = 0;
    
    while (i < strlen(input) && input[i] != ']') {
        if (input[i] == '[') {
            i++; // skip '['
            int col_count = 0;
            
            while (i < strlen(input) && input[i] != ']') {
                if ((input[i] >= '0' && input[i] <= '9') || input[i] == '-') {
                    int num = 0;
                    bool negative = false;
                    if (input[i] == '-') {
                        negative = true;
                        i++;
                    }
                    while (i < strlen(input) && input[i] >= '0' && input[i] <= '9') {
                        num = num * 10 + (input[i] - '0');
                        i++;
                    }
                    if (negative) num = -num;
                    grid_data[row_count][col_count++] = num;
                } else {
                    i++;
                }
            }
            
            grid_ptrs[row_count] = grid_data[row_count];
            col_sizes[row_count] = col_count;
            row_count++;
            
            if (i < strlen(input)) i++; // skip ']'
        } else {
            i++;
        }
    }
    
    *gridSize = row_count;
    *gridColSize = col_sizes;
    return grid_ptrs;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0; // remove newline
    
    int gridSize;
    int* gridColSize;
    int** grid = parseGrid(input, &gridSize, &gridColSize);
    
    printf("%d\n", shortestDistance(grid, gridSize, gridColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of the mn cells, we might run BFS which takes O(mn) time in worst case

⚠ Quadratic Growth

Space Complexity

O(mn)

BFS queue and visited array for each search

⚡ Linearithmic Space

58.3K Views

Medium-High Frequency

~25 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (BFS from Each Empty Land) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler