# Find the GCD of LCM of all unique pairs in an Array

Given an integer array arr[] of size N, the task is to find the GCD of LCM of all unique pair (i, j) of the array, such that i < j.

Examples:

Input: arr[] = {10, 24, 40, 80}
Output: 40
Explanation:
LCM of all unique pairs following given conditions are:
LCM(10, 24) = 120
LCM(10, 40) = 40
LCM(10, 80) = 80
LCM(24, 40) = 120
LCM(24, 80) = 240
LCM(40, 80) = 80
Therefore, GCD of these LCM = GCD(120, 40, 80, 120, 240, 80) = 40

Input: arr[] = {1, 1}
Output: 1

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: The simplest approach is the find all unique pairs in the array. Then find their LCM. Then find the GCD of all the LCM.

Efficient Approach: The above naive approach can be optimised with the help of Suffix array. We can use the Suffix array to find the LCM of each element paired with other elements, efficiently. Then we can simply find and return the GCD of this LCM array.

• For every element A[i], we need to calculate LCM(a[i], a[j]), where j belong to [i+1, N-1].
• LCM of all pairs where starting element is A[i] can be written as

LCM(A[i], GCD(all j in range i+1 to n-1))

• For that we build a suffix array. Let say suffix[] that stores the gcd of elements that belong to the range [i+1, N-1].
• Then create a LCM array to store the LCM of A[i] and GCD of all elements after it, i.e.

LCM[i] = LCM(A[i], suffix[i+1])

Where suffix[i+1] stores the GCD of elements [i+1, n-1]

• Finaly compute the GCD of all elements in LCM array.

## C++

 `// C++ code to find the GCD of LCM ` `// of all unique pairs in an Array ` `#include ` `using` `namespace` `std; ` ` `  `// Find lcm of element x and y ` `int` `LCM(``int` `x, ``int` `y) ` `{ ` `    ``return` `x * y / __gcd(x, y); ` `} ` ` `  `// Function that finds gcd of lcm ` `// of all pairs of elements. ` `void` `gcd_of_lcm(``int` `n, ``int` `arr[]) ` `{ ` `     `  `    ``// n is the size of the array. ` `    ``// arr is the array. ` ` `  `    ``// Suffix array that stores ` `    ``// the gcd of the array elements. ` `    ``int` `suff[n]; ` `     `  `    ``// Initialize suffix array. ` `    ``for``(``int` `x = 0; x < n; x++) ` `    ``{ ` `       ``suff[x] = 1; ` `    ``} ` `     `  `    ``// Loop that make the suffix gcd array ` `    ``suff[n - 1] = arr[n - 1]; ` `    ``for``(``int` `i = n - 2; i >= 0; i--) ` `    ``{ ` `       ``suff[i] = __gcd(arr[i], suff[i + 1]); ` `    ``} ` `     `  `    ``// lcm array that store the lcm ` `    ``// of ith elements for all j ` `    ``// that satisfy given condition. ` `    ``vector<``int``> lcm; ` `    ``for``(``int` `i = 0; i < n - 1; i++) ` `    ``{ ` `        `  `       ``// we find lcm[i] for lcm ` `       ``// of ith elements for all j ` `       ``// using bellow formula. ` `       ``int` `y = LCM(arr[i], suff[i + 1]); ` `        `  `       ``// Add lcm of ith elements ` `       ``// for all j in lcm array. ` `       ``lcm.push_back(y); ` `    ``} ` `     `  `    ``// Now we find gcd of all ith elements. ` `    ``// where i = 0, 1, 2, 3.....n-2. ` `    ``int` `ans = lcm; ` `     `  `    ``for``(``int` `i = 1; i < n - 1; i++) ` `    ``{ ` `       ``ans = __gcd(ans, lcm[i]); ` `    ``} ` `    ``cout << ans << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 4; ` `    ``int` `a[] = { 10, 24, 40, 80 }; ` `     `  `    ``// Function call for input 1 ` `    ``gcd_of_lcm(n, a); ` `     `  `    ``n = 10; ` `    ``int` `b[] = { 540, 648, 810, 648, 720, ` `                ``540, 594, 864, 972, 648 }; ` `                 `  `    ``// Function call for input 2 ` `    ``gcd_of_lcm(n, b); ` `} ` ` `  `// This code is contributed by shobhitgupta907 `

