数论测试——阶乘除法

数论有一部分的总括

---

题目描述

给出两个数组$a$和$b$，求$\frac{a_{{}_1}!\ast a_{{}_2}!\ast a_{{}_3}!\ast ...\ast a_{{}_n}!}{b_{{}_1}!\ast b_{{}_2}!\ast b_{{}_3}!\ast ...\ast b_{{}_m}!}\mathrm{m}\mathrm{o}\mathrm{d}T$。数据保证答案为整数。

数据范围
$n,m,a_i,b_i\le 10^5,T\le 10^9$

前置芝士——勒让德定理

链接（百度百科is a good guy）
简单的再解释一下。假设有一个质数$p$，然后把$n!$分解质因数，则质数$p$的指数为$$\sum _{k=1}^{n\ge p^k}[\frac{n}{p^k}]$$

分析

对于定理而言，是在质数的基础之上建立的，所以——
先筛出质数表。（不要问我什么范围，直接上最大值）

我们可以把分子和分母都化成质数的乘积形式，然后上下约分，再快速幂得出结果。
所以，关键是如何转化。

为了方便说明，先定义两个概念：
$p{r}_i$：第$i$个质数 \quad\quad\quad $tot$：$1——10^5$范围内的质数个数。

以下内容只是对分子的分析，因为分子分母的分解过程十分相似。

首先，可以较为轻松地想出一个暴力算法——把每一个数遍历一下再分解，可以看一下大体的程序：
$$\sum _{k=1}^n\sum _{i=1}^{tot}\sum _{j=1}^{n\ge p^j}[\frac{a_{{}_k}}{{p{r}_{{}_i}}^j}]$$
不过，我们可以知道，$tot=9592$，所以这个程序前两个循环就爆了。

---

分析定理，再看一看循化——后面两个是必要的，肯定不可以省，所以就只能省第一个。

该怎么省呢？假设把后面两个先写上，那么我们可以确定${p{r}_i}^j$。
可以考虑一下对除法的分析。

因为除法的结果取整是会有分段性的，例如连续自然数除以8就是每8个结果增加1，所以可以把数组$a$弄成这样的分段形式，就可以用桶来分段储存。

如果我们枚举一下商，那么我们可以把商对应的范围求出来。
令商为$k$，那么满足$[\frac{x}{{p{r}_{{}_i}}^j}]=k$的$x$在区间$[{p{r}_{{}_i}}^j\ast k,{p{r}_{{}_i}}^j\ast (x+1))$之间

为什么？因为那个分段性。除以${p{r}_{{}_i}}^j$就是每${p{r}_{{}_i}}^j$分一段，于是可以得出这个结果。

所以接下来就是求在$[{p{r}_{{}_i}}^j\ast k,{p{r}_{{}_i}}^j\ast (x+1))$之间的数的个数了。该怎么求呢？因为$a_i,b_i$的范围较小，所以可以使用桶和前缀和$O(1)$算出答案。_{（线段树and树状数组？？？区间求和不是我们的生意吗？？？）}因为这个不需要动态操作，所以可以直接使用前缀和实现$O(1)$查询。

最后，直接把每一个质数的指数加起来（幂的乘法），对分母处理就减去指数就好了。
因为质数都是互质的，而且答案是整数，所以只能形成整除，因此每一个质数之间互相约掉才能有整数，所以不会存在负幂的情况，就可以直接来了。

代码实现

#include<map>
#include<set>
#include<list>
#include<queue>
#include<deque>
#include<stack>
#include<ctime>
#include<cmath>
#include<vector>
#include<bitset>
#include<cstdio>
#include<cctype>
#include<string>
#include<sstream>
#include<fstream>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;
#define reg register
#define ONLINE_JUDGE
#ifdef ONLINE_JUDGE
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int getc() { return p1 == p2 && (++p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++; }
#define getchar getc
#endif
template<typename T>
inline T read() {
    T a = 0; char f = 1, c = getchar();
    while(c < '0' || c > '9') {
        if(c == -1) return -1;
        if(c == '-') f = -f;
        c = getchar();
    }
    while('0' <= c && c <= '9') {
        a = (a << 3) + (a << 1) +(c ^ 48);
        c = getchar();
    }
    return a;
}
template<class T>
inline int write(T x) {
    if(x < 0) {
        putchar('-');
        x = (~x) + 1;
    }
    if(x / 10) write(x / 10);
    return putchar(x % 10 | 48);
}
template<class T>
inline int write(T x, char c) {
    return write(x) && putchar(c);
}
template<class T>
inline T Min(T a, T b) { return a < b ? a : b; }
template<class T>
inline T Max(T a, T b) { return a > b ? a : b; }

const int MAXN = 100001;
int n = read<int>(), m = read<int>(), T = read<int>();
int pr[9593], tot; bool vis[MAXN];
long long c[MAXN], w[9593];
long long M = -1;
long long ans = 1, down = 1;
inline void Euler(int n)
{
    for(reg int i = 2; i <= n; i++) {
        if (!vis[i])
            pr[++tot] = i;
        for(reg int j = 1; j <= tot && i * pr[j] <= n; j++) {
            vis[i * pr[j]] = 1;
            if (i % pr[j] == 0)
                break;
        }
    }
}
inline void solve(int n, long long f) {
    memset(c, 0, sizeof c);
    for(reg int i = 1; i <= n; i++) {
        long long a = read<long long>();
        c[a]++;
        M = Max(a, M);
    }
    for(reg int i = 2; i <= M; i++)
        c[i] += c[i - 1];
    for(reg int i = 1; i <= tot; i++) {
        for(reg long long j = pr[i]; j <= M; j *= pr[i]) {
            for(reg int k = 1; j * k <= M; k++) {
                long long l = j * k, r = Min(j * (k + 1) - 1, M);
                w[i] += f * (c[r] - c[l - 1]) * k;
            }
        }
    }
}
inline long long piow(long long a, long long b) {
    long long ans = 1;
    while(b) {
        if(b & 1) ans = ans * a % T;
        a = a * a % T;
        b >>= 1;
    }
    return ans;
}
int main() {
    Euler(MAXN - 1);
    solve(n, 1);
    solve(m, -1);
    for(reg int i = 1; i <= tot; i++)
        ans = ans * piow(pr[i], w[i]) % T;
    write(ans);
}