给定两个整数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]范围内进行迭代，对于每个整数，找到其主要因子并将其求和，然后对所得的总和进行递归重复，直到其总和为获得素数。
高效方法：可以使用动态编程来优化上述方法。请按照以下步骤解决问题：
- 使用Eratosthenes的Sieve方法预先计算质数。
- 使用使用Sieve的Prime Factorization，预先计算每个整数的最小素数，以找出素数。
- 现在，对于[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 smllest
// 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 smllest
// 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 SinghPython3
# 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 smllest
# 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 SinghC#
// 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 smllest
// 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输出：
4
时间复杂度： O((NlogN)
辅助空间： O(N)