Maximize the Distance Between Points on a Square

Maximize the Distance Between Points on a Square - Problem

Imagine you're a city planner tasked with placing k emergency stations on the perimeter of a square city block to maximize safety coverage. You want to ensure that the closest distance between any two stations is as large as possible.

Given a square with side length side and corners at (0, 0), (0, side), (side, 0), and (side, side), you have a list of candidate locations points on the boundary where stations can be placed. Each point is represented as [x, y].

Your goal is to select exactly k points from the available locations such that the minimum Manhattan distance between any two selected points is maximized.

The Manhattan distance between two points (x₁, y₁) and (x₂, y₂) is |x₁ - x₂| + |y₁ - y₂|.

Return the maximum possible minimum Manhattan distance between the selected k points.

Input & Output

example_1.py — Small Square

$ Input: side = 2, k = 2, points = [[0,0], [1,0], [2,0], [2,1], [2,2], [1,2], [0,2], [0,1]]

› Output: 4

💡 Note: We can select points [0,0] and [2,2] (opposite corners). The Manhattan distance between them is |0-2| + |0-2| = 4, which is the maximum possible minimum distance for k=2 points.

example_2.py — More Points

$ Input: side = 3, k = 3, points = [[0,0], [0,1], [0,2], [0,3], [1,3], [2,3], [3,3], [3,2], [3,1], [3,0], [2,0], [1,0]]

› Output: 4

💡 Note: We can select points [0,0], [3,1], and [1,3]. The minimum distance between any pair is 4, achieved by multiple pairs. This gives us optimal spacing for 3 points.

example_3.py — Edge Case

$ Input: side = 1, k = 4, points = [[0,0], [0,1], [1,1], [1,0]]

› Output: 2

💡 Note: With only 4 corner points available and needing to select all 4, the minimum distance between adjacent corners is 2 (like [0,0] and [0,1]).

Constraints

1 ≤ side ≤ 10⁹
2 ≤ k ≤ points.length ≤ 10⁵
points[i] is on the boundary of the square
All points are distinct and lie exactly on the square's perimeter

Visualization

Tap to expand

Understanding the Visualization

Map Boundary Points

Convert 2D boundary coordinates to 1D linear positions (bottom→right→top→left)

Sort Linear Coordinates

Sort all positions for efficient processing

Binary Search

Search for the maximum feasible minimum distance

Greedy Validation

For each distance, greedily place k points and verify feasibility

Key Takeaway

🎯 Key Insight: By converting the 2D square boundary to a 1D linear coordinate system, we can efficiently use binary search to find the optimal minimum distance, making this complex optimization problem tractable.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 18

The optimal solution uses binary search on the answer combined with a greedy placement strategy. First, convert all boundary points to a linear coordinate system (0 to 4×side), then binary search for the maximum feasible minimum distance. For each candidate distance, greedily check if k points can be placed with at least that distance apart. Time complexity: O(n log n + n log D) where D is the maximum possible distance.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Greedy (Optimal)	O(n log n + n log D)	O(n)	Binary search on the minimum distance, use greedy strategy to check feasibility
Brute Force (Try All Combinations)	O(C(n,k) × k²)	O(k)	Generate all possible combinations of k points and find the one with maximum minimum distance

Binary Search + Greedy (Optimal) — Algorithm Steps

Convert all points on square boundary to linear coordinates (0 to 4×side)
Sort the linear coordinates
Binary search on the minimum distance from 0 to maximum possible distance
For each candidate distance, use greedy algorithm to check if k points can be placed
Greedy check: place first point, then place next point at least 'distance' away
Return the maximum feasible minimum distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Linear

Transform square boundary points to linear coordinates (0 to 4×side)

Sort Coordinates

Sort all linear coordinates for efficient processing

Binary Search

Search for maximum feasible minimum distance

Greedy Check

For each candidate distance, greedily place k points

Code -

solution.c — C

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

int pointToLinear(int x, int y, int side) {
    if (y == 0) return x;  // Bottom edge
    if (x == side) return side + y;  // Right edge
    if (y == side) return 2 * side + (side - x);  // Top edge
    return 3 * side + (side - y);  // Left edge
}

int canPlaceKPoints(int* coords, int n, int k, int minDist, int perimeter) {
    int count = 1;
    int lastPos = coords[0];
    
    for (int i = 1; i < n; i++) {
        int directDist = coords[i] - lastPos;
        int wraparoundDist = perimeter - directDist;
        int actualDist = (directDist < wraparoundDist) ? directDist : wraparoundDist;
        
        if (actualDist >= minDist) {
            count++;
            lastPos = coords[i];
            if (count >= k) return 1;
        }
    }
    
    return 0;
}

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

int maxDistance(int side, int k, int** points, int n) {
    int* linearCoords = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        linearCoords[i] = pointToLinear(points[i][0], points[i][1], side);
    }
    
    qsort(linearCoords, n, sizeof(int), compare);
    int perimeter = 4 * side;
    
    int left = 0, right = perimeter / 2;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canPlaceKPoints(linearCoords, n, k, mid, perimeter)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    free(linearCoords);
    return result;
}

int main() {
    // Input parsing and function call would be implemented here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n log D)

n log n for sorting, n log D for binary search where D is maximum distance

⚡ Linearithmic

Space Complexity

O(n)

Space to store converted linear coordinates

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler