อัลกอริธึมแบบแฟคทอเรียลมีประสิทธิภาพมากกว่าการคูณแบบไร้เดียงสา

ฉันรู้วิธีเขียนโค้ดสำหรับแฟคทอเรียลที่ใช้ทั้งแบบวนซ้ำและวนซ้ำ (เช่นn * factorial(n-1)สำหรับตัวอย่าง) ฉันอ่านในตำราเรียน (โดยไม่ได้รับคำอธิบายเพิ่มเติมใด ๆ ) ว่ามีวิธีที่มีประสิทธิภาพยิ่งขึ้นในการเขียนโปรแกรมสำหรับแฟคทอเรียลด้วยการแบ่งครึ่งแบบวนซ้ำ

ฉันเข้าใจว่าทำไมถึงเป็นเช่นนั้น อย่างไรก็ตามฉันต้องการลองเขียนโค้ดด้วยตัวเองและฉันไม่คิดว่าจะเริ่มต้นอย่างไร เพื่อนแนะนำให้ฉันเขียนเคสพื้นฐานก่อน และฉันกำลังคิดที่จะใช้อาร์เรย์เพื่อให้ฉันสามารถติดตามตัวเลข ... แต่ฉันไม่เห็นวิธีการออกแบบรหัสดังกล่าว

ฉันควรค้นคว้าเทคนิคแบบใด

