Open In App

Minimum replacement of pairs by their LCM required to reduce given array to its LCM

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array arr[] consisting of N positive integers, the task is to find the minimum number of pairs (arr[i], arr[j]) from the given array needed to be replaced with their LCM such that the array is reduced to a single element equal to the LCM of the initial array.
Examples: 

Input: arr[] = {1, 2, 3, 4} 
Output:
Explanation: 
LCM of the array = 12 
Step 1: LCM(3, 4) = 12. Therefore array is modified to {1, 2, 12} 
Step 2: LCM(1, 12) = 12. Therefore array is modified to {2, 12} 
Step 3: LCM(2, 12) = 12. Therefore array is modified to {12}
Input: arr[] = {7, 9, 3} 
Output:
Explanation: 
LCM of the array = 63 
Step 1: LCM(7, 9) = 63. Therefore array is modified to {63, 3} 
Step 2: LCM(63, 3) = 63. Therefore array is modified to {63} 
 

Naive Approach: The idea is to generate all possible pairs and for each pair, replace them by their LCM and calculate the number of steps required to reduce them to a single array element equal to their LCM. Print the minimum number of operations required.
Time Complexity: O((N!)*log N) 
Auxiliary Space: O(N) 

Efficient Approach: The above approach can be optimized based on the following observations: 

  • The LCM of an array is equal to the product of all prime numbers in the array.
  • In (X – 1) steps, the LCM of all the X prime numbers can be obtained using two numbers as pairs.
  • In next (N – 2) steps convert the rest (N – 2) elements equals to the LCM of the array.
  • Therefore, the total number of steps is given by: 
     

(N – 2) + (X – 1) for N > 2 
 

  • For N = 1, the number of operations is simply 0 and for N = 2, the number of operations is 1.

Steps:  

  1. If N = 1 then the count of steps is 0.
  2. If N = 2 then the count of steps is 1.
  3. Generate all primes up to N using Sieve Of Eratosthenes.
  4. Store the count of primes in a variable, say X.
  5. The total count of operations is given by: 
     

(N – 2) + (X – 1) for N > 2  

Below is the implementation of the above approach:
 

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
const int maxm = 10001;
 
// Boolean array to set or unset
// prime non-prime indices
bool prime[maxm];
 
// Stores the prefix sum of the count
// of prime numbers
int prime_number[maxm];
 
// Function to check if a number
// is prime or not from 0 to N
void SieveOfEratosthenes()
{
    memset(prime, true, sizeof(prime));
 
    for (int p = 2; p * p < maxm; p++) {
 
        // If p is a prime
        if (prime[p] == true) {
 
            // Set its multiples as
            // non-prime
            for (int i = p * p; i < maxm;
                i += p)
                prime[i] = false;
        }
    }
 
    prime[0] = false;
    prime[1] = false;
}
 
// Function to store the count of
// prime numbers
void num_prime()
{
    prime_number[0] = 0;
 
    for (int i = 1; i <= maxm; i++)
 
        prime_number[i]
            = prime_number[i - 1]
            + prime[i];
}
 
// Function to count the operations
// to reduce the array to one element
// by replacing each pair with its LCM
void min_steps(int arr[], int n)
{
    // Generating Prime Number
    SieveOfEratosthenes();
 
    num_prime();
 
    // Corner Case
    if (n == 1)
        cout << "0\n";
 
    else if (n == 2)
        cout << "1\n";
 
    else
        cout << prime_number[n] - 1
                    + (n - 2);
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 5, 4, 3, 2, 1 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    min_steps(arr, N);
 
    return 0;
}


Java




// Java program for the above approach
import java.util.*;
class GFG{
     
static final int maxm = 10001;
 
// Boolean array to set or unset
// prime non-prime indices
static boolean prime[];
 
// Stores the prefix sum of the count
// of prime numbers
static int prime_number[];
 
// Function to check if a number
// is prime or not from 0 to N
static void SieveOfEratosthenes()
{
    Arrays.fill(prime,true);
 
    for(int p = 2; p * p < maxm; p++)
    {
         
        // If p is a prime
        if (prime[p] == true)
        {
             
            // Set its multiples as
            // non-prime
            for(int i = p * p; i < maxm; i += p)
                prime[i] = false;
        }
    }
    prime[0] = false;
    prime[1] = false;
}
 
// Function to store the count of
// prime numbers
static void num_prime()
{
    prime_number[0] = 0;
 
    for(int i = 1; i <= maxm; i++)
    {
        int tmp;
        if(prime[i] == true)
        {
            tmp = 1;
        }
        else
        {
            tmp = 0;
        }
        prime_number[i] = prime_number[i - 1] + tmp;
    }
}
 
// Function to count the operations
// to reduce the array to one element
// by replacing each pair with its LCM
static void min_steps(int arr[], int n)
{
     
    // Generating Prime Number
    SieveOfEratosthenes();
 
    num_prime();
 
    // Corner Case
    if (n == 1)
    {
        System.out.println("0");
    }
    else if (n == 2)
    {
        System.out.println("1");
    }
    else
    {
        System.out.println(prime_number[n] - 1 +
                                        (n - 2));
    }
}
 
// Driver code   
public static void main(String[] args)
{
    prime = new boolean[maxm + 1];
     
    // Stores the prefix sum of the count
    // of prime numbers
    prime_number = new int[maxm + 1];
     
    // Given array arr[]
    int arr[] = { 5, 4, 3, 2, 1 };
    int N = arr.length;
     
    // Function call
    min_steps(arr, N);
}
}
 
// This code is contributed by rutvik_56


Python3




# Python3 program for
# the above approach
maxm = 10001;
 
# Boolean array to set or unset
# prime non-prime indices
prime = [True] * (maxm + 1);
 
# Stores the prefix sum of the count
# of prime numbers
prime_number = [0] * (maxm + 1);
 
# Function to check if a number
# is prime or not from 0 to N
def SieveOfEratosthenes():
 
    for p in range(2, (int(maxm ** 1 / 2))):
 
        # If p is a prime
        if (prime[p] == True):
 
            # Set its multiples as
            # non-prime
            for i in range(p * p, maxm, p):
                prime[i] = False;
 
    prime[0] = False;
    prime[1] = False;
 
# Function to store the count of
# prime numbers
def num_prime():
    prime_number[0] = 0;
 
    for i in range(1, maxm + 1):
        tmp = -1;
        if (prime[i] == True):
            tmp = 1;
        else:
            tmp = 0;
 
        prime_number[i] = prime_number[i - 1] + tmp;
 
 
# Function to count the operations
# to reduce the array to one element
# by replacing each pair with its LCM
def min_steps(arr, n):
   
    # Generating Prime Number
    SieveOfEratosthenes();
 
    num_prime();
 
    # Corner Case
    if (n == 1):
        print("0");
    elif (n == 2):
        print("1");
    else:
        print(prime_number[n] - 1 + (n - 2));
 
# Driver code
if __name__ == '__main__':
   
    # Given array arr
    arr = [5, 4, 3, 2, 1];
    N = len(arr);
 
    # Function call
    min_steps(arr, N);
 
# This code is contributed by Rajput-Ji


C#




// C# program for the above approach
using System;
class GFG{
     
static readonly int maxm = 10001;
 
// Boolean array to set or unset
// prime non-prime indices
static bool []prime;
 
// Stores the prefix sum of the count
// of prime numbers
static int []prime_number;
 
// Function to check if a number
// is prime or not from 0 to N
static void SieveOfEratosthenes()
{
    for(int i = 0; i < prime.Length; i++)
        prime[i] = true;
    for(int p = 2; p * p < maxm; p++)
    {       
        // If p is a prime
        if (prime[p] == true)
        {           
            // Set its multiples as
            // non-prime
            for(int i = p * p; i < maxm;
                i += p)
                prime[i] = false;
        }
    }
    prime[0] = false;
    prime[1] = false;
}
 
// Function to store the count of
// prime numbers
static void num_prime()
{
    prime_number[0] = 0;
 
    for(int i = 1; i <= maxm; i++)
    {
        int tmp;
        if(prime[i] == true)
        {
            tmp = 1;
        }
        else
        {
            tmp = 0;
        }
        prime_number[i] = prime_number[i - 1] +
                          tmp;
    }
}
 
// Function to count the operations
// to reduce the array to one element
// by replacing each pair with its LCM
static void min_steps(int []arr, int n)
{   
    // Generating Prime Number
    SieveOfEratosthenes();
 
    num_prime();
 
    // Corner Case
    if (n == 1)
    {
        Console.WriteLine("0");
    }
    else if (n == 2)
    {
        Console.WriteLine("1");
    }
    else
    {
        Console.WriteLine(prime_number[n] - 1 +
                          (n - 2));
    }
}
 
// Driver code   
public static void Main(String[] args)
{
    prime = new bool[maxm + 1];
     
    // Stores the prefix sum of the count
    // of prime numbers
    prime_number = new int[maxm + 1];
     
    // Given array []arr
    int []arr = {5, 4, 3, 2, 1};
    int N = arr.Length;
     
    // Function call
    min_steps(arr, N);
}
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
// javascript program for the above approach
     const maxm = 10001;
 
    // Boolean array to set or unset
    // prime non-prime indices
    var prime = Array();
 
    // Stores the prefix sum of the count
    // of prime numbers
    var prime_number = Array();
 
    // Function to check if a number
    // is prime or not from 0 to N
    function SieveOfEratosthenes()
    {
        for(i = 0; i < maxm; i++)
        prime[i] = true;
        for (p = 2; p * p < maxm; p++)
        {
 
            // If p is a prime
            if (prime[p] == true)
            {
 
                // Set its multiples as
                // non-prime
                for (i = p * p; i < maxm; i += p)
                    prime[i] = false;
            }
        }
        prime[0] = false;
        prime[1] = false;
    }
 
    // Function to store the count of
    // prime numbers
    function num_prime() {
        prime_number[0] = 0;
 
        for (i = 1; i <= maxm; i++) {
            var tmp;
            if (prime[i] == true) {
                tmp = 1;
            } else {
                tmp = 0;
            }
            prime_number[i] = prime_number[i - 1] + tmp;
        }
    }
 
    // Function to count the operations
    // to reduce the array to one element
    // by replacing each pair with its LCM
    function min_steps(arr , n) {
 
        // Generating Prime Number
        SieveOfEratosthenes();
 
        num_prime();
 
        // Corner Case
        if (n == 1) {
            document.write("0");
        } else if (n == 2) {
            document.write("1");
        } else {
            document.write(prime_number[n] - 1 + (n - 2));
        }
    }
 
    // Driver code
     
        // Stores the prefix sum of the count
        // of prime numbers
        prime_number.fill(0);
 
        // Given array arr
        var arr = [ 5, 4, 3, 2, 1 ];
        var N = arr.length;
 
        // Function call
        min_steps(arr, N);
 
// This code is contributed by aashish1995
</script>


Output: 

5

 

Time Complexity: O(N + log(log(maxm)) 
Auxiliary Space: O(maxm) 



Last Updated : 13 Apr, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads