Find Edges in Shortest Paths - Practice Coding Problems

Find Edges in Shortest Paths - Problem

Imagine you're a network engineer designing optimal routes through a communication network. You have an undirected weighted graph representing n network nodes (numbered from 0 to n-1) connected by m communication links.

Each link is represented as edges[i] = [a_i, b_i, w_i], meaning there's a connection between nodes a_i and b_i with transmission cost w_i.

Your mission: Find all the critical communication links that are part of at least one shortest path from the source node 0 to the destination node n-1.

Goal: Return a boolean array answer where answer[i] is true if edge edges[i] lies on at least one shortest path from node 0 to node n-1.

Note: The network might be disconnected, so some paths may not exist!

Input & Output

example_1.py — Simple Path

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

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

💡 Note: The shortest path from 0 to 3 has length 9 and follows route 0→1→2→3 with cost 4+2+3=9. The alternative route 0→4→3 has cost 5+6=11, so edges involving node 4 are not part of any shortest path.

example_2.py — 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: There are two shortest paths from 0 to 3, both with length 2: path 0→1→3 and path 0→2→3. Since every edge participates in at least one shortest path, all edges are marked as true.

example_3.py — Disconnected Graph

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

› Output: [false, false]

💡 Note: Node 0 and node 3 are in different connected components, so no path exists between them. Therefore, no edge can be part of a shortest path from 0 to 3.

Constraints

2 ≤ n ≤ 10⁴
0 ≤ edges.length ≤ min(10⁴, n * (n - 1) / 2)
edges[i].length == 3
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
1 ≤ w_i ≤ 10⁶
No multi-edges or self-loops
The graph may be disconnected

Visualization

Tap to expand

Understanding the Visualization

🏁 Forward Scan

Calculate shortest distances from source to all nodes using Dijkstra's algorithm

🎯 Backward Scan

Calculate shortest distances from destination back to all nodes

🔍 Edge Analysis

For each network link, check if it's part of an optimal route using the distance formula

✅ Critical Path Identification

Mark all links that contribute to at least one shortest path

Key Takeaway

🎯 Key Insight: An edge is critical if it lies on at least one shortest path. We can determine this efficiently by checking if the sum of distances (source→edge_start + edge_weight + edge_end→destination) equals the overall shortest path length.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 31

The optimal solution uses Two-Pass Dijkstra algorithm. We run Dijkstra's algorithm once from the source node and once from the destination node to get shortest distances. Then, for each edge, we check if it lies on a shortest path using the formula: dist_from_source[u] + edge_weight + dist_to_dest[v] == shortest_path_length. Time complexity: O((V + E) log V), Space complexity: O(V + E).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Paths Enumeration)	O(V! * E)	O(V * P)	Find all paths from source to destination and identify which edges appear in shortest ones
Two-Pass Dijkstra (Optimal)	O((V + E) log V)	O(V + E)	Run Dijkstra from both source and destination, then check each edge for shortest path inclusion

Brute Force (All Paths Enumeration) — Algorithm Steps

Use DFS to find all possible paths from node 0 to node n-1
Calculate the length of each path and find the minimum
Filter paths that have the minimum length (shortest paths)
For each edge, check if it appears in any of the shortest paths
Return boolean array indicating which edges are part of shortest paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edge array

Explore All Paths

Use DFS to find every path from source to destination

Find Minimum Cost

Calculate cost of each path and identify shortest ones

Mark Critical Edges

Mark edges that appear in any shortest path

Code -

solution.c — C

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

typedef struct {
    int cost;
    int* edges;
    int edgeCount;
} Path;

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

typedef struct {
    Edge* edges;
    int count;
    int capacity;
} AdjList;

Path* allPaths;
int pathCount;
int pathCapacity;

void dfs(int node, int target, int cost, int* usedEdges, int edgeCount,
         bool* visited, AdjList* graph, int n) {
    if (node == target) {
        if (pathCount >= pathCapacity) {
            pathCapacity *= 2;
            allPaths = realloc(allPaths, pathCapacity * sizeof(Path));
        }
        allPaths[pathCount].cost = cost;
        allPaths[pathCount].edges = malloc(edgeCount * sizeof(int));
        for (int i = 0; i < edgeCount; i++) {
            allPaths[pathCount].edges[i] = usedEdges[i];
        }
        allPaths[pathCount].edgeCount = edgeCount;
        pathCount++;
        return;
    }
    
    for (int i = 0; i < graph[node].count; i++) {
        Edge edge = graph[node].edges[i];
        if (!visited[edge.neighbor]) {
            visited[edge.neighbor] = true;
            usedEdges[edgeCount] = edge.edgeIdx;
            dfs(edge.neighbor, target, cost + edge.weight, usedEdges, edgeCount + 1,
                visited, graph, n);
            visited[edge.neighbor] = false;
        }
    }
}

bool* findEdgesInShortestPaths(int n, int** edges, int edgesSize, int* edgesColSize) {
    bool* result = calloc(edgesSize, sizeof(bool));
    
    if (n <= 1) return result;
    
    AdjList* graph = malloc(n * sizeof(AdjList));
    for (int i = 0; i < n; i++) {
        graph[i].edges = NULL;
        graph[i].count = 0;
        graph[i].capacity = 0;
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1], w = edges[i][2];
        
        if (graph[u].count >= graph[u].capacity) {
            graph[u].capacity = graph[u].capacity == 0 ? 1 : graph[u].capacity * 2;
            graph[u].edges = realloc(graph[u].edges, graph[u].capacity * sizeof(Edge));
        }
        graph[u].edges[graph[u].count++] = (Edge){v, w, i};
        
        if (graph[v].count >= graph[v].capacity) {
            graph[v].capacity = graph[v].capacity == 0 ? 1 : graph[v].capacity * 2;
            graph[v].edges = realloc(graph[v].edges, graph[v].capacity * sizeof(Edge));
        }
        graph[v].edges[graph[v].count++] = (Edge){u, w, i};
    }
    
    pathCount = 0;
    pathCapacity = 10;
    allPaths = malloc(pathCapacity * sizeof(Path));
    
    bool* visited = calloc(n, sizeof(bool));
    int* usedEdges = malloc(edgesSize * sizeof(int));
    
    visited[0] = true;
    dfs(0, n-1, 0, usedEdges, 0, visited, graph, n);
    
    if (pathCount > 0) {
        int minCost = allPaths[0].cost;
        for (int i = 1; i < pathCount; i++) {
            if (allPaths[i].cost < minCost) {
                minCost = allPaths[i].cost;
            }
        }
        
        for (int i = 0; i < pathCount; i++) {
            if (allPaths[i].cost == minCost) {
                for (int j = 0; j < allPaths[i].edgeCount; j++) {
                    result[allPaths[i].edges[j]] = true;
                }
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < pathCount; i++) {
        free(allPaths[i].edges);
    }
    free(allPaths);
    free(visited);
    free(usedEdges);
    for (int i = 0; i < n; i++) {
        free(graph[i].edges);
    }
    free(graph);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(V! * E)

In worst case, we might explore V! different paths, and for each path we check all E edges

✓ Linear Growth

Space Complexity

O(V * P)

We need to store all paths, where P is the number of paths and each path can have up to V vertices

✓ Linear Space

52.3K Views

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (All Paths Enumeration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler