[数学]关于组合数

约定$C(n,k)$表示$C_n^k$

方法一 最直接的

只适用于$n\le 15$的情况 没什么用 不多说了
$$C_n^k=\frac{n!}{k!\times (n-k)!}$$

using ll = long long;

ll fact(int n){
    ll ret=1;
    for(int i=2;i<=n;i++) ret*=i;
    return ret;
}

ll cc(int n,int k){
    return fact(n)/fact(k)*fact(n-k);
}

方法二 递推约分

其实就是手算组合数的方法模拟

先上结论

using ll = long long;

ll combination(int n,int k){
    k=min(k,n-k);
    ll res=1;
    for(int i=1;i<=k;i++){
        res=res/i*(n-i+1);
    }
    return res;
}

时间复杂度$O(k)$，适用$n\le 10^9,k\le 50$，不会溢出

推导：

首先$$C_n^k\iff C_n^{n-k}$$所以k=min(k,n-k);

---

$$C_n^k=\frac{n!}{k!\times (n-k)!}$$
直接乘会溢出
显然里面有很多可以约分的地方
先写出分子：
$$n!=n\times (n-1)\times (n-2)\times \cdots \times 1$$
再写出分母：
$$k!(n-k)!=(k\times (k-1)\times \cdots \times 1)\times ((n-k)\times (n-k-1)\times \cdots \times 1)$$
约去$(n-k)\times (n-k-1)\times \cdots \times 1$

得到分式：
$$C_n^k=\frac{n\times (n-1)\times \cdots \times (n-k+1)}{k\times (k-1)\times \cdots \times 1}$$

这样，我们 只需要计算 ( k ) 个数相乘，而不是整个 ( n! )，避免了大数溢出问题。

---

让分子从 ( n ) 递减 ( k ) 次，分母从 ( 1 ) 递增 ( k ) 次：
$$C_n^k=\frac{n}{1}\times \frac{n-1}{2}\times \frac{n-2}{3}\times \cdots \times \frac{n-k+1}{k}$$

数学上保证了每次乘进来一项 分母都能整除分子
每一项都是$\frac{n-i+1}{i}$

for(int i=1;i<=k;i++){
	res=res/i*(n-i+1);
}	

先除后乘避免溢出

方法三 Pascal三角形预处理

适用情况

适用多次访问组合数的值
$n<=2000,k<=n$
空间复杂度$O(n^2)$，时间复杂度$O(n^2)$

推导

dp思想
从n个数中选k个，分两种情况：

• 选n，那么情况数就是前n-1个数中选k-1个
• 不选n，情况数就是前n-1个数中选k个

状态转移方程就出来了：
dp[n][k]=dp[n-1][k-1]+dp[n-1][k];

---

边界:

• dp[i][0]=1 从i个数中选0个 只有一种情况
• dp[i][i]=1 从i个数中选i个 只有一种情况

---

图示：

  1
  1 1
  1 2 1
  1 3 3 1
  1 4 6 4 1
  1 5 10 10 5 1

每个数是它左上方和右上方两个数的和。

---

代码实现

using ll = long long;
const int N=1010;
ll c[N][N];

void init(){
    for(int i=0;i<N;i++){
        c[i][0]=c[i][i]=1;
        for(int j=1;j<i;j++){
            c[i][j]=c[i-1][j-1]+c[i-1][j];
        }
    }
}	

目前只会这两个 等我学了Lucas+费马小定理再更新

下面是gpt写的

方法 4：使用 Lucas 定理（适用于大素数取模）

如果需要计算 模某个大素数 $p$ 的组合数，可以使用 Lucas 定理。

当 $C(n,k)$ 需要 模一个素数 $p$，可以拆分计算：
$$C(n,k)\mathrm{mod}p=C(n/p,k/p)\times C(n\%p,k\%p)\mathrm{mod}p$$
代码实现：

#include <iostream>
using namespace std;

const int P = 1e9 + 7;

// 快速幂计算 (x^y) % p
long long qpow(long long x, long long y, long long p) {
    long long res = 1;
    while (y) {
        if (y & 1) res = res * x % p;
        x = x * x % p;
        y >>= 1;
    }
    return res;
}

// 计算 n! % p 以及逆元
long long fact[100005], invFact[100005];

void init(int p) {
    fact[0] = 1;
    for (int i = 1; i < p; i++) {
        fact[i] = fact[i - 1] * i % p;
    }
    invFact[p - 1] = qpow(fact[p - 1], p - 2, p);
    for (int i = p - 2; i >= 0; i--) {
        invFact[i] = invFact[i + 1] * (i + 1) % p;
    }
}

long long comb(int n, int k, int p) {
    if (k > n) return 0;
    return fact[n] * invFact[k] % p * invFact[n - k] % p;
}

// Lucas 定理
long long lucas(long long n, long long k, int p) {
    if (k == 0) return 1;
    return lucas(n / p, k / p, p) * comb(n % p, k % p, p) % p;
}

int main() {
    init(P);
    long long n = 1000000, k = 500000;
    cout << "C(" << n << ", " << k << ") % " << P << " = " << lucas(n, k, P) << endl;
    return 0;
}

适用场景：
✅ $n,k$ 很大（如 $10^{18}$) 但需要模一个素数 $p$（如 $10^9+7$）
✅ 递归分解，使得计算时间大幅减少