Path Existence Queries in a Graph II

Path Existence Queries in a Graph II - Problem

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

You are given an integer n representing the number of nodes in a graph, labeled from 0 to n - 1. You are also given an integer array nums of length n and an integer maxDiff.

An undirected edge exists between nodes i and j if the absolute difference between nums[i] and nums[j] is at most maxDiff (i.e., |nums[i] - nums[j]| <= maxDiff).

You are also given a 2D integer array queries. For each queries[i] = [u_i, v_i], find the minimum distance between nodes u_i and v_i. If no path exists between the two nodes, return -1 for that query.

Return an array answer, where answer[i] is the result of the ith query.

Note: The edges between the nodes are unweighted.

Input & Output

Example 1 — Basic Path Query

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

› Output: [3]

💡 Note: Nodes connected if |nums[i] - nums[j]| ≤ 2. Path: 0→1→2→3 (distance 3) since |1-3|≤2, |3-5|≤2, |5-7|≤2

Example 2 — No Path Exists

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

› Output: [-1]

💡 Note: No path from node 0 to node 2. Nodes 0,1 connect (|1-3|≤2) but no connection to nodes 2,3 (|3-10|>2)

Example 3 — Multiple Queries

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

› Output: [1,1,1]

💡 Note: All nodes connected: |2-4|≤3, |2-6|≤3, |4-6|≤3. Each query has direct path (distance 1)

Constraints

2 ≤ n ≤ 10⁴
nums.length == n
-10⁹ ≤ nums[i] ≤ 10⁹
0 ≤ maxDiff ≤ 10⁹
1 ≤ queries.length ≤ 10⁴
queries[i].length == 2
0 ≤ u_i, v_i < n

Visualization

Tap to expand

Asked in

G Google 35 M Meta 28 a Amazon 22

The key insight is to model this as a graph where edges exist between nodes with value differences ≤ maxDiff, then use BFS to find shortest paths. The optimized approach sorts nodes by values to reduce graph construction time from O(n²) to O(n log n + n×k). Time: O(n² + q×n), Space: O(n + e)

Common Approaches

✓ Build Graph + BFS for Each Query

⏱️ Time: O(n² + q × (n + e)) Space: O(n + e)

First construct the graph by checking all pairs of nodes to see if they should be connected based on maxDiff. Then for each query, perform BFS to find the shortest path.

Optimized Graph Construction with Sorting

⏱️ Time: O(n log n + n × k + q × (n + e)) Space: O(n + e)

Instead of checking all O(n²) pairs, sort nodes by their values and only check nearby nodes within maxDiff range. This reduces the graph construction time significantly.

Build Graph + BFS for Each Query — Algorithm Steps

Build adjacency list by checking all node pairs
For each query, run BFS from source to target
Return distance found or -1 if no path exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Connect nodes where |nums[i] - nums[j]| ≤ maxDiff

BFS Search

Start from source node, explore neighbors level by level

Find Target

Return distance when target is reached, or -1 if unreachable

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_QUEUE 10000

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

typedef struct {
    int data[MAX_QUEUE][2];
    int front, rear;
} Queue;

void initQueue(Queue* q) {
    q->front = q->rear = 0;
}

bool isEmpty(Queue* q) {
    return q->front == q->rear;
}

void enqueue(Queue* q, int node, int dist) {
    q->data[q->rear][0] = node;
    q->data[q->rear][1] = dist;
    q->rear++;
}

void dequeue(Queue* q, int* node, int* dist) {
    *node = q->data[q->front][0];
    *dist = q->data[q->front][1];
    q->front++;
}

int* solution(int n, int* nums, int maxDiff, int** queries, int queriesSize, int* returnSize) {
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
    }

    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;
            }
        }
    }

    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;

    for (int q = 0; q < queriesSize; q++) {
        int start = queries[q][0];
        int end = queries[q][1];

        if (start == end) {
            result[q] = 0;
            continue;
        }

        Queue queue;
        initQueue(&queue);
        for (int i = 0; i < n; i++) {
            visited[i] = false;
        }

        enqueue(&queue, start, 0);
        visited[start] = true;

        int found = -1;
        while (!isEmpty(&queue) && found == -1) {
            int node, dist;
            dequeue(&queue, &node, &dist);

            for (int i = 0; i < graphSize[node]; i++) {
                int neighbor = graph[node][i];
                if (neighbor == end) {
                    found = dist + 1;
                    break;
                }
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    enqueue(&queue, neighbor, dist + 1);
                }
            }
        }

        result[q] = found;
    }

    return result;
}

int main() {
    static char line[10000];
    static int nums[MAX_N];

    int n;
    fgets(line, sizeof(line), stdin);
    n = atoi(line);

    fgets(line, sizeof(line), stdin);
    int numsSize = 0;
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        char* endptr;
        int num = (int)strtol(p, &endptr, 10);
        if (p != endptr) {
            nums[numsSize++] = num;
            p = endptr;
        } else {
            p++;
        }
    }

    int maxDiff;
    fgets(line, sizeof(line), stdin);
    maxDiff = atoi(line);

    fgets(line, sizeof(line), stdin);
    static int queryData[1000][2];
    int** queries = (int**)malloc(1000 * sizeof(int*));
    int queriesSize = 0;

    p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;

    while (*p) {
        while (*p && *p != '[') p++;
        if (!*p) break;
        p++;

        char* endptr;
        int first = (int)strtol(p, &endptr, 10);
        if (p == endptr) break;
        p = endptr;

        while (*p == ' ' || *p == ',') p++;

        int second = (int)strtol(p, &endptr, 10);
        if (p == endptr) break;
        p = endptr;

        while (*p && *p != ']') p++;
        if (*p == ']') p++;

        queryData[queriesSize][0] = first;
        queryData[queriesSize][1] = second;
        queries[queriesSize] = queryData[queriesSize];
        queriesSize++;
    }

    int returnSize;
    int* result = solution(n, nums, maxDiff, queries, queriesSize, &returnSize);

    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");

    free(result);
    free(queries);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

O(n²) to build graph, O(q × (n + e)) for q queries each doing BFS over n nodes and e edges

⚡ Linearithmic

Space Complexity

O(n + e)

Adjacency list stores up to e edges, plus O(n) for BFS queue and visited array

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Build Graph + BFS for Each Query — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler