Path Existence Queries in a Graph I - Practice Coding Problems

Path Existence Queries in a Graph I - Problem

Path Existence Queries in a Graph

Imagine you're building a social network where people can only be friends if their interests are similar enough! You have n users numbered from 0 to n-1, each with a compatibility score stored in the sorted array nums.

Two users i and j can be directly connected (friends) if the absolute difference between their scores is at most maxDiff: |nums[i] - nums[j]| ≤ maxDiff.

But here's the interesting part: users can also be indirectly connected through mutual friends! If user A is friends with user B, and user B is friends with user C, then A and C are connected through B.

Given multiple queries asking whether two users are connected (directly or indirectly), your task is to return a boolean array indicating the connectivity for each query.

Input & Output

example_1.py — Basic connectivity

$ Input: n = 5, nums = [1, 3, 5, 7, 9], maxDiff = 2, queries = [[0, 1], [1, 2], [0, 4]]

› Output: [true, true, false]

💡 Note: Node 0 (value=1) connects to node 1 (value=3) since |1-3|=2 ≤ maxDiff. Node 1 connects to node 2 (value=5). So 0→1→2 forms a path. But node 4 (value=9) is isolated since |7-9|=2 but there's no path from component {0,1,2,3} to {4}.

example_2.py — All connected

$ Input: n = 4, nums = [2, 4, 6, 8], maxDiff = 3, queries = [[0, 3], [1, 2]]

› Output: [true, true]

💡 Note: With maxDiff=3, we have connections: 0↔1 (|2-4|=2), 1↔2 (|4-6|=2), 2↔3 (|6-8|=2). This creates one connected component containing all nodes, so all queries return true.

example_3.py — No connections

$ Input: n = 3, nums = [1, 10, 20], maxDiff = 2, queries = [[0, 1], [0, 2], [1, 2]]

› Output: [false, false, false]

💡 Note: No two nodes can connect since all value differences exceed maxDiff=2. Each node forms its own isolated component, so all connectivity queries return false.

Constraints

2 ≤ n ≤ 10⁵
nums.length == n
0 ≤ nums[i] ≤ 10⁹
nums is sorted in non-decreasing order
0 ≤ maxDiff ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ queries[i][0], queries[i][1] < n

Visualization

Tap to expand

Understanding the Visualization

Initialize Users

Each user starts as their own social circle

Form Friendships

Connect users whose compatibility scores differ by at most maxDiff

Build Communities

Friends-of-friends form larger connected communities

Answer Queries

Check if two users belong to the same social community

Key Takeaway

🎯 Key Insight: Union-Find efficiently groups users into connected communities, allowing instant answers to connectivity queries after initial preprocessing.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses Union-Find (Disjoint Set Union) data structure to efficiently handle connectivity queries. Since the input array is sorted, we can optimize the connection-building phase by breaking early when the difference exceeds maxDiff. The preprocessing takes O(n² × α(n)) time, but each query is answered in nearly constant time, making it ideal for multiple queries.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(n² × α(n) + q × α(n))	O(n)	Use Union-Find data structure to efficiently handle connectivity queries

Union-Find (Optimal) — Algorithm Steps

Initialize Union-Find structure with n components
For each pair (i,j) where |nums[i] - nums[j]| ≤ maxDiff, union them
Since nums is sorted, we can optimize by only checking nearby elements
For each query (u,v), check if find(u) == find(v)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each node starts as its own parent (component)

Union Operations

Connect nodes with value difference ≤ maxDiff

Path Compression

Optimize find operations by flattening tree structure

Query Answer

Two nodes are connected if they have the same root parent

Code -

solution.c — C

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

typedef struct {
    int* parent;
    int* rank;
    int size;
} UnionFind;

UnionFind* createUF(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->size = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    
    return uf;
}

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

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

bool connected(UnionFind* uf, int x, int y) {
    return find(uf, x) == find(uf, y);
}

bool* solution(int n, int* nums, int maxDiff, int** queries, int queryCount) {
    UnionFind* uf = createUF(n);
    
    // Build connections
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (nums[j] - nums[i] > maxDiff) break;
            unionSets(uf, i, j);
        }
    }
    
    bool* result = (bool*)malloc(queryCount * sizeof(bool));
    for (int i = 0; i < queryCount; i++) {
        result[i] = connected(uf, queries[i][0], queries[i][1]);
    }
    
    return result;
}

int main() {
    printf("Union-Find solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × α(n) + q × α(n))

O(n²α(n)) for building connections where α(n) is inverse Ackermann function (nearly constant), plus O(α(n)) per query

⚠ Quadratic Growth

Space Complexity

O(n)

Space for Union-Find parent and rank arrays

⚡ Linearithmic Space

23.8K Views

High Frequency

~25 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

Path Existence Queries in a Graph

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Union-Find (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler