Largest Component Size by Common Factor

Largest Component Size by Common Factor - Problem

Array Hash Table Math Union Find Number Theory Hard

You are given an integer array nums of unique positive integers. Consider the following graph:

There are nums.length nodes, labeled nums[0] to nums[nums.length - 1]
There is an undirected edge between nums[i] and nums[j] if nums[i] and nums[j] share a common factor greater than 1

Return the size of the largest connected component in the graph.

Input & Output

Example 1 — All Connected

$ Input: nums = [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 of size 4.

Example 2 — Multiple Components

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

› Output: 2

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

Example 3 — All Separate

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

› Output: 8

💡 Note: Multiple numbers share common factors: 2-4-6-12, 3-6-12-21-39. All form one large connected component.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is that numbers are connected through shared prime factors, not direct GCD comparison. The optimal approach uses Union-Find with prime factorization to efficiently group connected components. Time: O(n × √max(nums)), Space: O(n + P) where P is the number of unique prime factors.

Common Approaches

✓ Hash Map

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

Brute Force with DFS

⏱️ Time: O(n² × log(max(nums))) Space: O(n²)

For each pair of numbers, compute their GCD to check if they share a common factor > 1. Build an adjacency list graph and use DFS to find all connected components.

Union-Find with Prime Factorization

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

Instead of checking all pairs, find prime factors of each number and use Union-Find to group numbers that share prime factors. This reduces the complexity significantly.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_POINTS 1000

bool solution(int points[][2], int n) {
    if (n <= 1) return true;
    
    int minX = points[0][0], maxX = points[0][0];
    
    // Find min and max x coordinates
    for (int i = 0; i < n; i++) {
        if (points[i][0] < minX) minX = points[i][0];
        if (points[i][0] > maxX) maxX = points[i][0];
    }
    
    // The reflection line is at the center
    double centerX = (minX + maxX) / 2.0;
    
    // Check if all points have their reflections
    for (int i = 0; i < n; i++) {
        int reflectedX = (int)(2 * centerX - points[i][0]);
        int reflectedY = points[i][1];
        
        bool found = false;
        for (int j = 0; j < n; j++) {
            if (points[j][0] == reflectedX && points[j][1] == reflectedY) {
                found = true;
                break;
            }
        }
        if (!found) return false;
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int points[MAX_POINTS][2];
    int n = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            points[n][0] = strtol(ptr, &ptr, 10);
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            points[n][1] = strtol(ptr, &ptr, 10);
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
            n++;
        }
        ptr++;
    }
    
    printf(solution(points, n) ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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