คำนวณจำนวนเต็มขนาดเล็กที่สุดอย่างมีประสิทธิภาพด้วยตัวหาร 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$ เป็นเรื่องเล็กน้อย - พวกเขาเป็นเพียงช่วงเวลาที่อยู่ในลำดับขึ้น

อย่างไรก็ตามความคิดแรกของฉันสำหรับการเลือก $e_i$ไม่ถูกต้อง ฉันคิดว่าคุณสามารถแยกตัวประกอบ$n$เรียงลำดับปัจจัยจากมากไปหาน้อยและลบ 1 ส่วนใหญ่ใช้งานได้ดีเช่นจำนวนเต็มเล็กที่สุดด้วย $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" เป็นจำนวนเต็มของแบบฟอร์ม $2^a·3^b·5^c...$ โดยที่ a ≥ b ≥ c ... และ (a + 1) (b + 1) (c + 1) ... = n

ดังนั้นคุณต้องหาวิธีทั้งหมดในการแสดง n เป็นผลคูณของจำนวนเต็ม≥ 2 ในลำดับที่ไม่ขึ้นและคำนวณและตรวจสอบผู้สมัครที่เกี่ยวข้อง ตัวอย่างเช่นเมื่อ n = 16, 16 = 8 · 2 = 4 · 4 = 4 · 2 · 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}$และหลังจะเล็กกว่าเสมอ

คุณสามารถหาเงื่อนไขบางอย่างเมื่ออาจมีปัจจัย $2^{ab-1}$ ตัวอย่างเช่นโดยการตรวจสอบว่า $2^{ab-1} > 2^{a-1}·x^{b-1}$สำหรับนายกเอกที่ไม่ได้เป็นปัจจัย ในตัวอย่าง n = 16 มีปัจจัย$2^3$ เพราะ $2^3 < 2·7$.