基础数论--组合数

C(a,b)表示从a中选b个苹果，0<=b<=a

n代表询问次数

根据不同的数据范围有不同的解法

1、1≤n≤10000，1<=b<=a<=2000

　　此时n较大，询问次数较多，而a，b较小，可以预处理出所有C(a,b)的值，然后进行查询

　　用到了公式C(a,b)=C(a-1,b-1)+C(a-1,b)；

　　推导：假设总共有a个苹果，从中选b个，则方案数为C(a,b)

　　　　　此时我拿出来一个单独考虑，那此时你就有两种方案，而且不会有重合或者漏算，即拿这个苹果或者不拿这个苹果

　　　　　那么方案数则为--->拿这个苹果C(a-1,b-1)，不拿这个苹果C(a-1,b)；

　　　　　得证。

#include<iostream>
using namespace std;
const int N=2010,mod=1e9+7;
int C[N][N];
void init(){
    for(int i=0;i<N;i++){
        for(int j=0;j<=i;j++){
            if(j==0) C[i][j]=1;
            else C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
        }
    }
}
int main(void){
    init();
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b;
        cin>>a>>b;
        cout<<C[a][b]<<endl;
    }
    return 0;
}

2、1≤n≤10000，1≤b≤a≤1e5

　　此时不能预处理出所有C(a,b)了，因为复杂度达到1e10了

　　而观察到a,b只有1e5，所以可以预处理出所有的阶乘

　　而因为C(a,b)太大，所以需要mod p ，所以可以预处理出阶乘的逆元和阶乘

#include<iostream>
using namespace std;
typedef long long LL;
const int N=1e5+10,mod=1e9+7;
LL fact[N],infact[N];
LL qmi(LL a,LL b,LL mod){
    LL res=1;
    while(b){
        if(b&1){
            res=res*a%mod;
        }
        b>>=1;
        a=a*a%mod;
    }
    return res;
}
void init(){
    fact[0]=infact[0]=1;
    for(int i=1;i<N;i++){//如果mod不是质数则需要用扩展欧几里得求逆元
        fact[i]=fact[i-1]*i%mod;
        infact[i]=infact[i-1]*qmi(i,mod-2,mod)%mod;
    }
}
int main(void){
    init();
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b;
        cin>>a>>b;
        cout<<fact[a]*infact[b]%mod*infact[a-b]%mod<<endl;
    }
    return 0;
}

3、1≤n≤20，1≤b≤a≤1e18，1≤p≤1e5

　　此时a，b非常大，而观察到p只有1e5，所以可以使用卢卡斯定理求解C(a,b)；

　　卢卡斯定理：C(a,b)%p=C(a%p,b%p)*C(a/p,b/p)；

　　可以看出卢卡斯定理转换为程序的话是一个递归的过程

　　

#include<iostream>
using namespace std;
typedef long long LL;
LL qmi(LL a,LL b,LL p){
    LL res=1;
    while(b){
        if(b&1){
            res=res*a%p;
        }
        b>>=1;
        a=a*a%p;
    }
    return res;
}
LL C(LL a,LL b,LL p){
    LL res=1;
    for(int i=a,j=1;i>a-b;i--,j++){
        res=res*i%p;
        res=res*qmi(j,p-2,p)%p;
    }
    return res;
}
LL lucas(LL a,LL b,LL p){
    if(a<p&&b<p)
        return C(a,b,p);
    return C(a%p,b%p,p)*lucas(a/p,b/p,p)%p;
}
int main(void){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        LL a,b,p;
        cin>>a>>b>>p;
        cout<<lucas(a,b,p)<<endl;
    }
    return 0;
}

4、1≤b≤a≤5000

如果不模某个数，那么这样的组合数是必须写高精度的。

你可以老老实实写一波高精度乘除

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> mul(vector<int>& a,int b){
    int flag=0;
    vector<int> res;
    for(int i=0;i<a.size();i++){
        flag=flag+a[i]*b;
        res.push_back(flag%10);
        flag/=10;
    }
    while(flag){
        res.push_back(flag%10);
        flag/=10;
    }
    while(res.size()>0&&res.back()==0){
        res.pop_back();
    }
    return res;
}

vector<int> div(vector<int>& a,int b){
    int r=0;
    vector<int> c;
    for(int i=a.size()-1;i>=0;i--){
        r=r*10+a[i];
        c.push_back(r/b);
        r=r%b;
    }
    reverse(c.begin(),c.end());
    while(c.size()>1&&c.back()==0)
        c.pop_back();
    return c;
}

int main(void){
    int a,b;
    cin>>a>>b;
    vector<int> t;
    t.push_back(1);

    for(int i=a;i>a-b;i--){
        t=mul(t,i);
    }



    for(int i=1;i<=b;i++){
        t=div(t,i);
    }
    for(int i=t.size()-1;i>=0;i--){
        cout<<t[i];
    }
    return 0;
}

或者根据唯一分解定理，可以只考虑最终答案的因子

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int N=5010;
int primes[N],cnt;
bool st[N];
int sum[N];
void get_primes(int n){
    for(int i=2;i<=n;i++){
        if(!st[i]){
            primes[cnt++]=i;
        }
        for(int j=0;primes[j]<=n/i;j++){
            st[primes[j]*i]=true;
            if(i%primes[j]==0) break;
        }
    }
}
int get(int n,int p){
    int res=0;
    int t=p;
    while(n>=p){
        res+=n/p;
        p*=t;
    }
    return res;
}
vector<int> mul(vector<int>& a,int b){
    int flag=0;
    vector<int> res;
    for(int i=0;i<a.size();i++){
        flag=flag+a[i]*b;
        res.push_back(flag%10);
        flag/=10;
    }
    while(flag){
        res.push_back(flag%10);
        flag/=10;
    }
    while(res.size()>0&&res.back()==0){
        res.pop_back();
    }
    return res;
}



int main(void){
    int a,b;
    cin>>a>>b;
    get_primes(max(a,b));
    for(int i=0;i<cnt;i++){
        sum[i]=get(a,primes[i])-get(b,primes[i])-get(a-b,primes[i]);
    }
    vector<int> res={1};
    for(int i=0;i<cnt;i++){
        for(int j=0;j<sum[i];j++){
            res=mul(res,primes[i]);
        }
    }
    for(int i=res.size()-1;i>=0;i--) cout<<res[i];
    return 0;
}