Best Meeting Point - Practice Coding Problems

Best Meeting Point - Problem

Imagine you and your friends live scattered across a city grid, and you want to find the perfect meeting point that minimizes everyone's total travel time!

Given an m × n binary grid where each 1 represents a friend's house, find the location that minimizes the total Manhattan distance for everyone to reach.

Manhattan Distance between two points is calculated as: |x₁ - x₂| + |y₁ - y₂|

Your goal is to return the minimal total travel distance when all friends meet at the optimal point.

Example: If friends live at (0,0), (0,4), and (2,2), the best meeting point might be (1,2) with total distance = 3 + 1 + 2 = 6

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: Friends are at (0,0), (0,4), and (2,2). The optimal meeting point is (0,2) with distances: 2 + 2 + 2 = 6.

example_2.py — Single Friend

$ Input: grid = [[1]]

› Output: 0

💡 Note: Only one friend, so the optimal meeting point is at their location with total distance 0.

example_3.py — Linear Arrangement

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

› Output: 4

💡 Note: Friends at (0,0), (0,1), (0,4). Median is at column 1, so meeting point (0,1) gives distances: 1 + 0 + 3 = 4.

Visualization

Tap to expand

Understanding the Visualization

Identify Friend Locations

Scan the grid to find all houses marked with 1

Separate Dimensions

Manhattan distance allows us to solve X and Y independently

Find Medians

The median coordinate minimizes total distance in each dimension

Calculate Total

Sum all Manhattan distances from friends to the median point

Key Takeaway

🎯 Key Insight: Manhattan distance allows independent optimization of X and Y coordinates using the median property, reducing complexity from O(m²n²) to O(mn).

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of m×n cells, we calculate distance to each of the friends (up to m×n friends)

⚠ Quadratic Growth

Space Complexity

O(k)

Where k is the number of friends, to store their positions

✓ Linear Space

Constraints

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

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25 Apple 18

The optimal solution uses the median property for Manhattan distance. Since Manhattan distance separates into X and Y components, we can find the optimal coordinates independently. The median minimizes the sum of absolute deviations in each dimension. Extract friend coordinates, find median X and Y values, then calculate total distance. Time complexity: O(mn) to scan grid, Space: O(k) where k is number of friends.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Cell)	O(m²n²)	O(k)	Test every possible meeting point and calculate total distance
Optimal Solution (Median Finding)	O(k log k)	O(k)	Use median property to find optimal coordinates independently

Brute Force (Try Every Cell) — Algorithm Steps

Extract all friend positions from the grid
For each cell (i,j) in the grid:
Calculate sum of Manhattan distances from all friends to (i,j)
Track the minimum total distance found
Return the minimum distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Friends

Find all positions marked with 1

Test Each Cell

Try every cell as potential meeting point

Calculate Distance

Sum Manhattan distances from all friends

Track Minimum

Keep track of the smallest total distance

Code -

solution.c — C

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

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

int minTotalDistance(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int friends[gridSize * gridColSize[0]][2];
    int friendCount = 0;
    
    // Extract friend positions
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[i]; j++) {
            if (grid[i][j] == 1) {
                friends[friendCount][0] = i;
                friends[friendCount][1] = j;
                friendCount++;
            }
        }
    }
    
    if (friendCount == 0) return 0;
    
    int minDistance = INT_MAX;
    
    // Try every cell as meeting point
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[i]; j++) {
            int totalDist = 0;
            for (int k = 0; k < friendCount; k++) {
                totalDist += abs_val(i - friends[k][0]) + abs_val(j - friends[k][1]);
            }
            if (totalDist < minDistance) {
                minDistance = totalDist;
            }
        }
    }
    
    return minDistance;
}

int main() {
    // Example usage
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of m×n cells, we calculate distance to each of the friends (up to m×n friends)

⚠ Quadratic Growth

Space Complexity

O(k)

Where k is the number of friends, to store their positions

✓ Linear Space

Constraints

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

52.4K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 Every Cell) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler