N 的阶乘的另一种解法

任何一个数都可以分解成素数乘积，利用着这性质就可以把 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整除）
16能被16整除
这样就得到了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;
}