Greatest Common Divisor Traversal - Practice Coding Problems

Greatest Common Divisor Traversal - Problem

Imagine you have an array of integers, and you want to determine if you can create a connected network where any two positions can reach each other through a series of jumps.

You are given a 0-indexed integer array nums. You can traverse (or jump) between index i and index j if and only if gcd(nums[i], nums[j]) > 1, where gcd is the greatest common divisor.

Your task is to determine if every pair of indices in the array can be connected through a sequence of valid traversals. In other words, can you reach any index from any other index by following the GCD rule?

Example: If nums = [2, 3, 6], you can traverse between indices 0 and 2 (since gcd(2,6)=2 > 1), and between indices 1 and 2 (since gcd(3,6)=3 > 1). This means all indices are connected through index 2.

Return true if it's possible to traverse between all pairs of indices, or false otherwise.

Input & Output

example_1.py — Basic Connected Array

$ Input: nums = [2, 3, 6]

› Output: true

💡 Note: We can traverse between indices 0 and 2 (gcd(2,6)=2 > 1), and between indices 1 and 2 (gcd(3,6)=3 > 1). Since index 2 connects to both 0 and 1, all indices are reachable from each other.

example_2.py — Disconnected Components

$ Input: nums = [3, 9, 5]

› Output: false

💡 Note: Index 0 and 1 can connect (gcd(3,9)=3 > 1), but index 2 cannot connect to either (gcd(3,5)=1, gcd(9,5)=1). The array has two separate components: {0,1} and {2}.

example_3.py — Single Element Edge Case

$ Input: nums = [4]

› Output: true

💡 Note: With only one element, there are no pairs to check. By definition, all elements (just one) are trivially connected.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
All values in nums are positive integers
Arrays with length 1 should return true

Visualization

Tap to expand

Understanding the Visualization

Identify Islands

Each array index represents an island with a treasure number

Check Bridge Rules

Bridges can only be built between islands where GCD of treasure numbers > 1

Build Bridge Network

Connect all valid island pairs using Union-Find for efficiency

Verify Connectivity

Check if all islands belong to one connected network

Key Takeaway

🎯 Key Insight: Numbers sharing prime factors create connected components. Use Union-Find with prime factorization for O(n√max + n log* n) optimal solution instead of O(n²) pairwise GCD checks.

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

This graph connectivity problem is optimally solved using Union-Find with prime factorization. Instead of checking all O(n²) pairs directly, we can group numbers by their prime factors - numbers sharing prime factors can traverse to each other. The key insight is that GCD > 1 means shared prime factors, making factorization-based grouping much more efficient than pairwise GCD calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Disjoint Set Union)	O(n² log(max(nums)))	O(n)	Use Union-Find to group connected indices efficiently

Union-Find (Disjoint Set Union) — Algorithm Steps

Initialize Union-Find with each index as separate component
For each pair of indices, calculate GCD
If GCD > 1, union the two indices in the data structure
Check if all indices belong to the same root component

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each index is its own component

Find GCD Pairs

Check all pairs for GCD > 1

Union Components

Merge connected indices

Check Unity

Verify single component remains

Code -

solution.c — C

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

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

UnionFind* createUnionFind(int n) {
    UnionFind* uf = malloc(sizeof(UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->rank = calloc(n, sizeof(int));
    uf->components = n;
    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]++;
    }
    uf->components--;
}

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

bool canTraverseAllPairs(int* nums, int numsSize) {
    if (numsSize <= 1) return true;
    
    UnionFind* uf = createUnionFind(numsSize);
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (gcd(nums[i], nums[j]) > 1) {
                unionSets(uf, i, j);
            }
        }
    }
    
    bool result = uf->components == 1;
    
    free(uf->parent);
    free(uf->rank);
    free(uf);
    
    return result;
}

int main() {
    int nums[] = {4, 3, 12, 8};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%s\n", canTraverseAllPairs(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log(max(nums)))

O(n²) to check all pairs, O(log(max)) for GCD, O(α(n)) for Union-Find operations

⚠ Quadratic Growth

Space Complexity

O(n)

Union-Find parent and rank arrays

⚡ Linearithmic Space

26.4K Views

Medium Frequency

~25 min Avg. Time

847 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

Union-Find (Disjoint Set Union) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler