转换为主要因子的步骤数

给定一个nrr个正整数的数组arr []。将每个数字表示为其因子(x * y = arr [i])[此处x或y不能为1]，直到无法将其进一步表示为x * y = arr [i]。打印将其拆分所需的步骤数，直到无法进一步表示为止。

例子：

Input: 4 4 4
Output: 3
Explanation: 1st step 2 2 4 4 . 
             2nd step 2 2 2 2 4 
             3rd step 2 2 2 2 2 2 

Input: 20 4 
Output: 3
Explanation: 1st step 20 2 2 (2*2 = 4)
             2nd step 2 10 2 2 (2*10 = 20)
             3rd step 2 2 5 2 2, (2*5 = 10)

方法是预先计算每个数字的素因。使用Sieve的实现可以有效地计算素因子，该实现需要N * logN 。我们知道一个数可以表示为其素因数的乘积，并且可以一直表示它不等于1，因此不计入1，因此，如果该数不是1，则可以计算素数的数，并且然后从中减去1。

C++

// CPP program to count number of steps
// required to convert an integer array
// to array of factors.
#include 
using namespace std;
  
const int MAX = 1000001;
  
// array to store prime factors
int factor[MAX] = { 0 };
  
// function to generate all prime factors
// of numbers from 1 to 10^6
void cal_factor()
{
    factor[1] = 1;
  
    // Initializes all the positions with their value.
    for (int i = 2; i < MAX; i++)
        factor[i] = i;
  
    // Initializes all multiples of 2 with 2
    for (int i = 4; i < MAX; i += 2)
        factor[i] = 2;
  
    // A modified version of Sieve of Eratosthenes to
    // store the smallest prime factor that divides
    // every number.
    for (int i = 3; i * i < MAX; i++) {
  
        // check if it has no prime factor.
        if (factor[i] == i) {
  
            // Initializes of j starting from i*i
            for (int j = i * i; j < MAX; j += i) {
  
                // if it has no prime factor before, then
                // stores the smallest prime divisor
                if (factor[j] == j)
                    factor[j] = i;
            }
        }
    }
}
  
// function to calculate the number of representations
int no_of_representations(int a[], int n)
{
    // keep an count of prime factors
    int count = 0;
  
    // traverse for every element
    for (int i = 0; i < n; i++) {
  
        int temp = a[i];
        int flag = 0;
  
        // count the no of factors
        while (factor[temp] != 1) {
            flag = -1;
            count++;
            temp = temp / factor[temp];
        }
  
        // subtract 1 if Ai is not 1 as the last step
        // wont be taken into count
        count += flag;
    }
  
    return count;
}
  
// driver program to test the above function
int main()
{
    // call sieve to calculate the factors
    cal_factor();
  
    int a[] = { 4, 4, 4 };
    int n = sizeof(a) / sizeof(a[0]);
  
    cout << no_of_representations(a, n);
  
    return 0;
}

Java

// Java program to count number of steps
// required to convert an integer array
// to array of factors.
  
class GFG 
{
    static final int MAX = 1000001;
  
    // array to store prime factors
    static int factor[] = new int[MAX];
  
    // function to generate all prime factors
    // of numbers from 1 to 10^6
    static void cal_factor() {
    factor[1] = 1;
  
    // Initializes all the positions
    // with their value.
    for (int i = 2; i < MAX; i++)
    factor[i] = i;
  
    // Initializes all multiples of 2 with 2
    for (int i = 4; i < MAX; i += 2)
    factor[i] = 2;
  
    // A modified version of Sieve of Eratosthenes to
    // store the smallest prime factor that divides
    // every number.
    for (int i = 3; i * i < MAX; i++) {
  
    // check if it has no prime factor.
    if (factor[i] == i) {
  
        // Initializes of j starting from i*i
        for (int j = i * i; j < MAX; j += i) {
  
        // if it has no prime factor before, then
        // stores the smallest prime divisor
        if (factor[j] == j)
            factor[j] = i;
        }
    }
    }
}
  
// function to calculate the 
// number of representations
static int no_of_representations(int a[], int n) {
      
    // keep an count of prime factors
    int count = 0;
  
    // traverse for every element
    for (int i = 0; i < n; i++) {
  
    int temp = a[i];
    int flag = 0;
  
    // count the no of factors
    while (factor[temp] != 1) {
        flag = -1;
        count++;
        temp = temp / factor[temp];
    }
  
    // subtract 1 if Ai is not 1 as the 
    // last step wont be taken into count
    count += flag;
    }
  
    return count;
}
  
// Driver code
public static void main(String[] args) {
      
    // call sieve to calculate the factors
    cal_factor();
  
    int a[] = {4, 4, 4};
    int n = a.length;
  
    System.out.print(no_of_representations(a, n));
}
}
  
// This code is contributed by Anant Agarwal.

Python 3

# Python 3 program to count number 
# of steps required to convert an 
# integer array to array of factors.
MAX = 1000001
  
# array to store prime factors
factor = [0] * MAX
  
# function to generate all prime 
# factors of numbers from 1 to 10^6
def cal_factor():
  
    factor[1] = 1
  
    # Initializes all the positions
    # with their value.
    for i in range(2, MAX):
        factor[i] = i
  
    # Initializes all multiples
    # of 2 with 2
    for i in range(4, MAX, 2):
        factor[i] = 2
  
    # A modified version of Sieve of 
    # Eratosthenes to store the smallest 
    # prime factor that divides every number.
    i = 3
    while i * i < MAX:
  
        # check if it has no prime factor.
        if (factor[i] == i) :
  
            # Initializes of j starting
            # from i*i
            for j in range(i * i, MAX, i) :
  
                # if it has no prime factor 
                # before, then stores the 
                # smallest prime divisor
                if (factor[j] == j):
                    factor[j] = i
                      
        i += 1
  
# function to calculate the
# number of representations
def no_of_representations(a, n):
  
    # keep an count of prime factors
    count = 0
  
    # traverse for every element
    for i in range(n) :
  
        temp = a[i]
        flag = 0
  
        # count the no of factors
        while (factor[temp] != 1) :
            flag = -1
            count += 1
            temp = temp // factor[temp]
  
        # subtract 1 if Ai is not 1 as the 
        # last step wont be taken into count
        count += flag
  
    return count
  
# Driver Code
if __name__ == "__main__":
      
    # call sieve to calculate the factors
    cal_factor()
  
    a = [ 4, 4, 4 ]
    n = len(a)
  
    print(no_of_representations(a, n))
  
# This code is contributed
# by ChitraNayal

C#

// C# program to count number of steps
// required to convert an integer array
// to array of factors.
using System;
  
class GFG {
      
    static int MAX = 1000001;
  
    // array to store prime factors
    static int []factor = new int[MAX];
  
    // function to generate all prime
    // factors of numbers from 1 to 10^6
    static void cal_factor()
    {
        factor[1] = 1;
      
        // Initializes all the positions
        // with their value.
        for (int i = 2; i < MAX; i++)
            factor[i] = i;
      
        // Initializes all multiples of
        // 2 with 2
        for (int i = 4; i < MAX; i += 2)
            factor[i] = 2;
      
        // A modified version of Sieve of
        // Eratosthenes to store the 
        // smallest prime factor that 
        // divides every number.
        for (int i = 3; i * i < MAX; i++)
        {
      
            // check if it has no prime
            // factor.
            if (factor[i] == i)
            {
          
                // Initializes of j 
                // starting from i*i
                for (int j = i * i; 
                           j < MAX; j += i)
                {
          
                    // if it has no prime 
                    // factor before, then
                    // stores the smallest
                    // prime divisor
                    if (factor[j] == j)
                        factor[j] = i;
                }
            }
        }
    }
  
    // function to calculate the 
    // number of representations
    static int no_of_representations(
                           int []a, int n)
    {
          
        // keep an count of prime factors
        int count = 0;
      
        // traverse for every element
        for (int i = 0; i < n; i++)
        {
            int temp = a[i];
            int flag = 0;
          
            // count the no of factors
            while (factor[temp] != 1)
            {
                flag = -1;
                count++;
                temp = temp / factor[temp];
            }
          
            // subtract 1 if Ai is not 1
            // as the last step wont be 
            // taken into count
            count += flag;
        }
      
        return count;
    }
      
    // Driver code
    public static void Main()
    {
          
        // call sieve to calculate
        // the factors
        cal_factor();
      
        int []a = {4, 4, 4};
        int n = a.Length;
      
        Console.WriteLine(
            no_of_representations(a, n));
    }
}
  
// This code is contributed by vt_m.

输出：

3

时间复杂度： O(n * log n)