Codestin Search App

Count Connected Components in LCM Graph - Problem

Array Hash Table Math Union Find Number Theory Hard

Imagine you're a network analyst tasked with finding clusters of related numbers based on their mathematical compatibility. You have an array of integers nums and a threshold value that determines when two numbers can be connected.

Two numbers nums[i] and nums[j] are considered connected if their Least Common Multiple (LCM) is less than or equal to the threshold: lcm(nums[i], nums[j]) ≤ threshold.

Your goal is to count how many separate connected components exist in this graph. A connected component is a group of numbers where you can reach any number from any other number in the same group through a series of connections, but cannot reach numbers in other groups.

Example: If nums = [2, 6, 4, 3] and threshold = 6:
• LCM(2, 6) = 6 ≤ 6 ✓ (connected)
• LCM(2, 4) = 4 ≤ 6 ✓ (connected)
• LCM(6, 4) = 12 > 6 ✗ (not connected)
• LCM(3, others) > 6 ✗ (isolated)

This creates 2 components: {2, 6, 4} and {3}.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: LCM(2,6) = 6 ≤ 6, LCM(2,4) = 4 ≤ 6, so {2,6,4} form one component. LCM(6,4) = 12 > 6, but they're already connected through 2. Element 3 has LCM > 6 with all others, forming its own component. Total: 2 components.

example_2.py — All Connected

$ Input: nums = [4, 6, 15, 35], threshold = 20

› Output: 1

💡 Note: LCM(4,6) = 12 ≤ 20, LCM(6,15) = 30 > 20, but LCM(4,15) = 60 > 20. However, we need to check all pairs: LCM(15,35) = 105 > 20. Actually, only 4 and 6 are connected, others form separate components. Wait - let me recalculate: this forms 3 components: {4,6}, {15}, {35}.

example_3.py — All Isolated

$ Input: nums = [5, 7, 11, 13], threshold = 10

› Output: 4

💡 Note: All numbers are prime and greater than threshold/2, so all LCM values exceed the threshold. Each number forms its own component, resulting in 4 separate components.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
1 ≤ threshold ≤ 10⁹
All elements in nums are unique

Visualization

Tap to expand

Understanding the Visualization

Initialize Components

Start with each person (number) as their own friend group

Check Compatibility

For every pair, calculate their LCM to see if they can be friends

Merge Groups

When two people are compatible, merge their entire friend groups

Count Final Groups

The number of distinct friend groups is our answer

Key Takeaway

🎯 Key Insight: Union-Find provides the optimal balance of efficiency and simplicity for dynamic connectivity problems, avoiding the need to build and traverse explicit graph structures.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses Union-Find (Disjoint Set Union) to efficiently merge connected components as we discover LCM relationships. While we still need O(n²) time to check all pairs, Union-Find provides near-constant time merging with path compression and union by rank. This avoids building an explicit adjacency list and provides cleaner component counting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with DFS	O(n²)	O(n²)	Build adjacency list by checking all pairs, then use DFS to count components
Union-Find (Disjoint Set Union)	O(n² α(n))	O(n)	Use Union-Find data structure to efficiently merge and count components

Brute Force with DFS — Algorithm Steps

Create adjacency list by checking LCM of every pair O(n²)
Initialize visited array and component counter
For each unvisited node, perform DFS to mark entire component
Increment component count for each DFS traversal
Return total number of components

Visualization

Tap to expand

Step-by-Step Walkthrough

Check All Pairs

Calculate LCM for every pair of numbers and build adjacency list

DFS Traversal

Start DFS from each unvisited node to find connected components

Count Components

Each DFS traversal represents one connected component

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);
}

void dfs(int node, int** adj, int* adjSize, bool* visited) {
    visited[node] = true;
    for (int i = 0; i < adjSize[node]; i++) {
        int neighbor = adj[node][i];
        if (!visited[neighbor]) {
            dfs(neighbor, adj, adjSize, visited);
        }
    }
}

int countComponents(int* nums, int numsSize, int threshold) {
    // Build adjacency list
    int** adj = (int**)malloc(numsSize * sizeof(int*));
    int* adjSize = (int*)calloc(numsSize, sizeof(int));
    int* adjCapacity = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        adj[i] = (int*)malloc(numsSize * sizeof(int));
        adjCapacity[i] = numsSize;
    }
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            long long lcmVal = ((long long)nums[i] * nums[j]) / gcd(nums[i], nums[j]);
            if (lcmVal <= threshold) {
                adj[i][adjSize[i]++] = j;
                adj[j][adjSize[j]++] = i;
            }
        }
    }
    
    // DFS to count components
    bool* visited = (bool*)calloc(numsSize, sizeof(bool));
    int components = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (!visited[i]) {
            dfs(i, adj, adjSize, visited);
            components++;
        }
    }
    
    // Cleanup
    for (int i = 0; i < numsSize; i++) {
        free(adj[i]);
    }
    free(adj);
    free(adjSize);
    free(adjCapacity);
    free(visited);
    
    return components;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) to check all pairs and calculate LCM, plus O(n + edges) for DFS traversal

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n²) for adjacency list storage in worst case where all nodes are connected

⚠ Quadratic Space

52.4K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 with DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler