公众号的运营地区厦门seo报价

约定$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个数中选0个 只有一种情况

---

图示：

  11 11 2 11 3 3 11 4 6 4 11 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$）
✅ 递归分解，使得计算时间大幅减少