Number of Restricted Paths From First to Last Node - Problem

There is an undirected weighted connected graph. You are given a positive integer n which denotes that the graph has n nodes labeled from 1 to n, and an array edges where each edges[i] = [u_i, v_i, weight_i] denotes that there is an edge between nodes u_i and v_i with weight equal to weight_i.

A path from node start to node end is a sequence of nodes [z₀, z₁, z₂, ..., z_k] such that z₀ = start and z_k = end and there is an edge between z_i and z_i+1 where 0 ≤ i ≤ k-1.

The distance of a path is the sum of the weights on the edges of the path. Let distanceToLastNode(x) denote the shortest distance of a path between node n and node x. A restricted path is a path that also satisfies that distanceToLastNode(z_i) > distanceToLastNode(z_i+1) where 0 ≤ i ≤ k-1.

Return the number of restricted paths from node 1 to node n. Since that number may be too large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Path

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

› Output: 3

💡 Note: There are 3 restricted paths: 1→2→5, 1→3→5, and 1→4→5. Each path has decreasing distance to node 5.

Example 2 — Simple Chain

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

› Output: 1

💡 Note: Only one path exists: 1→2. Distance decreases from 1 to 0, so it's a valid restricted path.

Example 3 — Complex Graph

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

› Output: 2

💡 Note: Two restricted paths exist: 1→2→3→4 and 1→3→4. Both satisfy the decreasing distance condition.

Constraints

2 ≤ n ≤ 200
n-1 ≤ edges.length ≤ 2 * 10⁴
edges[i].length == 3
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i
1 ≤ weight_i ≤ 10⁶
There is at most one edge between any two nodes

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 f Facebook 4

The key insight is that a restricted path requires distance to destination to always decrease. Best approach uses Dijkstra + Memoized DFS: first calculate shortest distances from target node n, then count paths where we only move to nodes closer to the target. Time: O(E log V + V²), Space: O(V²)

Common Approaches

✓ Brute Force DFS

⏱️ Time: O(2^n) Space: O(n)

Use depth-first search to explore all paths from node 1 to node n. For each path, verify that the distance to node n decreases at each step. This requires calculating shortest distances from every node to node n multiple times.

Dijkstra + Memoized DFS

⏱️ Time: O(E log V + V²) Space: O(V²)

Use Dijkstra's algorithm to find shortest distances from node n to all other nodes. Then use memoized DFS to count restricted paths, where we only move to nodes with smaller distance to the target.

Brute Force DFS — Algorithm Steps

Step 1: For each possible path, use DFS to explore
Step 2: At each step, calculate distance to node n
Step 3: Count paths where distance always decreases

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at node 1, explore all neighbors

Check Restriction

For each path, verify distance decreases

Count Valid

Sum up all paths that satisfy restriction

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 205

int graph[MAX_N][MAX_N];
int dist[MAX_N];
int visited[MAX_N];
int n;

void dijkstra(int start) {
    int processed[MAX_N] = {0};
    
    for (int i = 1; i <= n; i++) {
        dist[i] = INT_MAX;
    }
    dist[start] = 0;
    
    for (int i = 1; i <= n; i++) {
        int u = -1;
        for (int j = 1; j <= n; j++) {
            if (!processed[j] && (u == -1 || dist[j] < dist[u])) {
                u = j;
            }
        }
        processed[u] = 1;
        
        for (int v = 1; v <= n; v++) {
            if (graph[u][v] != -1 && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }
}

int dfs(int node, int target) {
    if (node == target) return 1;
    int count = 0;
    
    for (int neighbor = 1; neighbor <= n; neighbor++) {
        if (graph[node][neighbor] != -1 && !visited[neighbor] && dist[node] > dist[neighbor]) {
            visited[neighbor] = 1;
            count = (count + dfs(neighbor, target)) % MOD;
            visited[neighbor] = 0;
        }
    }
    return count;
}

int solution(int nodes, int edges[][3], int edgeCount) {
    n = nodes;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            graph[i][j] = -1;
        }
    }
    
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1], w = edges[i][2];
        if (graph[u][v] == -1 || graph[u][v] > w) {
            graph[u][v] = w;
            graph[v][u] = w;
        }
    }
    
    dijkstra(n);
    memset(visited, 0, sizeof(visited));
    visited[1] = 1;
    return dfs(1, n);
}

int main() {
    int nodes;
    scanf("%d\n", &nodes);
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int edges[1000][3];
    int edgeCount = 0;
    
    char *ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            edges[edgeCount][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            edges[edgeCount][1] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            edges[edgeCount][2] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            edgeCount++;
        }
        ptr++;
    }
    
    printf("%d\n", solution(nodes, edges, edgeCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Explores all possible paths exponentially, with distance calculations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth up to n nodes

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 min Avg. Time

342 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

Number of Restricted Paths From First to Last Node - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler