有效计算n个除数的最小整数

为了解决这个问题，我首先观察到

$$\phi(p_1^{e_1} \space p_2^{e_2} \cdots \space p_k^{e_k}) = (e_1 + 1)(e_2 + 1)\cdots(e_k +1)$$

其中$\phi(m)$是的（不一定是素数）的除数数$m$。如果$m$是使得的最小整数$\phi(m) = n$，则

$$\phi(m) = n$$ $$(e_1 + 1)(e_2 + 1)\cdots(e_k +1) = n$$

现在，我们必须选择$e_i$这样$\prod_{i} p_i^{e_i}$是最小的。的选择$p$很简单-它们只是升序的质数。

然而，我的选择首先想到的$e_i$是不正确的。我以为您可以简单地将$n$分解为因子，然后按降序对因子进行排序，然后减去1。在大多数情况下，它可以正常工作，例如$n = 15$除数的最小整数是：

$$15 = 5 \cdot 3$$ $$15 = (4 + 1)(2 + 1)$$ $$m = 2^4 3^2 = 144$$

但这对于是不正确的$n = 16$：

16 = （1 + 1 ）（1 + 1 ）（1 + 1 ）（1 + 1 ）米= 2 1 3 1 5 1 7 1 =

$$16 = 2 \cdot 2\cdot 2 \cdot 2$$ $$16 = (1 + 1)(1 + 1)(1 + 1)(1 + 1)$$ $$m = 2^1 3^1 5^1 7^1 = 210$$

正确的答案是：

米= 2 3 3 1 5 1 =

$$16 = (3 + 1)(1 + 1)(1 + 1)$$ $$m = 2^3 3^1 5^1 = 120$$

很明显，有时候我们需要合并因素。在这种情况下，因为。但是我没有完全看到一种干净直接的合并策略。例如，有人可能认为我们必须始终合并为2的幂，但这是不正确的：$7^1 > 2^2$$2$

米= 2 96 3 1 5 1 7 1 11 1 > 2 96 3 3 5 1 7

$$1552 = (96 + 1)(1 + 1)(1 + 1)(1 + 1)(1 + 1)$$ $$m = 2^{96} 3^1 5^1 7^1 11^1 > 2^{96} 3^3 5^1 7^1$$

我不能立即想到一个例子，但是我的直觉是，如果某些贪婪的方法首先合并了错误的权力，它们可能会失败。

是否有一个简单的最佳策略来合并这些能力以获得正确答案？

---

$n = 3072$

$$2^2 3^1 5^1 7^1 11^1 13^1 17^1 19^1 23^1 29^1 31^1$$

$$2^3 3^2 5^1 7^1 11^1 13^1 17^1 19^1 23^1 29^1$$

$$2^5 3^3 5^1 7^1 11^1 13^1 17^1 19^1 23^1$$

但是，最佳解决方案是：

$$2^7 3^3 5^2 7^1 11^1 13^1 17^1 19^1$$

根据我上面的评论，这是一个解决方案。我没有主张这是最佳选择。

$T(n,m)$$n$$m$

$$\begin{align} T(n, 1) &= 2^{n-1}\\ T(2^m, m) &= p_1p_2\cdots p_m \end{align}$$

而且我们也有复发：

$$\begin{equation} T(n,m) = \min_{d|n} [T\left(\frac{n}{d}, m-1\right)\cdot p_m^{d-1}] \end{equation}$$

最后，您要寻找的数量是

$$\begin{equation} \min_{1\le i\le\lceil\log(n)\rceil} T(n, i) \end{equation}$$

为此，下面是一些Python代码，该代码与您在上面给出的所有数字都一致。请注意，它与对数配合使用以使数字保持较小：因此，您要查找的实际整数是round(2**smallest(n))。

import functools
import itertools
import math

# All primes less than 100.
PRIMES = [
  2, 3, 5, 7, 11,
  13, 17, 19, 23, 29,
  31, 37, 41, 43, 47,
  53, 59, 61, 67, 71,
  73, 79, 83, 89, 97,
]

LOG_PRIMES = [math.log2(p) for p in PRIMES]

def smallest(n):
  max_factors = math.ceil(math.log2(n))
  min_so_far = float('Infinity')
  factors = factorize(n)
  memo = {}
  for i in range(1, max_factors+1):
    t = T(n,i, factors, memo)
    if 0.0 < t < min_so_far:
      min_so_far = t
  return min_so_far

def T(n, m, factors=None, memo=None):
  if memo is None:
    memo = {}
  if n < 2 or m < 1:
    return 0
  elif m == 1:
    # Everything on the smallest prime.
    return (n-1) * LOG_PRIMES[0]
  elif n < 2**m:
    return 0
  elif n == 2**m:
    # Product of first m primes, in log.
    return sum(LOG_PRIMES[:m])
  elif (n,m) in memo:
    return memo[(n,m)]

  if factors is None:
    factors = factorize(n)
  if len(factors) < m:
    return 0

  smallest = float('Infinity')  
  for factor_list in powerset(factors):
    divisor = product(factor_list)
    first = T(divisor, m-1, factor_list, memo)
    # No such product.
    if first < 1.0:
      continue
    second = (n/divisor - 1) * LOG_PRIMES[m-1]
    total = first + second
    if total < smallest:
      smallest = total

  memo[(n,m)] = smallest
  return smallest

def product(nums):
  return functools.reduce(lambda x,y: x*y, nums, 1)

def factorize(n):
  prime_factors = []
  for p in PRIMES:
    while n%p == 0:
      n //= p
      prime_factors.append(p)
    if n == 1:
      break
  return prime_factors

def powerset(lst):
  # No empty set.
  return itertools.chain.from_iterable(itertools.combinations(lst, r) 
                                       for r in range(1, len(lst)+1))

“具有n个除数的最小整数”的可能候选形式为的整数，其中a≥b≥c ...和（a + 1）（b + 1） （c + 1）... = n。$2^a·3^b·5^c...$

因此，您需要找到所有方法以非升序形式将n表示为整数≥2的乘积，并计算并检查相应的候选者。例如，当n = 16，16 = 8·2 = 4·4 = 4·2·2 = 2·2·2·2，所以可能性是，，，，最小是。$2^7·3$$2^3·3^3$$2^3·3·5$$2·3·5·7$$2^3·3·5 = 120$

如果n是两个素数p·q的乘积，p≥q，则唯一的候选项是和，后者总是较小。$2^{pq-1}$$2^{p-1}·3^{q-1}$

例如，可以通过检查某些因素是否为来找出可能存在因子的某些情况。素数x不是一个因素。在示例n = 16中，因数是因为。 2 a b − 1 > 2 a − 1 · x b − 1 2 3 2 3 < 2 · $2^{ab-1}$$2^{ab-1} > 2^{a-1}·x^{b-1}$$2^3$$2^3 < 2·7$