总和等于N的阶乘分解的最小数量

给定数字N (<10 ¹⁰ )，任务是找到将N表示为它们的总和的最小阶乘。另外，打印那些析因。
例子：

Input: N = 30
Output: 2
24, 6
Explanation:
Factorials needed to represent 30: 24, 6

Input: N = 150
Output: 3
120, 24, 6
Explanation:
Factorials needed to represent 150: 120 24 6

方法：

1. 为了有效地找到将N表示为它们的和所需要的阶乘，我们可以预先计算阶乘直到N(N <10 ¹⁰ )并将它们存储在数组中，以进行更快的计算。
2. 然后，使用贪婪算法，我们可以从该数组中提取最大阶乘，然后将其相乘以表示N。
3. 从最大可能的阶乘开始，并在剩余值大于0时继续添加阶乘。
4. 以下是完整的算法。
   • 将结果初始化为空
   • 找到小于N的最大阶乘
   • 将找到的阶乘添加到结果中。从N中减去找到的阶乘的值
   • 如果N变为0，则打印结果。否则，重复步骤2和3以获得N的新值

下面是上述方法的实现：

C++

// C++ program to find minimum number of factorials
 
#include 
#define ll long long int
using namespace std;
 
// Array to calculate all factorials
// less than or equal to N
// Since there can be only 14 factorials
// till 10^10
// Hence the maximum size of fact[] is 14
ll fact[14];
 
// Store the actual size of fact[]
int size = 1;
 
// Function to precompute factorials till N
void preCompute(int N)
{
    // Precomputing factorials
    fact[0] = 1;
 
    for (int i = 1; fact[i - 1] <= N; i++) {
        fact[i] = (fact[i - 1] * i);
        size++;
    }
}
 
// Function to find the minimum number
// of factorials whose sum represents N
void findMin(int N)
{
 
    // Precompute factorials
    preCompute(N);
 
    int originalN = N;
 
    // Initialize result
    vector ans;
 
    // Traverse through all factorials
    for (int i = size - 1; i >= 0; i--) {
 
        // Find factorials
        while (N >= fact[i]) {
            N -= fact[i];
            ans.push_back(fact[i]);
        }
    }
 
    // Print min count
    cout << ans.size() << "\n";
 
    // Print result
    for (int i = 0; i < ans.size(); i++)
        cout << ans[i] << " ";
}
 
// Driver program
int main()
{
    int n = 27;
    findMin(n);
    return 0;
}

Java

// Java program to find minimum number of factorials
import java.util.*;
 
class GFG{
  
// Array to calculate all factorials
// less than or equal to N
// Since there can be only 14 factorials
// till 10^10
// Hence the maximum size of fact[] is 14
static int []fact = new int[14];
  
// Store the actual size of fact[]
static int size = 1;
  
// Function to precompute factorials till N
static void preCompute(int N)
{
    // Precomputing factorials
    fact[0] = 1;
  
    for (int i = 1; fact[i - 1] <= N; i++) {
        fact[i] = (fact[i - 1] * i);
        size++;
    }
}
  
// Function to find the minimum number
// of factorials whose sum represents N
static void findMin(int N)
{
  
    // Precompute factorials
    preCompute(N);
  
    int originalN = N;
  
    // Initialize result
    Vector ans = new Vector();
  
    // Traverse through all factorials
    for (int i = size - 1; i >= 0; i--) {
  
        // Find factorials
        while (N >= fact[i]) {
            N -= fact[i];
            ans.add(fact[i]);
        }
    }
  
    // Print min count
    System.out.print(ans.size()+ "\n");
  
    // Print result
    for (int i = 0; i < ans.size(); i++)
        System.out.print(ans.get(i)+ " ");
}
  
// Driver program
public static void main(String[] args)
{
    int n = 27;
    findMin(n);
}
}
 
// This code is contributed by PrinciRaj1992

Python3

# Python3 program to find minimum number of factorials
 
# Array to calculate all factorials
# less than or equal to N
# Since there can be only 14 factorials
# till 10^10
# Hence the maximum size of fact[] is 14
fact = [0]*14
 
# Store the actual size of fact[]
size = 1
 
# Function to precompute factorials till N
def preCompute(N):
    global size
     
    # Precomputing factorials
    fact[0] = 1
 
    i = 1
 
    while fact[i - 1] <= N:
        fact[i] = fact[i - 1] * i
        size += 1
        i += 1
 
# Function to find the minimum number
# of factorials whose sum represents N
def findMin(N):
 
    # Precompute factorials
     
    preCompute(N)
 
    originalN = N
 
    # Initialize result
    ans = []
 
    # Traverse through all factorials
    for i in range(size-1, -1, -1):
 
        # Find factorials
        while (N >= fact[i]):
            N -= fact[i]
            ans.append(fact[i])
 
    # Prmin count
    print(len(ans))
 
    # Prresult
    for i in ans:
        print(i, end=" ")
 
# Driver program
 
n = 27
findMin(n)
 
# This code is contributed by mohit kumar 29

C#

// C# program to find minimum number of factorials
using System;
using System.Collections.Generic;
 
class GFG{
   
// Array to calculate all factorials
// less than or equal to N
// Since there can be only 14 factorials
// till 10^10
// Hence the maximum size of fact[] is 14
static int []fact = new int[14];
   
// Store the actual size of fact[]
static int size = 1;
   
// Function to precompute factorials till N
static void preCompute(int N)
{
    // Precomputing factorials
    fact[0] = 1;
   
    for (int i = 1; fact[i - 1] <= N; i++) {
        fact[i] = (fact[i - 1] * i);
        size++;
    }
}
   
// Function to find the minimum number
// of factorials whose sum represents N
static void findMin(int N)
{
   
    // Precompute factorials
    preCompute(N);
   
    int originalN = N;
   
    // Initialize result
    List ans = new List();
   
    // Traverse through all factorials
    for (int i = size - 1; i >= 0; i--) {
   
        // Find factorials
        while (N >= fact[i]) {
            N -= fact[i];
            ans.Add(fact[i]);
        }
    }
   
    // Print min count
    Console.Write(ans.Count+ "\n");
   
    // Print result
    for (int i = 0; i < ans.Count; i++)
        Console.Write(ans[i]+ " ");
}
   
// Driver program
public static void Main(String[] args)
{
    int n = 27;
    findMin(n);
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// Javascript program to find minimum number of factorials
 
// Array to calculate all factorials
// less than or equal to N
// Since there can be only 14 factorials
// till 10^10
// Hence the maximum size of fact[] is 14
var fact = Array(14).fill(0);
 
// Store the actual size of fact[]
var size = 1;
 
// Function to precompute factorials till N
function preCompute(N)
{
    // Precomputing factorials
    fact[0] = 1;
 
    for (var i = 1; fact[i - 1] <= N; i++) {
        fact[i] = (fact[i - 1] * i);
        size++;
    }
}
 
// Function to find the minimum number
// of factorials whose sum represents N
function findMin(N)
{
 
    // Precompute factorials
    preCompute(N);
 
    var originalN = N;
 
    // Initialize result
    ans = [];
 
    // Traverse through all factorials
    for (var i = size - 1; i >= 0; i--) {
 
        // Find factorials
        while (N >= fact[i]) {
            N -= fact[i];
            ans.push(fact[i]);
        }
    }
 
    // Print min count
    document.write(ans.length + "<br>");
 
    // Print result
    for (var i = 0; i < ans.length; i++)
        document.write(ans[i] + " ");
}
 
// Driver program
var n = 27;
findMin(n);
 
// This code is contributed by rutvik_56.

输出：

3
24 2 1