Graph Connectivity With Threshold - Practice Coding Problems

Graph Connectivity With Threshold - Problem

Imagine you're a city planner working on a transportation network for n cities numbered from 1 to n. The unique rule for building roads is fascinating: two cities can be directly connected if they share a common divisor greater than a given threshold.

More specifically, cities x and y have a bidirectional road between them if there exists an integer z such that:

x % z == 0 (z divides x)
y % z == 0 (z divides y)
z > threshold

Your task is to answer multiple queries asking whether two cities are connected (directly or through a path of roads). Given n, threshold, and an array of queries where each query is [a, b], return an array of boolean values indicating connectivity.

Goal: Efficiently determine if cities can reach each other through the road network.
Input: Number of cities n, threshold value, and queries array
Output: Boolean array indicating connectivity for each query

Input & Output

example_1.py — Basic connectivity

$ Input: n = 6, threshold = 2, queries = [[1,4],[2,5],[3,6]]

› Output: [false, false, true]

💡 Note: Cities 1 and 4 have no common divisor > 2. Cities 2 and 5 have no common divisor > 2. Cities 3 and 6 share divisor 3 > 2, so they're connected.

example_2.py — Low threshold

$ Input: n = 6, threshold = 0, queries = [[4,5],[3,4]]

› Output: [true, true]

💡 Note: With threshold = 0, many cities are connected. Cities 4 and 5 don't share divisor > 0 directly, but 4 connects to 2,6 and forms a large component. City 3 connects to 6, which connects to other cities.

example_3.py — High threshold edge case

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

› Output: [false, false, false]

💡 Note: Since threshold = 10 > n = 5, no cities can be connected through common divisors. Only self-queries would return true.

Constraints

1 ≤ n ≤ 10⁴
0 ≤ threshold ≤ n
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
1 ≤ a_i, b_i ≤ n
a_i != b_i

Visualization

Tap to expand

Understanding the Visualization

Identify Common Factors

For each divisor greater than threshold, find all cities (multiples) that share this factor

Build Transport Groups

Connect all cities that share the same significant factor using Union-Find

Merge Networks

Cities that share multiple factors get connected through overlapping groups

Answer Queries

Check if two cities belong to the same connected transportation network

Key Takeaway

🎯 Key Insight: Instead of checking all pairs O(n²), group cities by their common divisors using Union-Find. Cities sharing any divisor > threshold will end up in the same connected component, enabling O(1) query responses.

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 28

The optimal solution uses Union-Find with sieve-like optimization. Instead of checking all city pairs for common divisors, we group cities by processing each potential divisor z > threshold and unioning all its multiples. This transforms an O(n² × √n) graph construction into an O(n log log n) grouping problem, with near-constant time queries.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n² * √n + q * (n + m))	O(n²)	For each query, use DFS/BFS to check if cities are connected
Union-Find with Sieve Optimization (Optimal)	O(n log log n + q α(n))	O(n)	Use Union-Find to group cities by common multiples efficiently

Brute Force (Check All Pairs) — Algorithm Steps

For each pair of cities (i,j), check if they share a common divisor > threshold
Build adjacency list representation of the graph
For each query, perform DFS/BFS to check connectivity
Return results for all queries

Visualization

Tap to expand

Step-by-Step Walkthrough

Check All Pairs

Compare every city pair (i,j) where i < j

Find GCD

Calculate greatest common divisor for each pair

Build Graph

Add edge if GCD > threshold

Query Processing

Use BFS/DFS for each connectivity query

Code -

solution.c — C

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

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

bool* areConnected(int n, int threshold, int** queries, int queriesSize, int* returnSize) {
    // Build adjacency matrix
    bool** graph = (bool**)calloc(n + 1, sizeof(bool*));
    for (int i = 0; i <= n; i++) {
        graph[i] = (bool*)calloc(n + 1, sizeof(bool));
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (gcd(i, j) > threshold) {
                graph[i][j] = graph[j][i] = true;
            }
        }
    }
    
    bool* result = (bool*)malloc(queriesSize * sizeof(bool));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int a = queries[q][0], b = queries[q][1];
        if (a == b) {
            result[q] = true;
            continue;
        }
        
        // BFS
        bool* visited = (bool*)calloc(n + 1, sizeof(bool));
        int* queue = (int*)malloc(n * sizeof(int));
        int front = 0, rear = 0;
        
        queue[rear++] = a;
        visited[a] = true;
        result[q] = false;
        
        while (front < rear) {
            int node = queue[front++];
            if (node == b) {
                result[q] = true;
                break;
            }
            
            for (int i = 1; i <= n; i++) {
                if (graph[node][i] && !visited[i]) {
                    visited[i] = true;
                    queue[rear++] = i;
                }
            }
        }
        
        free(visited);
        free(queue);
    }
    
    for (int i = 0; i <= n; i++) {
        free(graph[i]);
    }
    free(graph);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * √n + q * (n + m))

n² pairs to check, √n to find divisors, q queries each taking O(n+m) for traversal

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency list can contain up to n² edges in worst case

⚠ Quadratic Space

28.5K Views

Medium-High Frequency

~25 min Avg. Time

867 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 (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler