Calcular eficientemente el entero más pequeño con n divisores

Para abordar este problema, primero observé que

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

Donde es el número de divisores (no necesariamente primos) de m . Si m es el entero más pequeño tal que ϕ ( m ) = n , entonces$\phi(m)$$m$$m$$\phi(m) = n$

( e 1 + 1 ) ( e 2 + 1 ) ⋯ ( e k + 1 ) =

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

Ahora debemos elegir tal que ∏ i p e i i sea ​​mínimo. Las opciones para p son triviales: son solo los números primos en orden ascendente.$e_i$$\prod_{i} p_i^{e_i}$$p$

Sin embargo, mi primer pensamiento para elegir fue incorrecto. Pensé que podría simplemente factorizar n , ordenar los factores en orden descendente y restar 1. La mayoría de las veces esto funciona bien, por ejemplo, el entero más pequeño con n = 15 divisores es:$e_i$$n$$n = 15$

15 = ( 4 + 1 ) ( 2 + 1 ) m = 2 4 3 2 =

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

Pero esto es incorrecto para :$n = 16$

16 = ( 1 + 1 ) ( 1 + 1 ) ( 1 + 1 ) ( 1 + 1 ) m = 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$$

Mientras que la respuesta correcta es:

m = 2 3 3 1 5 1 =

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

Entonces está claro que a veces necesitamos fusionar factores. En este caso porque . Pero no veo exactamente una estrategia de fusión limpia y directa. Por ejemplo, uno podría pensar que siempre debemos fusionarnos en el poder 2 , pero esto no es cierto:$7^1 > 2^2$$2$

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

No puedo pensar de inmediato en un ejemplo, pero mi instinto dice que algunos enfoques ambiciosos pueden fallar si fusionan primero los poderes equivocados.

¿Existe una estrategia óptima simple para fusionar estos poderes para obtener la respuesta correcta?

---

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

Sin embargo, la solución óptima es:

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

Aquí hay una solución, basada en mis comentarios anteriores. No hago afirmaciones, esto es óptimo.

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

Y también tenemos la recurrencia:

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

Para ese fin, aquí hay un código de Python, que está de acuerdo con todos los números que proporcionó anteriormente. Tenga en cuenta que funciona con los logaritmos para mantener los números más pequeños: por lo tanto, el entero real que busca es 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))

$2^a·3^b·5^c...$

$2^7·3$$2^3·3^3$$2^3·3·5$$2·3·5·7$$2^3·3·5 = 120$

$2^{pq-1}$$2^{p-1}·3^{q-1}$

$2^{ab-1}$$2^{ab-1} > 2^{a-1}·x^{b-1}$$2^3$$2^3 < 2·7$