C语言或C++求组合数的四种方法

组合数公式

---

递推求组合数

应用场景：

数据范围小，且有取模条件

// c[a][b] 表示从a中选b个的方案数
for (int i = 0; i < N; i ++ )
    for (int j = 0; j <= i; j ++ )
        if (!j) c[i][j] = 1;
        else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;

---

预处理阶乘求逆元求组合数

应用场景

有取模条件，根据取模条件，如果模数是质数用费马小定理，用快速幂就可求逆元，否则用扩展欧几里得求逆元

费马小定理求逆元

// a 的 k 次方 mod p (p为质数)
int qmi(int a, int k, int p) //快速幂模板
{
	int res = 1;
	while (k)
	{
		if (k & 1) res = (long long)res * a % p;
		a = (long long)a * a % p;
		k >>= 1;
	}
	return res % p;
}

扩展欧几里得求逆元

// a 为求逆元的数，b 为模数，运算完成后 x 就是在模数为 b 下 a 的逆元
int exgcd(int a, int b, int &x, int &y)
{
	if (!b)
	{
		x = 1, y = 0;
		return a;
	}
	int d = exgcd(b, a % b, y, x);
	y -= a / b * x;
	return d;
}

预处理阶乘的逆元

// fact为阶乘 infact为阶乘的逆元
fact[0] = infact[0] = 1;
for (int i = 1; i < N; i ++ )
{
    fact[i] = (LL)fact[i - 1] * i % mod;
    infact[i] = (LL)infact[i - 1] * qmi(i, mod - 2, mod) % mod;
}

最后运用开头的组合数公式将除法换成逆元乘法并取模就行。

---

卢卡斯定理求组合数

应用场景

求大组合数，、, 且 模数  较小的情况下。求逆元根据  的情况来定，为质数可用费马小定理，否则用扩展欧几里得求逆元

根据公式实现

#include<iostream>

using namespace std;
typedef long long LL;
int p;

int ksm(int a, int b) // 快速幂
{
	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) // 组合数 C 
{
	int res = 1;
	for (int i = 1, j = a; i <= b; i++, j--)
	{
		res = (LL)res * j % p;
		res = (LL)res * ksm(i, p - 2) % p;
	}
	return res;
}

int lucas(LL a, LL b) // 卢卡斯
{
	if (a < p && b < p) return C(a, b);
	return (LL)C(a % p, b % p) * lucas(a / p, b / p) % p;
}

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

	return 0;
}

---

分解质因数求组合数

引用场景

没有取模条件

用公式  对 ，, 分解质因数消去相同的因子，化简式子用高精度乘法运算解决问题

#include<iostream>
#include<vector>
#include<cmath>

using namespace std;
const int N = 5050;
int primes[N], cnt;//a以内的素数有多少个
bool st[N];
int sum[N];//因子p的k次方，存k
int a, b;

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 a, int p)//get k
{
	int sum = 0;
	while (a)
	{
		sum += a / p;
		a /= p;
	}
	return sum;
}

vector<int > mul(vector<int> &a, int b) // 高精度乘法
{
	vector<int> c;
	int t = 0;
	for (int i = 0; i < a.size() || t; i++)
	{
		if (i < a.size()) t += a[i] * b;
		c.push_back(t % 10);
		t /= 10;
	}
	return c;
}

int main()
{
	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);
	}
	
	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];
	cout << endl;
	
	return 0;
}

---

卡特兰数练手题

网格

快乐