Path Existence Queries in a Graph II - Practice Coding Problems

Path Existence Queries in a Graph II - Problem

Array Two Pointers Binary Search Dynamic Programming Greedy Bit Manipulation Graph Sorting Hard

Path Existence Queries in a Graph II

Imagine you're building a social network where people are connected based on how similar their interests are! 🌐

You're given n people (nodes 0 to n-1) in a network, where each person has an interest score stored in array nums. Two people are connected (have an edge between them) if their interest scores are similar enough - specifically, if the absolute difference between their scores is at most maxDiff.

Your task: For each query [u, v], find the shortest path (minimum number of connections) between person u and person v. If they can't be connected through any chain of friendships, return -1.

Input:
• n: number of people
• nums: array of interest scores
• maxDiff: maximum allowed difference for connection
• queries: pairs of people to check

Output: Array of shortest distances for each query

Input & Output

example_1.py — Basic Example

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

› Output: [1, 1, 2]

💡 Note: Graph edges: 0-1 (|1-3|=2≤2), 1-2 (|3-5|=2≤2), 0-3 (|1-2|=1≤2). Query [0,3]: direct connection, distance=1. Query [1,2]: direct connection, distance=1. Query [0,2]: path 0→1→2, distance=2.

example_2.py — Disconnected Components

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

› Output: [-1, 1]

💡 Note: Graph edges: 1-3 (|5-6|=1≤3). Node 0 (val=1) and node 2 (val=10) are in separate components, so distance=-1. Nodes 1 and 3 are directly connected, distance=1.

example_3.py — Self Query

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

› Output: [0, -1]

💡 Note: No edges exist since all differences > 1. Query [0,0]: same node, distance=0. Query [1,2]: no path exists since |4-6|=2>1, distance=-1.

Constraints

2 ≤ n ≤ 300
1 ≤ nums.length = n
1 ≤ nums[i] ≤ 10⁶
0 ≤ maxDiff ≤ 10⁶
1 ≤ queries.length ≤ 10⁵
queries[i] = [u_i, v_i] where 0 ≤ u_i, v_i < n

Visualization

Tap to expand

Understanding the Visualization

Create Connections

Connect people whose interest scores differ by at most maxDiff

Find Shortest Path

Use BFS to find the minimum number of connections between two people

Handle Queries

Answer multiple queries efficiently using the prebuilt network

Key Takeaway

🎯 Key Insight: Build the graph once during preprocessing, then use BFS for efficient shortest path queries. This transforms an O(Q×n²) problem into O(n² + Q×n) by avoiding repeated graph construction.

Asked in

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

The optimal approach involves preprocessing the graph once by checking all pairs of nodes and creating edges where |nums[i] - nums[j]| ≤ maxDiff. Then for each query, run BFS on the prebuilt graph to find the shortest path. Time complexity: O(n² + Q × (n + E)) where Q is the number of queries.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Build Graph + BFS for Each Query)	O(Q × n²)	O(n²)	Build the complete graph and run BFS for each query independently
Preprocessing + BFS (Optimal)	O(n² + Q × (n + E))	O(n²)	Build the graph once, then use BFS for each query on the prebuilt graph

Brute Force (Build Graph + BFS for Each Query) — Algorithm Steps

For each query, build adjacency list by checking all node pairs
Check if |nums[i] - nums[j]| <= maxDiff to create edges
Run BFS from source to target to find shortest path
Return path length or -1 if no path exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Complete Graph

For each query, check all pairs of nodes to build edges

Run BFS

Use breadth-first search to find shortest path

Repeat for Next Query

Rebuild graph and run BFS again (inefficient!)

Code -

solution.c — C

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

typedef struct {
    int node;
    int dist;
} QueueItem;

int* solution(int n, int* nums, int maxDiff, int** queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    for (int q = 0; q < queriesSize; q++) {
        int start = queries[q][0];
        int end = queries[q][1];
        
        if (start == end) {
            result[q] = 0;
            continue;
        }
        
        // Build adjacency list
        int** graph = (int**)malloc(n * sizeof(int*));
        int* graphSize = (int*)calloc(n, sizeof(int));
        
        for (int i = 0; i < n; i++) {
            graph[i] = (int*)malloc(n * sizeof(int));
        }
        
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (abs(nums[i] - nums[j]) <= maxDiff) {
                    graph[i][graphSize[i]++] = j;
                    graph[j][graphSize[j]++] = i;
                }
            }
        }
        
        // BFS
        QueueItem* queue = (QueueItem*)malloc(n * sizeof(QueueItem));
        int* visited = (int*)calloc(n, sizeof(int));
        int front = 0, rear = 0;
        
        queue[rear++] = (QueueItem){start, 0};
        visited[start] = 1;
        
        int found = -1;
        while (front < rear && found == -1) {
            QueueItem current = queue[front++];
            
            for (int i = 0; i < graphSize[current.node]; i++) {
                int neighbor = graph[current.node][i];
                if (neighbor == end) {
                    found = current.dist + 1;
                    break;
                }
                if (!visited[neighbor]) {
                    visited[neighbor] = 1;
                    queue[rear++] = (QueueItem){neighbor, current.dist + 1};
                }
            }
        }
        
        result[q] = found;
        
        // Cleanup
        for (int i = 0; i < n; i++) {
            free(graph[i]);
        }
        free(graph);
        free(graphSize);
        free(queue);
        free(visited);
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × n²)

Q queries, each requiring O(n²) to build graph and O(n²) for BFS

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency list can have O(n²) edges in worst case

⚠ Quadratic Space

43.7K Views

Medium-High Frequency

~25 min Avg. Time

1.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Build Graph + BFS for Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler