任何一个数都可以分解成素数乘积,利用着这性质就可以把 N! 保存在一个数组 arg[i] 里面,arg[i] 保存的是 i 的幂。素数可以直接线性打表, 主要的问题就是要求出 arg[i] 数组:
首先要知道 s1 = N/b 表示小于等于 N 的数中有 s1 个能被 b 整除。
s2 = N / (b^2) 表示小于等于 N 的数中有 s2 个能被 b^2 整除(被 b 整除 而且被 b^2 整除)
s3 = N / (b^3) 表示小于等于 N 的数中有 s3 个能被 b^3 整除(被 b 整除 而且被 b^2 整除 而且被 b^3整除)
………
sn = N / (b^n)(被 b 整除而且被 b^2 整除而且被 b^3 整除 … 而且被 b^n 整除)
现在想想 s1 + s2 + s3 + … + sn 表示什么呢?
是不是就是 1 * 2 * 3 * … * N 这个数分解质因数后 b 的个数?
看得出 s2 中的数在 s1 中加了一次(相当于加了2次)
s3 中的数在 s2 和 s1 中都加了一次(相当于加了3次)
sn 中的数载 sn-1 … s2 和 s1 中都加了一次(相当于加了n次)
看懂上面的话就回归正题吧
看看计算 20! 的过程:
1.先求出20以内的素数(2, 3, 5, 7, 11, 13, 17, 19);
2.再求各个素数的阶数
arg[2] = 20/(2^1) + 20/(2^2) + 20/(2^3) + 20/(2^4) = 18;
arg[3] = 20/(3^1) + 20/(3^2) = 8;
arg[5] = 20/(5^1) = 4;
…
arg[19] = 20/(19^1) = 1;
所以 20! = (2^18) * (3^8) * (5^4) * … * (19^1);
解释:
2、4、6、8、10、12、14、16、18、20能被2整除
4、8、12、16、20能被4整除(即被2除一次后还能被2整除)
8、16能被8整除(即被2除两次后还能被2整除)
这样就得到了2的幂。其它可以依次递推
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
int arg[1000005];
bool isprime[1000005];
ll prime[200005], top;
void Prime(int n) //素数打表
{
top = 0;
memset(isprime, true, sizeof(isprime));
for(int i = 2; i < n; i++){
if(isprime[i])
prime[top++] = i;
for(int k = 0; k < top && i * prime[k] < n; k++){
isprime[i*prime[k]] = false;
if(i % prime[k] == 0)
break;
}
}
}
ll Pow(ll x, ll y, ll mod) //快速幂
{
ll res = 1;
while(y){
if (y & 1)
res = (res * x) % mod;
y = y >> 1 ;
x = (x * x) % mod;
}
return res;
}
void fac(int *arg, ll n) //计算阶乘
{
ll len = -1;
while(prime[++len] <= n){
ll sum = 0;
arg[prime[len]] = 0; //初始化
ll num = prime[len]; // N/b
while(num <= n){
sum += n / num;
num = num * prime[len]; // b^n
}
arg[prime[len]] += sum;
}
}
int main()
{
ll n, mod;
Prime(1000000); //素数打表
while(cin>>n>>mod){
fac(arg, n); //计算阶乘保存在 arg 里面
ll res = 1;
for(int i = 0; prime[i] <= n; i++){
res = (res * Pow(prime[i], arg[prime[i]], mod)) % mod;
}
cout<<res%mod<<endl;
}
return 0;
}
版权声明:本文为博主原创文章,未经博主允许不得转载。