Minimum Cost to Reach Destination in Time

Minimum Cost to Reach Destination in Time - Problem

Imagine you're planning a road trip across a country with n cities numbered from 0 to n-1. All cities are connected by bi-directional roads, but here's the catch: every city charges a passing fee just to enter!

You start at city 0 and need to reach city n-1 within maxTime minutes. Your challenge is to find the minimum cost route that gets you there on time.

Input:

edges[i] = [xi, yi, timei] - A road between cities xi and yi taking timei minutes
passingFees[j] - The fee you pay when entering city j
maxTime - Maximum time allowed for your journey

Output: Return the minimum cost to reach the destination within the time limit, or -1 if impossible.

Note: You pay the passing fee for every city you visit, including your starting city and destination!

Input & Output

example_1.py — Basic Path Selection

$ Input: maxTime = 30, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]

› Output: 11

💡 Note: The optimal path is 0 → 1 → 2 → 5. Total time: 10+10+10 = 30 minutes (exactly within limit). Total cost: 5+1+2+3 = 11 dollars.

example_2.py — Time Constraint Forces Expensive Route

$ Input: maxTime = 29, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]

› Output: 48

💡 Note: With one less minute, the direct path 0→1→2→5 takes 30 minutes (too long). Must take 0→3→4→5: time = 1+10+15 = 26 minutes, cost = 5+20+20+3 = 48 dollars.

example_3.py — Impossible Within Time Limit

$ Input: maxTime = 25, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]

› Output: -1

💡 Note: No path can reach the destination within 25 minutes. The fastest path takes 26 minutes (0→3→4→5).

Constraints

1 ≤ n ≤ 1000
n - 1 ≤ edges.length ≤ 1000
0 ≤ xi, yi ≤ n - 1
1 ≤ timei ≤ 1000
1 ≤ passingFees[j] ≤ 1000
0 ≤ maxTime ≤ 1000
The graph is connected (there exists a path from city 0 to city n-1)

Visualization

Tap to expand

Asked in

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

This problem requires finding the minimum cost path with a time constraint. The optimal approach uses a modified Dijkstra's algorithm where each state represents (city, time_used). We use a priority queue to always process the minimum cost state first, and maintain a 2D DP table to track the minimum cost to reach each (city, time) combination. This ensures we find the optimal solution in O(n × maxTime × log(n × maxTime)) time.

Common Approaches

✓ Brute Force (DFS with All Paths)

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

Use depth-first search to explore every possible path from start to destination. For each path, calculate total time and cost, keeping track of the minimum cost among valid paths.

Dijkstra's Algorithm (Optimal)

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

Use a modified version of Dijkstra's algorithm where each state represents (city, time_used). We prioritize by cost and ensure we don't exceed the time limit. This finds the minimum cost path efficiently.

Brute Force (DFS with All Paths) — Algorithm Steps

Start DFS from city 0 with initial cost of passingFees[0]
For each neighbor, recursively explore if we haven't exceeded maxTime
When reaching destination, update minimum cost if path is valid
Use backtracking to explore all possible routes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at city 0

Begin DFS with initial cost of passingFees[0]

Explore neighbors

Visit each unvisited neighbor if we have enough time

Backtrack

Return to previous city and try other paths

Track minimum

Keep track of minimum cost path to destination

Code -

solution.c — C

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

#define MAX_CITIES 1000
#define MAX_EDGES  2000
#define MAX_HEAP   1000000
#define INF        INT_MAX

typedef struct { int to, time; } Edge;
typedef struct { Edge edges[MAX_EDGES]; int count; } AdjList;
typedef struct { int cost, city, time; } State;

static AdjList graph[MAX_CITIES];
static int     fees[MAX_CITIES];
static int     dist[MAX_CITIES][1001];
static State   heap[MAX_HEAP];
static int     heapSize;

void addEdge(int u, int v, int t) {
    graph[u].edges[graph[u].count++] = (Edge){v, t};
    graph[v].edges[graph[v].count++] = (Edge){u, t};
}

void heapPush(State s) {
    int i = heapSize++;
    while (i > 0) {
        int p = (i - 1) / 2;
        if (heap[p].cost <= s.cost) break;
        heap[i] = heap[p];
        i = p;
    }
    heap[i] = s;
}

State heapPop() {
    State min = heap[0];
    State last = heap[--heapSize];
    int i = 0;
    while (1) {
        int l = 2*i+1, r = 2*i+2, s = i;
        if (l < heapSize && heap[l].cost < heap[s].cost) s = l;
        if (r < heapSize && heap[r].cost < heap[s].cost) s = r;
        if (s == i) break;
        heap[i] = heap[s];
        i = s;
    }
    heap[i] = last;
    return min;
}

int solve(int n, int maxT) {
    for (int i = 0; i < n; i++)
        for (int j = 0; j <= maxT; j++)
            dist[i][j] = INF;

    heapSize = 0;
    dist[0][0] = fees[0];
    heapPush((State){fees[0], 0, 0});

    while (heapSize > 0) {
        State cur = heapPop();

        if (cur.cost > dist[cur.city][cur.time]) continue;

        for (int i = 0; i < graph[cur.city].count; i++) {
            int nb   = graph[cur.city].edges[i].to;
            int newT = cur.time + graph[cur.city].edges[i].time;
            int newC = cur.cost + fees[nb];

            if (newT > maxT)            continue;
            if (newC >= dist[nb][newT]) continue;

            dist[nb][newT] = newC;
            heapPush((State){newC, nb, newT});
        }
    }

    int ans = INF;
    for (int t = 0; t <= maxT; t++)
        if (dist[n-1][t] < ans) ans = dist[n-1][t];

    return (ans == INF) ? -1 : ans;
}

int readInt(char *buf, int *pos) {
    while (buf[*pos] && (buf[*pos] < '0' || buf[*pos] > '9')) (*pos)++;
    int val = 0;
    while (buf[*pos] >= '0' && buf[*pos] <= '9')
        val = val * 10 + (buf[(*pos)++] - '0');
    return val;
}

int main(void) {
    static char buf[1 << 20];
    int len = 0, c;
    while ((c = getchar()) != EOF) buf[len++] = c;
    buf[len] = '\0';

    int pos = 0;
    int maxT = readInt(buf, &pos);

    int ex[MAX_EDGES], ey[MAX_EDGES], et[MAX_EDGES], edgeCount = 0;

    while (buf[pos] && buf[pos] != '[') pos++;
    pos++;
    while (buf[pos]) {
        while (buf[pos] && buf[pos] != '[' && buf[pos] != ']') pos++;
        if (buf[pos] == ']') { pos++; break; }
        pos++;
        ex[edgeCount] = readInt(buf, &pos);
        ey[edgeCount] = readInt(buf, &pos);
        et[edgeCount] = readInt(buf, &pos);
        edgeCount++;
        while (buf[pos] && buf[pos] != ']') pos++;
        pos++;
    }

    int n = 0;
    while (buf[pos] && buf[pos] != '[') pos++;
    pos++;
    while (buf[pos] && buf[pos] != ']') {
        while (buf[pos] && (buf[pos] < '0' || buf[pos] > '9') && buf[pos] != ']') pos++;
        if (buf[pos] == ']') break;
        fees[n++] = readInt(buf, &pos);
    }

    for (int i = 0; i < n; i++) graph[i].count = 0;
    for (int i = 0; i < edgeCount; i++) addEdge(ex[i], ey[i], et[i]);

    printf("%d\n", solve(n, maxT));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case, we might explore all permutations of cities

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth up to number of cities

⚡ Linearithmic Space

43.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (DFS with All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler