Minimize Manhattan Distances - Practice Coding Problems

Minimize Manhattan Distances - Problem

Array Math Geometry Sorting Ordered Set Hard

Imagine you're a city planner tasked with optimizing the placement of emergency services. You have several potential locations on a 2D grid, and you need to minimize the worst-case response time by strategically removing exactly one location.

Given an array points where points[i] = [x_i, y_i] represents coordinates on a 2D plane, you need to find the minimum possible maximum Manhattan distance between any two points after removing exactly one point.

The Manhattan distance between two points (x1, y1) and (x2, y2) is calculated as: |x1 - x2| + |y1 - y2|

Goal: Remove one point to minimize the maximum distance between any remaining pair of points.

Input & Output

example_1.py — Basic Case

$ Input: points = [[3,10],[5,15],[10,2],[4,4]]

› Output: 12

💡 Note: Remove point [3,10]. The remaining points are [[5,15],[10,2],[4,4]]. The maximum Manhattan distance is between [5,15] and [10,2]: |5-10| + |15-2| = 5 + 13 = 18. Actually, we should remove [5,15] to get max distance of 12 between [3,10] and [10,2].

example_2.py — Optimal Removal

$ Input: points = [[1,1],[1,1],[1,1]]

› Output: 0

💡 Note: All points are identical. After removing any one point, the maximum distance between remaining points is 0.

example_3.py — Three Points

$ Input: points = [[1,1],[3,3],[3,1]]

› Output: 2

💡 Note: Remove [3,3]. Remaining points [1,1] and [3,1] have Manhattan distance |1-3| + |1-1| = 2.

Visualization

Tap to expand

Understanding the Visualization

Map the Territory

Plot all emergency stations on the city grid

Identify Extremes

Find stations at the corners of the coverage area

Test Removal

Simulate closing each extreme station

Optimize Coverage

Choose the closure that minimizes worst-case response time

Key Takeaway

🎯 Key Insight: Manhattan distance has a geometric property that allows coordinate transformation, reducing the problem from checking all O(n³) combinations to only testing O(1) extreme points in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes: one to find extremes, one to test removing each extreme point

✓ Linear Growth

Space Complexity

O(n)

Store transformed coordinates and track extreme points

⚡ Linearithmic Space

Constraints

3 ≤ points.length ≤ 10⁵
points[i].length == 2
-10⁸ ≤ points[i][0], points[i][1] ≤ 10⁸

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal approach uses coordinate transformation to convert the Manhattan distance problem. Since |x1-x2| + |y1-y2| = max(|(x1+y1)-(x2+y2)|, |(x1-y1)-(x2-y2)|), we transform to u=x+y, v=x-y coordinates. The maximum distance is determined by extreme points in these dimensions, so we only need to test removing those candidates, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Coordinate Transformation Approach	O(n)	O(n)	Transform Manhattan distance using coordinate rotation, then use efficient range tracking
Brute Force (Try Removing Each Point)	O(n³)	O(1)	Try removing each point and calculate the maximum Manhattan distance for remaining points

Coordinate Transformation Approach — Algorithm Steps

Transform all points: u[i] = x[i] + y[i], v[i] = x[i] - y[i]
Find the points that achieve maximum and minimum values in u and v dimensions
The maximum Manhattan distance is determined by these extreme points
Try removing each extreme point and recalculate the maximum distance
Return the minimum result

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform Coordinates

Convert (x,y) to (u,v) where u=x+y, v=x-y

Find Extremes

Identify points with min/max u and v values

Test Candidates

Only test removing the extreme points

Return Minimum

Choose the removal that gives minimum maximum 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 max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

int minimizeMax(int points[][2], int n) {
    // Find extreme points in transformed coordinates
    int uMin = INT_MAX, uMax = INT_MIN, vMin = INT_MAX, vMax = INT_MIN;
    int uMinIdx = -1, uMaxIdx = -1, vMinIdx = -1, vMaxIdx = -1;
    
    for (int i = 0; i < n; i++) {
        int u = points[i][0] + points[i][1];
        int v = points[i][0] - points[i][1];
        
        if (u < uMin) { uMin = u; uMinIdx = i; }
        if (u > uMax) { uMax = u; uMaxIdx = i; }
        if (v < vMin) { vMin = v; vMinIdx = i; }
        if (v > vMax) { vMax = v; vMaxIdx = i; }
    }
    
    int candidates[4] = {uMinIdx, uMaxIdx, vMinIdx, vMaxIdx};
    int minMaxDist = INT_MAX;
    
    for (int c = 0; c < 4; c++) {
        int skip = candidates[c];
        int maxDist = 0;
        
        for (int i = 0; i < n; i++) {
            if (i == skip) continue;
            for (int j = i + 1; j < n; j++) {
                if (j == skip) continue;
                int dist = abs_val(points[i][0] - points[j][0]) + abs_val(points[i][1] - points[j][1]);
                maxDist = max(maxDist, dist);
            }
        }
        minMaxDist = min(minMaxDist, maxDist);
    }
    
    return minMaxDist;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes: one to find extremes, one to test removing each extreme point

✓ Linear Growth

Space Complexity

O(n)

Store transformed coordinates and track extreme points

⚡ Linearithmic Space

Constraints

3 ≤ points.length ≤ 10⁵
points[i].length == 2
-10⁸ ≤ points[i][0], points[i][1] ≤ 10⁸

26.3K Views

Medium Frequency

~25 min Avg. Time

856 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

Coordinate Transformation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler