วิธีที่มีประสิทธิภาพมากที่สุดในการคำนวณแฟคทอเรียลโมดูโลคืออะไร?

คุณรู้จักอัลกอริธึมที่คำนวณแฟคทอเรียลหลังจากโมดูลัสอย่างมีประสิทธิภาพหรือไม่?

ตัวอย่างเช่นฉันต้องการโปรแกรม:

for(i=0; i<5; i++)
  sum += factorial(p-i) % p;

แต่pเป็นจำนวนมาก (นายก) สำหรับการใช้ปัจจัยโดยตรง8)$(p \leq 10^ 8)$

ใน Python งานนี้ง่ายมาก แต่ฉันอยากรู้วิธีเพิ่มประสิทธิภาพ

(คำตอบนี้ถูกโพสต์ครั้งแรกโดยผู้ถาม jonaprietoภายในคำถาม)

ฉันจำทฤษฎีบทของ Wilsonและฉันสังเกตเห็นสิ่งเล็กน้อย:

ในโปรแกรมข้างต้นจะดีกว่าถ้าฉันเขียน:

$$\begin{align} (p-1)! &\equiv -1 &\pmod p\\ (p-2)! &\equiv (p-1)! (p-1)^ {-1} \equiv \bf{1} &\pmod p\\ (p-3)! &\equiv (p-2)! (p-2)^ {-1} \equiv \bf{(p-2)^{-1}} &\pmod p\\ (p-4)! &\equiv (p-3)! (p-3)^ {-1} \equiv \bf{(p-2)^{-1}} \bf{(p-3)^{-1}} &\pmod p\\ \ (p-5)! &\equiv (p-4)! (p-4)^ {-1} \equiv \bf{(p-2)^{-1}} \bf{(p-3)^{-1}}\bf{(p-4)^{-1}} &\pmod p\\ \end{align}$$

และคุณสามารถหาเพราะดังนั้นด้วยอัลกอริธึมแบบขยาย Euclidianคุณสามารถหาค่าของนั่นคือ โมดูลัสของผกผัน gcd ( p , p - i ) = 1 ( p - i ) - $(p-i)^{-1}$$\operatorname{gcd}(p, p-i) = 1$$(p-i)^{-1}$

คุณสามารถดูความสอดคล้องกันเช่นกันเช่น: ดังนั้นผลรวมเท่ากับ: และถ้าคุณแยกตัวประกอบในการเริ่มต้นแฟกทอเรียลคุณจะได้ และ, voila, โมดูลัสของผกผันมีประสิทธิภาพมากกว่าแฟคทอเรียล (-24)-1+(6)-1+(-2)-18⋅(-24)-

$$\begin{align*} (p-5)! &\equiv (p-24)^{-1}&\pmod p\\ (p-4)! &\equiv (p+6)^{-1}&\pmod p\\ (p-3)! &\equiv (p-2)^{-1} &\pmod p\\ (p-2)! &\equiv 1&\pmod p\\ (p-1)! &\equiv -1&\pmod p\\ \end{align*}$$ $$(-24)^{-1}+(6)^{-1} +(-2)^{-1}$$ $$8\cdot (-24)^{-1} \pmod p$$

ตัวอย่างที่คุณกำลังโพสต์นั้นเกี่ยวข้องกับปัญหาออยเลอร์อย่างมาก # 381 ดังนั้นฉันจะโพสต์คำตอบที่ไม่แก้ปัญหาออยเลอร์ ฉันจะโพสต์วิธีที่คุณสามารถคำนวณแฟคทอเรียลแบบโมดูโล

ดังนั้น: วิธีคำนวณ n! modulo p

การสังเกตอย่างรวดเร็ว: ถ้า n ≥ p ดังนั้น n! มีตัวประกอบ p ดังนั้นผลลัพธ์คือ 0 เร็วมาก และถ้าเราเพิกเฉยต่อข้อกำหนดที่ว่า p ควรเป็นไพร์มแล้วให้ q เป็นตัวประกอบที่เล็กที่สุดของ p และ n! modulo p คือ 0 ถ้า n ≥ q นอกจากนี้ยังมีเหตุผลไม่มากที่ต้องการให้ p เป็นตัวเลือกสำคัญในการตอบคำถามของคุณ

ในตัวอย่างของคุณ (n - i)! สำหรับ 1 ≤ i ≤ 5 ขึ้นมา คุณไม่ต้องคำนวณห้าแฟคทอเรียล: คุณคำนวณ (n - 5)! คูณด้วย (n - 4) ไปรับ (n - 4)! คูณด้วย (n - 3) เพื่อรับ (n - 3)! ฯลฯ ซึ่งจะช่วยลดการทำงานเกือบเป็นปัจจัย 5 อย่าแก้ปัญหาอย่างแท้จริง

คำถามคือวิธีการคำนวณ n! โมดูโลเอ็ม วิธีที่ชัดเจนคือการคำนวณ n !, ตัวเลขที่มีตัวเลขทศนิยม n log n โดยประมาณและคำนวณโมดูโลส่วนที่เหลือ นั่นเป็นงานหนัก คำถาม: เราจะได้ผลลัพธ์นี้เร็วขึ้นได้อย่างไร โดยไม่ทำสิ่งที่ชัดเจน

เรารู้ว่า ((a * b * c) modulo p = (((* * *) modulo p) * c) modulo p

ในการคำนวณ n! เรามักจะเริ่มต้นด้วย x = 1 แล้วคูณ x ด้วย 1, 2, 3, ... n การใช้สูตรโมดูโล่เราคำนวณ n! modulo p โดยไม่คำนวณ n!, โดยเริ่มต้นด้วย x = 1, และสำหรับ i = 1, 2, 3, .. , n เราแทนที่ x ด้วย (x * i) modulo p

เรามักจะมี x <p และ i <n ดังนั้นเราจึงต้องการเพียงความแม่นยำเพียงพอในการคำนวณ x * p ไม่ใช่ความแม่นยำที่สูงกว่าในการคำนวณ n! ดังนั้นเพื่อคำนวณ n! modulo p สำหรับ p ≥ 2 เราทำตามขั้นตอนต่อไปนี้:

Step 1: Find the smallest prime factor q of p. If n ≥ q then the result is 0.
Step 2: Let x = 1, then for 1 ≤ i ≤ n replace x with (x * i) modulo p, and x is the result. 

(บางคำตอบพูดถึงทฤษฎีบทของ Wilson ซึ่งตอบเฉพาะคำถามในกรณีพิเศษของตัวอย่างที่กำหนดและมีประโยชน์มากในการแก้ปัญหาออยเลอร์ # 381 แต่โดยทั่วไปแล้วไม่มีประโยชน์ในการแก้ปัญหาที่ถาม)

นี่คือการใช้งานของฉันของทฤษฎีบทวิลสัน:

ฟังก์ชั่น factMOD เป็นหนึ่งในการเรียกร้องให้คำนวณ (n!)% MOD เมื่อ MOD-n นั้นน้อยเมื่อเทียบกับ n

มีคนรู้วิธีการที่มีประสิทธิภาพอื่น ๆ เมื่อไม่ใช่กรณี (เช่น: n = 1e6 และ MOD = 1e9 + 7)

ll powmod(ll a, ll b){//a^b % MOD
  ll x=1,y=a;
  while(b){
    if(b&1){
      x*=y; if(x>=MOD)x%=MOD;
    }
    y*=y; if(y>=MOD)y%=MOD;
    b>>=1;
  }
  return x;
} 
ll InverseEuler(ll n){//modular inverse of n
  return powmod(n,MOD-2);
}
ll factMOD(ll n){ //n! % MOD efficient when MOD-n<n
   ll res=1,i;
   for(i=1; i<MOD-n; i++){
     res*=i;
     if(res>=MOD)res%=MOD;
   }
   res=InverseEuler(res);   
    if(!(n&1))
      res= -res +MOD;
  }
  return res%MOD;
}