线性求逆元算法原理与实现详解

1. 线性求逆元算法概述

在数论和密码学应用中，模逆元计算是一个基础而重要的操作。给定整数a和模数p，我们需要找到整数x使得a*x ≡ 1 mod p。当需要计算1到n所有数对模p的逆元时，采用逐个计算的方法时间复杂度为O(n log p)，而线性算法可以将复杂度降至O(n)，这在处理大规模数据时优势明显。

这个算法的核心思想是利用动态规划和递推关系，通过已知小数的逆元推导出大数的逆元。洛谷P3811题目正是这种场景的典型应用——要求计算1到n所有数对质数p的逆元。

2. 算法原理深度解析

2.1 数学推导过程

我们从模运算的基本性质出发，设p是质数，i是待求逆元的数：

1. 基础情况：inv[1] ≡ 1 mod p（任何数乘以1都是其本身）
2. 对于i > 1，设p = k*i + r（其中k = ⌊p/i⌋，r = p mod i）
3. 在模p下有：k*i + r ≡ 0 mod p
4. 两边乘以inv[i]inv[r]得：kinv[r] + inv[i] ≡ 0 mod p
5. 整理得到递推式：inv[i] ≡ -k*inv[r] mod p

这个推导的关键在于将大数i的逆元转化为更小数r=p%i的逆元，形成递推关系。由于r = p mod i < i，保证了递推的正确性。

2.2 算法正确性证明

我们需要证明递推公式inv[i] ≡ (p - p/i) * inv[p%i] % p的正确性：

1. 由p = (p/i)*i + (p%i)（整数除法性质）
2. 即p%i = p - (p/i)*i
3. 代入递推式：inv[i] ≡ - (p/i) * inv[p%i] mod p
4. 由于我们希望结果为正，用p - p/i代替 -p/i
5. 最终得到：inv[i] ≡ (p - p/i) * inv[p%i] % p

这个证明展示了如何从模运算的基本性质得到实用的递推公式，保证了算法在数学上的严谨性。

3. 算法实现与优化

3.1 基础代码实现

cpp复制const int N = 3e6 + 10;
int inv[N];

void linear_inverse(int n, int p) {
    inv[1] = 1;
    for(int i = 2; i <= n; ++i) {
        inv[i] = (long long)(p - p / i) * inv[p % i] % p;
    }
}

实现要点：

1. 使用long long防止中间结果溢出
2. 数组大小N应大于最大可能的n值
3. 初始条件inv[1] = 1必须设置

3.2 性能优化技巧

1. 循环展开：对于现代CPU，可以展开4-8次循环减少分支预测开销
2. 内存访问优化：确保inv数组在内存中连续存储
3. 并行计算：对于特别大的n，可以考虑分块并行计算
4. 编译器优化：使用-O2或-O3优化级别

注意：p必须是质数且大于n，否则算法不适用。对于非质数模数，需要采用其他方法。

4. 应用场景与实际问题

4.1 典型应用场景

1. 组合数计算：预处理阶乘和逆元阶乘用于快速计算C(n,k)
2. 多项式运算：在有限域中进行多项式除法需要逆元
3. 密码学算法：如RSA、ElGamal等公钥加密系统
4. 数论题目：如洛谷P3811这类竞赛题目

4.2 洛谷P3811题解

题目要求计算1到n所有数对质数p的逆元，直接应用我们的线性算法：

cpp复制#include <iostream>
using namespace std;

const int MAXN = 3e6 + 10;
int inv[MAXN];

int main() {
    int n, p;
    cin >> n >> p;
    
    inv[1] = 1;
    cout << inv[1] << "\n";
    
    for(int i = 2; i <= n; ++i) {
        inv[i] = (long long)(p - p / i) * inv[p % i] % p;
        cout << inv[i] << "\n";
    }
    
    return 0;
}

这个解法时间复杂度O(n)，空间复杂度O(n)，完全满足题目约束（n≤3×10^6）。

5. 边界情况与错误处理

5.1 常见错误情况

1. 模数非质数：当p不是质数时，某些数可能没有逆元
2. 数值溢出：没有使用long long导致中间结果溢出
3. 数组越界：n值超过预设数组大小
4. 错误初始条件：忘记设置inv[1] = 1

5.2 错误检测方法

1. 检查inv[i]*i % p == 1是否对所有i成立
2. 使用assert验证关键条件
3. 对小规模数据手工验证

cpp复制// 验证代码示例
bool verify(int n, int p) {
    for(int i = 1; i <= n; ++i) {
        if((long long)inv[i] * i % p != 1) {
            return false;
        }
    }
    return true;
}

6. 算法扩展与变种

6.1 同时求阶乘逆元

在组合数学应用中，我们常需要同时计算1!到n!的逆元。可以在线性逆元基础上进一步优化：

cpp复制void factorial_inverse(int n, int p) {
    vector<int> inv(n+1), fac(n+1), ifac(n+1);
    
    inv[1] = 1;
    for(int i = 2; i <= n; ++i) {
        inv[i] = (long long)(p - p / i) * inv[p % i] % p;
    }
    
    fac[0] = ifac[0] = 1;
    for(int i = 1; i <= n; ++i) {
        fac[i] = (long long)fac[i-1] * i % p;
        ifac[i] = (long long)ifac[i-1] * inv[i] % p;
    }
}

6.2 非质数模数情况

当模数p不是质数时，可以采用扩展欧几里得算法逐个计算逆元：

cpp复制int exgcd(int a, int b, int &x, int &y) {
    if(b == 0) {
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}

int mod_inverse(int a, int p) {
    int x, y;
    int d = exgcd(a, p, x, y);
    return d == 1 ? (x % p + p) % p : -1;
}

7. 性能对比与测试

7.1 不同算法时间对比

测试环境：Intel i7-9700K, p=1e9+7

7.2 内存使用分析

线性算法需要O(n)空间存储逆元数组，对于n=3e6：

• int类型：3e6*4B ≈ 12MB
• long long类型：约24MB

这在现代计算机上完全可接受，但需要注意栈空间限制，建议使用全局数组或动态分配。

8. 实际应用中的技巧

1. 模板化实现：将算法封装为模板类便于重用
2. 编译期计算：对于固定的小p，可以使用C++17的constexpr计算
3. 多模数处理：同时处理多个不同模数的逆元计算
4. 延迟计算：按需计算而非预处理所有逆元

cpp复制// 模板化实现示例
template<int P>
struct ModInt {
    int x;
    ModInt(int x = 0) : x(x % P) {}
    ModInt inv() const {
        return x <= 1 ? x : ModInt(P - P / x) * ModInt(P % x).inv();
    }
    // 其他运算符重载...
};

这个模板类提供了类型安全的模运算，包括逆元计算。虽然递归实现不如迭代高效，但展示了面向对象的设计方法。