在算法竞赛中，模运算（取模运算）是一个非常重要的概念，尤其在处理大数、防止溢出、以及解决与周期性相关的问题时。C++ 中的模运算使用 % 运算符，但它的行为和使用场景需要特别注意。

1. 模运算的基本概念

模运算是指求一个数除以另一个数的余数。在 C++ 中，模运算使用 % 运算符。例如：

int a = 17;
int b = 5;
int result = a % b; // result = 2，因为 17 除以 5 的余数是 2

2. 模运算的性质

模运算有一些重要的性质，这些性质在算法竞赛中经常被用到：

• 结合律:

  

• 分配律:

  

• 幂运算的模:

  

3. 模运算的应用场景

3.1 防止整数溢出

        在算法竞赛中，经常会遇到大数运算，直接计算可能会导致整数溢出。使用模运算可以有效地防止溢出。

例如，计算 (a×b)%m时，可以先对 a和 b分别取模，然后再相乘取模：

long long a = 123456789;
long long b = 987654321;
long long m = 1000000007;
long long result = (a % m) * (b % m) % m;

3.2 周期性问题的处理

        模运算常用于处理周期性或循环性质的问题。例如，计算某个数在模 m 下的性质，或者判断两个数在模 m 下是否相等。（同余定理）

3.3 快速幂算法

        快速幂算法（Exponentiation by Squaring）是一种高效计算大数幂模的方法。通过递归或迭代的方式，可以将时间复杂度从 O(n) 降低到 O(log⁡n)。

long long fast_pow(long long base, long long exp, long long mod) {
    long long result = 1;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp /= 2;
    }
    return result;
}

3.4 组合数学中的模运算

        在组合数学中，模运算常用于计算组合数、排列数等。由于组合数可能非常大，通常会使用模运算来限制结果的大小。

例如，计算组合数 C(n,k)%m时，可以使用递推公式或预处理阶乘和逆阶乘的方法。

4. 负数的模运算

在 C++ 中，计算规则是：先按正整数求余，然后加上符号，模运算的结果符号与被除数相同。例如：

int a = -17;
int b = 5;
int result = a % b; // result = -2，因为 -17 除以 5 的余数是 -2

如果需要得到非负的余数，可以手动调整：（非常重要）

int mod(int a, int m) {
    return (a % m + m) % m;
}

5. 模运算的常见错误

• 除数为零：模运算的除数不能为零，否则会导致运行时错误。

• 负数模运算：需要注意负数的模运算结果可能不符合预期，需要手动调整。

• 溢出问题：即使使用了模运算，仍然需要注意中间结果的溢出问题。

6.取模操作满足以下性质

（1）加：（a+b）%m=((a%m)+(b&m))%m。如果没有限制a、b的正负，在C代码中的左右可能符号相反、大小相差m。

（2）减：（a-b）%m=((a%m)-(b&m))%m。在C代码中左右可能符号相反、大小相差m。

（3）乘：（a*b）%m=((a%m)*(b&m))%m。

（4）然而，对除法取模进行类似操作是错误的：（a/b）%m=((a%m)/(b&m))%m。

例如，（100/50）%20=2，（100%20）/（50%20）%20=0，两者不相等。

1. 加法取模：(a+b)%m=((a%m)+(b%m))%m

问题描述

如果没有限制 aa 和 bb 的正负，在 C++ 中，左右两边的结果可能符号相反、大小相差 mm。

原因分析

在 C++ 中，模运算 % 的结果符号与被除数相同。例如：

• 7%5=2

• −7%5=−2

        因此，如果 a 或 b 是负数，a%m 或 b%m 的结果可能是负数。当两个负数相加时，结果可能超出模数 m 的范围，导致最终结果符号相反或大小相差 m。

解决方法

为了保证结果非负，可以在最终结果上加上 m 再取模：

int mod_add(int a, int b, int m) {
    return ((a % m) + (b % m) + m) % m;
}

---

2. 减法取模：(a−b)%m=((a%m)−(b%m))%m

问题描述

在 C++ 中，左右两边的结果可能符号相反、大小相差 m。

原因分析

        与加法类似，如果 a%m或 b%m 是负数，减法结果可能超出模数 m 的范围，导致最终结果符号相反或大小相差 m。

解决方法

为了保证结果非负，可以在最终结果上加上 m 再取模：

int mod_sub(int a, int b, int m) {
    return ((a % m) - (b % m) + m) % m;
}

---

3. 乘法取模：(a×b)%m=((a%m)×(b%m))%m

问题描述

乘法取模的性质在 C++ 中成立，但需要注意中间结果可能溢出。

原因分析

乘法取模的性质是基于模运算的结合律和分配律的，因此在 C++ 中成立。但如果 a 和 b 较大，直接计算 (a%m)×(b%m)可能会导致溢出。

解决方法

使用更大的数据类型（如 long long）来存储中间结果，或者分步计算：

int mod_mul(int a, int b, int m) {
    return ((long long)(a % m) * (b % m)) % m;
}

---

4. 除法取模：(a/b)%m≠((a%m)/(b%m))%m

问题描述

除法取模的性质在 C++ 中不成立。

原因分析

除法取模的性质不成立的原因是：

• 除法运算 a/b 的结果与模运算 a%m 和 b%m 没有直接关系。

• 模运算会丢失部分信息，导致除法结果无法正确反映。

解决方法

        在模运算中，除法需要通过乘法逆元来实现。如果 mm 是质数，可以使用费马小定理计算逆元：(a/b)%m=(a×b−1)%m

其中 b−1 是 b 的模 m 逆元。

代码实现：

// 快速幂算法计算逆元
long long inv(long long b, long long m) {
    return fast_pow(b, m - 2, m);
}

// 除法取模
int mod_div(int a, int b, int m) {
    return ((long long)(a % m) * inv(b, m)) % m;
}

7. 模运算的优化技巧

• 预处理：在需要多次进行模运算的情况下，可以预处理一些中间结果，减少重复计算。

• 位运算：在某些情况下，可以使用位运算来加速模运算，尤其是在模数为 2 的幂时。

8. 示例代码

以下是一个使用模运算的示例代码，计算斐波那契数列的第 n项模 m：

#include <iostream>
using namespace std;

const int MOD = 1000000007;

int fibonacci(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;

    int a = 0, b = 1, c;
    for (int i = 2; i <= n; ++i) {
        c = (a + b) % MOD;
        a = b;
        b = c;
    }
    return b;
}

int main() {
    int n;
    cin >> n;
    cout << fibonacci(n) << endl;
    return 0;
}