Find Edges in Shortest Paths

Find Edges in Shortest Paths - Problem

You are given an undirected weighted graph of n nodes numbered from 0 to n - 1. The graph consists of m edges represented by a 2D array edges, where edges[i] = [a_i, b_i, w_i] indicates that there is an edge between nodes a_i and b_i with weight w_i.

Consider all the shortest paths from node 0 to node n - 1 in the graph. You need to find a boolean array answer where answer[i] is true if the edge edges[i] is part of at least one shortest path. Otherwise, answer[i] is false.

Return the array answer.

Note: The graph may not be connected.

Input & Output

Example 1 — Basic Graph

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

› Output: [true,true,false,false]

💡 Note: Shortest path from 0 to 3 has distance 3. Path 0→1→3 uses edges [0,1,1] and [1,3,2]. Alternative path 0→2→3 has distance 5, so edges [0,2,4] and [2,3,1] are not on shortest paths.

Example 2 — Multiple Shortest Paths

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

› Output: [true,true,true,true]

💡 Note: Two shortest paths exist: 0→1→3 (distance 2) and 0→2→3 (distance 2). All edges participate in at least one shortest path.

Example 3 — Disconnected Graph

$ Input: n = 3, edges = [[0,1,1]]

› Output: [false]

💡 Note: No path exists from 0 to 2, so no edge can be part of a shortest path from 0 to n-1.

Constraints

2 ≤ n ≤ 1000
1 ≤ edges.length ≤ 5000
edges[i] = [a_i, b_i, w_i]
0 ≤ a_i, b_i < n
a_i ≠ b_i
1 ≤ w_i ≤ 10⁵

Visualization

Tap to expand

Asked in

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

The key insight is to use Dijkstra's algorithm twice: once from the source and once from the destination. An edge is on a shortest path if the distance through that edge equals the shortest path distance. Best approach is Dijkstra with bidirectional check. Time: O((V + E) log V), Space: O(V + E)

Common Approaches

✓ All Paths Enumeration

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

Generate all possible paths from source to destination using DFS, keep track of shortest path length, then identify which edges appear in any shortest path.

Dijkstra with Path Reconstruction

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

First run Dijkstra from source to get shortest distances. Then for each edge, check if it could be part of any shortest path by verifying if dist[u] + weight + dist[v] equals shortest path distance.

All Paths Enumeration — Algorithm Steps

Step 1: Use DFS to find all paths from 0 to n-1
Step 2: Track the minimum path distance found
Step 3: Mark edges that appear in any path with minimum distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edge array

DFS All Paths

Find every possible path from 0 to n-1

Filter Shortest

Keep only paths with minimum distance and mark their edges

Code -

solution.c — C

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

#define MAX_NODES 1000
#define MAX_EDGES 10000
#define MAX_PATHS 10000

typedef struct {
    int neighbor;
    int weight;
    int edgeIdx;
} Edge;

typedef struct {
    int distance;
    int usedEdges[MAX_EDGES];
    int edgeCount;
} Path;

Edge graph[MAX_NODES][MAX_NODES];
int graphSize[MAX_NODES];
Path allPaths[MAX_PATHS];
int pathCount = 0;

void dfs(int node, int target, bool* path, int distance, int* usedEdges, int edgeCount) {
    if (node == target) {
        allPaths[pathCount].distance = distance;
        allPaths[pathCount].edgeCount = edgeCount;
        for (int i = 0; i < edgeCount; i++) {
            allPaths[pathCount].usedEdges[i] = usedEdges[i];
        }
        pathCount++;
        return;
    }
    
    for (int i = 0; i < graphSize[node]; i++) {
        Edge e = graph[node][i];
        if (!path[e.neighbor]) {
            path[e.neighbor] = true;
            usedEdges[edgeCount] = e.edgeIdx;
            dfs(e.neighbor, target, path, distance + e.weight, usedEdges, edgeCount + 1);
            path[e.neighbor] = false;
        }
    }
}

bool* solution(int n, int edges[][3], int edgeCount) {
    bool* result = (bool*)calloc(edgeCount, sizeof(bool));
    
    if (n <= 1) return result;
    
    memset(graphSize, 0, sizeof(graphSize));
    pathCount = 0;
    
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1], w = edges[i][2];
        
        graph[u][graphSize[u]].neighbor = v;
        graph[u][graphSize[u]].weight = w;
        graph[u][graphSize[u]].edgeIdx = i;
        graphSize[u]++;
        
        graph[v][graphSize[v]].neighbor = u;
        graph[v][graphSize[v]].weight = w;
        graph[v][graphSize[v]].edgeIdx = i;
        graphSize[v]++;
    }
    
    bool path[MAX_NODES] = {false};
    int usedEdges[MAX_EDGES];
    path[0] = true;
    
    dfs(0, n - 1, path, 0, usedEdges, 0);
    
    if (pathCount == 0) return result;
    
    int minDist = allPaths[0].distance;
    for (int i = 1; i < pathCount; i++) {
        if (allPaths[i].distance < minDist) {
            minDist = allPaths[i].distance;
        }
    }
    
    for (int i = 0; i < pathCount; i++) {
        if (allPaths[i].distance == minDist) {
            for (int j = 0; j < allPaths[i].edgeCount; j++) {
                result[allPaths[i].usedEdges[j]] = true;
            }
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    fgets(line, sizeof(line), stdin);
    
    int edges[MAX_EDGES][3];
    int edgeCount = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                sscanf(ptr, "%d,%d,%d", &edges[edgeCount][0], &edges[edgeCount][1], &edges[edgeCount][2]);
                edgeCount++;
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr) ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    bool* result = solution(n, edges, edgeCount);
    
    printf("[");
    for (int i = 0; i < edgeCount; i++) {
        printf("%s", result[i] ? "true" : "false");
        if (i < edgeCount - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

DFS explores all possible paths, which can be exponential in worst case

⚠ Quadratic Growth

Space Complexity

O(2^n)

Stores all possible paths in memory plus recursion stack

⚠ Quadratic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

245 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

All Paths Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler