Checking Existence of Edge Length Limited Paths II - 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, and the graph may not be connected.

Implement the DistanceLimitedPathsExist class:

DistanceLimitedPathsExist(int n, int[][] edgeList) Initializes the class with an undirected graph.
boolean query(int p, int q, int limit) Returns true if there exists a path from p to q such that each edge on the path has a distance strictly less than limit, and otherwise false.

Input & Output

Example 1 — Basic Graph

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

› Output: [false,true]

💡 Note: Query 1: path 0→3 with limit 2. Only edge (1,2) and (2,3) have weight < 2, but 0 is not connected. Query 2: path 0→3 with limit 4. Edges (0,1), (1,2), (2,3) all have weight < 4, so path 0→1→2→3 exists.

Example 2 — No Valid Path

$ Input: n = 3, edges = [[0,1,10],[1,2,5]], queries = [[0,2,3]]

› Output: [false]

💡 Note: Query: path 0→2 with limit 3. All edges have weight ≥ 3, so no valid path exists.

Example 3 — Direct Connection

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

› Output: [true,false]

💡 Note: Query 1: path 0→1 with limit 3. Edge weight 2 < 3, so direct path exists. Query 2: path 0→1 with limit 1. Edge weight 2 ≥ 1, so no valid path.

Constraints

2 ≤ n ≤ 10⁴
0 ≤ edges.length ≤ 10⁴
edges[i].length == 3
0 ≤ ui, vi < n
ui ≠ vi
0 ≤ disi ≤ 10⁹
0 ≤ queries.length ≤ 10⁴
queries[j].length == 3
0 ≤ pj, qj < n
pj ≠ qj
0 ≤ limitj ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

This problem requires checking connectivity between nodes using only edges with weight below a limit. The key insight is to use Union-Find with offline processing: sort edges by weight and queries by limit, then process them together to avoid rebuilding the graph for each query. Best approach is Union-Find with sorting. Time: O((E + Q) log (E + Q)), Space: O(N + Q)

Common Approaches

✓ One Pass Hash

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

Brute Force DFS

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

For each query, build a subgraph containing only edges with weight strictly less than the limit, then perform DFS to check connectivity between the two nodes.

Union-Find with Offline Processing

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

Sort edges by weight and queries by limit. Process them together, adding valid edges to Union-Find and answering queries when all edges with weight < limit have been added.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

static int graph[MAX_N][MAX_N];
static int graph_size[MAX_N];
static bool visited[MAX_N];

bool dfs(int node, int target, int n) {
    if (node == target) return true;
    visited[node] = true;
    
    for (int i = 0; i < graph_size[node]; i++) {
        int neighbor = graph[node][i];
        if (!visited[neighbor] && dfs(neighbor, target, n)) {
            return true;
        }
    }
    return false;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin); // consume newline
    
    // Read edges
    fgets(line, sizeof(line), stdin);
    int edges[MAX_EDGES][3];
    int edge_count = 0;
    
    char *ptr = strchr(line, '[');
    if (ptr && *(ptr + 1) != ']') {
        ptr++;
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                edges[edge_count][0] = strtol(ptr, &ptr, 10);
                ptr++; // skip comma
                edges[edge_count][1] = strtol(ptr, &ptr, 10);
                ptr++; // skip comma
                edges[edge_count][2] = strtol(ptr, &ptr, 10);
                edge_count++;
            }
            ptr++;
        }
    }
    
    // Read queries
    fgets(line, sizeof(line), stdin);
    int queries[MAX_QUERIES][3];
    int query_count = 0;
    
    ptr = strchr(line, '[');
    if (ptr && *(ptr + 1) != ']') {
        ptr++;
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                queries[query_count][0] = strtol(ptr, &ptr, 10);
                ptr++; // skip comma
                queries[query_count][1] = strtol(ptr, &ptr, 10);
                ptr++; // skip comma
                queries[query_count][2] = strtol(ptr, &ptr, 10);
                query_count++;
            }
            ptr++;
        }
    }
    
    // Process queries
    printf("[");
    for (int q = 0; q < query_count; q++) {
        if (q > 0) printf(",");
        
        int p = queries[q][0];
        int target = queries[q][1];
        int limit = queries[q][2];
        
        // Reset graph
        for (int i = 0; i < n; i++) {
            graph_size[i] = 0;
            visited[i] = false;
        }
        
        // Build graph with edges having distance < limit
        for (int i = 0; i < edge_count; i++) {
            int u = edges[i][0];
            int v = edges[i][1];
            int dist = edges[i][2];
            if (dist < limit) {
                graph[u][graph_size[u]++] = v;
                graph[v][graph_size[v]++] = u;
            }
        }
        
        // DFS to check connectivity
        bool result = dfs(p, target, n);
        printf("%s", result ? "true" : "false");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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