Related Articles

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

• Last Updated : 09 Apr, 2021

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

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)`

## C#

 `// C# code to find the GCD of LCM``// of all unique pairs in an array``using` `System;` `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;``    ` `    ``for``(``int` `i = 1; i < n - 1; i++)``    ``{``        ``ans = gcd(ans, lcm[i]);``    ``}``    ` `    ``// Print the answer``    ``Console.WriteLine(ans);``}` `// Driver code``public` `static` `void` `Main()``{``    ` `    ``// 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 sanjoy_62`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up