En küçük tamsayıyı n bölenlerle verimli bir şekilde hesaplama

Bu sorunu çözmek için önce şunu gözlemledim:

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

Burada arasında (zorunlu olarak asal olan) bölenler sayısıdır m . Eğer m küçük tamsayıdır öyle ki \ phi (m) = n sonra,$\phi(m)$$m$$m$$\phi(m) = n$

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

Şimdi seçmelisiniz $e_i$ böyle $\prod_{i} p_i^{e_i}$ minimumdur. $p$ için seçenekler önemsiz - onlar sadece artan düzende ilkeler.

Ancak, e_i'yi seçmeye yönelik ilk düşüncem $e_i$yanlıştı. Basitçe $n$ faktör, azalan sırayla faktörleri sıralamak ve 1 çıkarmak düşündüm . Çoğu zaman bu iyi çalışır, örneğin $n = 15$ bölenleri ile en küçük tamsayı :

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

Ancak bu n = 16 için yanlıştır $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$$

Oysa doğru cevap:

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

Bu yüzden bazen faktörleri birleştirmemiz gerektiği açıktır. Bu durumda . Ancak tam olarak temiz ve doğrudan birleşme stratejisi görmüyorum. Örneğin, kişi her zaman güçle birleşmemiz gerektiğini düşünebilir , ancak bu doğru değildir:$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$$

Hemen bir örnek düşünemiyorum ama içgüdüm, ilk önce yanlış güçleri birleştirmeleri durumunda bazı açgözlü yaklaşımların başarısız olabileceğini söylüyor.

Doğru cevabı almak için bu güçleri birleştirmek için basit bir optimal strateji var mı?

---

Ek. Mümkün olan her birleştirmeyi denetleyen ve en iyi olanı bir birleştirme temelinde gerçekleştiren açgözlü bir algoritma başarısız olur . Tek tek birleştirme serisi:$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$$

Ancak en uygun çözüm:

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

İşte yukarıdaki yorumlarıma dayalı bir çözüm. Bunun en uygun olduğunu iddia etmiyorum.

Fikir kabul etmektir biz "tam olan en küçük pozitif tamsayı olarak tanımlar, bölenler ve farklı asal çarpanları". Kolay gözlemler yapıyoruz:$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}$$

Ve ayrıca nüks var:

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

Son olarak, aradığınız miktar

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

Bu amaçla, yukarıda verdiğiniz tüm sayıları kabul eden bazı Python kodları. Sayıları daha küçük tutmak için logaritmalarla birlikte çalıştığını unutmayın: böylece aradığınız gerçek tamsayı 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 bölen en küçük tamsayı" için olası adaylar formunun tam sayılarıdır; burada ≥ b ≥ c ... ve (a + 1) (b + 1) (c + l) ... = n.$2^a·3^b·5^c...$

Bu nedenle, n değerini artan sayılarda ≥ 2 tamsayısının ürünü olarak ifade etmenin tüm yollarını bulmanız ve karşılık gelen adayları hesaplamanız ve kontrol etmeniz gerekir. Örneğin, n = 16, 16 = 8 · 2 = 4 · 4 = 4 · 2 · 2 = 2 · 2 · 2 · 2 olduğu için olasılıklar , , , ve en küçüğü .$2^7·3$$2^3·3^3$$2^3·3·5$$2·3·5·7$$2^3·3·5 = 120$

Eğer n iki p · q, p ≥ q primerinin ürünü ise, tek adaylar ve ve ikincisi her zaman daha küçüktür .$2^{pq-1}$$2^{p-1}·3^{q-1}$

Olabilir zaman bazı koşul anlamaya bir faktör , örneğin kontrol ederek olmadığını için bazı asal x bu bir faktör değildir. Örneğin, n = 16, bir faktör olduğu için .$2^{ab-1}$$2^{ab-1} > 2^{a-1}·x^{b-1}$$2^3$$2^3 < 2·7$