Эффективное вычисление наименьшего целого числа с 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 = ( 4 + 1 ) ( 2 + 1 ) т = 2 4 3 2 =

$$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$$

Тогда как правильный ответ:

m = 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$

m = 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}$

Вы можете выяснить некоторые условия, когда, например, может быть коэффициент , проверив, для некоторых штрих х, это не фактор. В примере 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$