# Largest component size in a graph formed by connecting non-co-prime nodes

Last Updated : 03 May, 2022

Given a graph with N nodes and their values defined in array A, the task is to find the largest component size in a graph by connecting non-co-prime nodes. An edge is between two nodes U and V if they are non-co-prime, which means that the greatest common divisor of A[U] and A[V] should be greater than 1.

Examples:

```Input : A = [4, 6, 15, 35]
Output : 4
Graph will be :
4
|
6
|
15
|
35

Input : A = [2, 3, 6, 7, 4, 12, 21, 39]
Output : 8```

Naive Approach:
We can iterate over all the pairs of nodes and check whether they are co-prime or not. If they are not co-prime, we will connect them. Once the graph is created, we will apply Depth First Search to find the maximum component size.

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;` ` `  `int` `dfs(``int` `u, vector<``int``>* adj, ``int` `vis[])` `{` `    ``// mark this node as visited` `    ``vis[u] = 1;` `    ``int` `componentSize = 1;` ` `  `    ``// apply dfs and add nodes belonging to this component` `    ``for` `(``auto` `it : adj[u]) {` `        ``if` `(!vis[it]) {` `            ``componentSize += dfs(it, adj, vis);` `        ``}` `    ``}` `    ``return` `componentSize;` `}` ` `  `int` `maximumComponentSize(``int` `a[], ``int` `n)` `{` `    ``// create graph and store in adjacency list form` `    ``vector<``int``> adj[n];` ` `  `    ``// iterate over all pair of nodes` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = i + 1; j < n; j++) {` `            ``// if not co-prime` `            ``if` `(__gcd(a[i], a[j]) > 1)` `                ``// build undirected graph` `                ``adj[i].push_back(j);` `            ``adj[j].push_back(i);` `        ``}` `    ``}` `    ``int` `answer = 0;` ` `  `    ``// visited array for dfs` `    ``int` `vis[n];` `    ``for``(``int` `k=0;k

## Java

 `import` `java.util.*;`   `class` `GFG{`   `static` `int` `dfs(``int` `u, Vector []adj,` `               ``int` `vis[])` `{` `    `  `    ``// Mark this node as visited` `    ``vis[u] = ``1``;` `    ``int` `componentSize = ``1``;`   `    ``// Apply dfs and add nodes belonging ` `    ``// to this component` `    ``for``(``int` `it : adj[u])` `    ``{` `        ``if` `(vis[it] == ``0``)` `        ``{` `            ``componentSize += dfs(it, adj, vis);` `        ``}` `    ``}` `    ``return` `componentSize;` `}`   `static` `int` `maximumComponentSize(``int` `a[], ``int` `n)` `{` `    `  `    ``// Create graph and store in adjacency ` `    ``// list form` `    ``@SuppressWarnings``(``"unchecked"``)` `    ``Vector []adj = ``new` `Vector[n];` `    ``for``(``int` `i = ``0``; i < adj.length; i++)` `        ``adj[i] = ``new` `Vector();` `        `  `    ``// Iterate over all pair of nodes` `    ``for``(``int` `i = ``0``; i < n; i++)` `    ``{` `        ``for``(``int` `j = i + ``1``; j < n; j++)` `        ``{` `            `  `            ``// If not co-prime` `            ``if` `(__gcd(a[i], a[j]) > ``1``)` `            `  `                ``// Build undirected graph` `                ``adj[i].add(j);` `                `  `            ``adj[j].add(i);` `        ``}` `    ``}` `    ``int` `answer = ``0``;`   `    ``// Visited array for dfs` `    ``int` `[]vis = ``new` `int``[n];` `    ``for``(``int` `k = ``0``; k < n; k++)` `    ``{` `        ``vis[k] = ``0``;` `    ``}` `    `  `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{` `        ``if` `(vis[i] == ``0``)` `        ``{` `            ``answer = Math.max(answer, ` `                              ``dfs(i, adj, vis));` `        ``}` `    ``}` `    ``return` `answer;` `}`   `static` `int` `__gcd(``int` `a, ``int` `b) ` `{  ` `    ``return` `b == ``0` `? a : __gcd(b, a % b);     ` `} `   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``8``;` `    ``int` `A[] = { ``2``, ``3``, ``6``, ``7``, ``4``, ``12``, ``21``, ``39` `};` `    `  `    ``System.out.print(maximumComponentSize(A, n));` `}` `}`   `// This code is contributed by Amit Katiyar`

