Ефективне обчислення найменшого цілого числа з 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$

Однак моя перша думка про вибір була неправильною. Я думав, що ви можете просто помножити , сортувати коефіцієнти у порядку зменшення та відняти 1. Більшість випадків це працює нормально, наприклад, найменше ціле число з дільниками:$e_i$$n$$n = 15$

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

Але для це неправильно :$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$$

Тоді як правильна відповідь:

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

Тож зрозуміло, що іноді нам потрібно об'єднати фактори. У цьому випадку тому, що . Але я точно не бачу чистої та прямої стратегії злиття. Наприклад, можна подумати, що ми завжди повинні зливатися у сили, але це неправда:$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$$

Я не можу одразу придумати приклад, але мій інстинкт говорить, що деякі жадібні підходи можуть зазнати невдачі, якщо вони спочатку з’єднають неправильні сили.

Чи існує проста оптимальна стратегія об'єднання цих повноважень, щоб отримати правильну відповідь?

---

Додаток Жадібний алгоритм, який перевіряє кожне можливе злиття та виконує найкраще на основі об'єднання за об'єднанням, не працює на . Серія злиття один за одним:$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}$

Ви можете з'ясувати деяку умову, коли може бути фактор наприклад, перевіривши, чи для деяких prime x, що не є фактором. У прикладі n = 16 є коефіцієнт тому що .$2^{ab-1}$$2^{ab-1} > 2^{a-1}·x^{b-1}$$2^3$$2^3 < 2·7$