Best Position for a Service Centre - Practice Coding Problems

Best Position for a Service Centre - Problem

Problem Overview: A delivery company is expanding to a new city and needs to strategically place their service center. They have the exact coordinates of all their customers on a 2D map and want to minimize the total travel distance.

Your Task: Given an array positions where positions[i] = [xi, yi] represents the coordinates of the ith customer, find the optimal location [xcentre, ycentre] for the service center that minimizes the sum of Euclidean distances to all customers.

The Euclidean distance between two points (x1, y1) and (x2, y2) is √[(x1-x2)² + (y1-y2)²].

Note: This is a classic geometric optimization problem known as the Geometric Median or Fermat Point problem. Answers within 10⁻⁵ of the actual value will be accepted.

Input & Output

example_1.py — Python

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

› Output: 4.00000

💡 Note: The service center should be placed at (1,1). Total distance = √[(1-0)² + (1-1)²] + √[(1-1)² + (1-0)²] + √[(1-1)² + (1-2)²] + √[(1-2)² + (1-1)²] = 1 + 1 + 1 + 1 = 4.00000

example_2.py — Python

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

› Output: 2.82843

💡 Note: The optimal center is at (2,2). Total distance = √[(2-1)² + (2-1)²] + √[(2-3)² + (2-3)²] = √2 + √2 = 2√2 ≈ 2.82843

example_3.py — Python

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

› Output: 0.00000

💡 Note: With only one customer, the optimal service center location is at the customer's position (1,1), resulting in zero total distance.

Visualization

Tap to expand

Understanding the Visualization

Plot Customers

Mark all customer locations on a 2D map

Search Strategy

Choose between grid search (test every point) or smart optimization

Calculate Distances

For each candidate location, sum up distances to all customers

Find Minimum

The location with smallest total distance is optimal

Key Takeaway

🎯 Key Insight: The geometric median minimizes total Euclidean distances and can be found efficiently using mathematical optimization techniques rather than brute force search.

Time & Space Complexity

Time Complexity

⏱️

O(log³(1/ε) × n)

Nested ternary searches with precision ε, each evaluation costs O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only need variables for search bounds and current best

✓ Linear Space

Constraints

1 ≤ positions.length ≤ 50
positions[i].length == 2
0 ≤ positions[i][0], positions[i][1] ≤ 100
Answers within 10^-5 of the actual value will be accepted

Asked in

a Amazon 45 G Google 38 U Uber 32 D DoorDash 28

This is a geometric median problem that can be solved using gradient descent or ternary search. The optimal approach uses iterative optimization to find the point that minimizes the sum of Euclidean distances. While brute force grid search works for small inputs, ternary search provides O(log³(1/ε) × n) complexity with much better precision and performance.

Common Approaches

Approach	Time	Space	Notes
✓ Ternary Search Optimization	O(log³(1/ε) × n)	O(1)	Use ternary search to find optimal x and y coordinates separately
Grid Search Brute Force	O(G × n)	O(G)	Try every point on a fine grid and calculate total distance

Ternary Search Optimization — Algorithm Steps

Define helper function to calculate total distance for given (x,y)
Use ternary search to find optimal x-coordinate
For each candidate x, use ternary search to find optimal y
Return the minimum total distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Start with wide search bounds for x and y coordinates

Divide & Test

Split range into thirds, test middle candidates

Converge

Eliminate 1/3 of search space each iteration until precise enough

Code -

solution.c — C

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

int** global_positions;
int global_size;

double distanceSum(double x, double y) {
    double sum = 0;
    for (int i = 0; i < global_size; i++) {
        double dx = x - global_positions[i][0];
        double dy = y - global_positions[i][1];
        sum += sqrt(dx * dx + dy * dy);
    }
    return sum;
}

double ternarySearchY(double x, double left, double right) {
    while (right - left > 1e-7) {
        double m1 = left + (right - left) / 3;
        double m2 = right - (right - left) / 3;
        if (distanceSum(x, m1) > distanceSum(x, m2)) {
            left = m1;
        } else {
            right = m2;
        }
    }
    return (left + right) / 2;
}

double ternarySearchX(double left, double right, double minY, double maxY) {
    while (right - left > 1e-7) {
        double m1 = left + (right - left) / 3;
        double m2 = right - (right - left) / 3;
        
        double y1 = ternarySearchY(m1, minY, maxY);
        double y2 = ternarySearchY(m2, minY, maxY);
        
        if (distanceSum(m1, y1) > distanceSum(m2, y2)) {
            left = m1;
        } else {
            right = m2;
        }
    }
    return (left + right) / 2;
}

double getMinDistSum(int** positions, int positionsSize, int* positionsColSize) {
    global_positions = positions;
    global_size = positionsSize;
    
    if (positionsSize == 0) return 0.0;
    
    double minX = positions[0][0], maxX = positions[0][0];
    double minY = positions[0][1], maxY = positions[0][1];
    
    for (int i = 0; i < positionsSize; i++) {
        if (positions[i][0] < minX) minX = positions[i][0];
        if (positions[i][0] > maxX) maxX = positions[i][0];
        if (positions[i][1] < minY) minY = positions[i][1];
        if (positions[i][1] > maxY) maxY = positions[i][1];
    }
    
    minX -= 1; maxX += 1;
    minY -= 1; maxY += 1;
    
    double optimalX = ternarySearchX(minX, maxX, minY, maxY);
    double optimalY = ternarySearchY(optimalX, minY, maxY);
    
    return distanceSum(optimalX, optimalY);
}

Time & Space Complexity

Time Complexity

⏱️

O(log³(1/ε) × n)

Nested ternary searches with precision ε, each evaluation costs O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only need variables for search bounds and current best

✓ Linear Space

Constraints

1 ≤ positions.length ≤ 50
positions[i].length == 2
0 ≤ positions[i][0], positions[i][1] ≤ 100
Answers within 10^-5 of the actual value will be accepted

28.4K Views

Medium Frequency

~25 min Avg. Time

850 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

Ternary Search Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler