Checking Existence of Edge Length Limited Paths II

Checking Existence of Edge Length Limited Paths II - Problem

Imagine you're designing a smart navigation system for a delivery network where roads have different weight limits. You need to quickly answer queries about whether packages can be delivered between two locations using only roads that can handle weights strictly less than a given limit.

You're given an undirected graph with n nodes representing locations, defined by edgeList where edgeList[i] = [ui, vi, disi] represents a road between locations ui and vi with weight capacity disi. Note that there may be multiple roads between two locations, and some locations might be unreachable from others.

Your task: Implement the DistanceLimitedPathsExist class that can efficiently answer multiple queries about path existence under weight constraints.

The class should support:

DistanceLimitedPathsExist(int n, int[][] edgeList) - Initialize with the graph
boolean query(int p, int q, int limit) - Return true if there's a path from p to q using only edges with weight strictly less than limit

Input & Output

example_1.py — Basic Connectivity

$ Input: n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]] Queries: query(0, 1, 2), query(0, 2, 5)

› Output: [false, true]

💡 Note: First query: limit=2, no edges < 2 exist, so 0 and 1 not connected. Second query: limit=5, edges [0,1,2] and [1,2,4] both < 5, creating path 0->1->2.

example_2.py — Multiple Components

$ Input: n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]] Queries: query(0, 4, 14), query(1, 4, 13)

› Output: [true, false]

💡 Note: First query: All edges < 14, path exists 0->1->2->3->4. Second query: Edge [3,4,13] not usable (13 ≥ 13), so nodes 1 and 4 disconnected.

example_3.py — Same Node Query

$ Input: n = 2, edgeList = [[0,1,20]] Queries: query(0, 0, 10)

› Output: [true]

💡 Note: Querying connectivity from a node to itself always returns true, regardless of edge constraints.

Visualization

Tap to expand

Understanding the Visualization

Network Setup

Create delivery network with weighted road connections

Sort by Capacity

Organize roads by their weight capacity limits

Build Route Map

For each query, include only suitable roads in the route map

Check Connectivity

Use Union-Find to verify if source and destination are connected

Key Takeaway

🎯 Key Insight: By sorting edges by weight and using Union-Find, we can efficiently determine connectivity under weight constraints, making this approach optimal for handling multiple queries on the same graph structure.

Time & Space Complexity

Time Complexity

⏱️

O((E + Q) log(E + Q) + (E + Q)α(V))

Sorting edges and queries, plus Union-Find operations with inverse Ackermann function

⚡ Linearithmic

Space Complexity

O(V + E + Q)

Union-Find structure, sorted arrays, and result storage

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁴
0 ≤ edgeList.length ≤ min(n*(n-1)/2, 10⁴)
edgeList[i].length == 3
0 ≤ u_i, v_i, p, q ≤ n-1
u_i != v_i
0 ≤ dis_i, limit ≤ 10⁹
At most 10⁴ calls will be made to query

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses Union-Find (Disjoint Set Union) with sorted edges to efficiently handle multiple queries. By sorting edges by weight and processing them incrementally for each query limit, we achieve O((E+Q)α(V)) amortized time complexity per query, where α is the inverse Ackermann function. This approach significantly outperforms naive DFS for each query, especially when handling many queries on the same graph.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find with Offline Query Processing (Optimal)	O((E + Q) log(E + Q) + (E + Q)α(V))	O(V + E + Q)	Sort edges and queries, process with Union-Find for O((E+Q)α(V)) complexity
Brute Force (DFS for Each Query)	O(Q × (V + E))	O(V + E)	For each query, run DFS using only edges below the limit

Union-Find with Offline Query Processing (Optimal) — Algorithm Steps

Sort edges by weight in ascending order
Sort queries by limit in ascending order (keep original indices)
Process queries in order, adding valid edges to Union-Find
For each query limit, add all edges with weight < limit
Check if source and destination are in same connected component
Store results and return in original query order

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Edges

Sort all edges by weight in ascending order

Initialize UF

Reset Union-Find with each node as its own parent

Add Valid Edges

Process edges with weight < limit, union connected nodes

Check Connectivity

Verify if source and destination have same root parent

Code -

solution.c — C

typedef struct {
    int n;
    int** edges;
    int edgeCount;
    int* parent;
    int* rank;
} DistanceLimitedPathsExist;

int compareEdges(const void* a, const void* b) {
    int* edgeA = *(int**)a;
    int* edgeB = *(int**)b;
    return edgeA[2] - edgeB[2];
}

int find(DistanceLimitedPathsExist* obj, int x) {
    if (obj->parent[x] != x) {
        obj->parent[x] = find(obj, obj->parent[x]);
    }
    return obj->parent[x];
}

void unionSets(DistanceLimitedPathsExist* obj, int x, int y) {
    int px = find(obj, x), py = find(obj, y);
    if (px == py) return;
    
    if (obj->rank[px] < obj->rank[py]) {
        obj->parent[px] = py;
    } else if (obj->rank[px] > obj->rank[py]) {
        obj->parent[py] = px;
    } else {
        obj->parent[py] = px;
        obj->rank[px]++;
    }
}

DistanceLimitedPathsExist* distanceLimitedPathsExistCreate(int n, int** edgeList, int edgeListSize, int* edgeListColSize) {
    DistanceLimitedPathsExist* obj = (DistanceLimitedPathsExist*)malloc(sizeof(DistanceLimitedPathsExist));
    obj->n = n;
    obj->edges = edgeList;
    obj->edgeCount = edgeListSize;
    obj->parent = (int*)malloc(n * sizeof(int));
    obj->rank = (int*)malloc(n * sizeof(int));
    
    qsort(obj->edges, edgeListSize, sizeof(int*), compareEdges);
    
    return obj;
}

bool distanceLimitedPathsExistQuery(DistanceLimitedPathsExist* obj, int p, int q, int limit) {
    // Reset Union-Find
    for (int i = 0; i < obj->n; i++) {
        obj->parent[i] = i;
        obj->rank[i] = 0;
    }
    
    // Add all edges with weight < limit
    for (int i = 0; i < obj->edgeCount; i++) {
        if (obj->edges[i][2] >= limit) break;
        unionSets(obj, obj->edges[i][0], obj->edges[i][1]);
    }
    
    return find(obj, p) == find(obj, q);
}

Time & Space Complexity

Time Complexity

⏱️

O((E + Q) log(E + Q) + (E + Q)α(V))

Sorting edges and queries, plus Union-Find operations with inverse Ackermann function

⚡ Linearithmic

Space Complexity

O(V + E + Q)

Union-Find structure, sorted arrays, and result storage

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁴
0 ≤ edgeList.length ≤ min(n*(n-1)/2, 10⁴)
edgeList[i].length == 3
0 ≤ u_i, v_i, p, q ≤ n-1
u_i != v_i
0 ≤ dis_i, limit ≤ 10⁹
At most 10⁴ calls will be made to query

23.5K Views

Medium 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

Union-Find with Offline Query Processing (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler