Checking Existence of Edge Length Limited Paths

Checking Existence of Edge Length Limited Paths - Problem

An undirected graph of n nodes is defined by edgeList, where edgeList[i] = [ui, vi, disi] denotes an edge between nodes ui and vi with distance disi. Note that there may be multiple edges between two nodes.

Given an array queries, where queries[j] = [pj, qj, limitj], your task is to determine for each queries[j] whether there is a path between pj and qj such that each edge on the path has a distance strictly less than limitj.

Return a boolean array answer, where answer.length == queries.length and the jth value of answer is true if there is a path for queries[j], and false otherwise.

Input & Output

Example 1 — Basic Connectivity

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

› Output: [true,true]

💡 Note: For query [0,1,10]: Can use edge [0,1,2] since 2 < 10. For query [0,2,5]: Can use path 0→1→2 with edges [0,1,2] and [1,2,4], since both 2 < 5 and 4 < 5.

Example 2 — No Valid Path

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

› Output: [false]

💡 Note: To go from 0 to 4, must use path 0→1→2→3→4. Edge weights are [10,5,20,15]. Since edge [2,3,20] has weight 20 ≥ 14, no valid path exists.

Example 3 — Multiple Valid Paths

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

› Output: [true]

💡 Note: Two paths exist: 0→1→3 (weights 3,1 both < 8) and 0→2→3 (weights 7,2 both < 8). Both paths are valid, so answer is true.

Constraints

1 ≤ 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⁹

Visualization

Tap to expand

Asked in

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

The key insight is to process queries offline by sorting both edges and queries, then using Union-Find to incrementally build connectivity. The brute force DFS approach has O(Q×(V+E)) time complexity, while the optimal Union-Find solution achieves O((E+Q) log (E+Q) + (E+Q)α(V)) time complexity. Best approach is Union-Find with sorting: Time: O((E+Q) log (E+Q)), Space: O(V+Q).

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Brute Force DFS

⏱️ Time: O(Q × (V + E)) Space: O(V)

For each query, perform depth-first search from source to destination, only traversing edges with weight strictly less than the query limit. This checks connectivity for each query independently.

Union-Find with Sorting

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

Sort edges by weight and queries by limit. Process queries offline by building connectivity incrementally using Union-Find as we add edges with increasing weights.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_EDGES 10000
#define MAX_QUERIES 10000

static int parent[MAX_N];
static int rank_arr[MAX_N];
static int edges[MAX_EDGES][3];
static int queries[MAX_QUERIES][4]; // [p, q, limit, orig_idx]
static int result[MAX_QUERIES];

void init_uf(int n) {
    for (int i = 0; i < n; i++) {
        parent[i] = i;
        rank_arr[i] = 0;
    }
}

int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]);
    }
    return parent[x];
}

void union_sets(int x, int y) {
    int px = find(x);
    int py = find(y);
    if (px == py) return;
    
    if (rank_arr[px] < rank_arr[py]) {
        int temp = px;
        px = py;
        py = temp;
    }
    parent[py] = px;
    if (rank_arr[px] == rank_arr[py]) {
        rank_arr[px]++;
    }
}

int connected(int x, int y) {
    return find(x) == find(y);
}

int compare_edges(const void *a, const void *b) {
    int *edge_a = (int *)a;
    int *edge_b = (int *)b;
    return edge_a[2] - edge_b[2];
}

int compare_queries(const void *a, const void *b) {
    int *query_a = (int *)a;
    int *query_b = (int *)b;
    return query_a[2] - query_b[2];
}

void solution(int n, int edge_count, int query_count) {
    // Sort edges by weight
    qsort(edges, edge_count, sizeof(edges[0]), compare_edges);
    
    // Sort queries by limit, keeping track of original indices
    qsort(queries, query_count, sizeof(queries[0]), compare_queries);
    
    // Initialize result array
    for (int i = 0; i < query_count; i++) {
        result[i] = 0;
    }
    
    init_uf(n);
    int edge_idx = 0;
    
    for (int i = 0; i < query_count; i++) {
        int p = queries[i][0];
        int q = queries[i][1];
        int limit = queries[i][2];
        int orig_idx = queries[i][3];
        
        // Add all edges with weight < limit to the union-find
        while (edge_idx < edge_count && edges[edge_idx][2] < limit) {
            int u = edges[edge_idx][0];
            int v = edges[edge_idx][1];
            union_sets(u, v);
            edge_idx++;
        }
        
        // Check if p and q are connected
        result[orig_idx] = connected(p, q);
    }
}

void parse_2d_array(const char* str, int arr[][3], int* count, int cols) {
    *count = 0;
    const char* p = str;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Look for inner '['
        while (*p && *p != '[') p++;
        if (*p != '[') break;
        p++; // skip '['
        
        // Parse numbers in this inner array
        for (int j = 0; j < cols; j++) {
            while (*p == ' ' || *p == ',') p++;
            if (*p == ']') break;
            
            char* endptr;
            arr[*count][j] = (int)strtol(p, &endptr, 10);
            p = endptr;
        }
        
        // Skip to closing ']' of inner array
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
        
        (*count)++;
        
        // Skip comma between arrays
        while (*p == ' ' || *p == ',') p++;
    }
}

int main() {
    char line[100000];
    
    // Read n
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    // Read edgeList
    fgets(line, sizeof(line), stdin);
    int edge_count;
    parse_2d_array(line, edges, &edge_count, 3);
    
    // Read queries and set up indexed queries
    fgets(line, sizeof(line), stdin);
    int temp_queries[MAX_QUERIES][3];
    int query_count;
    parse_2d_array(line, temp_queries, &query_count, 3);
    
    // Set up indexed queries with original indices
    for (int i = 0; i < query_count; i++) {
        queries[i][0] = temp_queries[i][0]; // p
        queries[i][1] = temp_queries[i][1]; // q
        queries[i][2] = temp_queries[i][2]; // limit
        queries[i][3] = i; // orig_idx
    }
    
    // Call solution
    solution(n, edge_count, query_count);
    
    // Print result
    printf("[");
    for (int i = 0; i < query_count; i++) {
        if (i > 0) printf(",");
        printf("%s", result[i] ? "true" : "false");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

23.0K Views

Medium Frequency

~35 min Avg. Time

890 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