Calcul efficace du plus petit entier avec n diviseurs

Afin de résoudre ce problème, j'ai d'abord 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)$$

Où est le nombre de diviseurs (pas nécessairement premiers) de . Si est le plus petit entier tel que , alors$\phi(m)$$m$$m$$\phi(m) = n$

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

Maintenant, nous devons choisir $e_i$ telle sorte que $\prod_{i} p_i^{e_i}$ soit minimal. Les choix pour $p$ sont triviaux - ce ne sont que les nombres premiers dans l'ordre croissant.

Cependant, ma première pensée pour choisir $e_i$ était incorrecte. Je pensais que vous pouviez simplement factoriser $n$ , trier les facteurs dans l'ordre décroissant et soustraire 1. La plupart du temps, cela fonctionne bien, par exemple le plus petit entier avec $n = 15$ diviseurs est:

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

Mais ceci est incorrect pour $n = 16$ :

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

Alors que la bonne réponse est:

m = 2 3 3 1 5 1 =

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

Il est donc clair que nous devons parfois fusionner des facteurs. Dans ce cas, car . Mais je ne vois pas exactement une stratégie de fusion claire et directe. Par exemple, on pourrait penser que nous devons toujours fusionner dans le pouvoir, mais ce n'est pas vrai:$7^1 > 2^2$$2$

m = 2 96 3 1 5 1 7 1 11 1 > 2 96 3 3 5 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$$

Je ne peux pas immédiatement penser à un exemple, mais mon instinct dit que certaines approches gourmandes peuvent échouer si elles fusionnent d'abord les mauvais pouvoirs.

Existe-t-il une stratégie optimale simple pour fusionner ces pouvoirs pour obtenir la bonne réponse?

---

Addenda. Un algorithme gourmand qui vérifie chaque fusion possible et effectue la meilleure fusion par fusion, échoue sur . La série de fusions un par un est la suivante:$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$$

Cependant, la solution optimale est:

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

Voici une solution, basée sur mes commentaires ci-dessus. Je ne prétends pas que c'est optimal.

L'idée est de considérer , que nous définissons comme "le plus petit entier positif avec exactement diviseurs et facteurs premiers distincts". Nous faisons les observations faciles:n $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}$$

Et nous avons aussi la récurrence:

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

Enfin, la quantité que vous recherchez est

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

À cette fin, voici du code Python, qui correspond à tous les chiffres que vous avez donnés ci-dessus. Notez que cela fonctionne avec les logarithmes pour garder les nombres plus petits: ainsi l'entier réel que vous recherchez est 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))

Les candidats possibles pour le "plus petit entier avec n diviseurs" sont les entiers de la forme où a ≥ b ≥ c ... et (a + 1) (b + 1) (c + 1) ... = n.$2^a·3^b·5^c...$

Vous devez donc trouver toutes les façons d'exprimer n comme le produit d'entiers ≥ 2 dans un ordre non croissant, et calculer et vérifier les candidats correspondants. Par exemple, lorsque n = 16, 16 = 8 · 2 = 4 · 4 = 4 · 2 · 2 = 2 · 2 · 2 · 2, les possibilités sont donc de , , , , et le plus petit est .$2^7·3$$2^3·3^3$$2^3·3·5$$2·3·5·7$$2^3·3·5 = 120$

Si n est le produit de deux nombres premiers p · q, p ≥ q, les seuls candidats sont et , et ce dernier est toujours plus petit .$2^{pq-1}$$2^{p-1}·3^{q-1}$

Vous pouvez comprendre une condition où il pourrait y avoir un facteur par exemple, en vérifiant si pour certains x premier qui n'est pas un facteur. Dans l'exemple n = 16, il y a un facteur car .$2^{ab-1}$$2^{ab-1} > 2^{a-1}·x^{b-1}$$2^3$$2^3 < 2·7$