Greatest Common Divisor Traversal

Greatest Common Divisor Traversal - Problem

You are given a 0-indexed integer array nums, and you are allowed to traverse between its indices. You can traverse between index i and index j, i != j, if and only if gcd(nums[i], nums[j]) > 1, where gcd is the greatest common divisor.

Your task is to determine if for every pair of indices i and j in nums, where i < j, there exists a sequence of traversals that can take us from i to j.

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

Input & Output

Example 1 — Connected Through Shared Factors

$ Input: nums = [4,3,12,8]

› Output: true

💡 Note: gcd(4,12)=4>1, gcd(12,3)=3>1, gcd(4,8)=4>1. All indices can be reached: 0↔2↔1 and 0↔3, so all pairs are traversable.

Example 2 — Disconnected Components

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

› Output: true

💡 Note: gcd(2,6)=2>1 connects indices 0 and 2, and gcd(3,6)=3>1 connects indices 1 and 2. All indices are connected through the path 0↔2↔1, so we can traverse between all pairs.

Example 3 — Single Element

$ Input: nums = [7]

› Output: true

💡 Note: With only one element, there are no pairs to check, so the answer is trivially true.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 M Microsoft 15

The key insight is that two indices can be traversed if their values share a prime factor. Instead of checking all pairs, we use Union-Find with prime factorization to efficiently group connected indices. Best approach: Union-Find. Time: O(n × √M), Space: O(n + P).

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Brute Force Graph Construction

⏱️ Time: O(n²) Space: O(n²)

Calculate GCD for every pair of numbers to build an adjacency list, then use DFS to check if all indices are in the same connected component.

Union-Find with Prime Factorization

⏱️ Time: O(n × √M) Space: O(n + P)

Instead of checking every pair, factor each number into primes and use Union-Find to merge indices that share prime factors. This reduces complexity significantly.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char* solution(char* s) {
    int freq[26] = {0};
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int result_idx = 0;
    
    while (1) {
        int has_chars = 0;
        for (int i = 0; i < 26; i++) {
            if (freq[i] > 0) {
                has_chars = 1;
                break;
            }
        }
        if (!has_chars) break;
        
        // Ascending phase
        char last_char = 0;
        int first = 1;
        
        while (1) {
            int next_idx = -1;
            
            for (int i = 0; i < 26; i++) {
                if (freq[i] > 0) {
                    char c = 'a' + i;
                    if (first || c >= last_char) {
                        next_idx = i;
                        break;
                    }
                }
            }
            
            if (next_idx == -1) break;
            
            char next_char = 'a' + next_idx;
            result[result_idx++] = next_char;
            freq[next_idx]--;
            last_char = next_char;
            first = 0;
        }
        
        has_chars = 0;
        for (int i = 0; i < 26; i++) {
            if (freq[i] > 0) {
                has_chars = 1;
                break;
            }
        }
        if (!has_chars) break;
        
        // Descending phase
        while (1) {
            int next_idx = -1;
            
            for (int i = 25; i >= 0; i--) {
                if (freq[i] > 0) {
                    char c = 'a' + i;
                    if (c <= last_char) {
                        next_idx = i;
                        break;
                    }
                }
            }
            
            if (next_idx == -1) break;
            
            char next_char = 'a' + next_idx;
            result[result_idx++] = next_char;
            freq[next_idx]--;
            last_char = next_char;
        }
    }
    
    result[result_idx] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

28.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

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler