Count Connected Components in LCM Graph

Count Connected Components in LCM Graph - Problem

Array Hash Table Math Union Find Number Theory Hard

You are given an array of integers nums of size n and a positive integer threshold. There is a graph consisting of n nodes with the i-th node having a value of nums[i].

Two nodes i and j in the graph are connected via an undirected edge if lcm(nums[i], nums[j]) <= threshold.

Return the number of connected components in this graph.

A connected component is a subgraph of a graph in which there exists a path between any two vertices, and no vertex of the subgraph shares an edge with a vertex outside of the subgraph. The term lcm(a, b) denotes the least common multiple of a and b.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: LCM(2,6) = 6 ≤ 6, so nodes 0,1 connect. LCM(2,3) = 6 ≤ 6, so nodes 0,2 connect. LCM(2,4) = 4 ≤ 6, so nodes 0,3 connect. LCM(6,3) = 6 ≤ 6, so nodes 1,2 connect. This forms one component {0,1,2,3}. Total: 1 component.

Example 2 — All Disconnected

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

› Output: 4

💡 Note: All LCM values exceed threshold 2: LCM(3,4)=12, LCM(3,6)=6, LCM(3,8)=24, etc. No connections exist, so each node forms its own component.

Example 3 — All Connected

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

› Output: 1

💡 Note: LCM(1,2)=2≤6, LCM(1,3)=3≤6, LCM(2,3)=6≤6. All nodes are connected in one large component.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
1 ≤ threshold ≤ 10¹⁵

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

This problem builds a graph where nodes connect if their LCM ≤ threshold, then counts connected components. The key insight is recognizing this as a graph connectivity problem. Union-Find provides the cleanest solution with O(n²) time for checking all pairs and O(n) space for the data structure.

Common Approaches

✓ Brute Force with DFS

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

Build adjacency list by checking LCM of every pair, then use DFS to traverse and count connected components. Simple but inefficient for large inputs.

Union-Find (Disjoint Set)

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

Instead of building explicit graph, use Union-Find data structure to merge connected components as we find LCM connections. More memory efficient and cleaner implementation.

Brute Force with DFS — Algorithm Steps

Calculate LCM for all pairs O(n²)
Build adjacency list of connected nodes
Use DFS to find all connected components

Visualization

Tap to expand

Step-by-Step Walkthrough

Check All Pairs

Calculate LCM for every pair of numbers

Build Graph

Connect nodes where LCM ≤ threshold

Count Components

Use DFS to find all connected groups

Code -

solution.c — C

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

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

long long lcm(long long a, long long b) {
    if (a < 0) a = -a;
    if (b < 0) b = -b;
    return (a * b) / gcd(a, b);
}

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

int solution(int* nums, int numsSize, int threshold) {
    if (numsSize == 0) return 0;
    
    // Build adjacency list
    int** graph = (int**)malloc(numsSize * sizeof(int*));
    int* graphSizes = (int*)calloc(numsSize, sizeof(int));
    int* graphCapacity = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        graph[i] = (int*)malloc(numsSize * sizeof(int));
        graphCapacity[i] = numsSize;
    }
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (lcm((long long)nums[i], (long long)nums[j]) <= threshold) {
                graph[i][graphSizes[i]++] = j;
                graph[j][graphSizes[j]++] = i;
            }
        }
    }
    
    // DFS to count connected components
    bool* visited = (bool*)calloc(numsSize, sizeof(bool));
    int components = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (!visited[i]) {
            dfs(i, graph, graphSizes, visited);
            components++;
        }
    }
    
    // Cleanup
    for (int i = 0; i < numsSize; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSizes);
    free(graphCapacity);
    free(visited);
    
    return components;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    char* ptr = line + 1; // Skip '['
    while (*ptr && *ptr != ']') {
        nums[numsSize++] = strtol(ptr, &ptr, 10);
        if (*ptr == ',') ptr++;
    }
    
    int threshold;
    scanf("%d", &threshold);
    
    printf("%d\n", solution(nums, numsSize, threshold));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Check all n×n pairs, each LCM calculation takes O(log(min(a,b)))

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency list can have up to n² edges in worst case

⚠ Quadratic Space

8.5K Views

Medium Frequency

~25 min Avg. Time

234 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