【模板】拓展卢卡斯

本文深入探讨了ExLucas算法的实现细节,包括快速幂、扩展欧几里得算法、组合数计算等核心模块,并通过具体实例展示了算法的优化过程。文章还提供了完整的代码示例,便于读者理解和应用。

粘代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
template<typename T>
inline void read(T&x)
{
    T f = 1,c = 0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){c=c*10+ch-'0';ch=getchar();}
    x = f*c;
}
ll n,m,P;
ll fastpow(ll x,ll y,ll MOD)
{
    ll ret = 1;
    while(y)
    {
        if(y&1)ret=ret*x%MOD;
        x=x*x%MOD;y>>=1;
    }
    return ret;
}
void exgcd(ll a,ll b,ll&x,ll&y)
{
    if(!b){x=1,y=0;return ;}
    exgcd(b,a%b,y,x);y-=a/b*x;
}
ll inv(ll a,ll MOD){ll x,y;exgcd(a,MOD,x,y);return (x%MOD+MOD)%MOD;}
ll p[30],pk[30],pnt,f[30][1000050];
ll jc[1000050],jny[1000050];
void init()
{
    ll now = P;
    for(ll i=2;i*i<=now;i++)if(now%i==0)
    {
        p[++pnt]=i,pk[pnt]=1;
        while(now%i==0)now/=i,pk[pnt]*=i;
    }
    if(now!=1)
    {
        p[++pnt]=now,pk[pnt]=now;
    }
    if(p[1]==MOD)
    {
        jc[0] = 1;
        for(ll i=1;i<P;i++)jc[i]=jc[i-1]*i%P;
        jny[P-1] = inv(jc[P-1],P);
        for(ll i=P-1;i;i--)jny[i-1]=jny[i]*i%P;
        return ;
    }
    for(ll i=1;i<=pnt;i++)
    {
        f[i][0]=1;
        for(ll j=1;j<pk[i];j++)
            if(j%p[i])f[i][j]=f[i][j-1]*j%pk[i];
            else f[i][j]=f[i][j-1];
    }
}
ll calp(ll x,ll P){ll ret=0;for(x/=P;x;x/=P)ret+=x;return ret;}
ll calc(ll x,ll i)
{
    if(!x)return 1;
    return fastpow(f[i][pk[i]-1],x/pk[i],pk[i])*f[i][x%pk[i]]%pk[i]*calc(x/p[i],i);
}
ll Lucas(ll x,ll y)
{
    if(x<y)return 0;
    if(x<P)return jc[x]*jny[y]%P*jny[x-y]%P;
    return Lucas(x/P,y/P)*Lucas(x%P,y%P)%P;
}
ll eLucas(ll x,ll y,int i)
{
    ll k = calp(x,p[i])-calp(y,p[i])-calp(x-y,p[i]);
    return fastpow(p[i],k,pk[i])
            *calc(x,i)%pk[i]
            *inv(calc(y,i),pk[i])%pk[i]
            *inv(calc(x-y,i),pk[i])%pk[i];
}
ll ExLucas(ll x,ll y)
{
    if(p[1]==MOD)return Lucas(x,y);
    ll ans = 0;
    for(ll i=1;i<=pnt;i++)
        ans= (ans + eLucas(x,y,i) * (P/pk[i])% P * inv(P/pk[i],pk[i]) % P)%P;
    return ans;
}
int main()
{
    read(n),read(m),read(P);
    init();
    printf("%lld\n",ExLucas(n,m));
    return 0;
}
View Code

upd:有一个地方:

ll calc(ll x,ll i)
{
    if(!x)return 1;
    return fastpow(f[i][pk[i]-1],x/pk[i],pk[i])*f[i][x%pk[i]]%pk[i]*calc(x/p[i],i);
}
曾经的代码

他可以这样变强:

ll mul(ll x,int i)
{
    if(!x)return 1;ll bas = pk[i]-1;
    if(p[i]==2)bas=(pk[i]==4)?3:1;
    return 1ll*fastpow(bas,x/pk[i],pk[i])*f[i][x%pk[i]]%pk[i]*mul(x/p[i],i)%pk[i];
}
变强的代码

所以说对于质数$p$($p$不为$2$)与他的整数次幂$pk$存在$\prod _{i=1,i⊥p}^{pk}i ≡ pk-1 \; (mod\;pk)$?

先证一下这个:$$(p-2)!≡1\;(mod\;p)$$

这个可好证了……

先特判$3$时显然成立。

因为$1$的逆元是自己,$-1*-1=1$即$(p-1)*(p-1)≡1\;(mod\;p)$,所以这两个的逆元都是自己。

剩下的$2,3……p-2$共$p-3$个数,在$p$不为$2$时能两两一对组成逆元。

所以这一堆乘一起为$1$。

所以$(p-2)!≡1\;(mod\;p)$。

现在我们来证$\prod _{i=1,i⊥p}^{pk}i ≡ pk-1 \; (mod\;pk)$。

证法和上面那个差不多。

所有$p$的倍数没有逆元,$1$和$pk-1$的逆元是自己,剩下两两配对都是$1$。

 

upd:刚才证完了非$2$部分,现在来证一下$2$的部分。

刚才的伪证是在只有$1$和$pk-1$的逆元是自己的前提下,而当$p=2$且$k>2$时,$2^{n-1}-1$和$2^{n-1}+1$的逆元也是自己。

很巧的是这四个数乘一起得$1$。

(应该没有其他的锅了吧……)

转载于:https://www.cnblogs.com/LiGuanlin1124/p/11128840.html

卢卡斯定理(Lucas Theorem)是组合数学中用于高效计算组合数模一个质数的常用方法,尤其是在组合数的参数远大于模数的情况下。洛谷P3807题是卢卡斯定理的标准模板题之一,其核心目标是计算 $ C_{n+m}^{n} \mod p $,其中 $ n, m \leq 10^9 $,而 $ p $ 是一个质数且 $ p \leq 10^5 $。这种情况下,直接计算阶乘再取模会超出时间限制或精度限制,因此需要使用卢卡斯定理来优化计算过程。 ### 卢卡斯定理的基本思想 卢卡斯定理指出,对于非负整数 $ A, B $ 和质数 $ p $,将 $ A $ 和 $ B $ 表示为 $ p $ 进制数后,组合数模 $ p $ 的值等于各位组合数的乘积模 $ p $。即: $$ C_B^A \mod p = \prod_{i=0}^{\min\{n,m\}} C_{b_i}^{a_i} \mod p $$ 其中 $ A = a_n \times p^n + a_{n-1} \times p^{n-1} + \cdots + a_0 $,$ B = b_m \times p^m + b_{m-1} \times p^{m-1} + \cdots + b_0 $。这一性质将大范围的组合数分解为多个小范围组合数的乘积,便于计算[^1]。 ### 实现方法 在实现过程中,需要预先计算阶乘和逆元的模值。具体来说,需要构建两个数组: - `s1[]`:存储阶乘模 $ p $ 的结果,即 $ s1[i] = i! \mod p $。 - `s2[]`:存储逆元的前缀积,即 $ s2[i] = (i!)^{-1} \mod p $。 组合数 $ C_n^m \mod p $ 可以通过以下公式计算: $$ C_n^m \mod p = \frac{s1[n]}{s1[m] \cdot s1[n-m]} \mod p $$ 在模运算中,除法等价于乘以逆元。因此,可以通过预先计算阶乘和逆元的数组来快速完成计算。 #### 递归实现 卢卡斯定理的递归形式为: $$ C_n^m = C_{n/p}^{m/p} \cdot C_{n \mod p}^{m \mod p} \mod p $$ 当 $ n \leq p $ 且 $ m \leq p $ 时,直接调用预处理的组合数计算函数;否则,递归地将问题分解为更小的子问题。 #### 代码实现 以下是基于上述思想的C++代码实现: ```cpp #include <bits/stdc++.h> using namespace std; typedef long long ll; const int maxn = 1e5 + 5; ll n, m, p; ll s1[maxn], s2[maxn]; // s1[]表示阶乘,s2[]表示逆元前缀积 inline ll C(ll n, ll m) { return n < m ? 0 : s1[n] * s2[m] % p * s2[n - m] % p; } ll lucas(ll n, ll m) { return (n <= p && m <= p) ? C(n, m) : lucas(n % p, m % p) * lucas(n / p, m / p) % p; } inline void pre() { s1[0] = s2[0] = s2[1] = 1; // 注意s2[0]=1很重要 for (ll i = 1; i <= p; i++) s1[i] = (s1[i - 1] * i) % p; for (ll i = 2; i <= p; i++) s2[i] = (p - p / i) % p * s2[p % i] % p; for (int i = 2; i <= p; i++) s2[i] = s2[i - 1] * s2[i] % p; } int main() { int T; scanf("%d", &T); while (T--) { scanf("%lld%lld%lld", &n, &m, &p); pre(); printf("%lld\n", lucas(n + m, n)); } return 0; } ``` ### 优化与注意事项 - **预处理阶乘和逆元**:在每次测试用例中,都需要重新预处理阶乘和逆元数组,以确保模数 $ p $ 的正确性。 - **边界条件**:当 $ n = 0 $ 或 $ m = 0 $ 时,组合数为 1,需特别处理。 - **递归终止条件**:当 $ n \leq p $ 且 $ m \leq p $ 时,可以直接调用组合数计算函数,避免不必要的递归调用。 ### 总结 卢卡斯定理通过将大范围的组合数问题分解为小范围问题,极大地提高了计算效率。结合预处理阶乘和逆元数组,可以在 $ O(p) $ 的时间内完成预处理,并在 $ O(\log_p n) $ 的时间内完成每次查询。这种方法在处理组合数模质数的问题中具有广泛的应用价值。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值