📜  给定乘积的 N 个整数的最大 GCD

📅  最后修改于: 2021-10-27 07:57:34             🧑  作者: Mango

给定 N 个未知值 (a i > 0) 的整数,其乘积为 P。任务是找到这 N 个整数的最大可能的最大公约数。
例子:

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.

方法:

  • 首先找出乘积P的所有质因数并存入Hashmap。
  • 当一个素因子在所有整数中是共同的时, N 个整数将具有最大 GCD。
  • 所以如果P = p1 k1 * p2 k2 * p3 k3 ….其中 p1, p2 … 是素数,那么可以获得的最大 GCD 将是ans = p1 k1 / N * p2 k2 / N * p3 k3 / N …。

下面是上述方法的实现:

C++
// C++ implementation of above approach
#include 
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 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;
}


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


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


C#
// C# implementation of above approach
using System;
using System.Collections.Generic;
 
class GFG
{
     
// 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
    Dictionary prime_factors =
                        new Dictionary< int,int>();
 
    // prime factorization of P
    for (int i = 2; i * i <= P; i++)
    {
 
        while (P % i == 0)
        {
 
            if(!prime_factors.ContainsKey(i))
                prime_factors.Add(i, 1);
            else
            prime_factors[i] = prime_factors[i] + 1;
             
            P /= i;
        }
    }
 
    if (P != 1)
            if(!prime_factors.ContainsKey(P))
                prime_factors.Add(P, 1);
            else
            prime_factors[P] = prime_factors[P] + 1;
 
    // traverse all prime factors and
    // multiply its 1/N power to the result
    foreach(KeyValuePair me in prime_factors)
    {
             
        ans *= (int)Math.Pow(me.Key,me.Value / N);
    }
 
    return ans;
}
 
// Driver code
public static void Main(String []args)
{
    int N = 3, P = 24;
 
    Console.WriteLine( maxGCD(N, P));
}
}
 
// This code is contributed by PrinciRaj1992


Javascript


输出:
2

如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程