📌  相关文章
📜  乘积为M的N个长度序列的数目

📅  最后修改于: 2021-05-07 05:08:20             🧑  作者: Mango

给定两个整数NM ,任务是找到长度为N的可能序列a 1 ,a 2 …的计数,以使该序列所有元素的乘积为M。

例子:

方法:

  • 考虑M的素因式分解为p 1 k 1 p 2 k 2 …p z k z
  • 对于每个素数因子,其指数必须分布在N个不同的组中,因为在乘以这N个项时,素数因子的指数将相加。可以使用此处说明的公式完成此操作。
  • 对于每个素数因子,将其指数分布在N个序列中的方式数量等于
    1≤i≤z N + K i -1 C N-1
  • 使用乘法的基本原理,将所有主要因子的结果相乘以获得答案。

下面是上述方法的实现:

C++
// C++ implementation of the above approach
#include 
using namespace std;
  
// Function to calculate the
// value of ncr effectively
int ncr(int n, int r)
{
  
    // Initializing the result
    int res = 1;
  
    for (int i = 1; i <= r; i += 1) {
  
        // Multiply and divide simultaneously
        // to avoid overflow
        res *= (n - r + i);
        res /= i;
    }
  
    // Return the answer
    return res;
}
  
// Function to return the number of sequences
// of length N such that their product is M
int NoofSequences(int N, int M)
{
  
    // Hashmap to store the prime factors of M
    unordered_map prime;
  
    // Calculate the prime factors of M
    for (int i = 2; i <= sqrt(M); i += 1) {
  
        // If i divides M it means it is a factor
        // Divide M by i till it could be
        // divided to store the exponent
        while (M % i == 0) {
  
            // Increase the exponent count
            prime[i] += 1;
            M /= i;
        }
    }
  
    // If the number is a prime number
    // greater than sqrt(M)
    if (M > 1) {
        prime[M] += 1;
    }
  
    // Initializing the ans
    int ans = 1;
  
    // Multiply the answer for every prime factor
    for (auto it : prime) {
  
        // it.second represents the
        // exponent of every prime factor
        ans *= (ncr(N + it.second - 1, N - 1));
    }
  
    // Return the result
    return ans;
}
  
// Driver code
int main()
{
    int N = 2, M = 6;
  
    cout << NoofSequences(N, M);
  
    return 0;
}


Java
// Java implementation of the above approach
import java.util.HashMap;
  
class geeks 
{
  
    // Function to calculate the
    // value of ncr effectively
    public static int nCr(int n, int r) 
    {
  
        // Initializing the result
        int res = 1;
        for (int i = 1; i <= r; i++) 
        {
  
            // Multiply and divide simultaneously
            // to avoid overflow
            res *= (n - r + i);
            res /= i;
        }
  
        // Return the answer
        return res;
    }
  
    // Function to return the number of sequences
    // of length N such that their product is M
    public static int NoofSequences(int N, int M) 
    {
          
        // Hashmap to store the prime factors of M
        HashMap prime = new HashMap<>();
  
        // Calculate the prime factors of M 
        for (int i = 2; i <= Math.sqrt(M); i++) 
        {
  
            // If i divides M it means it is a factor
            // Divide M by i till it could be
            // divided to store the exponent
            while (M % i == 0)
            {
  
                // Increase the exponent count
                if (prime.get(i) == null)
                    prime.put(i, 1);
                else 
                {
                    int x = prime.get(i);
                    prime.put(i, ++x);
                }
                M /= i;
            }
        }
  
        // If the number is a prime number
        // greater than sqrt(M) 
        if (M > 1)
        {
            if (prime.get(M) != null) 
            {
                int x = prime.get(M);
                prime.put(M, ++x);
            } 
            else
                prime.put(M, 1);
        }
  
        // Initializing the ans
        int ans = 1;
  
        // Multiply the answer for every prime factor 
        for (HashMap.Entry entry : prime.entrySet())
        {
  
            // entry.getValue() represents the
            // exponent of every prime factor
            ans *= (nCr(N + entry.getValue() - 1, N - 1));
        }
  
        // Return the result
        return ans;
    }
      
    // Driver code
    public static void main(String[] args) 
    {
        int N = 2, M = 6;
        System.out.println(NoofSequences(N, M));
    }
}
  
// This code is contributed by
// sanjeev2552


Python3
# Python3 implementation of the above approach
  
# Function to calculate the
# value of ncr effectively
def ncr(n, r):
  
  
    # Initializing the result
    res = 1
  
    for i in range(1,r+1):
  
        # Multiply and divide simultaneously
        # to avoid overflow
        res *= (n - r + i)
        res //= i
  
    # Return the answer
    return res
  
# Function to return the number of sequences
# of length N such that their product is M
def NoofSequences(N, M):
  
    # Hashmap to store the prime factors of M
    prime={}
  
    # Calculate the prime factors of M
    for i in range(2,int(M**(.5))+1):
  
        # If i divides M it means it is a factor
        # Divide M by i till it could be
        # divided to store the exponent
        while (M % i == 0):
  
            # Increase the exponent count
            prime[i]= prime.get(i,0)+1
            M //= i
  
  
    # If the number is a prime number
    # greater than sqrt(M)
    if (M > 1):
        prime[M] =prime.get(M,0) + 1
  
    # Initializing the ans
    ans = 1
  
    # Multiply the answer for every prime factor
    for it in prime:
  
        # it.second represents the
        # exponent of every prime factor
        ans *= (ncr(N + prime[it] - 1, N - 1))
  
    # Return the result
    return ans
  
# Driver code
  
N = 2
M = 6
  
print(NoofSequences(N, M))
  
# This code is contributed by mohit kumar 29


C#
// C# implementation of the approach
using System;
using System.Collections.Generic;
      
public class geeks 
{
   
    // Function to calculate the
    // value of ncr effectively
    public static int nCr(int n, int r) 
    {
   
        // Initializing the result
        int res = 1;
        for (int i = 1; i <= r; i++) 
        {
   
            // Multiply and divide simultaneously
            // to avoid overflow
            res *= (n - r + i);
            res /= i;
        }
   
        // Return the answer
        return res;
    }
   
    // Function to return the number of sequences
    // of length N such that their product is M
    public static int NoofSequences(int N, int M) 
    {
           
        // Hashmap to store the prime factors of M
        Dictionaryprime = new Dictionary();
   
        // Calculate the prime factors of M 
        for (int i = 2; i <= Math.Sqrt(M); i++) 
        {
   
            // If i divides M it means it is a factor
            // Divide M by i till it could be
            // divided to store the exponent
            while (M % i == 0)
            {
   
                // Increase the exponent count
                if (!prime.ContainsKey(i))
                    prime.Add(i, 1);
                else
                {
                    int x = prime[i];
                    prime.Remove(i);
                    prime.Add(i, ++x);
                }
                M /= i;
            }
        }
   
        // If the number is a prime number
        // greater than sqrt(M) 
        if (M > 1)
        {
            if (prime.ContainsKey(M)) 
            {
                int x = prime[M];
                prime.Remove(M);
                prime.Add(M, ++x);
            } 
            else
                prime.Add(M, 1);
        }
   
        // Initializing the ans
        int ans = 1;
   
        // Multiply the answer for every prime factor 
        foreach(KeyValuePair entry in prime)
        {
   
            // entry.getValue() represents the
            // exponent of every prime factor
            ans *= (nCr(N + entry.Value - 1, N - 1));
        }
   
        // Return the result
        return ans;
    }
       
    // Driver code
    public static void Main(String[] args) 
    {
        int N = 2, M = 6;
        Console.WriteLine(NoofSequences(N, M));
    }
}
  
// This code is contributed by Princi Singh


输出:
4