Faktörleri modulo prime hesaplamanın en etkili yolu nedir?

Modülü sonra faktöriyel etkili bir şekilde hesaplayan bir algoritma biliyor musunuz?

Örneğin, programlamak istiyorum:

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

Ancak, pfaktöriyeli doğrudan uygulamak için büyük bir sayıdır (asal) $(p \leq 10^ 8)$ .

Python'da bu görev gerçekten kolay, ama gerçekten nasıl optimize edileceğini bilmek istiyorum.

(Bu cevap başlangıçta sorunun içinde asker jonaprieto tarafından yayınlanmıştır .)

Wilson teoremini hatırlıyorum ve küçük şeyler fark ettim:

Yukarıdaki programda şöyle yazarsam daha iyi olur:

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

Ve çünkü , bu nedenle genişletilmiş Öklid algoritması ile değerini bulabilirsiniz . ters modül.$(p-i)^{-1}$$\operatorname{gcd}(p, p-i) = 1$$(p-i)^{-1}$

Aynı kongrüasyonları da görüntüleyebilirsiniz: , toplam eşittir: ve başlangıçta faktöriyelleri çarpanlarına ayırırsanız, alırsınız. Ve tersine, ters modül faktöriyellerden daha verimlidir.

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

Gönderdiğiniz örnek 388 numaralı Euler sorunu ile çok yakından ilgilidir. Bu yüzden Euler sorununu çözmeyen bir cevap göndereceğim. Bir faktöriyel modulo nasıl hesaplayabileceğinizi yazacağım.

Yani: n nasıl hesaplanır! modulo p?

Hızlı gözlem: n ≥ p ise n! bir p faktörüne sahiptir, dolayısıyla sonuç 0 olur. Çok hızlı. Ve p'nin asal olması şartı göz ardı edilirse, q'nun p'nin en küçük asal faktörü olmasına izin verin ve n! n ≥ q ise modulo p 0'dır. Ayrıca, p'nin sorunuzu cevaplamak için bir ana olmasını gerektirecek çok fazla neden yoktur.

Şimdi örneğinizde (n - i)! 1 ≤ i ≤ 5 geldi. Beş faktöriyeli hesaplamak zorunda değilsiniz: (n - 5)! Bu, işi neredeyse bir faktör 5 azaltır. Sorunu tam anlamıyla çözmeyin.

Soru n'nin nasıl hesaplanacağı! modulo m. Açık olan yol, kabaca n log n ondalık basamağı olan bir sayı olan n! 'Yı hesaplamak ve kalan modulo p'yi hesaplamaktır. Bu zor bir iş. Soru: Bu sonucu nasıl daha çabuk alabiliriz? Bariz olanı yapmayarak.

((A * b * c) modulo p = ((((a * b) modulo p) * c) modulo p olduğunu biliyoruz.

N! 'Yi hesaplamak için normalde x = 1 ile başlayıp, x'i 1, 2, 3, ... n ile çarparız. Modulo formülünü kullanarak n'yi hesaplıyoruz! n! 'yi hesaplamaksızın modulo p, x = 1 ile başlayıp i = 1, 2, 3, .. için, n yerine x'i (x * i) modulo p ile değiştiriyoruz.

Her zaman x <p ve i <n'ye sahibiz, bu nedenle x * p'yi hesaplamak için yeterli hassasiyete ihtiyacımız var, n'yi hesaplamak için çok daha yüksek hassasiyete değil! N hesaplamak için! p ≥ 2 için modulo p aşağıdaki adımları atıyoruz:

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. 

(Bazı cevaplar, yalnızca verilen örneğin çok özel durumunda soruyu cevaplayan Wilson'ın teoreminden bahseder ve Euler problemi # 381'i çözmek için çok yararlıdır, ancak genel olarak sorulan soruyu çözmek için yararlı değildir).

Wilson teoremini benim uygulamamda kullanıyorum:

FactMOD işlevi, MOD-n, n'ye karşı çok küçük olduğunda, (n!)% MOD'u hesaplamak için çağrılacak işlevdir.

Biri durum böyle olmadığında başka etkili bir yaklaşım biliyor mu (örn: n = 1e6 ve 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;
}