อัลกอริทึมที่ดีที่สุดที่เป็นที่รู้จักคือการแสดงแฟคทอเรียลเป็นผลิตภัณฑ์ของมหาอำนาจ หนึ่งสามารถกำหนดช่วงเวลาได้อย่างรวดเร็วเช่นเดียวกับพลังงานที่เหมาะสมสำหรับแต่ละนายกโดยใช้วิธีการตะแกรง การคำนวณพลังงานแต่ละอย่างสามารถทำได้อย่างมีประสิทธิภาพโดยใช้กำลังสองซ้ำแล้วปัจจัยจะถูกคูณเข้าด้วยกัน สิ่งนี้อธิบายโดย Peter B. Borwein, บนความซับซ้อนของการคำนวณแฟคทอเรียล , วารสารอัลกอริทึม6 376–380, 1985. ( PDF ) โดยย่อ, สามารถคำนวณได้ในO ( n ( บันทึกn ) 3บันทึกบันทึกn )เวลาเมื่อเทียบกับΩ ( $n!$$O(n(\log n)^3\log \log n)$$\Omega(n^2 \log n)$เวลาที่ต้องใช้เมื่อใช้คำจำกัดความ

สิ่งที่ตำราเรียนอาจหมายถึงคือวิธีการแบ่งและพิชิต หนึ่งสามารถลดการคูณ$n-1$โดยใช้รูปแบบปกติของผลิตภัณฑ์

$n?$$1 \cdot 3 \cdot 5 \dotsm (2n-1)$$(2n)! = 1 \cdot 2 \cdot 3 \dotsm (2n)$

$$(2n)! = n! \cdot 2^n \cdot 3 \cdot 5 \cdot 7 \dotsm (2n-1).$$ $n = 2^k$$k>0$$n$$(2^k)! = (2^{k-1})!2^{2^{k-1}}(2^{k-1})?$ $$(2^k)! = \left(2^{2^{k-1}+2^{k-2}+\dots+2^0}\right) \prod_{i=0}^{k-1} (2^i)? = \left(2^{2^k - 1}\right) \prod_{i=1}^{k-1} (2^i)?.$$ $(2^{k-1})?$$(k-2) + 2^{k-1} - 2$$2$$2^k-2$$2$$2^k-1$

$n?$

def oddprod(l,h)
  p = 1
  ml = (l%2>0) ? l : (l+1)
  mh = (h%2>0) ? h : (h-1)
  while ml <= mh do
    p = p * ml
    ml = ml + 2
  end
  p
end

def fact(k)
  f = 1
  for i in 1..k-1
    f *= oddprod(3, 2 ** (i + 1) - 1)
  end
  2 ** (2 ** k - 1) * f
end

print fact(15)

แม้แต่รหัสผ่านแรกนี้ก็ยังดีขึ้นเล็กน้อย

f = 1; (1..32768).map{ |i| f *= i }; print f

ประมาณ 20% ในการทดสอบของฉัน

$n$$2$

โปรดทราบว่าฟังก์ชันแฟกทอเรียลเติบโตอย่างรวดเร็วจนคุณต้องใช้จำนวนเต็มตามอำเภอใจเพื่อรับประโยชน์จากเทคนิคที่มีประสิทธิภาพมากกว่าวิธีไร้เดียงสา factorial ใน 21 ที่มีอยู่แล้วมีขนาดใหญ่เกินไปที่จะใส่ใน unsigned long long int64

$n!$$n$

$\Theta(|a| \cdot |b|)$$|x|$$x$$\Omega(|a| + |b|)$$\max(|a|,|b|)$

ด้วยพื้นหลังนี้บทความ Wikipediaควรสมเหตุสมผล

เนื่องจากความซับซ้อนของการคูณขึ้นอยู่กับขนาดของจำนวนเต็มที่จะถูกคูณคุณสามารถประหยัดเวลาด้วยการจัดเรียงการคูณตามลำดับที่ช่วยให้ตัวเลขถูกคูณด้วยขนาดเล็ก มันจะทำงานได้ดีขึ้นถ้าคุณจัดเรียงตัวเลขให้มีขนาดเท่ากัน "การแบ่งครึ่ง" ที่ตำราของคุณอ้างถึงประกอบด้วยวิธีการแบ่งและพิชิตต่อไปนี้เพื่อคูณชุดจำนวนเต็ม (หลาย):

1. จัดเรียงตัวเลขที่จะคูณ (เริ่มแรกคือจำนวนเต็มทั้งหมดจากถึง ) ในสองชุดซึ่งผลิตภัณฑ์มีขนาดเท่ากัน นี่มันแพงน้อยกว่าการคูณ:(นอกจากหนึ่งเครื่อง)n | a ⋅ b | ≈ | a | + | b $1$$n$$|a \cdot b| \approx |a| + |b|$
2. ใช้อัลกอริธึมวนซ้ำในแต่ละชุดย่อยสองชุด
3. คูณผลลัพธ์กลางสองรายการ

ดูคู่มือ GMPสำหรับข้อมูลเฉพาะเพิ่มเติม

มีวิธีการที่เร็วกว่าซึ่งไม่เพียง แต่จะจัดเรียงตัวประกอบถึงแต่แยกตัวเลขโดยแยกย่อยพวกมันออกเป็นตัวประกอบเฉพาะกลุ่ม ฉันเพิ่งจะอ้างอิงจากเอกสารอ้างอิงจากบทความวิกิพีเดีย: “ในความซับซ้อนของการคำนวณแฟกทอเรี” โดยปีเตอร์ Borweinและการใช้งานโดยปีเตอร์ Luschny$1$$n$

¹ _{มีวิธีการที่เร็วขึ้นของการคำนวณมีความใกล้เคียงของแต่นั่นไม่ได้คำนวณแฟคทอเรียลอีกต่อไป แต่มันคำนวณโดยประมาณ$n!$}

เนื่องจากฟังก์ชั่นแฟกทอเรียลเติบโตอย่างรวดเร็วคอมพิวเตอร์ของคุณสามารถเก็บได้เพียงสำหรับขนาดค่อนข้างเล็กnตัวอย่างเช่นdoubleสามารถเก็บค่าได้สูงสุด. ดังนั้นหากคุณต้องการอัลกอริทึมที่รวดเร็วมากสำหรับการคำนวณเพียงแค่ใช้ตารางของขนาด171ไม่มี171 ! n ! $n!$$n$$171!$$n!$$171$

คำถามจะน่าสนใจยิ่งขึ้นหากคุณสนใจหรือใน function (หรือใน ) ในทุกกรณี (รวมถึง ) ฉันไม่เข้าใจความคิดเห็นในหนังสือเรียนของคุณΓ log Γ n $\log(n!)$$\Gamma$$\log \Gamma$$n!$

นอกจากนี้อัลกอริทึมแบบวนซ้ำและแบบเรียกซ้ำของคุณจะเทียบเท่า (ข้อผิดพลาดของจุดลอย) เนื่องจากคุณใช้การเรียกซ้ำแบบหาง