Largest Component Size by Common Factor - Practice Coding Problems

Largest Component Size by Common Factor - Problem

Array Hash Table Math Union Find Number Theory Hard

You're given an array nums of unique positive integers. Your task is to find connected groups where numbers are linked if they share a common factor greater than 1.

Think of this as a friendship network where two numbers are friends if they have a common factor greater than 1. For example, 6 and 15 are friends because they both share the factor 3.

Goal: Return the size of the largest connected group in this network.

Example: In [4, 6, 15, 35]:

4 and 6 share factor 2 → connected
6 and 15 share factor 3 → connected
15 and 35 share factor 5 → connected
All four numbers form one connected component of size 4

Input & Output

example_1.py — Basic Case

$ Input: [4,6,15,35]

› Output: 4

💡 Note: 4 and 6 share factor 2, 6 and 15 share factor 3, 15 and 35 share factor 5. All numbers form one connected component.

example_2.py — Multiple Components

$ Input: [20,50,9,63]

› Output: 2

💡 Note: 20 and 50 share factor 2 and 5 (component size 2). 9 and 63 share factor 3 and 9 (component size 2). Maximum is 2.

example_3.py — All Prime Numbers

$ Input: [2,3,6,7,4,12,21,39]

› Output: 8

💡 Note: 2-6-4-12 connected by factor 2, 3-6-12-21-39 connected by factor 3, creating one large component through number 6 and 12.

Visualization

Tap to expand

Understanding the Visualization

Identify Interests

Find prime factors for each number (person's interests)

Connect Through Interests

Numbers sharing prime factors get connected

Find Largest Group

Union-Find tracks the largest connected component

Key Takeaway

🎯 Key Insight: Connect numbers through prime factors rather than direct GCD checks, reducing complexity from O(n²) to O(n√max)

Time & Space Complexity

Time Complexity

⏱️

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

O(n²) pairs × O(log(max)) for GCD computation + O(n²) for DFS

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency list can have O(n²) edges in worst case

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i] ≤ 10⁵
All values in nums are unique

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses Union-Find with prime factorization. Instead of checking all pairs (O(n²)), we connect numbers through their prime factors. Each prime factor acts as a bridge connecting all numbers that contain it. This reduces time complexity to O(n × √max(nums)) and elegantly solves the connected components problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs + DFS)	O(n² * log(max(nums)))	O(n²)	Check every pair for common factors, build adjacency list, then DFS to find components
Union-Find with Prime Factorization (Optimal)	O(n * sqrt(max(nums)))	O(n + max(nums))	Use Union-Find to connect numbers through their prime factors

Brute Force (Check All Pairs + DFS) — Algorithm Steps

For each pair (i,j), compute GCD(nums[i], nums[j])
If GCD > 1, add edge between i and j in adjacency list
Run DFS from each unvisited node to find component sizes
Return the maximum component size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Pairs

Compare every pair using GCD

Build Graph

Create edges for pairs with GCD > 1

Find Components

Use DFS to find connected components

Code -

solution.c — C

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

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int dfs(int node, int** graph, int* graphSize, bool* visited) {
    visited[node] = true;
    int size = 1;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (!visited[neighbor]) {
            size += dfs(neighbor, graph, graphSize, visited);
        }
    }
    return size;
}

int largestComponentSize(int* nums, int numsSize) {
    int** graph = (int**)malloc(numsSize * sizeof(int*));
    int* graphSize = (int*)calloc(numsSize, sizeof(int));
    
    // Initialize graph
    for (int i = 0; i < numsSize; i++) {
        graph[i] = (int*)malloc(numsSize * sizeof(int));
    }
    
    // Build adjacency list
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (gcd(nums[i], nums[j]) > 1) {
                graph[i][graphSize[i]++] = j;
                graph[j][graphSize[j]++] = i;
            }
        }
    }
    
    bool* visited = (bool*)calloc(numsSize, sizeof(bool));
    int maxSize = 1;
    
    for (int i = 0; i < numsSize; i++) {
        if (!visited[i]) {
            int size = dfs(i, graph, graphSize, visited);
            if (size > maxSize) {
                maxSize = size;
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < numsSize; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    free(visited);
    
    return maxSize;
}

int main() {
    int nums[] = {4, 6, 15, 35};
    printf("%d\n", largestComponentSize(nums, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

O(n²) pairs × O(log(max)) for GCD computation + O(n²) for DFS

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency list can have O(n²) edges in worst case

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i] ≤ 10⁵
All values in nums are unique

32.5K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Pairs + DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler