O(N)求1~N逆元

最新推荐文章于 2025-01-16 00:57:46 发布

CoderFly

最新推荐文章于 2025-01-16 00:57:46 发布

阅读量430

点赞数

分类专栏：算法-一文章标签：逆元

本文链接：https://blog.youkuaiyun.com/CoderFly/article/details/59109504

版权

算法-一专栏收录该内容

8 篇文章

订阅专栏

ll inv[N];
void init(){
    inv[1] = inv[0] = 1;
    for(int i = 2;i < N;i++)
        inv[i] = inv[mod%i]*(mod-mod/i)%mod;
}

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

CoderFly

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

求逆元的四个方法

小帅哥快来看啊的博客

07-04

278

扩展欧几里得求逆元最小的逆元x： a∗x≡1(mod%b) 的c=1的情况 int x, y; void exgcd(ll a, ll b){ if(b == 0){ x = 1; y = 0; return; } exgcd(b, a%b); ll nowx = x; x = y; y = now...

O(n)递推求乘法逆元和阶乘逆元

yhhy666的博客

07-21

319

i−1∗i≡1(modp)p=k∗i+r(k=⌊ip⌋)(r=pmodi)k∗i+r≡0(modp)k∗r−1+i−1≡0(modp)i−1≡−⌊ip⌋∗pmodi(modp)i−1≡(p−p/i)∗inv[pmodi](modp)阶乘逆元inv[i+1]=(i+1)!1。

参与评论您还未登录，请先登录后发表或查看评论

线性O(n)求1~n逆元

jz_terry的博客

10-28

662

求某个数的逆元，我们可以用log(n)的时间算出来。但是，如果是求1~n的所有逆元呢？是不是就要用nlog(n)的时间了？其实我们有一种线性的方法，可以在O(n)的复杂度求出1~n的逆元。我们现在想要求1~n中一个数x的逆元先假设模数y=ax+b 则ax+b0 (%y) 将两边同时除以x·b （因为你的目的是得到一个形式为……的式子）则式子变为0 拆开得a·+...

线性求1~n逆元

bcr_233的博客

02-23

701

O(n)求1~n所有数的逆元（转载自jz_terry的博客）

O(N) 求1~N的逆元

abc473848880_的专栏

11-05

828

因为逆元是完全积性函数，这个可以用线筛来做，但是我们有一个更短更快的方法对于一个数a，有x，y满足ax+y=mod 且0 就有 ax+y = 0 (% mod) ax = -y (% mod) a^-1 = -x*y^-1 所以a的逆元等于-x*y的逆元，在这里，我们可以取mod/a为x，mod%a为y,这样就可以了

求乘法逆元方法总结

chr1stopher

08-04

458

目录简介扩展欧几里得法IdeaCode快速幂法IdeaCode线性求[1,n]逆元IdeaCode线性求任意n个数的逆元IdeaCode 简介若有线性同余方程 ax≡1(mod p)ax\equiv 1\left( mod~p\right)ax≡1(mod p)，则称 xxx 为 aaa 在模 ppp 意义下的逆元，记作 a−1a^{-1}a−1 扩展欧几里得法 Idea 原方程 ax≡1(mod p)ax\equiv 1\left( mod~p\right)ax≡1(mod

【蓝桥杯】Python算法——求逆元的两种算法

2301_77168269的博客

01-16

1398

介绍了两种方法求解逆元：扩展欧几里得算法和费马小定理算法，前者实用性广，而后者有一个前提，即模数必须为素数，不过一般用费马小定理的情况要多一些。

P3811 【模板】模意义下的乘法逆元题解

yaosichengalpha的博客

07-30

560

P3811 【模板】模意义下的乘法逆元题解

求逆元

NaNa

03-21

1409

求逆元乘法逆元扩展欧几里得求逆元费马小定理/欧拉定理乘法逆元如果 a⋅x≡1(mod p)a·x≡1(mod\ p)a⋅x≡1(mod p) 且 gcd(a,p)=1gcd(a,p)=1gcd(a,p)=1（aaa，ppp互质），那么 xxx 为模 ppp 意义下 aaa 的乘法逆元。一个数有逆元的充分必要条件是 gcd(a,p)=1gcd(a,p)=1gcd(a,p)=...

[AcWing]876. 快速幂求逆元（C++实现）快速幂求逆元模板题

cloud的博客

12-06

1869

[AcWing]875. 快速幂（C++实现）快速幂模板题1. 题目2. 读题（需要重点注意的东西）3. 解法4. 可能有帮助的前置习题5. 所用到的数据结构与算法思想6. 总结 1. 题目 2. 读题（需要重点注意的东西）思路：快速幂的作用快速地求出a的k次方模上p的结果快速幂的主要思想预处理出logk个数，然后用这logk个数中的若干个数在O(1)的时间组合出a的k次方模上p的结果。 3. 解法 -------------------------------------------

O(n)时间求出1~n对模MOD的逆元

whyorwhnt的专栏

02-13

4417

转自：http://www.2cto.com/kf/201401/272375.html 新学的一个求逆元的方法： inv[i] = ( MOD - MOD / i ) * inv[MOD%i] % MOD 证明：设t = MOD / i , k = MOD % i 则有 t * i + k == 0 % MOD 有 -t * i == k % MOD

O(N) 求 1~N 逆元模板及证明

Felix-Lee的博客

11-02

9750

O(N) 求 1~N 逆元模板及证明 Solutioninv[i]=(mo−mo / i)∗inv[mo % i] % moinv[i] = (mo-mo\ /\ i ) * inv[mo\ \%\ i]\ \%\ mo证明：设 t=mo / it=mo\ /\ i ,k=mo % ik=mo\ \%\ i ，则有：t∗i+k≡0 (mod mo)t*i+k≡

无数种求逆元的方法总结

xuanweiace的博客

07-29

1万+

乘法逆元对于缩系中的元素，每个数a均有唯一的与之对应的乘法逆元x，使得ax≡1(mod n) 一个数有逆元的充分必要条件是gcd(a,n)=1，此时逆元唯一存在逆元的含义：模n意义下，1个数a如果有逆元x，那么除以a相当于乘以x。下面给出求逆元的几种方法： 1.扩展欧几里得给定模数m，求a的逆相当于求解ax=1(mod m) 这个方程可以转化为ax-my=1 然后套用求二...

乘法逆元的几种求法总结

最新发布

06-15

(1) main1_AOA_VMD.m 核心功能：使用阿基米德算法算术优化算法(AOA) 优化变分模态分解(VMD) 的关键参数（惩罚因子α和模态数K），对多通道信号进行自适应分解。关键步骤：用AOA优化VMD参数（最小化包络熵）用最优参数执行VMD分解绘制分解结果（IMF分量）读取4个Excel文件（0.xlsx~3.xlsx）的振动信号数据数据预处理（替换0值为4）对每个信号通道：保存原始信号和VMD分解结果 (2) main2_AOA_VMD_BiLSTM.m 核心功能：对比普通BiLSTM 和 AOA-VMD-BiLSTM 在故障诊断中的性能：方案1：原始信号 → BiLSTM分类方案2：VMD分解信号 → BiLSTM分类关键步骤：普通BiLSTM（20个隐藏单元） AOA-VMD-BiLSTM（100个隐藏单元）加载main1生成的信号数据划分训练集/测试集（70%/30%）构建两个BiLSTM模型：评估指标：准确率/精确率/召回率/F1分数绘制混淆矩阵和性能对比曲线

毕业设计-plc小车行驶的plc控制系统课程设计.doc

06-15

毕业设计-plc小车行驶的plc控制系统课程设计.doc

【西门子PLC例程】-真空乳化机.zip

06-15

【西门子PLC例程】-真空乳化机.zip

线性逆元求组合数

05-11

<think>好的，我现在需要解决用户的问题：如何用线性逆元高效计算组合数，并给出算法实现。首先，我需要回顾一下用户提供的引用内容，看看有哪些已有的信息可以利用。根据引用[2]和引用[4]，用户提到了两种求逆元的方法：费马小定理和线性算法。用户特别关注的是线性逆元的应用，所以重点应该放在线性逆元方法上。引用[4]中的代码使用了费马小定理来计算阶乘的逆元，而用户现在想用线性逆元的方法，也就是引用[2]中的第二种方法。首先，我需要理清组合数的计算公式。组合数C(n, m)的公式是n!/(m!*(n-m)!))。在模运算中，除法需要转换为乘以逆元。因此，组合数取模可以表示为：C(n,m) % p = (n! * inv(m!) * inv((n-m)!)) % p，其中inv表示逆元。接下来，线性逆元的计算方法。引用[2]中的线性算法部分给出了一个预处理逆元数组的方法，预处理每个数的逆元。代码示例中的ny数组是通过递推公式计算的：ny[i] = (p - p/i) * ny[p%i] % p。这里的ny[i]是i的逆元。这种方法可以在O(n)的时间内预处理出1到n的逆元。但这里有个问题，组合数计算中需要的是阶乘的逆元，而不是单个数的逆元。所以，可能需要分两步处理：首先预处理出每个数的逆元，然后计算阶乘的逆元。例如，先预处理inv[1...n]，然后阶乘的逆元可以通过递推得到，比如infact[i] = infact[i-1] * inv[i] % p。这样，阶乘的逆元可以通过线性时间计算出来。再看引用[3]，其中提到了一种同时计算阶乘和逆元的方法，使用了一个递推式。可能这种方法可以更高效地同时处理阶乘及其逆元。但用户现在希望用线性逆元的方法，也就是先预处理每个数的逆元，再计算阶乘的逆元。所以，步骤大致如下： 1. 预处理逆元数组inv，其中inv[i]是i在模p下的逆元，使用线性递推方法。 2. 计算阶乘数组fact，其中fact[i] = i! % p。 3. 计算阶乘的逆元数组infact，其中infact[i] = (i!)^{-1} % p。这可以通过infact[i] = infact[i-1] * inv[i] % p来计算。 4. 组合数C(n,m)的计算公式即为 fact[n] * infact[m] % p * infact[n-m] % p。现在需要验证这个过程是否正确。例如，假设已经计算了fact数组和infact数组，那么组合数的计算是否正确。是的，因为每个阶乘的逆元已经预先计算好了，相乘即可得到分母部分的逆元。接下来要考虑的是实现中的细节，比如数组的大小，预处理的范围。如果n和m的最大值较大，比如1e5或者更高，需要确保数组足够大。例如，在引用[4]的代码中，预处理了N=1e5+10的阶乘和阶乘逆元。用户的问题中可能需要类似的预处理。那么具体的实现步骤：预处理部分： - 初始化fact[0...maxN]和infact[0...maxN]，以及inv[1...maxN]。 - fact[0] = 1，然后fact[i] = fact[i-1] * i % p。 - 预处理inv数组，使用线性递推：inv[1] = 1，然后对于i>=2，inv[i] = (p - p/i) * inv[p % i] % p。 - 计算infact数组：infact[0] = 1，然后infact[i] = infact[i-1] * inv[i] % p。这样，当需要计算C(n,m)时，只要n和m不超过maxN，就可以直接通过fact[n] * infact[m] % p * infact[n-m] % p得到结果。需要注意的是，这种方法的时间复杂度是O(maxN)，对于多次查询组合数的情况非常高效，因为预处理后每次查询都是O(1)时间。现在需要检查是否存在可能的错误。例如，当p不是质数时，线性逆元的方法是否有效？根据线性递推的条件，p必须是质数才能确保每个数都有逆元吗？其实，线性逆元方法要求i和p互质，所以当p是质数时，1到p-1的数都与p互质，此时可以正确计算逆元。如果p不是质数，可能某些i没有逆元，导致预处理失败。因此，该方法适用于p为质数的情况。用户提供的引用中，例如引用[2]中的费马小定理部分提到p为素数且a和p互质。所以，这里可能需要假设p是一个足够大的质数，这样预处理才能正确进行。因此，在实现中，需要确保p是质数，并且在预处理时处理到足够大的maxN，以满足后续查询的n和m的范围。现在，编写代码的大致结构：首先预处理inv数组，然后fact和infact数组。例如： const int maxN = 1e5 + 10; int fact[maxN], infact[maxN], inv[maxN]; int p; // 模数，假设为质数 void preprocess() { fact[0] = infact[0] = 1; inv[1] = 1; for (int i = 2; i < maxN; ++i) inv[i] = (p - p / i) * inv[p % i] % p; for (int i = 1; i < maxN; ++i) { fact[i] = fact[i-1] * i % p; infact[i] = infact[i-1] * inv[i] % p; } } 然后，计算组合数时： int C(int n, int m) { if (m < 0 || m > n) return 0; return fact[n] * infact[m] % p * infact[n - m] % p; } 但需要确保n和m都不超过maxN-1，否则数组会越界。如果n可能很大，比如达到1e5，则需要预先设置maxN足够大。或者，如果n的范围不确定，可能需要动态处理，但预处理通常适用于已知最大范围的情况。测试一下是否正确。例如，当p=1e9+7，计算C(5,2)=10。按照上述步骤： fact[5] = 120，infact[2] = 2的阶乘逆元的逆元。假设inv[2]=500000004（因为2*500000004 mod 1e9+7=1），infact[2] = infact[1] * inv[2] → infact[1]是1的逆元的乘积。可能过程需要更仔细的计算。或者，可能直接通过阶乘的逆元来计算。例如，fact[5]=120，infact[2]= (2!)^{-1} = (2)^{-1} * (1)^{-1} → 但按照infact的计算方法，infact[i] = infact[i-1] * inv[i]，所以infact[2] = infact[1] * inv[2}。而infact[1} = inv[1}=1。所以infact[2}=1 * inv[2}。inv[2}是500000004。因此，infact[2}=500000004。同理，infact[3}=infact[2} * inv[3}，以此类推。所以，当计算C(5,2)时，fact[5] * infact[2} * infact[3}。即120 * 500000004 * 333333336 % 1e9+7。计算这个值： 500000004 * 333333336 = (1/2) * (1/3) = 1/6，所以乘以120得到20。但正确的结果是10。这说明哪里出错了？哦，这里可能哪里弄错了。例如，C(5,2)=10。但根据上述计算，结果得到的是20？可能我的计算有误。让我们详细计算：假设p=1e9+7，此时： fact[5] = 120 infact[2}= (2!)^{-1} = inv[1] * inv[2} = 1 * inv[2} = 500000004 infact[3}= (3!)^{-1} = infact[2} * inv[3} → inv[3}=333333336，所以 infact[3}=500000004 * 333333336 mod p = 500000004 * 333333336 = (1/2) * (1/3) = 1/6 → 因此，infact[3}=166666668. 所以，组合数C(5,2) = 120 * 500000004 * 166666668 % p. 计算这三个数的乘积： 500000004 * 166666668 = ? 先计算500000004 × 166666668： 500000004 * 166666668 = (5e8 +4) * (1.66666668e8) 这可能需要模运算中的计算，但直接计算的话： 500000004 × 166666668 = ? 但是模1e9+7的话，这些数都是它们在该模下的逆元。例如，500000004是2的逆元，166666668是6的逆元。所以，2的逆元乘以6的逆元等于 (2*6)的逆元=12的逆元。但 120 × (2的逆元) × (6的逆元) = 120 × (12的逆元) = 120 /12 =10。所以结果正确。因此，上述方法是正确的。这说明算法是正确的。接下来，需要根据这个思路编写代码。例如，引用的代码中，用户提供的引用[4]使用了费马小定理来预处理阶乘的逆元，而用户现在希望用线性逆元的方法，所以需要修改这部分代码，将infact的预处理改为使用线性逆元数组。因此，正确的代码结构应该是：预处理inv数组，然后预处理fact和infact数组。例如： #include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; // 假设最大处理到1e5 int fact[N], infact[N], inv[N]; int p; void preprocess() { fact[0] = infact[0] = 1; inv[1] = 1; for (int i = 2; i < N; ++i) { inv[i] = (p - p / i) * 1LL * inv[p % i] % p; } for (int i = 1; i < N; ++i) { fact[i] = fact[i - 1] * 1LL * i % p; infact[i] = infact[i - 1] * 1LL * inv[i] % p; } } int C(int n, int m) { if (m < 0 || m > n) return 0; return fact[n] * 1LL * infact[m] % p * infact[n - m] % p; } int main() { // 示例：假设p是质数，比如1e9+7 p = 1e9 + 7; preprocess(); int n, m; cin >> n >> m; cout << C(n, m) << endl; return 0; } 这样，预处理部分使用线性逆元的方法来计算inv数组，然后用inv数组来递推计算infact数组。这样就避免了使用费马小定理的快速幂方法，从而提高了预处理的速度，尤其是在需要处理大范围的情况下，线性方法更高效。需要注意的是，这种方法的时间复杂度为O(N)，适用于多次查询的情况。同时，需要确保N足够大以覆盖所有可能的n和m值。用户的问题已经得到了解决，现在需要生成相关问题。根据用户的问题和回答，相关问题可能包括线性逆元的原理、组合数计算的其他方法、或者如何处理更大的n和m的情况等。</think>### 线性逆元求组合数算法实现 #### 核心步骤 1. **预处理线性逆元数组**：使用递推公式$inv[i] = (p - \lfloor p/i \rfloor) \cdot inv[p\%i] \% p$，时间复杂度$O(n)$ 2. **计算阶乘数组**：$fact[i] = fact[i-1] \times i \% p$ 3. **计算阶乘逆元数组**：$infact[i] = infact[i-1] \times inv[i] \% p$ 4. **组合数计算**：$C(n,m) = fact[n] \times infact[m] \times infact[n-m] \% p$ #### 算法模板 ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 10; int fact[MAXN], infact[MAXN], inv[MAXN], mod; void preprocess() { // 初始化边界条件 fact[0] = infact[0] = 1; inv[1] = 1; // 线性求逆元 for (int i = 2; i < MAXN; ++i) inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod; // 计算阶乘及其逆元 for (int i = 1; i < MAXN; ++i) { fact[i] = 1LL * fact[i-1] * i % mod; infact[i] = 1LL * infact[i-1] * inv[i] % mod; } } int comb(int n, int m) { if (m < 0 || m > n) return 0; return 1LL * fact[n] * infact[m] % mod * infact[n - m] % mod; } ``` #### 复杂度分析 - **时间复杂度**：预处理$O(n)$，单次查询$O(1)$ - **空间复杂度**：$O(n)$ - **适用条件**：模数$p$为质数且$n,m < MAXN$[^2][^4] #### 应用示例当$p=10^9+7$时，计算$C(10000,5000)$： 1. 预处理阶乘数组和逆元数组 2. 直接调用comb(10000, 5000)即可得到结果 3. 计算结果满足：$C(n,m) \equiv \frac{n!}{m!(n-m)!} \mod p$[^1][^3]