Number of Ways to Arrive at Destination - Practice Coding Problems

Number of Ways to Arrive at Destination - Problem

You're navigating through a city's road network to find the optimal route from your starting point to your destination. The city consists of n intersections numbered from 0 to n-1, connected by bi-directional roads.

Given an integer n and a 2D array roads where roads[i] = [ui, vi, timei] represents a road between intersections ui and vi that takes timei minutes to travel, your goal is to determine:

🎯 Find the shortest travel time from intersection 0 to intersection n-1
📊 Count how many different routes achieve this shortest time

Since there might be many optimal routes, return the count modulo 10⁹ + 7.

Note: The city is fully connected (you can reach any intersection from any other), and there's at most one direct road between any two intersections.

Input & Output

example_1.py — Basic Graph

$ Input: n = 7, roads = [[0,6,7],[0,1,2],[1,2,3],[1,3,3],[6,3,3],[3,5,1],[6,5,1],[2,5,1],[0,4,5],[4,6,2]]

› Output: 4

💡 Note: The shortest path from 0 to 6 takes 7 minutes. There are 4 different ways: (0→6), (0→4→6), (0→1→2→5→6), and (0→1→3→5→6).

example_2.py — Simple Path

$ Input: n = 2, roads = [[1,0,10]]

› Output: 1

💡 Note: There's only one road connecting the intersections, so there's exactly 1 way to travel from intersection 0 to intersection 1.

example_3.py — Multiple Equal Paths

$ Input: n = 4, roads = [[0,1,1],[0,2,1],[1,3,1],[2,3,1]]

› Output: 2

💡 Note: Two paths exist with the same shortest time of 2: (0→1→3) and (0→2→3). Both take exactly 2 minutes.

Visualization

Tap to expand

Understanding the Visualization

Initialize GPS

Set your starting point with distance 0 and 1 way to reach it

Explore Roads

Use priority queue to always explore the closest unvisited intersection first

Update Routes

For each intersection, check if we found a faster route or another equally fast route

Count Optimal Paths

Accumulate the number of ways to reach each intersection optimally

Key Takeaway

🎯 Key Insight: By enhancing Dijkstra's algorithm to track path counts alongside shortest distances, we solve both problems (shortest path + counting) in one efficient pass through the graph.

Time & Space Complexity

Time Complexity

⏱️

O((E + V) log V)

Standard Dijkstra complexity: E edges, V vertices, with priority queue operations taking O(log V)

⚡ Linearithmic

Space Complexity

O(V + E)

Space for adjacency list (E), distance and ways arrays (V), and priority queue (V)

✓ Linear Space

Constraints

1 ≤ n ≤ 200
n - 1 ≤ roads.length ≤ n × (n - 1) / 2
roads[i].length == 3
0 ≤ ui, vi ≤ n - 1
1 ≤ timei ≤ 10⁹
ui ≠ vi
All pairs (ui, vi) are unique
Graph is connected - you can reach any intersection from any other

Asked in

G Google 45 a Amazon 38 f Meta 31 ⊞ Microsoft 24 U Uber 19

This problem combines shortest path finding with path counting. The optimal approach uses Dijkstra's algorithm enhanced with path counting: when we find a shorter path to a node, we reset the ways count; when we find an equal-length path, we add to the ways count. This gives us O((E + V) log V) time complexity and handles both objectives in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS All Paths)	O(2^n)	O(n)	Explore all possible paths using DFS and count shortest ones
Dijkstra's Algorithm with Path Counting (Optimal)	O((E + V) log V)	O(V + E)	Find shortest paths and count them simultaneously using modified Dijkstra's algorithm

Brute Force (DFS All Paths) — Algorithm Steps

Use DFS to explore all paths from node 0 to node n-1
Keep track of current path time and minimum time found so far
When reaching destination, compare with minimum time
If shorter time found, reset count and update minimum
If same time found, increment count
Return final count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin exploring from node 0 with current time = 0

Explore Paths

Recursively visit all reachable unvisited neighbors

Reach Target

When reaching destination, compare with minimum time

Update Count

Update minimum time and count based on comparison

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

#define MOD 1000000007
#define MAX_N 200

typedef struct Edge {
    int to, weight;
    struct Edge* next;
} Edge;

static Edge* graph[MAX_N];
static long long minTime = LLONG_MAX;
static int count = 0;
static bool visited[MAX_N];

void addEdge(int from, int to, int weight) {
    Edge* edge = malloc(sizeof(Edge));
    edge->to = to;
    edge->weight = weight;
    edge->next = graph[from];
    graph[from] = edge;
}

void dfs(int node, int target, long long currentTime) {
    if (node == target) {
        if (currentTime < minTime) {
            minTime = currentTime;
            count = 1;
        } else if (currentTime == minTime) {
            count = (count + 1) % MOD;
        }
        return;
    }
    
    if (currentTime >= minTime) return;
    
    Edge* edge = graph[node];
    while (edge) {
        if (!visited[edge->to]) {
            visited[edge->to] = true;
            dfs(edge->to, target, currentTime + edge->weight);
            visited[edge->to] = false;
        }
        edge = edge->next;
    }
}

int countPaths(int n, int** roads, int roadsSize, int* roadsColSize) {
    for (int i = 0; i < n; i++) {
        graph[i] = NULL;
        visited[i] = false;
    }
    minTime = LLONG_MAX;
    count = 0;
    
    for (int i = 0; i < roadsSize; i++) {
        addEdge(roads[i][0], roads[i][1], roads[i][2]);
        addEdge(roads[i][1], roads[i][0], roads[i][2]);
    }
    
    visited[0] = true;
    dfs(0, n - 1, 0);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we might explore all possible paths in the graph, which can be exponential

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth limited by number of nodes in longest simple path

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 200
n - 1 ≤ roads.length ≤ n × (n - 1) / 2
roads[i].length == 3
0 ≤ ui, vi ≤ n - 1
1 ≤ timei ≤ 10⁹
ui ≠ vi
All pairs (ui, vi) are unique
Graph is connected - you can reach any intersection from any other

76.4K 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 All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler