Maximum GCD of N integers with given product

Given N integers with unknown values (ai > 0) having product P. The task is to find the maximum possible greatest common divisor of these N integers.

Examples:

Input : N = 3, P = 24
Output : 2
The integers will have maximum GCD of 2 when a1 = 2, a2 = 2, a3 = 6.

Input : N = 2, P = 1
Output : 1
Only possibility is a1 = 1 and a2 = 1.

Approach:

  • First find all the prime factors of product P and store it in a Hashmap.
  • The N integers will have maximum GCD when a prime factor will be common in all the integers.
  • So if P = p1k1 * p2k2 * p3k3 …. where p1, p2 … are prime numbers then, maximum GCD which can be obtained will be ans = p1k1 / N * p2k2 / N * p3k3 / N ….

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to find maximum GCD
// of N integers with product P
int maxGCD(int N, int P)
{
  
    int ans = 1;
  
    // map to store prime factors of P
    unordered_map<int, int> prime_factors;
  
    // prime factorization of P
    for (int i = 2; i * i <= P; i++) {
  
        while (P % i == 0) {
  
            prime_factors[i]++;
  
            P /= i;
        }
    }
  
    if (P != 1)
        prime_factors[P]++;
  
    // traverse all prime factors and
    // multiply its 1/N power to the result
    for (auto v : prime_factors) 
        ans *= pow(v.first, v.second / N);    
  
    return ans;
}
  
// Driver code
int main()
{
    int N = 3, P = 24;
  
    cout << maxGCD(N, P);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of above approach 
import java.util.*;
class Solution
{
// Function to find maximum GCD 
// of N integers with product P 
static int maxGCD(int N, int P) 
  
    int ans = 1
  
    // map to store prime factors of P 
    Map<Integer, Integer> prime_factors =  
                        new HashMap< Integer,Integer>(); 
  
    // prime factorization of P 
    for (int i = 2; i * i <= P; i++) { 
  
        while (P % i == 0) { 
  
            if(prime_factors.get(i)==null)
            prime_factors.put(i,1);
            else
            prime_factors.put(i,(prime_factors.get(i)+1));
              
  
            P /= i; 
        
    
  
    if (P != 1
            if(prime_factors.get(P)==null)
            prime_factors.put(P,1);
            else
            prime_factors.put(P,(prime_factors.get(P)+1)); 
  
    // traverse all prime factors and 
    // multiply its 1/N power to the result 
        Set< Map.Entry< Integer,Integer> > st = prime_factors.entrySet();    
    
       for (Map.Entry< Integer,Integer> me:st) 
       
             
        ans *= Math.pow(me.getKey(),me.getValue() / N);    
        }
  
    return ans; 
  
// Driver code 
public static void main(String args[])
    int N = 3, P = 24
  
    System.out.println( maxGCD(N, P)); 
  
}
//contributed by Arnab Kundu

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of 
# above approach 
from math import sqrt
  
# Function to find maximum GCD 
# of N integers with product P 
def maxGCD(N, P):
  
    ans = 1
  
    # map to store prime factors of P 
    prime_factors = {}
      
    # prime factorization of P 
    for i in range(2, int(sqrt(P) + 1)) :
  
        while (P % i == 0) :
              
            if i not in prime_factors :
                prime_factors[i] = 0
          
            prime_factors[i] += 1
            P //= i
          
    if (P != 1) :
        prime_factors[P] += 1
  
    # traverse all prime factors and 
    # multiply its 1/N power to the result 
    for key, value in prime_factors.items() :
        ans *= pow(key, value // N) 
  
    return ans
  
# Driver code 
if __name__ == "__main__"
  
    N, P = 3, 24
  
    print(maxGCD(N, P))
  
# This code is contributed by Ryuga

chevron_right


Output:

2


My Personal Notes arrow_drop_up