Checking Existence of Edge Length Limited Paths

Checking Existence of Edge Length Limited Paths - Problem

You're working with a weighted undirected graph where nodes represent cities and edges represent roads with specific distances. Your task is to answer multiple queries asking: "Can I travel from city A to city B using only roads shorter than a given limit?"

Given:

edgeList: An array where edgeList[i] = [u_i, v_i, dis_i] represents a road between cities u_i and v_i with distance dis_i
queries: An array where queries[j] = [p_j, q_j, limit_j] asks if there's a path from p_j to q_j using only edges with distance strictly less than limit_j

Goal: Return a boolean array indicating whether each query has a valid path.

Note: Multiple edges between the same pair of nodes are allowed, and you need to find if any valid path exists, not necessarily the shortest one.

Input & Output

example_1.py — Basic Graph

$ Input: n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]

› Output: [false, true]

💡 Note: For query [0,1,2]: No edge between 0 and 1 has weight < 2. For query [0,2,5]: Path 0→1→2 uses edges with weights 2 and 4, both < 5.

example_2.py — Disconnected Components

$ Input: n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]

› Output: [true, false]

💡 Note: For query [0,4,14]: Path 0→1→2→3→4 uses edges [10,5,9,13], all < 14. For query [1,4,13]: Edge 3→4 has weight 13, not < 13.

example_3.py — Multiple Edges

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

› Output: [true, true]

💡 Note: Multiple edges exist between nodes 0 and 1. For both queries, the edge with weight 3 can be used since 3 < 4 and 3 < 6.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with isolated cities, sort roads by danger level

Process Query

Add all roads with danger level below current query threshold

Connect Cities

Use Union-Find to efficiently connect cities via safe roads

Check Route

Verify if emergency vehicle can reach destination

Key Takeaway

🎯 Key Insight: By sorting both edges and queries, we can process them incrementally, building connectivity efficiently with Union-Find while avoiding redundant work across similar queries.

Time & Space Complexity

Time Complexity

⏱️

O(Q × (V + E))

Q queries, each requiring O(V + E) graph traversal in worst case

✓ Linear Growth

Space Complexity

O(V)

Space for visited array and recursion stack during DFS

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
0 ≤ edgeList.length, queries.length ≤ 10⁵
edgeList[i].length == 3
queries[j].length == 3
0 ≤ u_i, v_i, p_j, q_j ≤ n - 1
u_i ≠ v_i
p_j ≠ q_j
1 ≤ dis_i, limit_j ≤ 10⁹
Note: There may be multiple edges between two nodes

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses Union-Find with offline query processing. Sort edges by weight and queries by limit, then incrementally add edges while checking connectivity. This achieves O((E + Q) log(E + Q)) time complexity, much better than the brute force O(Q × (V + E)) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS for Each Query)	O(Q × (V + E))	O(V)	For each query, perform DFS/BFS using only edges below the limit
Union-Find with Sorted Processing (Optimal)	O((E + Q) log(E + Q))	O(V + Q)	Sort edges and queries, use Union-Find to incrementally build connectivity

Brute Force (DFS for Each Query) — Algorithm Steps

For each query [p, q, limit]
Start DFS/BFS from node p
Only traverse edges with weight < limit
Check if we can reach node q
Store the result and continue to next query

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Query

Begin DFS from source node for current query

Filter Edges

Only consider edges with weight less than limit

Explore Path

Recursively visit connected nodes

Check Target

Return true if target is reached, false otherwise

Code -

solution.c — C

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

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

bool dfs(int node, int target, int limit, bool* visited, Edge** graph) {
    if (node == target) return true;
    visited[node] = true;
    
    Edge* curr = graph[node];
    while (curr) {
        if (curr->weight < limit && !visited[curr->node]) {
            if (dfs(curr->node, target, limit, visited, graph)) {
                return true;
            }
        }
        curr = curr->next;
    }
    return false;
}

bool* distanceLimitedPathsExist(int n, int** edgeList, int edgeListSize, int* edgeListColSize, 
                               int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    // Build adjacency list
    Edge** graph = (Edge**)calloc(n, sizeof(Edge*));
    
    for (int i = 0; i < edgeListSize; i++) {
        int u = edgeList[i][0], v = edgeList[i][1], w = edgeList[i][2];
        
        Edge* edge1 = (Edge*)malloc(sizeof(Edge));
        edge1->node = v; edge1->weight = w; edge1->next = graph[u];
        graph[u] = edge1;
        
        Edge* edge2 = (Edge*)malloc(sizeof(Edge));
        edge2->node = u; edge2->weight = w; edge2->next = graph[v];
        graph[v] = edge2;
    }
    
    bool* result = (bool*)malloc(queriesSize * sizeof(bool));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        bool* visited = (bool*)calloc(n, sizeof(bool));
        result[i] = dfs(queries[i][0], queries[i][1], queries[i][2], visited, graph);
        free(visited);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × (V + E))

Q queries, each requiring O(V + E) graph traversal in worst case

✓ Linear Growth

Space Complexity

O(V)

Space for visited array and recursion stack during DFS

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
0 ≤ edgeList.length, queries.length ≤ 10⁵
edgeList[i].length == 3
queries[j].length == 3
0 ≤ u_i, v_i, p_j, q_j ≤ n - 1
u_i ≠ v_i
p_j ≠ q_j
1 ≤ dis_i, limit_j ≤ 10⁹
Note: There may be multiple edges between two nodes

31.3K Views

Medium-High Frequency

~25 min Avg. Time

847 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 for Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler