组合数详解

概念：
组合数我们用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;
}

题目代码：

#include<iostream>
#include<cstdio>
using namespace std;
long long C[2010][2010],sum[2010][2010],mod;
void pre()
{
	for(int i=0;i<=2000;i++)
	{
		C[i][1]=i%mod;
		C[i][i]=C[i][0]=1;
	}
	for(int i=2;i<=2000;i++)
		for(int j=2;j<i;j++)
			C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
	for(int i=1;i<=2000;i++)
		for(int j=1;j<=i;j++)//预处理出在i个数中1到j中有多少个组合数是mod的倍数 
			if(C[i][j]==0)//因为对mod取余，所以等于0就是mod的倍数 
				sum[i][j]=sum[i][j-1]+1;//前缀和计算 
			else sum[i][j]=sum[i][j-1];//不是的话就直接等于 
	return ;
}
int main()
{
	int n,m,T;
	scanf("%d %d",&T,&mod);//多组测试数据 
	pre();//直接求出2000以内所有组合数 
	while(T--)
	{
		long long ans=0;
		scanf("%d %d",&n,&m);
		for(int i=1;i<=n;i++)
			if(i>m)//这个要注意，因为如果i<m的话min(i,m)是等于i的 
				ans+=sum[i][m];
			else ans+=sum[i][i];
		printf("%lld\n",ans);//输出答案 
	}
	return 0;
}

阶乘逆元：
这个方法就是根据组合数的定义公式去求，根据C（n，m）=n！/（m！*（n-m）！），所以我们要预处理出所有的阶乘以及逆元。首先你要会阶乘逆元的预处理。不会阶乘逆元的点这
适用范围：
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\n",(((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\n",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）。
代码：
这个代码有两种，因为我们可以看见，在公式中我们是有组合数的，只不过范围降了下来，所以我们主要是用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\n",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\n",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\n",Lucas(n,m));//输出 
	}
	return 0;
}

补充：
对于这个组合数还有一个超牛掰的原理： 隔板原理 。
这个是什么东东？
其实也不会难。
问题原型：
给你n个物品，这些物品一毛一样，要你用m-1个隔板把它们划分成m组（每组都要有物品）。请问有多少种方案？
这和组合数有什么关系？
当然有关系！我们换个方式想一下，对于这m-1个隔板其实我们有n-1个位置可以放，而对于每种方法恰好对应一种方案，所以这个问题我们就可以化成对于m-1个隔板，有n-1个位置可以放，问放的方案数有多少？
这不就是组合数嘛。
对于这个问题还有一个变形，注意到我们上面要求的是每组都要有物品，那么如果可以没物品呢？其实也不难。
我们可以这么想，对于每组m，我们都人为地加m个物品，这样不就是上面的问题了吗？
在n+m-1个地方放m-1个隔板。
以上就是组合数提高组的所有知识，希望大家看后可以有理解。
如果有不清楚的欢迎留言询问。