Cách hiệu quả nhất để tính giai thừa modulo là số nguyên tố là gì?

Bạn có biết thuật toán nào tính toán giai thừa sau khi mô đun hiệu quả không?

Ví dụ, tôi muốn lập trình:

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

Nhưng, plà một con số lớn (nguyên tố) để áp dụng thừa trực tiếp $(p \leq 10^ 8)$ .

Trong Python, nhiệm vụ này thực sự dễ dàng, nhưng tôi thực sự muốn biết cách tối ưu hóa.

(Câu trả lời này ban đầu được đăng bởi người hỏi jonaprieto bên trong câu hỏi.)

Tôi nhớ định lý của Wilson và tôi nhận thấy những điều nhỏ nhặt:

Trong chương trình trên, sẽ tốt hơn nếu tôi viết:

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

Và bạn có thể tìm thấy vì , vì vậy với thuật toán Euclidian mở rộng, bạn có thể tìm thấy giá trị của , đó là mô đun nghịch đảo. gcd ( p , p - i ) = $(p-i)^{-1}$$\operatorname{gcd}(p, p-i) = 1$$(p-i)^{-1}$

Bạn cũng có thể xem các đồng loại tương tự, như: vì vậy, tổng bằng: và nếu bạn tính hệ số ban đầu, các yếu tố bạn nhận được Và, voila, mô đun nghịch đảo hiệu quả hơn các yếu tố.

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

Ví dụ mà bạn đang đăng có liên quan rất chặt chẽ đến vấn đề Euler # 381. Vì vậy, tôi sẽ đăng một câu trả lời không giải quyết được vấn đề Euler. Tôi sẽ đăng làm thế nào bạn có thể tính giai thừa modulo một số nguyên tố.

Vậy: Cách tính n! modulo p?

Quan sát nhanh: Nếu n ≥ p, thì n! có hệ số p, do đó kết quả là 0. Rất nhanh. Và nếu chúng ta bỏ qua yêu cầu rằng p phải là một số nguyên tố thì hãy để q là thừa số nguyên tố nhỏ nhất của p và n! modulo p bằng 0 nếu n ≥ q. Cũng không có nhiều lý do để yêu cầu p là số nguyên tố để trả lời câu hỏi của bạn.

Bây giờ trong ví dụ của bạn (n - i)! cho 1 ≤ i ≤ 5 đi lên. Bạn không phải tính năm yếu tố: Bạn tính (n - 5)!, Nhân với (n - 4) đi lấy (n - 4)!, Nhân với (n - 3) để lấy (n - 3)! vv Điều này làm giảm công việc gần như một yếu tố 5. Đừng giải quyết vấn đề theo nghĩa đen.

Câu hỏi là làm thế nào để tính n! modulo m. Cách rõ ràng là tính n!, Một số có khoảng n log n chữ số thập phân và tính modulo còn lại p. Đó là công việc khó khăn. Câu hỏi: Làm thế nào chúng ta có thể nhận được kết quả này nhanh hơn? Bằng cách không làm điều rõ ràng.

Chúng ta biết rằng ((a * b * c) modulo p = (((a * b) modulo p) * c) modulo p.

Để tính n!, Chúng ta thường bắt đầu bằng x = 1, sau đó nhân x với 1, 2, 3, ... n. Sử dụng công thức modulo, chúng tôi tính n! modulo p mà không tính n!, bằng cách bắt đầu với x = 1, và sau đó với i = 1, 2, 3, .., n chúng ta thay x bằng (x * i) modulo p.

Chúng tôi luôn có x <p và i <n, vì vậy chúng tôi chỉ cần đủ độ chính xác để tính x * p, chứ không phải độ chính xác cao hơn nhiều để tính n!. Vậy để tính n! modulo p cho p 2 chúng tôi thực hiện các bước sau:

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. 

.

Đây là cách sử dụng của tôi đối với định lý của wilson:

Hàm factMOD là hàm để gọi để tính (n!)% MOD khi MOD-n nhỏ so với n.

Có ai biết một cách tiếp cận hiệu quả khác khi không phải như vậy (ví dụ: n = 1e6 và 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;
}