Count All Possible Routes - Practice Coding Problems

Count All Possible Routes - Problem

Fuel-Constrained City Travel

Imagine you're planning a road trip across several cities with limited fuel! 🚗⛽

You're given an array locations where locations[i] represents the position of city i on a straight highway. You start at city start with fuel units of gas and want to reach city finish.

Travel Rules:
• You can move from any city i to any other city j (except the same city)
• Moving from city i to city j costs |locations[i] - locations[j]| fuel
• You can revisit cities multiple times (including start and finish)
• Your fuel can never go negative

Goal: Count all possible routes from start to finish with your available fuel. Since the answer can be huge, return it modulo 10⁹ + 7.

This is a classic dynamic programming problem that tests your ability to handle state transitions with constraints!

Input & Output

example_1.py — Basic Route Counting

$ Input: locations = [2,3,6,8,4], start = 1, finish = 3, fuel = 5

› Output: 4

💡 Note: There are 4 possible routes: 1→3 (direct), 1→0→3, 1→2→3, and 1→4→3. Each uses ≤5 fuel units.

example_2.py — Limited Fuel

$ Input: locations = [4,3,1], start = 1, finish = 0, fuel = 6

› Output: 5

💡 Note: Routes: 1→0, 1→2→0, 1→0→2→0, 1→2→1→0, 1→0→1→0. All fit within 6 fuel units.

example_3.py — No Valid Routes

$ Input: locations = [5,2,1], start = 0, finish = 2, fuel = 3

› Output: 0

💡 Note: Cannot reach city 2 from city 0 with only 3 fuel (minimum distance is 4).

Constraints

2 ≤ locations.length ≤ 100
1 ≤ locations[i] ≤ 10⁹
All locations[i] are distinct
0 ≤ start, finish < locations.length
1 ≤ fuel ≤ 200

Visualization

Tap to expand

Understanding the Visualization

State Definition

Each (city, remaining_fuel) represents a unique state

Transition

From each state, try moving to all other cities if fuel allows

Base Case

If current city equals finish, count this as one valid route

Memoization

Cache results to avoid recalculating the same state

Key Takeaway

🎯 Key Insight: Memoization transforms exponential route exploration into polynomial-time computation by caching results for each (city, fuel) state.

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal solution uses dynamic programming with memoization to cache results for each (city, fuel) state. This transforms an exponential brute force approach into an efficient O(n × fuel) solution. The key insight is recognizing this as a state-space problem where each state has a fixed number of routes to the destination.

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Recursion (Top-Down DP)	O(n × fuel)	O(n × fuel)	Use memoization to cache results of (city, fuel) states

Memoized Recursion (Top-Down DP) — Algorithm Steps

Create a memoization cache for (city, fuel) states
For each state, if already computed, return cached result
Otherwise, compute routes by trying all possible next cities
Cache the result before returning
Base case: if at finish city, count this as one route

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Cache

Before computing, check if (city, fuel) state already solved

Compute Routes

If not cached, calculate routes to all reachable cities

Store Result

Cache the computed result for future use

Return Answer

Return cached or computed result

Code -

solution.c — C

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

#define MOD 1000000007
int memo[101][201];

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int dfs(int* locations, int n, int currentCity, int finish, int remainingFuel) {
    if (remainingFuel < 0) return 0;
    if (memo[currentCity][remainingFuel] != -1) {
        return memo[currentCity][remainingFuel];
    }
    
    long long routes = (currentCity == finish) ? 1 : 0;
    
    for (int nextCity = 0; nextCity < n; nextCity++) {
        if (nextCity != currentCity) {
            int fuelCost = abs_val(locations[currentCity] - locations[nextCity]);
            if (remainingFuel >= fuelCost) {
                routes = (routes + dfs(locations, n, nextCity, finish, remainingFuel - fuelCost)) % MOD;
            }
        }
    }
    
    return memo[currentCity][remainingFuel] = (int)routes;
}

int countRoutes(int* locations, int n, int start, int finish, int fuel) {
    memset(memo, -1, sizeof(memo));
    return dfs(locations, n, start, finish, fuel);
}

int main() {
    printf("Input parsing required\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × fuel)

Each (city, fuel) state is computed exactly once, and there are n×fuel possible states

✓ Linear Growth

Space Complexity

O(n × fuel)

Memoization table stores results for all possible (city, fuel) combinations

⚡ Linearithmic Space

28.0K Views

Medium-High 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

Memoized Recursion (Top-Down DP) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler