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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ code to find the GCD of LCM
// of all unique pairs in an Array
#include <bits/stdc++.h>
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[0];
      
    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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.