## Python3

 `from` `math ``import` `gcd` `def` `dfs(u, adj, vis):`   `    ``# mark this node as visited` `    ``vis[u] ``=` `1` `    ``componentSize ``=` `1`   `    ``# apply dfs and add nodes belonging to this component` `    ``for` `x ``in` `adj[u]:` `        ``if` `(vis[x] ``=``=` `0``):` `            ``componentSize ``+``=` `dfs(x, adj, vis)` `    ``return` `componentSize`   `def` `maximumComponentSize(a,n):`   `    ``# create graph and store in adjacency list form` `    ``adj ``=` `[[] ``for` `i ``in` `range``(n)]`   `    ``# iterate over all pair of nodes` `    ``for` `i ``in` `range``(n):` `        ``for` `j ``in` `range``(i ``+` `1``, n):` `            ``# if not co-prime` `            ``if` `(gcd(a[i], a[j]) > ``1``):` `                ``# build undirected graph` `                ``adj[i].append(j)` `            ``adj[j].append(i)` `    ``answer ``=` `0`   `    ``# visited array for dfs` `    ``vis ``=` `[``0` `for` `i ``in` `range``(n)]` `    ``for` `i ``in` `range``(n):` `        ``if` `(vis[i]``=``=``False``):` `            ``answer ``=` `max``(answer, dfs(i, adj, vis))` `    ``return` `answer`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``n ``=` `8` `    ``A ``=` `[``2``, ``3``, ``6``, ``7``, ``4``, ``12``, ``21``, ``39``]` `    ``print``(maximumComponentSize(A, n))`   `# This code is contributed by Bhupendra_Singh`

## C#

 `// C# program to implement ` `// the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{`   `static` `int` `dfs(``int` `u, ` `               ``List<``int``> []adj, ` `               ``int` `[]vis)` `{    ` `  ``// Mark this node as visited` `  ``vis[u] = 1;` `  ``int` `componentSize = 1;`   `  ``// Apply dfs and add nodes belonging ` `  ``// to this component` `  ``foreach``(``int` `it ``in` `adj[u])` `  ``{` `    ``if` `(vis[it] == 0)` `    ``{` `      ``componentSize += dfs(it, ` `                           ``adj, vis);` `    ``}` `  ``}` `  ``return` `componentSize;` `}`   `  ``static` `int` `maximumComponentSize(``int` `[]a, ` `                                  ``int` `n)` `  ``{    ` `    ``// Create graph and store in adjacency ` `    ``// list form`   `    ``List<``int``> []adj = ``new` `List<``int``>[n];` `    ``for``(``int` `i = 0; i < adj.Length; i++)` `      ``adj[i] = ``new` `List<``int``>();`   `    ``// Iterate over all pair of nodes` `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `      ``for``(``int` `j = i + 1; j < n; j++)` `      ``{            ` `        ``// If not co-prime` `        ``if` `(__gcd(a[i], a[j]) > 1)`   `          ``// Build undirected graph` `          ``adj[i].Add(j);`   `        ``adj[j].Add(i);` `      ``}` `    ``}` `    ``int` `answer = 0;`   `    ``// Visited array for dfs` `    ``int` `[]vis = ``new` `int``[n];` `    ``for``(``int` `k = 0; k < n; k++)` `    ``{` `      ``vis[k] = 0;` `    ``}`   `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{` `      ``if` `(vis[i] == 0)` `      ``{` `        ``answer = Math.Max(answer, ` `                          ``dfs(i, ` `                              ``adj, vis));` `      ``}` `    ``}` `    ``return` `answer;` `}`   `static` `int` `__gcd(``int` `a, ``int` `b) ` `{  ` `  ``return` `b == 0 ? a : ` `         ``__gcd(b, a % b);     ` `} `   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``int` `n = 8;` `  ``int` `[]A = {2, 3, 6, 7, ` `             ``4, 12, 21, 39};` `  ``Console.Write(maximumComponentSize(A, n));` `}` `}`   `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output:

`8`

Time complexity: O(N2)

Auxiliary Space: O(N)

Efficient Approach

• For any two numbers to be non-co-prime, they must have at least one common factor. So, instead of traversing through all the pairs, it’s better to prime factorize each node value. The idea is to then club together numbers with common factors as a single group.
• Prime factorization can be done efficiently using the Sieve of Eratosthenes. For clubbing together of nodes we will use a Disjoint set data structure (Union by Rank and Path Compression).
• The following information will be stored :

par[i] -> represents the parent of node i
size[i] -> represents the size of the component node i belongs to
id[p] -> represents which node prime number p was first seen as a factor of A[i]

• For each node value, we will factorize and store the prime factors in set S. Iterate each element of S. If the prime number is seen for the first time as a factor of some number (id[p] is zero), then mark this prime id with the current index. If this prime has been marked, then simply merge this node with that of id[p].
This way, all nodes will belong to some component finally, and size[i] will be the size of component node i belongs to.

Below is the implementation of the above approach:

## C++

 `#include ` ` `  `using` `namespace` `std;` ` `  `// smallest prime factor` `int` `spf[100005];` ` `  `// Sieve of Eratosthenes` `void` `sieve()` `{` `    ``for` `(``int` `i = 2; i < 100005; i++) {` `        ``// is spf[i] = 0, then it's prime` `        ``if` `(spf[i] == 0) {` `            ``spf[i] = i;`   `            ``for` `(``int` `j = 2 * i; j < 100005; j += i) {`   `                ``// smallest prime factor of all multiples is i` `                ``if` `(spf[j] == 0)` `                    ``spf[j] = i;` `            ``}` `        ``}` `    ``}` `}` ` `  `// Prime factorise n,` `// and store prime factors in set s` `void` `factorize(``int` `n, set<``int``>& s)` `{` ` `  `    ``while` `(n > 1) {` `        ``int` `z = spf[n];` `        ``s.insert(z);` `        ``while` `(n % z == 0)` `            ``n /= z;` `    ``}` `}` ` `  `// for implementing DSU` `int` `id[100005];` `int` `par[100005];` `int` `sizeContainer[100005];` ` `  `// root of component of node i` `int` `root(``int` `i)` `{` `    ``if` `(par[i] == i)` `        ``return` `i;` `    ``// finding root as well as applying` `    ``// path compression` `    ``else` `        ``return` `par[i] = root(par[i]);` `}` ` `  `// merging two components` `void` `merge(``int` `a, ``int` `b)` `{` ` `  `    ``// find roots of both components` `    ``int` `p = root(a);` `    ``int` `q = root(b);` ` `  `    ``// if already belonging to the same component` `    ``if` `(p == q)` `        ``return``;` ` `  `    ``// Union by rank, the rank in this case is` `    ``// sizeContainer of the component. ` `    ``// Smaller sizeContainer will be merged into` `    ``// larger, so the larger's root will be ` `    ``// final root` `    ``if` `(sizeContainer[p] > sizeContainer[q])` `        ``swap(p, q);` ` `  `    ``par[p] = q;` `    ``sizeContainer[q] += sizeContainer[p];` `}` ` `  `// Function to find the maximum sized container` `int` `maximumComponentsizeContainer(``int` `a[], ``int` `n)` `{` ` `  `    ``// intitalise the parents, ` `    ``// and component sizeContainer` `    ``for` `(``int` `i = 0; i < 100005; i++) {` `        ``// initially all component sizeContainers are 1` `        ``// ans each node it parent of itself` `        ``par[i] = i;` `        ``sizeContainer[i] = 1;` `    ``}` ` `  `    ``sieve();` ` `  `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// store prime factors of a[i] in s` `        ``set<``int``> s;` `        ``factorize(a[i], s);` ` `  `        ``for` `(``auto` `it : s) {` `            ``// if this prime is seen as a factor` `            ``// for the first time` `            ``if` `(id[it] == 0)` `                ``id[it] = i + 1;` `            ``// if not then merge with that component` `            ``// in which this prime was previously seen` `            ``else` `                ``merge(i + 1, id[it]);` `        ``}` `    ``}` ` `  `    ``int` `answer = 0;`   `    ``// maximum of sizeContainer of all components` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``answer = max(answer, sizeContainer[i]);` ` `  `    ``return` `answer;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 8;` `    ``int` `A[] = { 2, 3, 6, 7, 4, 12, 21, 39 };` ` `  `    ``cout << maximumComponentsizeContainer(A, n);` ` `  `    ``return` `0;` `}`

## Java

 `// Java program to implement ` `// the above approach` `import` `java.util.*;` `class` `GFG{` ` `  `// smallest prime factor` `static` `int` `[]spf = ``new` `int``[``100005``];` ` `  `// Sieve of Eratosthenes` `static` `void` `sieve()` `{` `    ``for` `(``int` `i = ``2``; i < ``100005``; i++) ` `    ``{` `        ``// is spf[i] = 0, then it's prime` `        ``if` `(spf[i] == ``0``) ` `        ``{` `            ``spf[i] = i;` `            ``for` `(``int` `j = ``2` `* i; j < ``100005``; j += i) ` `            ``{` `                ``// smallest prime factor of all ` `                ``// multiples is i` `                ``if` `(spf[j] == ``0``)` `                    ``spf[j] = i;` `            ``}` `        ``}` `    ``}` `}` ` `  `// Prime factorise n,` `// and store prime factors in set s` `static` `void` `factorize(``int` `n, HashSet s)` `{ ` `    ``while` `(n > ``1``) ` `    ``{` `        ``int` `z = spf[n];` `        ``s.add(z);` `        ``while` `(n % z == ``0``)` `            ``n /= z;` `    ``}` `}` ` `  `// for implementing DSU` `static` `int` `[]id = ``new` `int``[``100005``];` `static` `int` `[]par = ``new` `int``[``100005``];` `static` `int` `[]sizeContainer = ``new` `int``[``100005``];` ` `  `// root of component of node i` `static` `int` `root(``int` `i)` `{` `    ``if` `(par[i] == i)` `        ``return` `i;` `    ``// finding root as well as applying` `    ``// path compression` `    ``else` `        ``return` `par[i] = root(par[i]);` `}` ` `  `// merging two components` `static` `void` `merge(``int` `a, ``int` `b)` `{ ` `    ``// find roots of both components` `    ``int` `p = root(a);` `    ``int` `q = root(b);` ` `  `    ``// if already belonging to the same component` `    ``if` `(p == q)` `        ``return``;` ` `  `    ``// Union by rank, the rank in this case is` `    ``// sizeContainer of the component. ` `    ``// Smaller sizeContainer will be merged into` `    ``// larger, so the larger's root will be ` `    ``// final root` `    ``if` `(sizeContainer[p] > sizeContainer[q]) ` `    ``{` `        ``p = p + q;` `        ``q = p - q;` `        ``p = p - q;` `    ``} ` `    ``par[p] = q;` `    ``sizeContainer[q] += sizeContainer[p];` `}` ` `  `// Function to find the maximum sized container` `static` `int` `maximumComponentsizeContainer(``int` `a[], ` `                                         ``int` `n)` `{ ` `    ``// intitalise the parents, ` `    ``// and component sizeContainer` `    ``for` `(``int` `i = ``0``; i < ``100005``; i++) ` `    ``{` `        ``// initially all component sizeContainers are 1` `        ``// ans each node it parent of itself` `        ``par[i] = i;` `        ``sizeContainer[i] = ``1``;` `    ``} ` `    ``sieve();` ` `  `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{` `        ``// store prime factors of a[i] in s` `        ``HashSet s = ``new` `HashSet();` `        ``factorize(a[i], s);` ` `  `        ``for` `(``int` `it : s) ` `        ``{` `            ``// if this prime is seen as a factor` `            ``// for the first time` `            ``if` `(id[it] == ``0``)` `                ``id[it] = i + ``1``;` `            ``// if not then merge with that component` `            ``// in which this prime was previously seen` `            ``else` `                ``merge(i + ``1``, id[it]);` `        ``}` `    ``} ` `    ``int` `answer = ``0``;`   `    ``// maximum of sizeContainer of all components` `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``answer = Math.max(answer, sizeContainer[i]);` ` `  `    ``return` `answer;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``8``;` `    ``int` `A[] = {``2``, ``3``, ``6``, ``7``, ` `               ``4``, ``12``, ``21``, ``39``}; ` `    ``System.out.print(` `           ``maximumComponentsizeContainer(A, n)); ` `}` `}`   `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 program to implement ` `# the above approach` `  `  `# smallest prime factor` `spf ``=` `[``0` `for` `i ``in` `range``(``100005``)]` `  `  `# Sieve of Eratosthenes` `def` `sieve():`   `    ``for` `i ``in` `range``(``2``, ``100005``):` `    `  `        ``# is spf[i] = 0, then it's prime` `        ``if` `(spf[i] ``=``=` `0``):` `        `  `            ``spf[i] ``=` `i;` `            ``for` `j ``in` `range``(``2` `*` `i, ``100005``, i):` `            `  `                ``# smallest prime factor of all ` `                ``# multiples is i` `                ``if` `(spf[j] ``=``=` `0``):` `                    ``spf[j] ``=` `i;` `             `  `# Prime factorise n,` `# and store prime factors in set s` `def` `factorize(n, s):` `    ``while` `(n > ``1``):   ` `        ``z ``=` `spf[n];` `        ``s.add(z);` `        ``while` `(n ``%` `z ``=``=` `0``):` `            ``n ``/``/``=` `z;` `     `  `# for implementing DSU` `id` `=` `[``0` `for` `i ``in` `range``(``100005``)]` `par ``=` `[``0` `for` `i ``in` `range``(``100005``)]` `sizeContainer ``=` `[``0` `for` `i ``in` `range``(``100005``)]` `  `  `# root of component of node i` `def` `root(i):`   `    ``if` `(par[i] ``=``=` `i):` `        ``return` `i;` `      `  `    ``# finding root as well as applying` `    ``# path compression` `    ``else``:` `        ``return` `root(par[i]);` `        ``return` `par[i]` ` `  `# merging two components` `def` `merge(a, b):`   `    ``# find roots of both components` `    ``p ``=` `root(a);` `    ``q ``=` `root(b);` `  `  `    ``# if already belonging to the same component` `    ``if` `(p ``=``=` `q):` `        ``return``;` `  `  `    ``# Union by rank, the rank in this case is` `    ``# sizeContainer of the component. ` `    ``# Smaller sizeContainer will be merged into` `    ``# larger, so the larger's root will be ` `    ``# final root` `    ``if` `(sizeContainer[p] > sizeContainer[q]):    ` `        ``p ``=` `p ``+` `q;` `        ``q ``=` `p ``-` `q;` `        ``p ``=` `p ``-` `q;   ` `    ``par[p] ``=` `q;` `    ``sizeContainer[q] ``+``=` `sizeContainer[p];` `  `  `# Function to find the maximum sized container` `def` `maximumComponentsizeContainer(a, n):`   `    ``# intitalise the parents, ` `    ``# and component sizeContainer` `    ``for` `i ``in` `range``(``100005``):` `        `  `        ``# initially all component sizeContainers are 1` `        ``# ans each node it parent of itself` `        ``par[i] ``=` `i;` `        ``sizeContainer[i] ``=` `1``;` `    ``sieve();` `    `  `    ``for` `i ``in` `range``(n):`   `        ``# store prime factors of a[i] in s` `        ``s ``=` `set``()        ` `        ``factorize(a[i], s);  ` `        ``for` `it ``in` `s:`   `            ``# if this prime is seen as a factor` `            ``# for the first time` `            ``if` `(``id``[it] ``=``=` `0``):` `                ``id``[it] ``=` `i ``+` `1``;` `                `  `            ``# if not then merge with that component` `            ``# in which this prime was previously seen` `            ``else``:` `                ``merge(i ``+` `1``, ``id``[it]);        ` `    ``answer ``=` `0``;` ` `  `    ``# maximum of sizeContainer of all components` `    ``for` `i ``in` `range``(n):  ` `        ``answer ``=` `max``(answer, sizeContainer[i]); ` `    ``return` `answer;` ` `  `# Driver Code` `if` `__name__``=``=``'__main__'``:` `    `  `    ``n ``=` `8``;` `    ``A ``=` `[``2``, ``3``, ``6``, ``7``, ``4``, ``12``, ``21``, ``39``]` `    ``print``(maximumComponentsizeContainer(A, n)); `   `# This code is contributed by Pratham76`

## C#

 `// C# program to implement ` `// the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Smallest prime factor` `static` `int` `[]spf = ``new` `int``[100005];`   `// Sieve of Eratosthenes` `static` `void` `sieve()` `{` `    ``for``(``int` `i = 2; i < 100005; i++) ` `    ``{` `        `  `        ``// Is spf[i] = 0, then it's prime` `        ``if` `(spf[i] == 0) ` `        ``{` `            ``spf[i] = i;` `            ``for``(``int` `j = 2 * i; j < 100005; j += i) ` `            ``{` `                `  `                ``// Smallest prime factor of all ` `                ``// multiples is i` `                ``if` `(spf[j] == 0)` `                    ``spf[j] = i;` `            ``}` `        ``}` `    ``}` `}`   `// Prime factorise n, and store` `// prime factors in set s` `static` `void` `factorize(``int` `n, HashSet<``int``> s)` `{ ` `    ``while` `(n > 1) ` `    ``{` `        ``int` `z = spf[n];` `        ``s.Add(z);` `        `  `        ``while` `(n % z == 0)` `            ``n /= z;` `    ``}` `}`   `// For implementing DSU` `static` `int` `[]id = ``new` `int``[100005];` `static` `int` `[]par = ``new` `int``[100005];` `static` `int` `[]sizeContainer = ``new` `int``[100005];`   `// Root of component of node i` `static` `int` `root(``int` `i)` `{` `    ``if` `(par[i] == i)` `        ``return` `i;` `        `  `    ``// Finding root as well as applying` `    ``// path compression` `    ``else` `        ``return` `par[i] = root(par[i]);` `}`   `// Merging two components` `static` `void` `merge(``int` `a, ``int` `b)` `{ ` `    `  `    ``// Find roots of both components` `    ``int` `p = root(a);` `    ``int` `q = root(b);`   `    ``// If already belonging to` `    ``// the same component` `    ``if` `(p == q)` `        ``return``;`   `    ``// Union by rank, the rank in this case is` `    ``// sizeContainer of the component. ` `    ``// Smaller sizeContainer will be merged into` `    ``// larger, so the larger's root will be ` `    ``// readonly root` `    ``if` `(sizeContainer[p] > sizeContainer[q]) ` `    ``{` `        ``p = p + q;` `        ``q = p - q;` `        ``p = p - q;` `    ``} ` `    ``par[p] = q;` `    ``sizeContainer[q] += sizeContainer[p];` `}`   `// Function to find the maximum sized container` `static` `int` `maximumComponentsizeContainer(``int` `[]a, ` `                                         ``int` `n)` `{ ` `    `  `    ``// Initialise the parents, ` `    ``// and component sizeContainer` `    ``for``(``int` `i = 0; i < 100005; i++) ` `    ``{` `        `  `        ``// Initially all component sizeContainers` `        ``// are 1 ans each node it parent of itself` `        ``par[i] = i;` `        ``sizeContainer[i] = 1;` `    ``} ` `    ``sieve();`   `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{` `        `  `        ``// Store prime factors of a[i] in s` `        ``HashSet<``int``> s = ``new` `HashSet<``int``>();` `        ``factorize(a[i], s);`   `        ``foreach``(``int` `it ``in` `s) ` `        ``{` `            `  `            ``// If this prime is seen as a factor` `            ``// for the first time` `            ``if` `(id[it] == 0)` `                ``id[it] = i + 1;` `                `  `            ``// If not then merge with that component` `            ``// in which this prime was previously seen` `            ``else` `                ``merge(i + 1, id[it]);` `        ``}` `    ``} ` `    ``int` `answer = 0;`   `    ``// Maximum of sizeContainer of all components` `    ``for``(``int` `i = 0; i < n; i++)` `        ``answer = Math.Max(answer, sizeContainer[i]);`   `    ``return` `answer;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `n = 8;` `    ``int` `[]A = { 2, 3, 6, 7, ` `                ``4, 12, 21, 39 }; ` `                `  `    ``Console.Write(` `        ``maximumComponentsizeContainer(A, n)); ` `}` `}`   `// This code is contributed by Princi Singh`

## Javascript

 ``

Output:

` 8`

Time Complexity : O(N * log(max(A)))

Auxiliary Space: O(105)