《算法笔记》第5章数学问题

数学问题

1. 数字与数组相互转化

const int n = 8; //位数
void to_arr(int num, int arr[]) { //从高位到底位，如12345转换为00012345
    for (int i = n - 1; i >= 0; i--) {
        arr[i] = num % 10;
        num /= 10;
    }
}

int to_num(int arr[]) { //从低位到高位，如00012345转换为12345
    int num = 0;
    for (int i = 0; i < n; i++) {
        num = num * 10 + arr[i];
    }
    return num;
}

---

2. 进制转换

2.1 P进制转换为十进制

#include <cstdio>

int to_ten(int x, int P) { //把P进制的x转换为十进制的y
    int y = 0, temp = 1;
    while (x != 0) {
        y += (x % 10) * temp;
        x /= 10;
        temp *= P;
    }
    return y;
}

int main() {
    printf("%d", to_ten(110, 9));
    return 0;
}

2.2 十进制转换为Q进制

除基取余法（以11转换为2进制为例）：

11除以2，得商为5，余数为1；

5除以2，得商为2，余数为1；

2除以2，得商为1，余数为0；

1除以2，得商为0，余数为1，算法终止。

将余数从后往前输出，得1011即为11的二进制数。

#include <cstdio>

int z[40], num = 0; //数组z存放Q进制数y的每一位，num为位数

void to_Q(int y, int Q) { //把十进制的y转换为Q进制的z
    do {
        z[num++] = y % Q; //除基取余
        y /= Q;
    } while (y != 0);
}

int main() {
    to_Q(93, 9);
    for (int i = num - 1; i >= 0; i--) { //逆序输出
        printf("%d", z[i]);
    }
    return 0;
}

2.3 大数进制转换（10进制以内）

2.4 大数进制转换（超过10进制）

---

3. 最大公约数与最小公倍数

最大公约数根据公式$gcd(a,b)=gcd(b,a\%b)$计算如下：

int gcd(int a, int b) {
    if (b == 0)
        return a;
    else
        return gcd(b, a % b);
}
//或者
int gcd(int a, int b) {
    return !b ? a : gcd(b, a % b);
}

假设最大公约数为d，则a和b的最小公倍数的为ab/d，考虑溢出可以写成a/d*b。

---

4. 分数的四则运算

4.1 分数的表示

分子分母尽量使用long long型来存储。使用假分数的形式来表示，且制定以下三个规则：

• 使分母down为非负数。如果分数为负，那么令分子up为负即可。
• 如果该分数恰为0，那么规定其分子up为0，分母为1。
• 分子和分母没有除了1以外的公约数。

typedef long long LL;

struct Fraction { //分数
    LL up, down; //分子、分母
};

4.2 分数的化简

typedef long long LL;

LL gcd(LL a, LL b) {
    if (b == 0)
        return a;
    else
        return gcd(b, a % b);
}

struct Fraction { //分数
    LL up, down; //分子、分母
};

Fraction reduction(Fraction ans) {
    if (ans.down < 0) { //分母为负数，令分子和分母都变为相反数
        ans.up = -ans.up;
        ans.down = -ans.down;
    }
    if (ans.up == 0) { //如果分子为0
        ans.down = 1; //令分母为1
    } else {
        //分子、分母的最大公约数
        LL d = gcd(abs(ans.up), abs(ans.down));
        ans.up /= d;
        ans.down /= d;
    }
    return ans;
}

4.3 分数的运算

//加
Fraction add(Fraction f1, Fraction f2) {
    Fraction ans;
    ans.up = f1.up * f2.down + f2.up * f1.down;
    ans.down = f1.down * f2.down;
    return reduction(ans);
}
//减
Fraction sub(Fraction f1, Fraction f2) {
    Fraction ans;
    ans.up = f1.up * f2.down - f2.up * f1.down;
    ans.down = f1.down * f2.down;
    return reduction(ans);
}
//乘
Fraction multi(Fraction f1, Fraction f2) {
    Fraction ans;
    ans.up = f1.up * f2.up;
    ans.down = f1.down * f2.down;
    return reduction(ans);
}
//除，当且仅当f2.up不为零时才能用下面的函数进行计算
Fraction div(Fraction f1, Fraction f2) {
    Fraction ans;
    ans.up = f1.up * f2.down;
    ans.down = f1.down * f2.up;
    return reduction(ans);
}

4.4 分数的输出

void showResult(Fraction r) {
    r = reduction(r);
    if (r.down == 1) //为整数
        printf("%lld", r.up);
    else if (abs(r.up) > r.down) { //假分数
        printf("%lld %lld/%lld", r.up / r.down, abs(r.up) % r.down, r.down);
    } else { //真分数
        printf("%lld/%lld", r.up, r.down);
    }
}

---

5. 素数

5.1 素数的判断

bool isPrime(int n) {
    if (n <= 1) return false;
    int sqr = (int)sqrt(1.0 * n);
    //如果n没有接近int型变量的范围上界，可以写i*i<=n
    for (int i = 2; i <= sqr; i++) { //遍历2~根号n
        if (n % i == 0) return false;
    }
    return true;
}

5.2 素数表的获取

const int maxn = 100010; //表长
// prime数组存放所有素数，pNum为素数个数
int prime[maxn], pNum = 0; 
bool p[maxn] = {false}; // p[i]=true表示i是素数

void findPrime() { //求素数表
    for (int i = 1; i < maxn; i++) {
        if (isPrime(i) == true) {
            prime[pNum++] = i;
            p[i] = true;
        }
    }
}

5.3 埃式筛法

const int maxn = 100010; //表长
int prime[maxn], pNum = 0; // prime数组存放所有素数，pNum为素数个数
bool p[maxn] = {false}; // 如果i为素数，则p[i]为false，否则p[i]为true

void findPrime() { //埃式筛法求素数表
    for (int i = 2; i < maxn; i++) {
        if (p[i] == false) { //如果i是素数
            prime[pNum++] = i;
            //从2*i开始
            for (int j = 2 * i; j < maxn; j += i) {
                //筛去所有i的倍数
                p[j] = true;
            }
        }
    }
}

---

6. 质因子分解

定义结构体factor来存储质因子

struct factor {
    int x, cnt; // x为质因子，cnt为其个数
} fac[10];

先打印出素数表，再进行质因子分解，只用进行到n的根号即可。

int num = 97532468, n = 0; // num为数字，n为不同质因子个数
int sqr = (int)sqrt(1.0 * num); // n的根号
//枚举根号n以内的质因子
for (int i = 0; i < pNum && prime[i] <= sqr; i++) {
    if (num % prime[i] == 0) { //如果prime[i]是n的质因子
        fac[n].x = prime[i]; //记录该质因子
        fac[n].cnt = 0;
        //计算质因子prime[i]的个数
        while (num % prime[i] == 0) {
            fac[n].cnt++;
            num /= prime[i];
        }
        n++; //不同质因子个数加1
    }
    if (num == 1) break;
}
if (num != 1) { //如果n不为1，说明n有且仅有一个大于sqrt(n)的质因子
    fac[n].x = num;
    fac[n++].cnt = 1;
}
for (int i = 0; i < n; i++) {
    printf("%d %d\n", fac[i].x, fac[i].cnt);
}

---

7. 大整数的运算

7.1 大整数的存储

使用构造函数自动初始化结构体。

struct bign {
    int d[1010];
    int len;
    bign() {
        memset(d, 0, sizeof(d));
        len = 0;
    }
};

7.2 大整数的转换

在读入大整数时，先用字符串读入，然后再把字符串转换为bign结构体，注意要让字符串逆序赋值。

bign change(char str[]) { //将整数转换为bign
    bign a;
    a.len = strlen(str); // bign的长度就是字符串的长度
    for (int i = 0; i < a.len; i++) {
        a.d[i] = str[a.len - i - 1] - '0'; //逆序赋值
    }
    return a;
}

7.3 大整数的比较

//比较a和b的大小，a大、相等、a小分别返回1、0、-1
int compare(bign a, bign b) {
    if (a.len > b.len) // a大
        return 1;
    else if (a.len < b.len) // a小
        return -1;
    else {
        for (int i = a.len - 1; i >= 0; i--) { //从高位往地位比较
            if (a.d[i] > b.d[i]) //只要有一位a更大，则a大
                return 1;
            else if (a.d[i] < b.d[i]) //只要有一位a更小，则a小
                return -1;
        }
        return 0; //两数相等
    }
}

7.4 大数的排序

7.5 大整数的四则运算

高精度加法

//下面的代码要求a和b都大于0，如果有一方是小于0的，则考虑高精度减法
//如果两方均为负，则去掉负号后用高精度加法，最后再把负号加回去即可
bign add(bign a, bign b) { //高精度a+b
    bign c;
    int carry = 0; // 进位
    //两个数相加，以较长的为界限
    for (int i = 0; i < a.len || i < b.len; i++) {
        int temp = a.d[i] + b.d[i] + carry; //两个对应位相加
        c.d[c.len++] = temp % 10; //个位数为该位结果
        carry = temp / 10; //十位数位新的进位
    }
    if (carry != 0) { //如果最后进位不为0，则直接赋给结果的最高位
        c.d[c.len++] = carry;
    }
    return c;
}

高精度减法

//下面的代码要求a大于b，如果a小于b，则交换a和b，输出负号再使用sub函数
bign sub(bign a, bign b) { //高精度a-b
    bign c;
    for (int i = 0; i < a.len || i < b.len; i++) {
        if (a.d[i] < b.d[i]) { //如果不够减
            a.d[i + 1]--; //向高位借1
            a.d[i] += 10; //当前位加10
        }
        c.d[c.len++] = a.d[i] - b.d[i]; //减法结果为当前位结果
    }
    while (c.len - 1 >= 1 && c.d[c.len - 1] == 0) {
        c.len--; //去除最高位的0，同时至少保留一位最低位
    }
    return c;
}

高精度乘法

//下面的代码要求a和b同号，如果a与b异号则需要先记录负号，去掉负号后再代入函数
bign multi(bign a, int b) { //高精度a乘低精度b
    bign c;
    int carry = 0; //进位
    for (int i = 0; i < a.len; i++) {
        int temp = a.d[i] * b + carry;
        c.d[c.len++] = temp % 10; //个位作为该位结果
        carry = temp / 10; //高位部分作为新的进位
    }
    while (carry != 0) { //和加法不同，乘法的进位可能不止一位
        c.d[c.len++] = carry % 10;
        carry /= 10;
    }
    return c;
}

高精度除法

//下面的代码要求a和b都大于0，如果a和b存在负数，则根据题目条件更改
bign div(bign a, int b, int &r) { //高精度a除以b，r为余数
    bign c;
    //被除数的每一位和商的每一位是一一对应的，因此先令长度相等
    c.len = a.len;
    for (int i = a.len - 1; i >= 0; i--) {
        r = r * 10 + a.d[i]; //和上一位遗留的余数组合
        if (r < b) { //不够除
            c.d[i] = 0;
        } else { //够除
            c.d[i] = r / b;
            r = r % b;
        }
    }
    while (c.len - 1 >= 1 && c.d[c.len - 1] == 0) {
        c.len--; //去除最高位的0，同时至少保留一位最低位
    }
    return c;
}

a+b

浮点数加法

---

8. 扩展欧几里得算法

8.1 $ax+by=gcd(a,b)$的求解

给定两个非零整数$a$和$b$，求一组整数解$(x,y)$，使得$ax+by=gcd(a,b)$成立，其中$gcd(a,b)$表示$a$和$b$的最大公约数。

当计算$gcd(a,b)$时，有$a{x}_1+b{y}_1=gcd$；而在下一步计算$gcd(b,a\%b)$时，又有$b{x}_2+(a\%b)y_2=gcd$成立（两个$gcd$相同）。因此$a{x}_1+b{y}_1=b{x}_2+(a\%b)y_2$成立。有考虑到$a\%b=a-(a/b)\ast b$成立（此处除法为整除），故有$a{x}_1+b{y}_1=a{y}_2+b(x_2-(a/b)y_2)$。故可以得到以下递推公式：
$$\{\begin{array}{rl}{x}_1& =y_2\\ y_1& =x_2+(a/b)y\end{array}$$

int exGcd(int a, int b, int &x, int &y) { //x和y的引用
    if (b == 0) { //b为0时，a为gcd，则a*1+b*0=gcd
        x = 1;
        y = 0;
        return a;
    }
    int g = exGcd(b, a % b, x, y); //递归计算exGcd(b,a%b)
    int temp = x; //存放x的值
    x = y; //更新x=y(old)
    y = temp - a / b * y;
    return g; //g是gcd
}

通过上述算法后可以得到其中一组解，再通过以下等式即可得到全部解：
$$\{\begin{array}{rl}{x}^{\prime }& =x+\frac{b}{gcd}\ast K\\ y^{\prime }& =y-\frac{a}{gcd}\ast K\end{array}$$
其中$K$为任意整数。

对任意整数来说，$(x\%\frac{b}{gcd}+\frac{b}{gcd})\%\frac{b}{gcd}$是最小非负整数解。

特别地，如果$gcd==1$，即$ax+by=1$时，全部解的公式化简如下：
$$\{\begin{array}{rl}{x}^{\prime }& =x+b\ast K\\ y^{\prime }& =y-a\ast K\end{array}$$
其中$K$为任意常数，且$x$的最小非负整数解也可以化简为
$$(x\%b+b)\%b$$

8.2 $ax+by=c$的求解

$ax+by=c$存在解的充要条件是$c\%gcd==0$，且一组解$(x,y)=(\frac{c{x}_0}{gcd},\frac{c{y}_0}{gcd})$。

其全部解为：
$$\{\begin{array}{rl}{x}^{\prime }& =x+\frac{b}{gcd}\ast K=\frac{c{x}_0}{gcd}+\frac{b}{gcd}\ast K\\ y^{\prime }& =y-\frac{a}{gcd}\ast K=\frac{c{y}_0}{gcd}-\frac{a}{gcd}\ast K\end{array}$$
其中$K$为任意常数。

8.3 同余式$ax\equiv c(modm)$的求解

同余式定义

对于整数$a$、$b$、$m$来说，如果$m$整除$a-b$，即$(a-b)\%m=0$，则称$a$与$b$模$m$同余，对应的同余式为$a\equiv b(modm)$，$m$称为同余式的模。例如10与13模3同余，10也与1模3同余，它们分别记为$10\equiv 13(mod3)$、$10\equiv 1(mod3)$。显然，每一个整数都各自与$[0,m)$中唯一的整数同余。

求解过程

解同余式$ax\equiv c(modm)$，即$(ax-c)\%m=0$成立，故存在整数$y$，使得$ax-c=my$成立。移项并令$y=-y$后即得$ax+my=c$。

由上述结论可知，当$c\%gcd(a,m)==0$时方程才有解，且解的形式如下，其中$(x,y)$是$ax+my=c$的其中一组解，可以先通过求解$ax+my=gcd(a,m)$得到$x_0,y_0$，然后由公式$(x,y)=(\frac{c{x}_0}{gcd},\frac{c{y}_0}{gcd})$直接得到。
$$\{\begin{array}{rl}{x}^{\prime }& =x+\frac{b}{gcd}\ast K\\ y^{\prime }& =y-\frac{a}{gcd}\ast K\end{array}$$
其中$K$为任意常数。

考虑$x^{\prime }=x+\frac{m}{gcd}\ast K$，会发现当K分别去0、1、2、…、$gcd(a,m)-1$时，所得到的解在模$m$意义下是不同的，而其他解都可以对应到$K$取这$gcd(a,m)$个数值之一。由此可以得到结论：

设$a,c,m$是整数，其中$m\ge 1$，则

1. 若$c\%gcd(a,m)\ne 0$，则同余式方程$ax\equiv c(modm)$无解。
2. 若$c\%gcd(a,m)=0$，则同余式方程$ax\equiv c(modm)$恰好有$gcd(a,m)$个模$m$意义下不同的解，且解的形式为

$$x^{\prime }=x+\frac{m}{gcd}\ast K$$

其中$K=0,1,\dots ,gcd(a,m)-1$，$x$是$ax+by=c$的一个解。

同余式$ax\equiv 1(modm)$

求解同余式$ax\equiv 1(modm)$的最小正整数解等同于求$a$模$m$的逆元。

8.4 逆元的求解以及$(b/a)\%m$的计算

逆元的定义

设$a、b、m$是整数，$m$＞1，且有$ab\equiv 1(modm)$成立，那么就说$a$和$b$互为模$m$的逆元，一般也记作$a\equiv \frac{1}{b}(modm)$或$b\equiv \frac{1}{a}(modm)$。更通俗地说，如果两个整数的乘积模$m$后等于1，就称它们互为$m$的逆元。

逆元的用处

对于乘法来说有$(b\ast a)\%m=((b\%m)\ast (a\%m))\%m$成立，而对于除法则没有。所以要计算$(b/a)\%m$就需要用到逆元的方法。通过找到$a$模$m$的逆元$x$，就有$(b/a)\%m=(b\ast x)\%m$成立（只考虑$b$是$a$的整数倍的情况）。于是就把除法取模转换为乘法取模。

由定义知，求$a$模$m$的逆元，就是求解同余式$ax\equiv 1(modm)$，并且在实际使用过程中，一般把$x$的最小正整数解称为$a$模$m$的逆元。显然，同余式$ax\equiv 1(modm)$是否有解取决于$1\%gcd(a,m)$是否为0，而这等价于$gcd(a,m)$是否为1：

1. 若$gcd(a,m)\ne 1$，则同余式方程$ax\equiv 1(modm)$无解。
2. 若$gcd(a,m)=1$，则同余式方程$ax\equiv 1(modm)$在$(0,m)$上有唯一解，可以通过求解$ax+my=1=gcd(a,m)$得到。由上述可知，所求的逆元为$(x\%m+m)\%m$。

逆元的求解

使用扩展欧几里得算法求解，使用条件是$gcd(a,m)=1$。

int inverse(int a, int m) {
    int x, y;
    int g = exGcd(a, m, x, y); //求解ax+my=1;
    return (x % m + m) % m; // a模m的逆元为(x%m+m)%m
}

若$m$是素数，且$a$不是$m$的倍数，则可以使用费马小定理求解逆元。

费马小定理

设$m$是素数，$a$是任意整数且$a\not\equiv 0(modm)$，则$a^{m-1}\equiv 1(modm)$。

由$a^{m-1}\equiv 1(modm)$知$a\ast a^{m-2}\equiv 1(modm)$，由逆元定义知$a^{m-2}\%m$就是$a$模$m$的逆元，通过快速幂来求解。

快速幂

#include <cstdio>
#include <cmath>

int exGcd(int a, int b, int &x, int &y) { //x和y的引用
    if (b == 0) { //b为0时，a为gcd，则a*1+b*0=gcd
        x = 1;
        y = 0;
        return a;
    }
    int g = exGcd(b, a % b, x, y); //递归计算exGcd(b,a%b)
    int temp = x; //存放x的值
    x = y; //更新x=y(old)
    y = temp - a / b * y;
    return g; //g是gcd
}

int inverse(int a, int m) {
    int x, y;
    int g = exGcd(a, m, x, y); //求解ax+my=1;
    return (x % m + m) % m; // a模m的逆元为(x%m+m)%m
}

typedef long long LL;
//求a^b%m，递归写法
//若初始时a大于m，则在进入函数前先让a对m取模
LL binaryPow(LL a, LL b, LL m) {
    if (b == 0) return 1;
    // b为奇数，转换为b-1
    if (b % 2 == 1) { //可用if (b & 1)替代
        return a * binaryPow(a, b - 1, m) % m;
    } else { // b为偶数，转换为b/2
        LL mul = binaryPow(a, b / 2, m);
        return mul * mul % m;
    }
}

bool isPrime(int n) {
    if (n <= 1) return false;
    int sqr = (int)sqrt(1.0 * n);
    //如果n没有接近int型变量的范围上界，可以写i*i<=n
    for (int i = 2; i <= sqr; i++) { //遍历2~根号n
        if (n % i == 0) return false;
    }
    return true;
}

int main() {
    int a, m, b;
    scanf("%d %d", &a, &m);
    if (isPrime(m) && a % m != 0) { //使用费马小定理
        a %= m;
        b = (int)binaryPow((LL)a, (LL)(m - 2), (LL)m);
    } else { //使用逆元
        b = inverse(a, m);
    }
    printf("逆元b=%d", b);
    return 0;
}

$gcd(a,m)\ne 1$时求$(b/a)\%m$

此时两种方法均失效。假设$(b/a)\%m=x$，因此存在整数$k$，使得$b/a=km+x$。等式两边同时乘以$a$，得$b=kam+ax$。等式两边同时除以$a$，得$(b\%(am))/a=x$，于是有$(b/a)\%m=(b\%(am))/a$成立。

因此$a$和$m$有可能不互素的情况下，可以使用公式$(b/a)\%m=(b\%(am))/a$来计算

$(b/a)\%m$，唯一注意的是$a$和$m$的乘积有可能会溢出。

---

9. 组合数

9.1 求$n!$中质因子p的个数

$n!$中有$(\frac{n}{p}+\frac{n}{p^2}+\frac{n}{p^3}+\dots )$个质因子$p$，其中除法均为向下取整，于是得到了O(logn)的算法：

//计算n!中有多少个质因子p
int cal(int n, int p) {
    int ans = 0;
    while (n) {
        ans += n / p;
        n /= p;
    }
    return ans;
}

$n!$中质因子$p$的个数，实际上等于1~$n$中$p$的倍数的个数$\frac{n}{p}$加上$\frac{n}{p}!$中质因子$p$的个数。所以代码递归版为：

//递归计算n!中有多少个质因子p
int cal(int n, int p) {
    if (n < p) return 0; // n<p时无质因子p
    //返回n/p加上(n/p!)中质因子p的个数
    return (n / p + cal(n / p, p));
}

求$n!$的末尾有多少个零等价于求$n!$中因子10的个数，而10=2×5，且质因子2的个数大于5，所以最终等价于求$n!$中质因子5的个数，即cal(n,5)。

9.2 组合数的计算

组合数$C_n^m=\frac{n!}{m!(n-m)!}$，由定义知$C_n^m=C_n^{n-m}$，且有$C_n^0=C_n^n=1$成立。

9.3 计算$C_n^m$

方法一：通过定义式

只能承受$n\le 20$的数据范围。

typedef long long LL;
LL C(LL n, LL m) {
    LL ans = 1;
    for (LL i = 1; i <= n; i++) { //计算n!
        ans *= i;
    }
    for (LL i = 1; i <= m; i++) { //除以m!
        ans /= i;
    }
    for (LL i = 1; i <= n-m; i++) { //除以(n-m)！
        ans /= i;
    }
    return ans;
}

方法二：通过递推式

利用$C_n^m=C_{n-1}^m+C_{n-1}^{m-1}$，注意到$C_n^0=C_n^n=1$。在$n=67、m=33$时开始溢出。

直接递归：

typedef long long LL;
LL C(LL n, LL m) {
    if (m == 0 || m == n) return 1; //递归边界
    return C(n - 1, m) + C(n - 1, m - 1);
}

直接递归会导致很多次重复计算，不妨记录已经计算过的C(n,m)：

typedef long long LL;
LL res[67][67] = {0};
LL C(LL n, LL m) {
    if (m == 0 || m == n) return 1;
    if (res[n][m] != 0) return res[n][m]; //已经算过
    //赋值给res[n][m]并返回
    return res[n][m] = C(n - 1, m) + C(n - 1, m - 1);
}

或者直接把整张表全部算出来（复杂度为$O(n^2)$）：

typedef long long LL;
const int n = 60;
LL res[n + 1][n + 1] = {0};
void calC() {
    for (int i = 0; i <= n; i++) {
        res[i][0] = res[i][i] = 1; //初始化边界
    }
    for (int i = 2; i <= n; i++) {
        for (int j = 0; j <= i / 2; j++) {
            //递推计算
            res[i][j] = res[i - 1][j] + res[i - 1][j - 1];
            res[i][i - j] = res[i][j]; // C(i,i-j)=C(i,j)
        }
    }
}

方法三：通过定义式的变形

由于有乘法，在$n=62、m=31$时开始溢出。

观察到:
$$\begin{array}{rl}{C}_n^m& =\frac{(n-m+1)\times (n-m+2)\times \dots \times (n-m+m)}{1\times 2\times \dots m}\\ & =\frac{\frac{\frac{\frac{(n-m+1)}{1}\times (n-m+2)}{2}\times \dots }{\dots }\times (n-m+m)}{m}\end{array}$$
故边乘边除，时间复杂度为$O(m)$：

typedef long long LL;
LL C(LL n, LL m) {
    LL ans = 1;
    for (LL i = 1; i <= m; i++) {
        ans = ans * (n - m + i) / i; //注意一定要乘再除(保证是整除)
    }
    return ans;
}

9.4 计算$C_n^m\%p$

方法一：通过递推式

假设两倍的$p$不会超过int型，适用于$m\le n\le 10000$且$p\le 10^9$。

递归：

int res[1010][1010] = {0};
int C(int n, int m, int p) {
    if (m == 0 || m == n) return 1; //递归边界
    if (res[n][m] != 0) return res[n][m]; //已经算过
    return res[n][m] = (C(n - 1, m) + C(n - 1, m - 1)) % p;
}

递推：

const int n = 1010;
int res[n][n] = {0};
void calC() {
    for (int i = 0; i <= n; i++) {
        res[i][0] = res[i][i] = 1; //初始化边界
    }
    for (int i = 2; i <= n; i++) {
        for (int j = 0; j <= i / 2; j++) {
            //递推计算
            res[i][j] = (res[i - 1][j] + res[i - 1][j - 1]) % p;
            res[i][i - j] = res[i][j]; // C(i,i-j)=C(i,j)
        }
    }
}

方法二：通过定义式

将组合数$C_n^m$进行质因子分解，假设分解结果为$C_n^m=p_1^{c_1}\times p_2^{c_2}\dots \times p_k^{c_k}$，那么$C_n^m\%p$就等于$p_1^{c_1}\times p_2^{c_2}\dots \times p_k^{c_k}\%p$，通过快速幂来计算每一组的$p_i^{c_i}\%p$，然后相乘取模就可以得到最终结果，时间复杂度为$O(klogn)$，其中$k$为不超过$n$的质数个数。适用于$m\le n\le 10^6$且$p\le 10^9$。

#include <cstdio>
#include <cmath>

const int maxn = 1000010; //表长
int prime[maxn], pNum = 0; // prime数组存放所有素数，pNum为素数个数
bool p[maxn] = {false}; // 如果i为素数，则p[i]为false，否则p[i]为true

//筛选得到素数表，表中最大素数不得小于n
void findPrime() {
    for (int i = 2; i < maxn; i++) {
        if (p[i] == false) { //如果i是素数
            prime[pNum++] = i;
            //从2*i开始
            for (int j = 2 * i; j < maxn; j += i) {
                //筛去所有i的倍数
                p[j] = true;
            }
        }
    }
}

//计算n!中有多少个质因子p
int cal(int n, int p) {
    int ans = 0;
    while (n) {
        ans += n / p;
        n /= p;
    }
    return ans;
}

//求a^b%m，递归写法
int binaryPow(int a, int b, int m) {
    if (b == 0) return 1;
    // b为奇数，转换为b-1
    if (b % 2 == 1) { //可用if (b & 1)替代
        return a * binaryPow(a, b - 1, m) % m;
    } else { // b为偶数，转换为b/2
        int mul = binaryPow(a, b / 2, m);
        return mul * mul % m;
    }
}

//计算C(n,m)%p
int C(int n, int m, int p) {
    int ans = 1;
    //遍历不超过n的所有质数
    for (int i = 0; prime[i] <= n; i++) {
        //计算C(n,m)中prime的指数c，cal(n,k)为n!中含质因子k的个数
        int c = cal(n, prime[i]) - cal(m, prime[i]) - cal(n - m, prime[i]);
        //快速幂计算prime[i]^c%p;
        ans = ans * binaryPow(prime[i], c, p) % p;
    }
    return ans;
}

int main() {
    findPrime();
    printf("%d", C(60, 34, 199999)); //69886166503903470%199999
    return 0;
}

方法三：通过定义式的变形

情况①：$m<p$，且$p$是素数。

基于计算$C_n^m$的方法三，但是不能在除法时直接模上$p$，因为每次的ans实际上是已经取过模的结果，不能再做除法。因此如果$p$是素数，可以使用扩展欧几里得算法或者费马小定理求出$i$模$p$的逆元，然后将除法取模转换为乘法取模。

需要注意的是必须满足$m<p$，否则逆元求取过程可能失效。显然时间复杂度为$O(mlogm)$，其中$O(logm)$是计算逆元的复杂度。适用于$m\le 10^6,n、p\le 10^9,m<p$，且$p$必须为素数。

#include <cstdio>

int exGcd(int a, int b, int &x, int &y) { // x和y的引用
    if (b == 0) { // b为0时，a为gcd，则a*1+b*0=gcd
        x = 1;
        y = 0;
        return a;
    }
    int g = exGcd(b, a % b, x, y); //递归计算exGcd(b,a%b)
    int temp = x; //存放x的值
    x = y; //更新x=y(old)
    y = temp - a / b * y;
    return g; // g是gcd
}

int inverse(int a, int m) {
    int x, y;
    int g = exGcd(a, m, x, y); //求解ax+my=1;
    return (x % m + m) % m; // a模m的逆元为(x%m+m)%m
}

typedef long long LL;
//计算C(n,m)%p且m小于p
LL C(int n, int m, int p) {
    LL ans = 1; //防止溢出用long long
    for (int i = 1; i <= m; i++) {
        ans = ans * (n - m + i) % p;
        ans = ans * inverse(i, p) % p; //求i模p的逆元
    }
    return ans;
}


int main() {
    printf("%lld", C(6000, 5000, 199999));
    return 0;
}

情况②：$m$任意，且$p$是素数。

由于$m$可能大于$p$，事实上由于$C_n^m=\frac{(n-m+1)\times (n-m+2)\times \dots \times (n-m+m)}{1\times 2\times \dots m}$，分子所含质因子$p$的个数必不少于分母所含质因子$p$的个数。故通过for循环过程中单独处理质因子$p$，对其他部分正常计算逆元。如果分子质因子$p$的个数大于分母，则直接返回0，否则返回计算结果。

显然时间复杂度为$O(mlogn)$，其中$O(logm)$是计算逆元的复杂度。适用于$m\le 10^6,n、p\le 10^9$，且$p$必须为素数。

#include <cstdio>

int exGcd(int a, int b, int &x, int &y) { // x和y的引用
    if (b == 0) { // b为0时，a为gcd，则a*1+b*0=gcd
        x = 1;
        y = 0;
        return a;
    }
    int g = exGcd(b, a % b, x, y); //递归计算exGcd(b,a%b)
    int temp = x; //存放x的值
    x = y; //更新x=y(old)
    y = temp - a / b * y;
    return g; // g是gcd
}

int inverse(int a, int m) {
    int x, y;
    int g = exGcd(a, m, x, y); //求解ax+my=1;
    return (x % m + m) % m; // a模m的逆元为(x%m+m)%m
}

typedef long long LL;
//计算C(n,m)%p
LL C(int n, int m, int p) {
    LL ans = 1; //防止溢出用long long
    int numP = 0; //统计质因子p的个数
    for (int i = 1; i <= m; i++) { //分子
        int temp = n - m + i;
        while (temp % p == 0) { //去除分子中的所有p，同时累计numP
            numP++;
            temp /= p;
        }
        ans = ans * temp % p; //乘以分子中除了p以外的部分
        temp = i;
        while (temp % p == 0) { //去除分母中的所有p，同时减少numP
            numP--;
            temp /= p;
        }
        ans = ans * inverse(temp, p) % p; //除以分母中除了p以外的部分
    }
    if (numP > 0) //分子中p的个数多余分母，直接返回0
        return 0;
    else
        return ans; //分子中p的个数等于分母，返回计算结果
}

int main() {
    printf("%lld", C(8000, 3000, 2953));
    return 0;
}

方法四：Lucas定理

如果$p$是素数，将$m$和$n$表示为$p$进制：
$$\begin{array}{rl}m& =m_k{p}^k+m_{k-1}{p}^{k-1}+\dots +m_0\\ n& =n_k{p}^k+n_{k-1}{p}^{k-1}+\dots +n_0\end{array}$$
那么Lucas（卢卡斯）定理告诉我们，$C_n^m\equiv C_{n_k}^{m_k}+C_{n_{k-1}}^{m_{k-1}}\dots +C_{n_0}^{m_0}(modp)$成立。

适用于$p\le 10^5，m\le n\le 10^{18}$，且$p$必须为素数。

#include <cstdio>

int p; //作为全局变量

int exGcd(int a, int b, int &x, int &y) { // x和y的引用
    if (b == 0) { // b为0时，a为gcd，则a*1+b*0=gcd
        x = 1;
        y = 0;
        return a;
    }
    int g = exGcd(b, a % b, x, y); //递归计算exGcd(b,a%b)
    int temp = x; //存放x的值
    x = y; //更新x=y(old)
    y = temp - a / b * y;
    return g; // g是gcd
}

int inverse(int a, int m) {
    int x, y;
    int g = exGcd(a, m, x, y); //求解ax+my=1;
    return (x % m + m) % m; // a模m的逆元为(x%m+m)%m
}

typedef long long LL;
//计算C(n,m)%p且m小于p
LL C(int n, int m) {
    LL ans = 1; //防止溢出用long long
    int numP = 0; //统计质因子p的个数
    for (int i = 1; i <= m; i++) { //分子
        int temp = n - m + i;
        while (temp % p == 0) { //去除分子中的所有p，同时累计numP
            numP++;
            temp /= p;
        }
        ans = ans * temp % p; //乘以分子中除了p以外的部分
        temp = i;
        while (temp % p == 0) { //去除分母中的所有p，同时减少numP
            numP--;
            temp /= p;
        }
        ans = ans * inverse(temp, p) % p; //除以分母中除了p以外的部分
    }
    if (numP > 0) //分子中p的个数多余分母，直接返回0
        return 0;
    else
        return ans; //分子中p的个数等于分母，返回计算结果
}


LL Lucas(LL n, LL m) {
    if (m == 0) return 1;
    return C(n % p, m % p) * Lucas(n / p, m / p) % p;
}

int main() {
    scanf("%d", &p); // 24281
    printf("%lld", Lucas(84560878, 4345));
    return 0;
}