求组合数 C++

递推法求组合数是一种动态规划的方法。它通过将问题分解成较小规模的子问题，并利用已经求解过的子问题的结果进行递推求解。

快速幂求组合数是利用快速幂算法来求解幂的问题，而组合数可以表示为一个幂的形式。

卢卡斯定理是用来求解组合数模质数的问题。它通过将组合数中的分子和分母都分解成质因数的幂次，然后利用模运算的性质进行计算。

- 卢卡斯定理的优点是可以高效地求解组合数模质数的问题，但它不能求解非素数的组合数。
- 递推法求组合数的优点是可以求解任意数量的组合数，但是它的时间复杂度较高，当问题规模较大时可能会超时。
- 快速幂求组合数的优点是可以高效地求解组合数的幂，但它需要预处理组合数的模数，且只能求解幂是整数的组合数。

递推法求组合数:

(n<=2000)

#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define KUI ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
const int con = 2e3;
const int mod = 993448335;
int n;
int c[con][con];
int main()
{
    KUI;
    cin >> n;

    for (int i = 0; i <= n; i++)
    {
        for (int j = 0; j <= i; j++)
        {
            if (j == 0)
            {
                c[i][j] = 1;
            }
            else
            {
                c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
            }
        }
    }
    for (int i = 0; i <= n; i++)
    {
        for (int j = 0; j <= i; j++)
        {
            cout << c[i][j] << " \n"[i == j];
        }
    }
    return 0;
}

快速幂求组合数:

(n<=100000)

#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define KUI ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
const int con = 1e5 + 5;
const int mod = 1e9 + 7;
int n, m;
int ny[con], jc[con];
ll ksm(ll a, ll b, ll p) // 开long long;
{
    ll int res = 1;
    while (b)
    {
        if (b % 2 == 1)
            res = res * a % p;
        a = a * a % p;
        b /= 2;
    }
    return res;
}
int main()
{
    KUI;
    cin >> n >> m;
    ny[1] = 1;
    jc[1] = 1;
    for (int i = 2; i <= 1e5; i++)
    {
        jc[i] = (ll)jc[i - 1] * i % mod;
        ny[i] = (ll)ny[i - 1] * ksm(i, mod - 2, mod) % mod;
        // 这里的ny[i]指的是i!(阶乘i)的逆元;
    }
    cout << (ll)jc[n] * ny[m] % mod * ny[n - m] % mod << endl;
    // 这里输出一定要long long才可以;
    return 0;
}

卢卡斯定理求组合数:

#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define KUI ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
const int con = 1e5 + 5;
// const int mod = 1e9 + 7;
int n, m, mod;
int ny[con], jc[con];
ll ksm(ll a, ll b, ll p) // 开long long;
{
    ll int res = 1;
    while (b)
    {
        if (b % 2 == 1)
            res = res * a % p;
        a = a * a % p;
        b /= 2;
    }
    return res;
}
void inital()
{
    ny[0] = 1;
    ny[1] = 1;
    jc[0] = 1;
    jc[1] = 1;
    for (int i = 2; i <= 1e5; i++)
    {
        jc[i] = (ll)jc[i - 1] * i % mod;
        ny[i] = (ll)ny[i - 1] * ksm(i, mod - 2, mod) % mod;
        // 这里的ny[i]指的是i!(阶乘i)的逆元;
    }
}
ll zuheshu(int a, int b)
{
    return (ll)jc[a] * ny[b] % mod * ny[a - b] % mod;
}
ll Lucas(ll a, ll b)
{
    if (b == 0) // 如果b==0,那么就是取0的组合数,返回1;
    {
        return 1;
    }
    return (ll)Lucas(a / mod, b / mod) * zuheshu(a % mod, b % mod) % mod;
}
int main()
{
    KUI;
    int t1;
    cin >> t1;
    while (t1--)
    {
        cin >> n >> m >> mod;
        inital(); // 初始化;
        cout << Lucas(n + m, m) << endl;
    }
    return 0;
}