求组合数（四种题型 合集）

---

求组合数 I

给定 n 组询问，每组询问给定两个整数 a，b，请你输出 Cba mod (10^9+7) 的值。

输入格式
第一行包含整数 n。

接下来 n 行，每行包含一组 a 和 b。

输出格式
共 n 行，每行输出一个询问的解。

数据范围
1≤n≤10000,
1≤b≤a≤2000

输入样例：
3
3 1
5 3
2 2
输出样例：
3
10
1

解法：使用递推预处理

//递推求法（类似dp）   																时间复杂度 O(N^2)

#include <iostream>

using namespace std;

const int N=2010;
const int mod=1e9+7;

int n;
int c[N][N];

void init()
{
    for(int i=0;i<N;i++)
        for(int j=0;j<=i;j++)	 //从 i中选 j个，所以 j <= i;
            if(!j) c[i][j]=1;	 //从 i中选 0个，只有一种方案
            else c[i][j]=(c[i-1][j-1]+c[i-1][j])%mod;//结果要模上 1e9+7
}

int main()
{
    cin>>n;
    init();
    while(n--)
    {
        int a,b;
        cin>>a>>b;
        cout<<c[a][b]<<endl;
    }
    return 0;
}

---

求组合数 II

给定 n 组询问，每组询问给定两个整数 a，b，请你输出 Cba mod (10^9+7) 的值。

输入格式
第一行包含整数 n。

接下来 n 行，每行包含一组 a 和 b。

输出格式
共 n 行，每行输出一个询问的解。

数据范围
1≤n≤100000,
1≤b≤a≤10^5

输入样例：
3
3 1
5 3
2 2
输出样例：
3
10
1

解法：费马小定理+快速幂

根据公式，用 a的阶乘，乘上 b和(a-b)阶乘的逆元，结果模上1e9+7

//逆元求法：使用费马小定理和快速幂求出阶乘的逆元									  时间复杂度 O(NlogN)

#include <iostream>

using namespace std;

typedef long long LL;

const int N=100010;
const int mod=1e9+7;

int fact[N],infact[N];	 	 //fact存阶乘，infact存阶乘的逆元
int n;

int qmi(int a,int b,int p)	 //快速幂模板
{
    int res=1;
    while(b)
    {
        if(b&1) res=(LL)res*a%mod;
        b>>=1;
        a=(LL)a*a%mod;
    }
    return res;
}

int main()
{
    fact[0]=infact[0]=1;	//让第 0位等于 1，方便阶乘
    for(int i=1;i<N;i++)
    {
        fact[i]=(LL)fact[i-1]*i%mod; //计算时别忘了先转为 long long ，防止溢出
        infact[i]=(LL)qmi(i,mod-2,mod)*infact[i-1]%mod;
    }
    scanf("%d",&n);
    while(n--){
        int a,b;
        scanf("%d%d",&a,&b); //数据量较大时使用 scanf 读入
        cout<<(LL)fact[a]*infact[a-b]%mod*infact[b]%mod<<endl;//每次相乘都要模上 1e9+7
    }
    return 0;
}

---

求组合数 III

给定 n 组询问，每组询问给定三个整数 a,b,p，其中 p 是质数，请你输出 Cba mod p 的值。

输入格式
第一行包含整数 n。

接下来 n 行，每行包含一组 a,b,p。

输出格式
共 n 行，每行输出一个询问的解。

数据范围
1≤n≤20,
1≤b≤a≤10^18,
1≤p≤10^5,

输入样例：
3
5 3 7
3 1 5
6 4 13
输出样例：
3
3
2

解法：卢卡斯定理（Lucas Theory）

//卢卡斯定理																		   时间复杂度 O(logpN)

#include <iostream>

using namespace std;

typedef long long LL;

int qmi(int a,int b,int p)	 //快速幂
{
    int res=1;
    while(b)
    {
        if(b&1) res=(LL)res*a%p;
        a=(LL)a*a%p;
        b>>=1;
    }
    return res;
}

int C(int a,int b,int p)	//根据定义求组合数（ a * (a-b)的逆元 * b的逆元 ）
{
    int res=1;
    for(int i=1,j=a;i<=b;i++,j--)//如果不理解可手动模拟
    {
        res=(LL)res*j%p;
        res=(LL)res*qmi(i,p-2,p)%p;//快速幂求逆元
    }
    return res;
}

LL lucas(LL a,LL b,int p)//这里 a 和 b 要用 long long 传入
{
    if(a<p&&b<p) return C(a,b,p);	//如果 a 和 b 都小于 p ，直接进行计算
    return C(a%p,b%p,p)*lucas(a/p,b/p,p)%p;	//否则使用卢卡斯定理
}

int main()
{
    int n;
    cin>>n;
    while(n--)
    {
        LL a,b;
        int p;
        cin>>a>>b>>p;
        cout<<lucas(a,b,p)<<endl;
    }
    return 0;
}

---

求组合数 IV

输入 a,b，求 Cba 的值。

注意结果可能很大，需要使用高精度计算。

输入格式
共一行，包含两个整数 a 和 b。

输出格式
共一行，输出 Cba 的值。

数据范围
1≤b≤a≤5000

输入样例：
5 3
输出样例：
10

解法：高精度+分解质因数

a! 中含质数 p 的个数 = [a/p]+[a/p2]+[a/p3]+… 即：

解释：[a/p]中包含了p的倍数的个数，但是p^2中包含了两个p，但是只被计算了一次，所以再加上 [a/p^2]；以此类推……

//高精度+分解质因数

#include <iostream>
#include <vector>

using namespace std;

typedef long long LL;

const int N=5010;

int cnt;		//质数的个数
int primes[N];  //存储质数
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]=1;
            if(i%primes[j]==0) break;
        }
    }
}

int get(int x,int p)  //获取 x 的阶乘中分解出质数 p 的次数
{
    int res=0;
    while(x)
    {
        res+=x/p;
        x/=p;
    }
    return res;
}

vector<int> mul(vector<int> a,int b)  //高精度
{
    int t=0;//用于进位
    vector<int> c;
    for(int i=0;i<a.size();i++){
        t+=a[i]*b;
        c.push_back(t%10);
        t/=10;
    }
    while(t){
        c.push_back(t%10);
        t/=10;
    }
    return c;
}

int main()
{
    int a,b;
    cin>>a>>b;
    get_primes(a);
    
    for(int i=0;i<cnt;i++){ //遍历所有筛出的质数
        int p=primes[i];
        sum[i]=get(a,p)-get(b,p)-get(a-b,p);  //利用分子分解出的质数个数减去分母的，即为最终结果中包含的质数 p 的次数
    }
    
    vector<int> res;
    res.push_back(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];
    puts("");
    return 0;
}

---