## Java

 `// Java code to find the GCD of LCM ` `// of all unique pairs in an array ` `class` `GFG{ ` `     `  `// Function to evaluate GCD of x and y ` `static` `int` `gcd(``int` `x, ``int` `y) ` `{ ` `    ``if` `(y == ``0``) ` `        ``return` `x; ` `    ``else`  `        ``return` `gcd(y, x % y); ` `}  ` ` `  `// Function that finds gcd of lcm  ` `// of all pairs of elements.  ` `static` `void` `gcd_of_lcm(``int` `n, ``int` `arr[]) ` `{ ` `     `  `    ``// n = size of array i.e. arr[] ` ` `  `    ``// Suffix array that stores ` `    ``// the GCD of the array elements.  ` `    ``int` `suff[] = ``new` `int``[n]; ` ` `  `    ``// initialise the suffix array ` `    ``for``(``int` `i = ``0``; i < n; i++) ` `        ``suff[i] = ``1``; ` ` `  `    ``// Loop that make suffix GCD array ` `    ``suff[n - ``1``] = arr[n - ``1``];  ` ` `  `    ``for``(``int` `i = n - ``2``; i >= ``0``; i--)  ` `        ``suff[i] = gcd(arr[i], suff[i + ``1``]);  ` ` `  `    ``// lcm array that store lcm for pairwise  ` `    ``// consecutive elements ` `    ``int` `lcm[] = ``new` `int``[n - ``1``]; ` `    ``for``(``int` `i = ``0``; i < n - ``1``; i++) ` `     `  `        ``// Find LCM using standard known formula ` `        ``lcm[i] = (arr[i] * suff[i + ``1``]) /  ` `               ``gcd(arr[i], suff[i + ``1``]); ` ` `  `    ``// Now we find gcd of all ith elements.  ` `    ``// where i = 0, 1, 2, 3.....n-2.  ` `    ``int` `ans = lcm[``0``];  ` `     `  `    ``for``(``int` `i = ``1``; i < n - ``1``; i++)  ` `    ``{  ` `        ``ans = gcd(ans, lcm[i]);  ` `    ``} ` `     `  `    ``// Print the answer ` `    ``System.out.println(ans); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `     `  `    ``// 1st input case ` `    ``int` `n = ``4``;  ` `    ``int` `a[] = { ``10``, ``24``, ``40``, ``80` `};  ` `     `  `    ``// Function call for input 1  ` `    ``gcd_of_lcm(n, a);  ` `     `  `    ``// 2nd input case ` `    ``n = ``10``;  ` `    ``int` `b[] = { ``540``, ``648``, ``810``, ``648``, ``720``,  ` `                ``540``, ``594``, ``864``, ``972``, ``648` `};  ` `                 `  `    ``// Function call for input 2  ` `    ``gcd_of_lcm(n, b);  ` `} ` `} ` ` `  `// This code is contributed by Soumitri Chattopadhyay `

## Python3

 `# Python3 code to find the GCD of LCM ` `# of all unique pairs in an Array ` ` `  `from` `math ``import` `gcd ` ` `  `# find lcm of element x and y ` `def` `LCM(x, y): ` `     `  `    ``return` `(x ``*` `y)``/``/``gcd(x, y) ` ` `  `# Function that finds gcd of lcm ` `# of all pairs of elements. ` `def` `gcd_of_lcm(n, arr): ` ` `  `    ``# n is the size of the array. ` `    ``# arr is the array. ` `     `  `    ``# suffix array that stores ` `    ``# the gcd of the array elements. ` `    ``suff ``=` `[``1``]``*``n ` ` `  `    ``# initialize suffix array. ` `     `  `    ``# loop that make the suffix gcd array. ` `    ``suff[n``-``1``] ``=` `arr[n``-``1``] ` `    ``for` `i ``in` `range``(n``-``2``, ``-``1``, ``-``1``): ` `         `  `        ``suff[i] ``=` `gcd(arr[i], suff[i ``+` `1``]) ` `     `  `    ``# lcm array that store the lcm ` `    ``# of ith elements for all j ` `    ``# that satisfy given condition. ` `    ``lcm ``=` `[] ` ` `  `    ``for` `i ``in` `range``(n``-``1``): ` ` `  `        ``# we find lcm[i] for lcm  ` `        ``# of ith elements for all j ` `        ``# using bellow formula. ` `        ``y ``=` `LCM( arr[i], suff[i ``+` `1``]) ` ` `  `        ``# add lcm of ith elements ` `        ``# for all j in lcm array. ` `        ``lcm.append(y) ` `     `  `    ``# now we find gcd of all ith elements. ` `    ``# where i = 0, 1, 2, 3.....n-2. ` `    ``ans ``=` `lcm[``0``] ` `    ``for` `i ``in` `range``(``1``, n``-``1``): ` `        ``ans ``=` `gcd(ans, lcm[i]) ` `     `  `    ``print``(ans) ` ` `  `if` `__name__``=``=` `"__main__"``:  ` ` `  `    ``n ``=` `4` `    ``a ``=``[``10``, ``24``, ``40``, ``80``] ` ` `  `    ``# function call for input 1 ` `    ``gcd_of_lcm(n, a) ` ` `  `    ``n ``=` `10` `    ``a ``=``[``540``, ``648``, ``810``, ``648``, ``720``,  ` `        ``540``, ``594``, ``864``, ``972``, ``648``] ` ` `  `    ``# function call for input 2 ` `    ``gcd_of_lcm(n, a) `

Output:

```40
54
```

Time Complexity: O(N * log M), where M is the maximum element in the array.
Space Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.