Minimum LCM of all pairs in a given array
Given an array arr[] of size N, the task is to find the minimum LCM (Least Common Multiple) of all unique pairs in the given array, where 1 <= N <= 105, 1 <= arr[i] <= 105.
Examples:
Input: arr[] = {2, 4, 3}
Output: 4
Explanation
LCM (2, 4) = 4
LCM (2, 3) = 6
LCM (4, 3) = 12
Minimum possible LCM is 4.
Input: arr [] ={1, 5, 2, 2, 6}
Output: 2
Naive Approach
- Generate all possible pairs and compute LCM for every unique pair.
- Find the minimum LCM from all unique pairs.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int gcd( int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
int minLCM( int arr[], int n)
{
int ans = INT_MAX;
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j < n; j++) {
int g = gcd(arr[i], arr[j]);
int lcm = arr[i] / g * arr[j];
ans = min(ans, lcm);
}
}
return ans;
}
int main()
{
int arr[] = { 2, 4, 3, 6, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << minLCM(arr, n) << endl;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static int gcd( int a, int b)
{
if (b == 0 )
return a;
return gcd(b, a % b);
}
static int minLCM( int arr[], int n)
{
int ans = Integer.MAX_VALUE;
for ( int i = 0 ; i < n; i++)
{
for ( int j = i + 1 ; j < n; j++)
{
int g = gcd(arr[i], arr[j]);
int lcm = arr[i] / g * arr[j];
ans = Math.min(ans, lcm);
}
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 2 , 4 , 3 , 6 , 5 };
int n = arr.length;
System.out.println(minLCM(arr,n));
}
}
|
Python3
import sys
def gcd(a, b):
if (b = = 0 ):
return a;
return gcd(b, a % b);
def minLCM(arr, n):
ans = 1000000000 ;
for i in range (n):
for j in range (i + 1 , n):
g = gcd(arr[i], arr[j]);
lcm = arr[i] / g * arr[j];
ans = min (ans, lcm);
return ans;
arr = [ 2 , 4 , 3 , 6 , 5 ];
print (minLCM(arr, 5 ))
|
C#
using System;
class GFG{
static int gcd( int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static int minLCM( int []arr, int n)
{
int ans = Int32.MaxValue;
for ( int i = 0; i < n; i++)
{
for ( int j = i + 1; j < n; j++)
{
int g = gcd(arr[i], arr[j]);
int lcm = arr[i] / g * arr[j];
ans = Math.Min(ans, lcm);
}
}
return ans;
}
public static void Main()
{
int []arr = { 2, 4, 3, 6, 5 };
int n = arr.Length;
Console.Write(minLCM(arr,n));
}
}
|
Javascript
<script>
function gcd(a, b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
function minLCM(arr, n)
{
let ans = Number.MAX_VALUE;
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
let g = gcd(arr[i], arr[j]);
let lcm = arr[i] / g * arr[j];
ans = Math.min(ans, lcm);
}
}
return ans;
}
let arr = [ 2, 4, 3, 6, 5 ];
let n = arr.length;
document.write(minLCM(arr, n));
</script>
|
Time Complexity: O(N2)
Auxiliary Space: O(log(Ai)), where Ai is the second maximum element in the array.
Efficient Approach: This approach depends upon the formula:
Product of two number = LCM of two number * GCD of two number
- In the formula of LCM, the denominator is the GCD of two numbers, and the GCD of two numbers will never be greater than the number itself.
- So for a fixed GCD, find the smallest two multiples of that fixed GCD that is present in the given array.
- Store only the smallest two multiples of each GCD because choosing a bigger multiple of GCD that is present in the array, no matter what, it will never give the minimum answer.
- Finally, use a sieve to find the minimum two number that is the multiple of the chosen GCD.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int minLCM( int arr[], int n)
{
int mx = 0;
for ( int i = 0; i < n; i++) {
mx = max(mx, arr[i]);
}
vector<vector< int > > mul(mx + 1);
for ( int i = 0; i < n; i++) {
if (mul[arr[i]].size() > 1) {
continue ;
}
mul[arr[i]].push_back(arr[i]);
}
for ( int i = 1; i <= mx; i++) {
for ( int j = i + i; j <= mx; j += i) {
if (mul[i].size() > 1) {
break ;
}
for ( int k : mul[j]) {
if (mul[i].size() > 1)
break ;
mul[i].push_back(k);
}
}
}
int ans = INT_MAX;
for ( int i = 1; i <= mx; i++) {
if (mul[i].size() <= 1)
continue ;
int a = mul[i][0], b = mul[i][1];
int lcm = (a * b) / i;
ans = min(ans, lcm);
}
return ans;
}
int main()
{
int arr[] = { 2, 4, 3, 6, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << minLCM(arr, n) << endl;
return 0;
}
|
Java
import java.util.Vector;
class GFG{
static int minLCM( int arr[],
int n)
{
int mx = 0 ;
for ( int i = 0 ; i < n; i++)
{
mx = Math.max(mx, arr[i]);
}
Vector<Integer> []mul = new Vector[mx + 1 ];
for ( int i = 0 ; i < mul.length; i++)
mul[i] = new Vector<Integer>();
for ( int i = 0 ; i < n; i++)
{
if (mul[arr[i]].size() > 1 )
{
continue ;
}
mul[arr[i]].add(arr[i]);
}
for ( int i = 1 ; i <= mx; i++)
{
for ( int j = i + i; j <= mx; j += i)
{
if (mul[i].size() > 1 )
{
break ;
}
for ( int k : mul[j])
{
if (mul[i].size() > 1 )
break ;
mul[i].add(k);
}
}
}
int ans = Integer.MAX_VALUE;
for ( int i = 1 ; i <= mx; i++)
{
if (mul[i].size() <= 1 )
continue ;
int a = mul[i].get( 0 ),
b = mul[i].get( 1 );
int lcm = (a * b) / i;
ans = Math.min(ans, lcm);
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 2 , 4 , 3 , 6 , 5 };
int n = arr.length;
System.out.print(minLCM(arr, n) + "\n" );
}
}
|
Python3
import sys
def minLCM(arr, n) :
mx = 0
for i in range (n) :
mx = max (mx, arr[i])
mul = [[] for i in range (mx + 1 )]
for i in range (n) :
if ( len (mul[arr[i]]) > 1 ) :
continue
mul[arr[i]].append(arr[i])
for i in range ( 1 , mx + 1 ) :
for j in range (i + i, mx + 1 , i) :
if ( len (mul[i]) > 1 ) :
break
for k in mul[j] :
if ( len (mul[i]) > 1 ) :
break
mul[i].append(k)
ans = sys.maxsize
for i in range ( 1 , mx + 1 ) :
if ( len (mul[i]) < = 1 ) :
continue
a, b = mul[i][ 0 ], mul[i][ 1 ]
lcm = (a * b) / / i
ans = min (ans, lcm)
return ans
arr = [ 2 , 4 , 3 , 6 , 5 ]
n = len (arr)
print (minLCM(arr, n))
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int minLCM( int []arr,
int n)
{
int mx = 0;
for ( int i = 0; i < n; i++)
{
mx = Math.Max(mx, arr[i]);
}
List< int > []mul = new List< int >[mx + 1];
for ( int i = 0; i < mul.Length; i++)
mul[i] = new List< int >();
for ( int i = 0; i < n; i++)
{
if (mul[arr[i]].Count > 1)
{
continue ;
}
mul[arr[i]].Add(arr[i]);
}
for ( int i = 1; i <= mx; i++)
{
for ( int j = i + i; j <= mx; j += i)
{
if (mul[i].Count > 1)
{
break ;
}
foreach ( int k in mul[j])
{
if (mul[i].Count > 1)
break ;
mul[i].Add(k);
}
}
}
int ans = int .MaxValue;
for ( int i = 1; i <= mx; i++)
{
if (mul[i].Count <= 1)
continue ;
int a = mul[i][0],
b = mul[i][1];
int lcm = (a * b) / i;
ans = Math.Min(ans, lcm);
}
return ans;
}
public static void Main(String[] args)
{
int []arr = {2, 4, 3, 6, 5};
int n = arr.Length;
Console.Write(minLCM(arr, n) + "\n" );
}
}
|
Javascript
<script>
function minLCM(arr, n)
{
var mx = 0;
for ( var i = 0; i < n; i++)
{
mx = Math.max(mx, arr[i]);
}
var mul = Array.from(Array(mx + 1), () => Array());
for ( var i = 0; i < n; i++)
{
if (mul[arr[i]].length > 1)
{
continue ;
}
mul[arr[i]].push(arr[i]);
}
for ( var i = 1; i <= mx; i++)
{
for ( var j = i + i; j <= mx; j += i)
{
if (mul[i].length > 1)
{
break ;
}
mul[j].forEach(k => {
if (mul[i].length <= 1)
{
mul[i].push(k);
}
});
}
}
var ans = 1000000000;
for ( var i = 1; i <= mx; i++)
{
if (mul[i].length <= 1)
continue ;
var a = mul[i][0], b = mul[i][1];
var lcm = (a * b) / i;
ans = Math.min(ans, lcm);
}
return ans;
}
var arr = [ 2, 4, 3, 6, 5 ];
var n = arr.length;
document.write( minLCM(arr, n) + "<br>" );
</script>
|
Time Complexity: O((N + M) * log(M))
Auxiliary Space: O(M) where M is the maximum element in the array.
Last Updated :
07 Oct, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...