Minimum Number of Refueling Stops

Minimum Number of Refueling Stops - Problem

Imagine you're planning a cross-country road trip with limited fuel! 🚗

Your car needs to travel from the starting position to a destination that is target miles away. Along the route, there are several gas stations positioned at different distances, each containing a specific amount of fuel.

The Challenge: Find the minimum number of refueling stops needed to reach your destination, or return -1 if it's impossible.

Key Details:

Your car starts with startFuel liters of fuel
The car consumes 1 liter per mile
Gas stations are represented as [position, fuel] pairs
When you stop at a station, you take all the fuel available there
You can reach a station or destination with exactly 0 fuel remaining

Goal: Return the minimum number of stops needed, or -1 if the journey is impossible.

Input & Output

example_1.py — Basic Journey

$ Input: target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]

› Output: 2

💡 Note: Start with 10 fuel, reach station at position 10. Refuel to get 60 more fuel (total distance reachable: 70). Travel to position 70, but need to reach 100. Look back at passed stations: used [10,60], have [20,30], [30,30], [60,40] available. Take the best one [60,40] retroactively. Now we can reach 70 + 40 = 110 ≥ 100. Total stops: 2.

example_2.py — Impossible Journey

$ Input: target = 100, startFuel = 50, stations = [[25,25],[50,50]]

› Output: 1

💡 Note: Start with 50 fuel, can reach position 50. Need 50 more fuel to reach target 100. Can use station [25,25] retroactively - with 25 additional fuel, can reach 50+25=75. Can also use station [50,50] retroactively - with 50 additional fuel, can reach 50+50=100. Choose [50,50] for 1 total stop.

example_3.py — No Refueling Needed

$ Input: target = 100, startFuel = 100, stations = [[10,60],[20,30],[30,30],[60,40]]

› Output: 0

💡 Note: We start with enough fuel (100) to reach the target (100) directly without any refueling stops.

Constraints

1 ≤ target, startFuel ≤ 10⁹
0 ≤ stations.length ≤ 500
0 < stations[i][0] < target
1 ≤ stations[i][1] < 10⁹
All stations are positioned before the target

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal approach uses a greedy strategy with max heap. We simulate the journey, traveling as far as possible with current fuel, and when we get stuck, we retroactively choose the best station (highest fuel) from those we've already passed. This achieves O(n log n) time complexity and finds the minimum stops needed.

Common Approaches

✓ Dynamic Programming (Bottom-up)

⏱️ Time: O(n²) Space: O(n)

Use dynamic programming where dp[i] represents the maximum distance we can reach with exactly i refueling stops. We iterate through each possible number of stops and for each stop count, we try using each gas station.

Greedy with Max Heap (Optimal)

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

This is the optimal approach using a greedy strategy with a max heap. We simulate the journey and keep track of all gas stations we pass. When we run out of fuel, we retroactively choose the station with the most fuel from those we've already passed.

Dynamic Programming (Bottom-up) — Algorithm Steps

Initialize dp[0] = startFuel (max distance with 0 stops)
For each number of stops from 1 to n:
For each gas station:
If we can reach this station with (stops-1) refuels:
Update dp[stops] = max(dp[stops], reach_station + station_fuel)
Return the minimum stops where dp[stops] >= target

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[0] = startFuel (distance with 0 stops)

Build States

For each stop count, try using each reachable station

Find Answer

Return minimum stops where distance >= target

Code -

solution.c — C

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

int minRefuelStops(int target, int startFuel, int** stations, int stationsSize, int* stationsColSize) {
    // dp[i] = maximum distance reachable with exactly i refueling stops
    long long* dp = (long long*)calloc(stationsSize + 1, sizeof(long long));
    dp[0] = startFuel;
    
    for (int i = 0; i < stationsSize; i++) {
        // Process in reverse order to avoid using updated values
        for (int t = i; t >= 0; t--) {
            if (dp[t] >= stations[i][0]) {
                long long newDist = dp[t] + stations[i][1];
                if (newDist > dp[t + 1]) {
                    dp[t + 1] = newDist;
                }
            }
        }
    }
    
    // Find minimum stops needed
    for (int i = 0; i <= stationsSize; i++) {
        if (dp[i] >= target) {
            free(dp);
            return i;
        }
    }
    
    free(dp);
    return -1;
}

int main() {
    int target, startFuel;
    char stationsStr[10000];
    
    scanf("%d", &target);
    scanf("%d", &startFuel);
    scanf(" %[^\n]", stationsStr);
    
    int** stations = NULL;
    int stationsSize = 0;
    int* stationsColSize = NULL;
    
    if (strcmp(stationsStr, "[]") != 0 && strlen(stationsStr) > 2) {
        // Count stations first
        char* temp = strdup(stationsStr);
        char* ptr = temp;
        int count = 0;
        while ((ptr = strstr(ptr, "[")) != NULL) {
            if (ptr != temp) count++; // Skip the first bracket
            ptr++;
        }
        stationsSize = count;
        free(temp);
        
        if (stationsSize > 0) {
            stations = (int**)malloc(stationsSize * sizeof(int*));
            stationsColSize = (int*)malloc(stationsSize * sizeof(int));
            
            // Parse stations
            char* token = strtok(stationsStr, "[]");
            int idx = 0;
            while (token != NULL && idx < stationsSize) {
                if (strlen(token) > 1) { // Skip empty tokens
                    stations[idx] = (int*)malloc(2 * sizeof(int));
                    stationsColSize[idx] = 2;
                    
                    char* comma = strchr(token, ',');
                    if (comma != NULL) {
                        *comma = '\0';
                        stations[idx][0] = atoi(token);
                        stations[idx][1] = atoi(comma + 1);
                        idx++;
                    }
                }
                token = strtok(NULL, "[]");
            }
            stationsSize = idx;
        }
    }
    
    int result = minRefuelStops(target, startFuel, stations, stationsSize, stationsColSize);
    printf("%d\n", result);
    
    // Cleanup
    for (int i = 0; i < stationsSize; i++) {
        free(stations[i]);
    }
    free(stations);
    free(stationsColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have n possible stops, and for each stop count we check all n stations

⚠ Quadratic Growth

Space Complexity

O(n)

We store the maximum reachable distance for each possible number of stops

⚡ Linearithmic Space

48.2K Views

High Frequency

~25 min Avg. Time

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

Dynamic Programming (Bottom-up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler