Minimize Max Distance to Gas Station - Practice Coding Problems

Minimize Max Distance to Gas Station - Problem

The Gas Station Optimization Challenge

Imagine you're a city planner tasked with optimizing gas station placement along a highway! You're given an integer array stations representing the positions of existing gas stations on the x-axis, and you have a budget to add exactly k new gas stations.

Your goal is to minimize the maximum distance between any two adjacent gas stations after adding the new ones. You can place new stations anywhere on the x-axis (not necessarily at integer positions).

Think of it this way: If the largest gap between stations is too big, drivers might run out of fuel! Your job is to strategically place new stations to make the worst-case scenario as good as possible.

Input: An array of station positions and number k of stations to add
Output: The smallest possible maximum distance between adjacent stations
Precision: Answers within 10^-6 of the actual answer will be accepted

Input & Output

example_1.py — Basic Case

$ Input: stations = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 9

› Output: 0.500000

💡 Note: With 9 additional stations, we can place one between each pair of existing stations, making all gaps equal to 0.5

example_2.py — Uneven Gaps

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

› Output: 14.000000

💡 Note: The largest gap is between positions 65 and 84 (length 19). Adding one station there creates two gaps of length 9.5, but other gaps remain larger. The maximum remaining gap is 14.

example_3.py — Edge Case

$ Input: stations = [1, 13, 17, 23], k = 5

› Output: 4.000000

💡 Note: Optimally distribute 5 stations among the gaps [12, 4, 6] to minimize the maximum gap to 4.0

Constraints

2 ≤ stations.length ≤ 10⁴
0 ≤ stations[i] ≤ 10⁸
stations is sorted in strictly increasing order
1 ≤ k ≤ 10⁶
Answers within 10^-6 of the actual answer will be accepted

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

We have existing gas stations with uneven gaps between them

Binary Search Strategy

Instead of finding positions, we search for the optimal maximum distance

Feasibility Test

For each candidate distance, check if achievable with k stations

Greedy Placement

Place stations greedily whenever gaps exceed our target distance

Key Takeaway

🎯 Key Insight: Transform the optimization problem into a series of decision problems using binary search on the answer, combined with greedy feasibility checking.

Asked in

G Google 35 a Amazon 28 Apple 22 ⊞ Microsoft 18

The optimal approach uses binary search on the answer combined with greedy feasibility checking. Instead of searching for station positions, we binary search on the maximum distance itself, checking if each candidate distance is achievable with k stations using a greedy placement strategy. Time complexity: O(n log(max_gap/ε)).

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue Approach	O(k log n)	O(n)	Use a max heap to always split the largest gap first
Binary Search on Answer (Optimal)	O(n log(max_gap / ε))	O(1)	Binary search on the maximum distance, checking feasibility with greedy placement

Priority Queue Approach — Algorithm Steps

Calculate all initial gaps between adjacent stations
Store gaps in a max heap with their positions
For each of k new stations, extract the largest gap
Split the gap in half and add both parts back to heap
The final maximum gap is our answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Calculate gaps between existing stations and add to max heap

Find Largest Gap

Extract the maximum gap from the priority queue

Split Gap

Add a station in the middle, creating two smaller gaps

Update Heap

Add the new gap back to the heap and repeat

Code -

solution.c — C

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

typedef struct {
    double gap;
    int divisions;
    int index;
} Gap;

void heapifyDown(Gap* heap, int size, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < size && heap[left].gap > heap[largest].gap)
        largest = left;
    if (right < size && heap[right].gap > heap[largest].gap)
        largest = right;
        
    if (largest != i) {
        Gap temp = heap[i];
        heap[i] = heap[largest];
        heap[largest] = temp;
        heapifyDown(heap, size, largest);
    }
}

double minmaxGasDist(int* stations, int stationsSize, int k) {
    Gap* heap = (Gap*)malloc((stationsSize - 1) * sizeof(Gap));
    int heapSize = stationsSize - 1;
    
    // Initialize heap
    for (int i = 0; i < stationsSize - 1; i++) {
        heap[i].gap = stations[i + 1] - stations[i];
        heap[i].divisions = 1;
        heap[i].index = i;
    }
    
    // Build max heap
    for (int i = heapSize / 2 - 1; i >= 0; i--) {
        heapifyDown(heap, heapSize, i);
    }
    
    // Add k stations
    for (int i = 0; i < k; i++) {
        Gap top = heap[0];
        int newDivisions = top.divisions + 1;
        double originalGap = stations[top.index + 1] - stations[top.index];
        double newGap = originalGap / newDivisions;
        
        heap[0].gap = newGap;
        heap[0].divisions = newDivisions;
        heapifyDown(heap, heapSize, 0);
    }
    
    double result = heap[0].gap;
    free(heap);
    return result;
}

int main() {
    int stations[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int k = 9;
    printf("%.6f\n", minmaxGasDist(stations, 10, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k log n)

k iterations, each with log n heap operations for n gaps

⚡ Linearithmic

Space Complexity

O(n)

Store all gaps in the heap

⚡ Linearithmic Space

20.8K Views

Medium Frequency

~25 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

Priority Queue Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler