Komputasi bilangan bulat terkecil secara efisien dengan n pembagi

Untuk mengatasi masalah ini saya pertama kali mengamati itu

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

Di mana adalah jumlah pembagi (tidak harus prima) dari . Jika adalah bilangan bulat terkecil sehingga , maka$\phi(m)$$m$$m$$\phi(m) = n$

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

Sekarang kita harus memilih sedemikian rupa sehingga minimal. Pilihan untuk sepele - mereka hanya bilangan prima dalam urutan menaik.$e_i$$\prod_{i} p_i^{e_i}$$p$

Namun, pemikiran pertama saya untuk memilih salah. Saya pikir Anda bisa memfaktorkan , mengurutkan faktor dalam urutan menurun dan mengurangi 1. Sebagian besar waktu ini berfungsi dengan baik, misalnya bilangan bulat terkecil dengan pembagi adalah:$e_i$$n$$n = 15$

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

Tetapi ini tidak benar untuk :$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$$

Sedangkan jawaban yang benar adalah:

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

Jadi jelas kadang-kadang kita perlu menggabungkan faktor. Dalam hal ini karena . Tapi saya tidak benar-benar melihat strategi penggabungan yang bersih dan langsung. Sebagai contoh, orang mungkin berpikir kita harus selalu bergabung dengan kekuatan, tetapi ini tidak benar:$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$$

Saya tidak dapat langsung memikirkan contoh, tetapi insting saya mengatakan bahwa beberapa pendekatan rakus dapat gagal jika mereka menggabungkan kekuatan yang salah terlebih dahulu.

Apakah ada strategi optimal sederhana untuk menggabungkan kekuatan-kekuatan ini untuk mendapatkan jawaban yang benar?

---

Tambahan. Algoritma serakah yang memeriksa setiap kemungkinan penggabungan dan melakukan yang terbaik berdasarkan penggabungan-penggabungan, gagal pada . Rangkaian penggabungan satu-per-satu adalah:$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$$

Namun solusi optimalnya adalah:

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

Inilah solusinya, berdasarkan komentar saya di atas. Saya tidak mengklaim ini optimal.

Idenya adalah untuk mempertimbangkan , yang kami definisikan sebagai "bilangan bulat positif terkecil dengan tepat pembagi dan faktor prima yang berbeda". Kami melakukan pengamatan mudah: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}$$

Dan kami juga memiliki pengulangan:

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

Akhirnya, jumlah yang Anda cari adalah

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

Untuk itu, berikut adalah beberapa kode Python, yang setuju dengan semua angka yang Anda berikan di atas. Perhatikan bahwa ia bekerja dengan logaritma untuk menjaga angka lebih kecil: sehingga bilangan bulat yang sebenarnya Anda cari adalah 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))

Calon yang memungkinkan untuk "bilangan bulat terkecil dengan n pembagi" adalah bilangan bulat dari formulir mana ≥ b ≥ c ... dan (a + 1) (b +1) (c + 1) ... = n.$2^a·3^b·5^c...$

Jadi, Anda perlu menemukan semua cara untuk mengekspresikan n sebagai produk bilangan bulat ≥ 2 dalam urutan non-naik, dan menghitung dan memeriksa kandidat yang sesuai. Misalnya, ketika n = 16, 16 = 8 · 2 = 4 · 4 = 4 · 2 · 2 = 2 · 2 · 2 · 2, jadi kemungkinannya adalah , , , , dan yang terkecil adalah .$2^7·3$$2^3·3^3$$2^3·3·5$$2·3·5·7$$2^3·3·5 = 120$

Jika n adalah produk dari dua bilangan prima p · q, p ≥ q, satu-satunya kandidat adalah dan , dan yang terakhir selalu lebih kecil .$2^{pq-1}$$2^{p-1}·3^{q-1}$

Anda dapat mengetahui beberapa kondisi ketika mungkin ada faktor misalnya, dengan memeriksa apakah untuk beberapa prime x yang bukan merupakan faktor. Dalam contoh n = 16, ada faktor karena .$2^{ab-1}$$2^{ab-1} > 2^{a-1}·x^{b-1}$$2^3$$2^3 < 2·7$