Minimum Number of Refueling Stops - Practice Coding Problems

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. Add stations [25,25] and [50,50] to available options. Even if we use both stations optimally, we get 50 + 25 + 50 = 125 total fuel, but started at position 0, so max reach is 125. Since target is 100, this should work, but let's recalculate: we use the better strategy and the answer is actually achievable.

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.

Visualization

Tap to expand

Understanding the Visualization

Drive Forward

Use your current fuel to travel as far as possible

Collect Options

Keep track of all gas stations you pass in a max heap

Smart Refuel

When stuck, retroactively choose the station with most fuel

Repeat Journey

Continue with new fuel until target is reachable

Key Takeaway

🎯 Key Insight: The greedy approach works because we can make optimal decisions retroactively - when we run out of fuel, we always want to have used the station with the most fuel from those we've passed.

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

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

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-up)	O(n²)	O(n)	Build up solutions for 0, 1, 2, ... stops until we reach the target
Greedy with Max Heap (Optimal)	O(n log n)	O(n)	Travel as far as possible, then retroactively pick the best stations when fuel runs out

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 = 1; i <= stationsSize; i++) {
        for (int j = 0; j < i; j++) {
            int stationPos = stations[j][0];
            int stationFuel = stations[j][1];
            // Can we reach station j with exactly (i-1) stops?
            if (dp[i-1] >= stationPos) {
                long long newDist = dp[i-1] + stationFuel;
                if (newDist > dp[i]) {
                    dp[i] = newDist;
                }
            }
        }
    }
    
    // Find minimum stops needed
    for (int i = 0; i <= stationsSize; i++) {
        if (dp[i] >= target) {
            free(dp);
            return i;
        }
    }
    
    free(dp);
    return -1;
}

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

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Bottom-up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler