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).

Visualization

Tap to expand

Understanding the Visualization

Start Your Journey

You begin at city 0, paying the entrance fee immediately. Your GPS (Dijkstra's algorithm) starts calculating optimal routes.

Explore Route Options

At each city, consider all connected roads. Can you afford the time for this route? Is this the cheapest way to reach the next city by this time?

Update Your Route Map

Keep track of the cheapest way to reach each city at each possible time. If you find a better route, update your plan.

Reach Destination

The first time you reach the destination city, you've found the optimal route (thanks to processing minimum costs first).

Key Takeaway

🎯 Key Insight: By tracking states as (city, time_used) pairs and always processing minimum cost first, we efficiently find the cheapest route that respects our time deadline!

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case, we might explore all permutations of cities

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth up to number of cities

⚡ Linearithmic Space

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)

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

Approach	Time	Space	Notes
✓ Brute Force (DFS with All Paths)	O(n!)	O(n)	Explore all possible paths using DFS and track minimum cost
Dijkstra's Algorithm (Optimal)	O(n * maxTime * log(n * maxTime))	O(n * maxTime)	Modified Dijkstra's algorithm tracking both cost and time constraints

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 <stdlib.h>
#include <limits.h>
#include <stdbool.h>

struct Edge {
    int to, time;
};

struct Graph {
    struct Edge* edges;
    int count, capacity;
};

int minCost = INT_MAX;

void dfs(int city, int timeLeft, int cost, bool* visited, 
         struct Graph* graph, int* passingFees, int n) {
    if (city == n - 1) {
        if (cost < minCost) minCost = cost;
        return;
    }
    
    for (int i = 0; i < graph[city].count; i++) {
        int nextCity = graph[city].edges[i].to;
        int travelTime = graph[city].edges[i].time;
        
        if (!visited[nextCity] && travelTime <= timeLeft) {
            visited[nextCity] = true;
            dfs(nextCity, timeLeft - travelTime, cost + passingFees[nextCity],
                visited, graph, passingFees, n);
            visited[nextCity] = false;
        }
    }
}

int minCostToReachDestination(int maxTime, int** edges, int edgesSize, int* edgesColSize, int* passingFees, int passingFeesSize) {
    int n = passingFeesSize;
    struct Graph* graph = calloc(n, sizeof(struct Graph));
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1], time = edges[i][2];
        
        if (graph[u].count == graph[u].capacity) {
            graph[u].capacity = graph[u].capacity ? graph[u].capacity * 2 : 2;
            graph[u].edges = realloc(graph[u].edges, 
                                   graph[u].capacity * sizeof(struct Edge));
        }
        graph[u].edges[graph[u].count++] = (struct Edge){v, time};
        
        if (graph[v].count == graph[v].capacity) {
            graph[v].capacity = graph[v].capacity ? graph[v].capacity * 2 : 2;
            graph[v].edges = realloc(graph[v].edges, 
                                   graph[v].capacity * sizeof(struct Edge));
        }
        graph[v].edges[graph[v].count++] = (struct Edge){u, time};
    }
    
    bool* visited = calloc(n, sizeof(bool));
    visited[0] = true;
    minCost = INT_MAX;
    
    dfs(0, maxTime, passingFees[0], visited, graph, passingFees, n);
    
    for (int i = 0; i < n; i++) {
        free(graph[i].edges);
    }
    free(graph);
    free(visited);
    
    return minCost == INT_MAX ? -1 : minCost;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case, we might explore all permutations of cities

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth up to number of cities

⚡ Linearithmic Space

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)

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS with All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler