Minimize Max Distance to Gas Station

Minimize Max Distance to Gas Station - Problem

You are given an integer array stations that represents the positions of gas stations on the x-axis. You are also given an integer k.

You should add k new gas stations. You can add the stations anywhere on the x-axis, and not necessarily on an integer position.

Let penalty() be the maximum distance between adjacent gas stations after adding the k new stations.

Return the smallest possible value of penalty().

Answers within 10^-6 of the actual answer will be accepted.

Input & Output

Example 1 — Basic Case

$ Input: stations = [1,3,6,10], k = 1

› Output: 3.0

💡 Note: Initial gaps are [2,3,4]. Adding one station optimally in the gap of 4 (between 6 and 10) at position 8 gives gaps [2,3,2,2]. Maximum gap is 3.0.

Example 2 — Multiple Additions

$ Input: stations = [23,24,36,39,46,56,57,65,84,98], k = 1

› Output: 14.0

💡 Note: Largest gap is 84-65=19. Adding one station at 74.5 splits it into two gaps of 9.5 each. New maximum gap becomes 14 (between 46 and 56).

Example 3 — Minimum Input

$ Input: stations = [1,2], k = 1

› Output: 0.5

💡 Note: Initial gap is 1. Adding one station at 1.5 creates two gaps of 0.5 each. Maximum gap is 0.5.

Constraints

2 ≤ stations.length ≤ 2000
0 ≤ stations[i] ≤ 10⁸
stations is sorted in a strictly increasing order
1 ≤ k ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18

The key insight is to use binary search on the answer space rather than trying all possible station placements. We binary search on the maximum distance value and check if it's achievable with k stations. The optimal approach has Time: O(n log(max_distance)), Space: O(1).

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(n log(max_distance)) Space: O(1)

Instead of searching for station positions, binary search on the answer itself. For each candidate maximum distance, check if it's achievable with k stations using a greedy placement strategy.

Greedy with Priority Queue

⏱️ Time: O(k log n) Space: O(n)

Use a priority queue to track segments by their current maximum distance. For each of k additions, place a station in the middle of the longest segment and update the queue.

Binary Search on Answer — Algorithm Steps

Set search range from 0 to maximum initial gap
For each mid value, check if achievable with k stations
Use greedy: place stations optimally in segments > mid

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Range

Set range [0, max_initial_gap]

Check Feasibility

For each mid value, check if achievable with k stations

Narrow Range

Update search range based on feasibility

Code -

solution.c — C

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

int canAchieve(int* stations, int stationsSize, int k, double maxDist) {
    int needed = 0;
    for (int i = 0; i < stationsSize - 1; i++) {
        double gap = stations[i + 1] - stations[i];
        needed += (int)fmax(0, ceil(gap / maxDist) - 1);
    }
    return needed <= k;
}

double solution(int* stations, int stationsSize, int k) {
    if (stationsSize < 2) {
        return 0.0;
    }
    
    double left = 0, right = 0;
    for (int i = 0; i < stationsSize - 1; i++) {
        double gap = stations[i + 1] - stations[i];
        if (gap > right) right = gap;
    }
    
    // Binary search with precision
    for (int i = 0; i < 100; i++) {
        double mid = (left + right) / 2;
        if (canAchieve(stations, stationsSize, k, mid)) {
            right = mid;
        } else {
            left = mid;
        }
    }
    
    return right;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int stations[1000];
    int stationsSize = 0;
    parseArray(line, stations, &stationsSize);
    
    int k;
    scanf("%d", &k);
    
    double result = solution(stations, stationsSize, k);
    printf("%g\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_distance))

Binary search with O(log max_distance) iterations, each taking O(n) to validate

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space for variables

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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 on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler