给定运算生成的质因数和的序列的最大长度

给定两个整数N和M ，任务是执行以下操作：

• 对于[N, M]范围内的每个值，计算其质因数的总和，然后是该总和的质因数的总和，依此类推。
• 为每个数组元素生成上述序列并计算序列的长度

Illustration 
N = 8 
Prime factors = {2, 2, 2}. Sum = 2 + 2 + 2 = 6. 
Prime factors of 6 = {2, 3}. Sum = 2 + 3 = 5. 
Now 5 cannot be reduced further. 
Therefore, the sequence is {8, 6, 5}. The length of the sequence is 3.

• 找出生成的此类子序列的最大长度。

例子：

Input: N = 5, M = 10 
Output: 3 
Explanation: 
For N = 5, the sequence is {5}, so length is 1 
For N = 6, the sequence is {6, 5}, so length is 2 
For N = 7, the sequence is {7}, so length is 1 
For N = 8, the sequence is {8, 6, 5}, so length is 3 
For N = 9, the sequence is {9, 6, 5}, so length is 3 
For N = 10, the sequence is {10, 7}, so length is 2 
Therefore, maximum length of sequence in this range is 3.

Input: N = 2, M = 14 
Output: 4

简单方法：解决该问题的最简单的方法是迭代范围[N，M]，并且对于每个整数，求其首要因素和它们求和并重复此为获得以及递归直至总和其本身的总和得到一个素数。

高效方法：上述方法可以使用动态规划进行优化。请按照以下步骤解决问题：

• 使用埃拉托色尼筛法预先计算素数。
• 使用 Sieve 使用质因数分解，预先计算每个整数的最小质因数以找出质因数。
• 现在，对于[N, M]范围内的每个整数，计算质因数的总和并递归地重复获得的总和。将序列的长度存储在dp[]数组中，以避免重新计算。如果获得的和是素数，则存储进一步的计算。
• 更新获得的最大长度并对[N, M]范围内的每个数字重复上述步骤，除了4 ，这导致无限循环。
• 打印获得的最大长度。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
// Smallest prime factor array
int spf[100005];
 
// Stores if a number is prime or not
bool prime[100005];
 
int dp[100005];
 
// Function to compute all primes
// using Sieve of Eratosthenes
void sieve()
{
    prime[0] = prime[1] = false;
 
    for (int i = 2; i < 100005; i++)
        prime[i] = true;
 
    for (int i = 2; i * i < 100005; i++) {
        if (prime[i]) {
            for (int j = i * i; j < 100005; j += i) {
                prime[j] = false;
            }
        }
    }
}
 
// Function for finding smallest
// prime factors for every integer
void smallestPrimeFactors()
{
    for (int i = 0; i < 100005; i++)
        spf[i] = -1;
    for (int i = 2; i * i < 100005; i++) {
        for (int j = i; j < 100005; j += i) {
            if (spf[j] == -1) {
                spf[j] = i;
            }
        }
    }
}
 
// Function to find the sum of
// prime factors of number
int sumOfPrimeFactors(int n)
{
 
    int ans = 0;
    while (n > 1) {
 
        // Add smallest prime
        // factor to the sum
        ans += spf[n];
 
        // Reduce N
        n /= spf[n];
    }
 
    // Return the answer
    return ans;
}
 
// Function to return the length of
// sequence of for the given number
int findLength(int n)
{
 
    // If the number is prime
    if (prime[n]) {
        return 1;
    }
 
    // If a previously computed
    // subproblem occurred
    if (dp[n]) {
        return dp[n];
    }
 
    // Calculate the sum of
    // prime factors
    int sum = sumOfPrimeFactors(n);
 
    return dp[n] = 1 + findLength(sum);
}
 
// Function to return the maximum length
// of sequence for the given range
int maxLength(int n, int m)
{
 
    // Pre-calculate primes
    sieve();
 
    // Precalculate smallest
    // prime factors
    smallestPrimeFactors();
 
    int ans = INT_MIN;
 
    // Iterate over the range
    for (int i = n; i <= m; i++) {
        if (i == 4) {
            continue;
        }
 
        // Update maximum length
        ans = max(ans, findLength(i));
    }
 
    return ans;
}
 
// Driver Code
int main()
{
    int n = 2, m = 14;
 
    cout << maxLength(n, m);
}

Java

// Java Program to implement
// the above approach
import java.util.*;
class GFG{
 
// Smallest prime factor array
static int spf[] = new int[100005];
 
// Stores if a number is prime or not
static boolean prime[] = new boolean[100005];
 
static int dp[] = new int[100005];
 
// Function to compute all primes
// using Sieve of Eratosthenes
static void sieve()
{
    prime[0] = prime[1] = false;
 
    for (int i = 2; i < 100005; i++)
        prime[i] = true;
 
    for (int i = 2; i * i < 100005; i++)
    {
        if (prime[i])
        {
            for (int j = i * i; j < 100005; j += i)
            {
                prime[j] = false;
            }
        }
    }
}
 
// Function for finding smallest
// prime factors for every integer
static void smallestPrimeFactors()
{
    for (int i = 0; i < 100005; i++)
        spf[i] = -1;
    for (int i = 2; i * i < 100005; i++)
    {
        for (int j = i; j < 100005; j += i)
        {
            if (spf[j] == -1)
            {
                spf[j] = i;
            }
        }
    }
}
 
// Function to find the sum of
// prime factors of number
static int sumOfPrimeFactors(int n)
{
 
    int ans = 0;
    while (n > 1)
    {
 
        // Add smallest prime
        // factor to the sum
        ans += spf[n];
 
        // Reduce N
        n /= spf[n];
    }
 
    // Return the answer
    return ans;
}
 
// Function to return the length of
// sequence of for the given number
static int findLength(int n)
{
 
    // If the number is prime
    if (prime[n])
    {
        return 1;
    }
 
    // If a previously computed
    // subproblem occurred
    if (dp[n] != 0)
    {
        return dp[n];
    }
 
    // Calculate the sum of
    // prime factors
    int sum = sumOfPrimeFactors(n);
 
    return dp[n] = 1 + findLength(sum);
}
 
// Function to return the maximum length
// of sequence for the given range
static int maxLength(int n, int m)
{
 
    // Pre-calculate primes
    sieve();
 
    // Precalculate smallest
    // prime factors
    smallestPrimeFactors();
 
    int ans = Integer.MIN_VALUE;
 
    // Iterate over the range
    for (int i = n; i <= m; i++)
    {
        if (i == 4)
        {
            continue;
        }
 
        // Update maximum length
        ans = Math.max(ans, findLength(i));
    }
 
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
    int n = 2, m = 14;
 
    System.out.print(maxLength(n, m));
}
}
 
// This code is contributed by Princi Singh

Python3

# Python3 program to implement
# the above approach
import sys
 
# Smallest prime factor array
spf = [0] * 100005
 
# Stores if a number is prime or not
prime = [False] * 100005
 
dp = [0] * 100005
 
# Function to compute all primes
# using Sieve of Eratosthenes
def sieve():
 
    for i in range(2, 100005):
        prime[i] = True
         
    i = 2
    while i * i < 100005:
        if(prime[i]):
            for j in range(i * i, 100005, i):
                prime[j] = False
                 
        i += 1
 
# Function for finding smallest
# prime factors for every integer
def smallestPrimeFactors():
 
    for i in range(10005):
        spf[i] = -1
 
    i = 2
    while i * i < 100005:
        for j in range(i, 100005, i):
            if(spf[j] == -1):
                spf[j] = i
 
        i += 1
 
# Function to find the sum of
# prime factors of number
def sumOfPrimeFactors(n):
 
    ans = 0
    while(n > 1):
 
        # Add smallest prime
        # factor to the sum
        ans += spf[n]
 
        # Reduce N
        n //= spf[n]
 
    # Return the answer
    return ans
 
# Function to return the length of
# sequence of for the given number
def findLength(n):
 
    # If the number is prime
    if(prime[n]):
        return 1
 
    # If a previously computed
    # subproblem occurred
    if(dp[n]):
        return dp[n]
 
    # Calculate the sum of
    # prime factors
    sum = sumOfPrimeFactors(n)
 
    dp[n] = 1 + findLength(sum)
 
    return dp[n]
 
# Function to return the maximum length
# of sequence for the given range
def maxLength(n, m):
 
    # Pre-calculate primes
    sieve()
 
    # Precalculate smallest
    # prime factors
    smallestPrimeFactors()
 
    ans = -sys.maxsize - 1
 
    # Iterate over the range
    for i in range(n, m + 1):
        if(i == 4):
            continue
 
        # Update maximum length
        ans = max(ans, findLength(i))
 
    return ans
 
# Driver Code
n = 2
m = 14
 
# Function call
print(maxLength(n, m))
 
# This code is contributed by Shivam Singh

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Smallest prime factor array
static int []spf = new int[100005];
 
// Stores if a number is prime or not
static bool []prime = new bool[100005];
 
static int []dp = new int[100005];
 
// Function to compute all primes
// using Sieve of Eratosthenes
static void sieve()
{
    prime[0] = prime[1] = false;
 
    for(int i = 2; i < 100005; i++)
        prime[i] = true;
 
    for(int i = 2; i * i < 100005; i++)
    {
        if (prime[i])
        {
            for(int j = i * i; j < 100005; j += i)
            {
                prime[j] = false;
            }
        }
    }
}
 
// Function for finding smallest
// prime factors for every integer
static void smallestPrimeFactors()
{
    for(int i = 0; i < 100005; i++)
        spf[i] = -1;
         
    for(int i = 2; i * i < 100005; i++)
    {
        for(int j = i; j < 100005; j += i)
        {
            if (spf[j] == -1)
            {
                spf[j] = i;
            }
        }
    }
}
 
// Function to find the sum of
// prime factors of number
static int sumOfPrimeFactors(int n)
{
    int ans = 0;
    while (n > 1)
    {
 
        // Add smallest prime
        // factor to the sum
        ans += spf[n];
 
        // Reduce N
        n /= spf[n];
    }
 
    // Return the answer
    return ans;
}
 
// Function to return the length of
// sequence of for the given number
static int findLength(int n)
{
 
    // If the number is prime
    if (prime[n])
    {
        return 1;
    }
 
    // If a previously computed
    // subproblem occurred
    if (dp[n] != 0)
    {
        return dp[n];
    }
 
    // Calculate the sum of
    // prime factors
    int sum = sumOfPrimeFactors(n);
 
    return dp[n] = 1 + findLength(sum);
}
 
// Function to return the maximum length
// of sequence for the given range
static int maxLength(int n, int m)
{
 
    // Pre-calculate primes
    sieve();
 
    // Precalculate smallest
    // prime factors
    smallestPrimeFactors();
 
    int ans = int.MinValue;
 
    // Iterate over the range
    for(int i = n; i <= m; i++)
    {
        if (i == 4)
        {
            continue;
        }
 
        // Update maximum length
        ans = Math.Max(ans, findLength(i));
    }
    return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
    int n = 2, m = 14;
 
    Console.Write(maxLength(n, m));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

// JavaScript program to implement
// the above approach
 
// Smallest prime factor array
let spf = Array.from({length: 100005}, (_, i) => 0);
   
// Stores if a number is prime or not
let prime = Array.from({length: 100005}, (_, i) => 0);
   
let dp = Array.from({length: 100005}, (_, i) => 0);
   
// Function to compute all primes
// using Sieve of Eratosthenes
function sieve()
{
    prime[0] = prime[1] = false;
   
    for (let i = 2; i < 100005; i++)
        prime[i] = true;
   
    for (let i = 2; i * i < 100005; i++)
    {
        if (prime[i])
        {
            for (let j = i * i; j < 100005; j += i)
            {
                prime[j] = false;
            }
        }
    }
}
   
// Function for finding smallest
// prime factors for every leteger
function smallestPrimeFactors()
{
    for (let i = 0; i < 100005; i++)
        spf[i] = -1;
    for (let i = 2; i * i < 100005; i++)
    {
        for (let j = i; j < 100005; j += i)
        {
            if (spf[j] == -1)
            {
                spf[j] = i;
            }
        }
    }
}
   
// Function to find the sum of
// prime factors of number
function sumOfPrimeFactors(n)
{
   
    let ans = 0;
    while (n > 1)
    {
   
        // Add smallest prime
        // factor to the sum
        ans += spf[n];
   
        // Reduce N
        n /= spf[n];
    }
   
    // Return the answer
    return ans;
}
   
// Function to return the length of
// sequence of for the given number
function findLength(n)
{
   
    // If the number is prime
    if (prime[n])
    {
        return 1;
    }
   
    // If a previously computed
    // subproblem occurred
    if (dp[n] != 0)
    {
        return dp[n];
    }
   
    // Calculate the sum of
    // prime factors
    let sum = sumOfPrimeFactors(n);
   
    return dp[n] = 1 + findLength(sum);
}
   
// Function to return the maximum length
// of sequence for the given range
function maxLength(n, m)
{
   
    // Pre-calculate primes
    sieve();
   
    // Precalculate smallest
    // prime factors
    smallestPrimeFactors();
   
    let ans = Number.MIN_VALUE;
   
    // Iterate over the range
    for (let i = n; i <= m; i++)
    {
        if (i == 4)
        {
            continue;
        }
   
        // Update maximum length
        ans = Math.max(ans, findLength(i));
    }
   
    return ans;
}
 
// Driver Code
 
    let n = 2, m = 14;
   
    document.write(maxLength(n, m));
                      

输出：

4

时间复杂度： O((NlogN)
辅助空间： O(N)

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