Graph Connectivity With Threshold

Graph Connectivity With Threshold - Problem

You have n cities labeled from 1 to n. Two different cities with labels x and y are directly connected by a bidirectional road if and only if x and y share a common divisor strictly greater than some threshold.

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

x % z == 0
y % z == 0
z > threshold

Given the integers n and threshold, and an array of queries, determine for each queries[i] = [ai, bi] if cities ai and bi are connected directly or indirectly.

Return an array answer, where answer[i] is true if there is a path between ai and bi, or false if no path exists.

Input & Output

Example 1 — Basic Connectivity

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

› Output: [false,false,true]

💡 Note: With threshold=2, cities are connected if they share divisor > 2. City 3 and 6 share divisor 3 > 2, so they're connected. Cities 1,4 and 4,5 don't share divisors > 2.

Example 2 — Lower Threshold

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

› Output: [true,true,true]

💡 Note: With threshold=0, cities need common divisor > 0. All pairs of cities have gcd ≥ 1, and since 1 > 0, all cities are connected through divisor 1.

Example 3 — No Connections

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

› Output: [false,false]

💡 Note: With high threshold=4, no cities can be connected since largest city is 5 and no pairs share divisor > 4.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15 M Microsoft 12

The key insight is that cities connected by common divisors form connected components that can be precomputed efficiently. The optimal approach uses Union-Find to group cities by iterating through divisors > threshold and unioning all cities divisible by each divisor. Time: O(n log n + q), Space: O(n)

Common Approaches

✓ Brute Force DFS for Each Query

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

Build the graph on-demand and perform depth-first search for each query. For every pair of cities, check if they share a common divisor greater than threshold, then traverse the graph to find connectivity.

Union-Find with Precomputed Components

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

Use Union-Find (Disjoint Set Union) to efficiently build connected components by iterating through all possible divisors greater than threshold. Once components are built, each query can be answered in near-constant time.

Brute Force DFS for Each Query — Algorithm Steps

For each query, build connections between all city pairs
Use DFS to check if path exists between query cities
Repeat for every query independently

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Check all city pairs for common divisors > threshold

DFS Search

For each query, traverse graph to find path

Result

Return true/false for each query

Code -

solution.c — C

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

typedef struct {
    int* q1;
    int* q2;
    int q1_front, q1_rear;
    int q2_front, q2_rear;
    int capacity;
} MyStack;

MyStack* myStackCreate() {
    MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
    stack->capacity = 1000;
    stack->q1 = (int*)malloc(stack->capacity * sizeof(int));
    stack->q2 = (int*)malloc(stack->capacity * sizeof(int));
    stack->q1_front = stack->q1_rear = 0;
    stack->q2_front = stack->q2_rear = 0;
    return stack;
}

void myStackPush(MyStack* obj, int x) {
    obj->q2[obj->q2_rear++] = x;
    while (obj->q1_front < obj->q1_rear) {
        obj->q2[obj->q2_rear++] = obj->q1[obj->q1_front++];
    }
    int* temp = obj->q1;
    obj->q1 = obj->q2;
    obj->q2 = temp;
    int temp_front = obj->q1_front;
    int temp_rear = obj->q1_rear;
    obj->q1_front = obj->q2_front;
    obj->q1_rear = obj->q2_rear;
    obj->q2_front = temp_front;
    obj->q2_rear = temp_rear;
}

int myStackPop(MyStack* obj) {
    return obj->q1[obj->q1_front++];
}

int myStackTop(MyStack* obj) {
    return obj->q1[obj->q1_front];
}

bool myStackEmpty(MyStack* obj) {
    return obj->q1_front >= obj->q1_rear;
}

void myStackFree(MyStack* obj) {
    free(obj->q1);
    free(obj->q2);
    free(obj);
}

void parseInput(char* line, char operations[][20], int* op_count, int values[], int* val_count) {
    *op_count = 0;
    *val_count = 0;
    
    char* ptr = strchr(line, '[');
    if (!ptr) return;
    ptr++;
    
    char* end = strchr(ptr, ']');
    if (!end) return;
    *end = '\0';
    
    char* token = strtok(ptr, ",");
    while (token && *op_count < 100) {
        while (isspace(*token)) token++;
        if (*token == '"') {
            token++;
            char* quote_end = strchr(token, '"');
            if (quote_end) *quote_end = '\0';
            strcpy(operations[(*op_count)++], token);
        }
        token = strtok(NULL, ",");
    }
}

void parseValues(char* line, int values[], int* val_count) {
    *val_count = 0;
    char* ptr = strchr(line, '[');
    if (!ptr) return;
    ptr++;
    
    char* end = strchr(ptr, ']');
    if (!end) return;
    *end = '\0';
    
    char* token = strtok(ptr, ",");
    while (token && *val_count < 100) {
        while (isspace(*token)) token++;
        if (strncmp(token, "null", 4) == 0) {
            values[(*val_count)++] = 0;
        } else {
            values[(*val_count)++] = atoi(token);
        }
        token = strtok(NULL, ",");
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[1000], line2[1000];
    char operations[100][20];
    int values[100];
    int op_count, val_count;
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    parseInput(line1, operations, &op_count, values, &val_count);
    parseValues(line2, values, &val_count);
    
    MyStack* stack = myStackCreate();
    printf("[");
    
    for (int i = 0; i < op_count; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "MyStack") == 0) {
            printf("null");
        } else if (strcmp(operations[i], "push") == 0) {
            myStackPush(stack, values[i]);
            printf("null");
        } else if (strcmp(operations[i], "pop") == 0) {
            printf("%d", myStackPop(stack));
        } else if (strcmp(operations[i], "top") == 0) {
            printf("%d", myStackTop(stack));
        } else if (strcmp(operations[i], "empty") == 0) {
            printf("%s", myStackEmpty(stack) ? "true" : "false");
        }
    }
    
    printf("]\n");
    myStackFree(stack);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n³)

For each of q queries, we check all n² city pairs and potentially traverse all n cities in DFS

⚠ Quadratic Growth

Space Complexity

O(n²)

Store adjacency list for up to n² connections during graph construction

⚠ Quadratic Space

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

Brute Force DFS for Each Query — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler