Shortest Distance from All Buildings - Practice Coding Problems

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: 2

💡 Note: Only one building exists at (0,0). The farthest empty cell is at (2,2) with distance 4, but the optimal location is (0,1) or (1,0) with distance 1. However, any empty cell works, so minimum distance is from adjacent cell = 1. Actually, let me recalculate: the question asks for shortest total distance, so (0,1) gives distance 1.

Visualization

Tap to expand

Understanding the Visualization

Survey the City

Identify all buildings (offices) and obstacles (lakes, mountains) in the city grid

Measure from Each Office

Instead of checking each empty lot, start from each office and measure walking distances outward

Accumulate Commute Times

For each empty lot, add up the walking distances from all offices

Choose Optimal Location

Select the empty lot with minimum total commute time to all offices

Key Takeaway

🎯 Key Insight: Instead of trying each empty location and measuring distances to all buildings (expensive), start from each building and measure distances to all empty locations (efficient). This reversal of perspective leads to the optimal Multi-Source BFS solution!

Time & Space Complexity

Time Complexity

⏱️

O(k·mn)

k is number of buildings, we run BFS from each building once through the mn grid

✓ Linear Growth

Space Complexity

O(mn)

Distance matrix and BFS queue storage

⚡ Linearithmic Space

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

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

Approach	Time	Space	Notes
✓ Brute Force (BFS from Each Empty Land)	O(m²n²)	O(mn)	For each empty land, run BFS to calculate distance to all buildings
Multi-Source BFS (Optimal)	O(k·mn)	O(mn)	Start BFS from all buildings simultaneously to find optimal house location

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>

#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++];
}

int bfsFromEmpty(int** grid, int m, int n, int startRow, int startCol, int buildingCount) {
    Queue q;
    initQueue(&q);
    bool visited[MAX_SIZE][MAX_SIZE] = {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) return -1;
    
    int m = gridSize, n = gridColSize[0];
    int buildingCount = 0;
    
    // Count buildings
    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;
}

int main() {
    // Parse input and call solution
    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

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

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

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler