Number of Restricted Paths From First to Last Node

Number of Restricted Paths From First to Last Node - Problem

Number of Restricted Paths From First to Last Node

Imagine you're navigating through a weighted network where you can only move through paths that get you progressively closer to your destination! 🎯

You're given an undirected weighted connected graph with n nodes labeled from 1 to n, and an array edges where each edges[i] = [ui, vi, weighti] represents an edge between nodes ui and vi with weight weighti.

A restricted path from node 1 to node n is a special path where:
• Each step takes you to a node that is strictly closer to node n than your current position
• "Closer" means having a smaller shortest distance to node n

Goal: Count the total number of such restricted paths from node 1 to node n.

Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Small Connected Graph

$ Input: n = 5, edges = [[1,2,3],[1,3,3],[2,3,1],[1,4,2],[5,2,2],[3,5,1],[5,4,10]]

› Output: 3

💡 Note: There are 3 restricted paths from node 1 to node 5: [1,2,5], [1,4,2,5], and [1,3,5]. Note that path [1,2,3,5] is not valid because dist[3]=4 > dist[5]=0, violating the restriction.

example_2.py — Linear Path

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

› Output: 1

💡 Note: There is only one restricted path: [1,2,3,4]. Each step moves us closer to node 4: dist[1]=3, dist[2]=2, dist[3]=1, dist[4]=0.

example_3.py — Multiple Valid Paths

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

› Output: 2

💡 Note: Two restricted paths exist: [1,2,3] and [1,3]. The direct path [1,3] is valid because dist[1]=2 > dist[3]=0. The path through node 2 is also valid: dist[1]=2 > dist[2]=1 > dist[3]=0.

Visualization

Tap to expand

Understanding the Visualization

Survey the Mountain

Use Dijkstra's algorithm like a helicopter survey to measure the shortest distance from every point to base camp

Start Descent from Summit

Begin at node 1 (summit) and explore all possible downhill paths using memoized DFS

Follow Only Downhill Routes

At each location, only consider paths to neighbors that are strictly closer to base camp

Cache Route Counts

Remember the number of valid paths from each location to avoid recalculating the same routes

Key Takeaway

🎯 Key Insight: By computing shortest distances first, we transform the problem into counting paths in a DAG, making memoized DFS highly efficient with O((E + V) log V) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O((E + V) log V + V + E)

Dijkstra takes O((E + V) log V), then DFS with memoization visits each node and edge once O(V + E)

⚡ Linearithmic

Space Complexity

O(V + E)

Space for adjacency list O(E), distance array O(V), and memoization cache O(V)

✓ Linear Space

Constraints

1 ≤ n ≤ 5 × 10⁴
n - 1 ≤ edges.length ≤ min(2 × 10⁴, n × (n - 1) / 2)
edges[i].length == 3
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i
1 ≤ weight_i ≤ 10⁶
The graph is connected

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses Dijkstra's algorithm to compute shortest distances from all nodes to the destination, then applies memoized DFS to count restricted paths. This transforms the problem into counting paths in a DAG where edges only go from nodes farther from the destination to nodes closer to it. Time complexity: O((E + V) log V).

Common Approaches

Approach	Time	Space	Notes
✓ Dijkstra + Dynamic Programming (Optimal)	O((E + V) log V + V + E)	O(V + E)	First compute shortest distances, then count paths using memoized DFS on the resulting DAG
Brute Force (DFS with Path Validation)	O(P * V * (E + V log V))	O(V + E)	Try all possible paths and validate the distance constraint for each

Dijkstra + Dynamic Programming (Optimal) — Algorithm Steps

Build adjacency list from edges
Run Dijkstra's algorithm from node n to get shortest distances to all nodes
Use memoized DFS starting from node 1
For each node, only consider neighbors with smaller distance to node n
Return cached results to avoid recomputation
Sum all paths and return modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Run Dijkstra from destination

Compute shortest distance from every node to node n

Start memoized DFS from node 1

Count paths using the distance information as constraints

Only visit closer neighbors

At each node, only consider neighbors with smaller distance to destination

Cache and return results

Use memoization to avoid recalculating the same subproblems

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 20005

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

struct Edge edges[MAXN * 2];
int head[MAXN], edgeCount;
int dist[MAXN];
int visited[MAXN];
int memo[MAXN];
int memoSet[MAXN];

void addEdge(int from, int to, int weight) {
    edges[edgeCount].to = to;
    edges[edgeCount].weight = weight;
    edges[edgeCount].next = head[from];
    head[from] = edgeCount++;
}

void dijkstra(int start, int n) {
    for (int i = 0; i <= n; i++) {
        dist[i] = INT_MAX;
        visited[i] = 0;
    }
    dist[start] = 0;
    
    for (int i = 0; i < n; i++) {
        int u = -1;
        for (int v = 1; v <= n; v++) {
            if (!visited[v] && (u == -1 || dist[v] < dist[u])) {
                u = v;
            }
        }
        
        if (u == -1 || dist[u] == INT_MAX) break;
        visited[u] = 1;
        
        for (int e = head[u]; e != -1; e = edges[e].next) {
            int v = edges[e].to;
            int w = edges[e].weight;
            if (dist[u] != INT_MAX && dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
            }
        }
    }
}

int dfs(int node, int target) {
    if (node == target) return 1;
    if (memoSet[node]) return memo[node];
    
    int count = 0;
    for (int e = head[node]; e != -1; e = edges[e].next) {
        int neighbor = edges[e].to;
        if (dist[neighbor] < dist[node]) {
            count = (count + dfs(neighbor, target)) % MOD;
        }
    }
    
    memo[node] = count;
    memoSet[node] = 1;
    return count;
}

int countRestrictedPaths(int n, int** edges_arr, int edgesSize, int* edgesColSize) {
    memset(head, -1, sizeof(head));
    memset(memoSet, 0, sizeof(memoSet));
    edgeCount = 0;
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges_arr[i][0];
        int v = edges_arr[i][1];
        int w = edges_arr[i][2];
        addEdge(u, v, w);
        addEdge(v, u, w);
    }
    
    dijkstra(n, n);
    return dfs(1, n);
}

Time & Space Complexity

Time Complexity

⏱️

O((E + V) log V + V + E)

Dijkstra takes O((E + V) log V), then DFS with memoization visits each node and edge once O(V + E)

⚡ Linearithmic

Space Complexity

O(V + E)

Space for adjacency list O(E), distance array O(V), and memoization cache O(V)

✓ Linear Space

Constraints

1 ≤ n ≤ 5 × 10⁴
n - 1 ≤ edges.length ≤ min(2 × 10⁴, n × (n - 1) / 2)
edges[i].length == 3
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i
1 ≤ weight_i ≤ 10⁶
The graph is connected

67.4K Views

Medium 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

Dijkstra + Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler