组合数

求C(n,m)%p;

概念：
组合数我们用C（n，m）表示，它代表在n个数中取m个数的方案。（这个概念主要用于将问题抽象到组合数上）。
公式：
1、C（n，m）=C（n，n-m）;
2、C（n，m）=C（n-1，m-1）+C（n-1，m）;

3、C（0，n）+C（1，n）+C（2，n）+C（3，n）+…+C（n，n）=2 ^ n，这个公式被我们成为二次项定理

求法：
对于组合数的求法挺多的：Lucas定理、递推、逆元

递推：
这个其实就是在推杨辉三角，这个主要是用于n和m<=2000。对于这种问题我们就比较适合递推。
适用范围：
n<=2000（n是组合数的下标的值，即C（n，m）中的n）

代码：

#include<iostream>
#include<cstdio>
using namespace std;
int C[1000][1000],mod=1e9+9;
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    for(int i=0;i<=n;i++)//边界一定要全 
    {
        C[i][1]=i%mod;//对于i个数中取一个数方案是i 
        C[i][i]=C[i][0]=1;//在i个数中取i个数只有一种方案 
    }
    for(int i=2;i<=n;i++)//直接开始递推 
        for(int j=2;j<i;j++)//边界不要计算 
            C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;//根据第二个公式，也就是杨辉三角的递推式 
    printf("%d",C[n][m]);//输出答案 
    return 0;
}

阶乘逆元：
这个方法就是根据组合数的定义公式去求，根据C（n，m）=n！/（m！*（n-m）！），所以我们要预处理出所有的阶乘以及逆元。

我们定义inv[i]表示i！的逆元，
我们可以知道inv[i+1]=（1/（i+1）！） ^ -1，（因为csdn比较难渲染数学公式，所以如果不方便看的话可以自己在纸上写），我们同乘i+1就变成了，inv[i+1]*（i+1）=（1/i!） ^ -1=inv[i]，所以我们可以得到：inv[i+1] * （i+1）=inv[i]，所以我们先求出n！的逆元，再倒推回来。
适用范围：
n<mod（n的意义上同，因为如果n>mod的话，其中有的阶乘就会因为是mod的倍数而没有逆元，这样就错了）
板子代码（费马小定理）：

#include<iostream>
#include<cstdio>
using namespace std;
long long inv[1000100],jc[1000100],mod=1e9+9;
long long pow(long long a,long long b)//快速幂 
{
    long long ans=1;
    while(b)
    {
        if(b%2==1)
            ans=(ans*a)%mod;
        a=(a*a)%mod;
        b=b>>1;
    }
    return ans;
}
void pre()
{
    jc[1]=1;//阶乘边界 
    for(int i=2;i<=1000000;i++)
        jc[i]=(jc[i-1]*i)%mod;//求阶乘 
    inv[1000000]=pow(jc[1000000],mod-2);//用费马小定理求 
    for(int i=999999;i>=0;i--)
        inv[i]=(inv[i+1]*(i+1))%mod;//倒推求阶乘逆元 
    return ;
}
int main()
{
    pre();
    int T;
    scanf("%d",&T);
    while(T--)
    {
        long long n,m;
        scanf("%lld %lld",&n,&m);
        printf("%lld
",(((jc[n]*inv[m])%mod)*inv[n-m])%mod);//求答案，记得mod，一直mod，乘完就mod！ 
    }
}

板子代码（拓展欧几里得）：

#include<iostream>
#include<cstdio>
using namespace std;
int mod=1e9+9,inv[1000100],jc[1000100],x,y;
void gcd(int a,int b)//拓展欧几里得 
{
    if(b==0)
    {
        x=1;
        y=0;
        return ;
    }
    gcd(b,a%b);
    int k=x;
    x=y;
    y=k-a/b*y;
    return ;
}
void pre()
{
    jc[1]=1;
    for(int i=2;i<=1000000;i++)//求阶乘 
        jc[i]=(jc[i-1]*i)%mod;
    gcd(jc[1000000],mod);//求最大阶乘逆元 
    inv[1000000]=(x+mod)%mod;//赋值 
    for(int i=999999;i>=0;i--)//倒推阶乘逆元 
        inv[i]=(inv[i+1]*(i+1))%mod;
    return ;
}
int C(int n,int m)
{
    return (((1LL*jc[n]*inv[m])%mod)*inv[n-m])%mod;//组合数 
}
int main()
{
    int T;
    scanf("%d",&T);
    pre();
    while(T--)
    {
        int n,m;
        scanf("%d %d",&n,&m);//读入 
        printf("%d
",C(n,m));//输出答案 
    }
    return 0;
}

Lucas定理：
这个定理个人觉得还好，主要是针对mod很小，如果用阶乘的话就有可能会是mod的倍数，这样逆元求组合数就gg了。可是对于递推又被卡的情况下我们就只能用这个了。
适用范围：
在递推和阶乘逆元都挂的时候，就用这个。
公式：
Lucas（n，m，mod）（n和m是C（n，m）中的，mod就是取模对象）=C（n%mod，m%mod） * Lucas（n/mod，m/mod，mod）。

C(n,m) % p = （C(n % p, m % p) * Lucas( n / p, m / p )) % p。（递归出口为m==0，return 1）
代码：
这个代码有两种，因为我们可以看见，在公式中我们是有组合数的，只不过范围降了下来，所以我们主要是用Lucas定理把原本卡死递推和阶乘逆元给救回来。所以我们才有两种代码。当mod比较小时我们可以采用递推，而mod比较大时我们可以用阶乘逆元。
递推：

#include<iostream>
#include<cstdio>
using namespace std;
int C[2010][2010],mod;
void pre()//预处理 
{
    for(int i=1;i<=mod;i++)
    {
        C[i][1]=i%mod;
        C[i][i]=C[i][0]=1;
    }
    for(int i=2;i<=mod;i++)
        for(int j=2;j<i;j++)
            C[i][j]=(C[i-1][j]+C[i-1][j-1])%mod;
    return ;
}
int Lucas(int n,int m)
{
    if(m==0)//边界 
        return 1;
    return (C[n%mod][m%mod]*Lucas(n/mod,m/mod))%mod;//Lucas定理的公式 
}
int main()
{
    int T;
    scanf("%d %d",&T,&mod);
    pre();
    while(T--)
    {
        int n,m;
        scanf("%d %d",&n,&m);
        printf("%d
",Lucas(n,m));//Lucas定理 
    }
    return 0;
}

阶乘逆元：
对于这个虽然有了小优化，可还是有一个条件：mod必须是质数才可以，要不然题目保证mod以内的阶乘不会是mod的倍数。
费马小定理：

#include<iostream>
#include<cstdio>
using namespace std;
int jc[1000100],inv[1000100],mod;
int pow(long long a,long long b)//快速幂 
{
    long long ans=1;
    while(b)
    {
        if(b%2==1)
            ans=(ans*a)%mod;
        a=(a*a)%mod;
        b=b>>1;
    }
    return (int)ans;
}
void pre()//预处理阶乘逆元 
{
    jc[1]=1;
    for(int i=2;i<mod;i++)
        jc[i]=(jc[i-1]*i)%mod;
    inv[mod-1]=pow(jc[mod-1],mod-2);//费马小定理 
    for(int i=mod-2;i>=0;i--)
        inv[i]=(inv[i+1]*(i+1))%mod;
}
int C(int n,int m)//组合数公式 
{
    return (((jc[n]*inv[m])%mod)*inv[n-m])%mod;
}
int Lucas(int n,int m)
{
    if(m==0)//边界 
        return 1;
    return (C(n%mod,m%mod)*Lucas(n/mod,m/mod))%mod;//Lucas定理公式 
}
int main()
{
    int T;
    scanf("%d %d",&T,&mod);
    pre();
    while(T--)
    {
        int n,m;
        scanf("%d %d",&n,&m);
        printf("%d
",Lucas(n,m));//输出 
    }
    return 0;
}

拓展欧几里得：

#include<iostream>
#include<cstdio>
using namespace std;
int mod,inv[1000100],jc[1000100],x,y;
void gcd(int a,int b)//拓展欧几里得 
{
    if(b==0)
    {
        x=1;
        y=0;
        return ;
    }
    gcd(b,a%b);
    int k=x;
    x=y;
    y=k-a/b*y;
    return ;
}
void pre()//预处理 
{
    jc[1]=1;
    for(int i=2;i<mod;i++)
        jc[i]=(jc[i-1]*i)%mod;
    gcd(jc[mod-1],mod);//处理出解 
    inv[mod-1]=(x+mod)%mod;//把解取正 
    for(int i=mod-2;i>=0;i--)
        inv[i]=(inv[i+1]*(i+1))%mod;
    return ;
}
int C(int n,int m)//组合数尝龟 
{
    return (((1LL*jc[n]*inv[m])%mod)*inv[n-m])%mod;
}
int Lucas(int n,int m)
{
    if(m==0)
        return 1;
    return (1LL*C(n%mod,m%mod)*Lucas(n/mod,m/mod))%mod;
}
int main()
{
    int T;
    scanf("%d %d",&T,&mod);//多组测试数据，mod的值 
    pre();
    while(T--)
    {
        int n,m;
        scanf("%d %d",&n,&m);
        printf("%d
",Lucas(n,m));//输出 
    }
    return 0;
}

例题：

 代码：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int mod =1e9+7;
ll quick(ll x,ll n) {
    ll res = 1;
    x%=mod;
    while (n) {
        if(n&1) res = res*x%mod;
        x = x*x %mod;
        n >>=1;
    }
    return res;
}
 
ll C(ll n,ll m) {
    if(n < m) return 0;
    // c(n,m) = n!/m!/(n-m)!
    ll res = 1;
    for(int i=1; i<=m; i++) {
        ll a = (n+i-m)%mod;
        ll b = i%mod;
        res = res*(a*quick(b,mod-2)%mod)%mod;
    }
    return res;
}
 
ll Lucas(ll n,ll m) {
    if(m == 0) return 1;
    return C(n%mod, m%mod) * Lucas(n/mod,m/mod)%mod;
}
int main(){
    ll m,n;
    string p;
    cin>>n>>m>>p;  //m<n
    ll ans = 0;
    for(int i=0;p[i]!='';i++){
        ans= (ans*10+p[i]-'0')%mod;
    }
    if(Lucas(n,m)==ans)
        cout<<"Yes!"<<endl;
    else
        cout<<"No!"<<endl;
    return 0;
}