求逆元的方法汇总

最新推荐文章于 2021-11-16 00:29:17 发布
最新推荐文章于 2021-11-16 00:29:17 发布
阅读量2.2k 收藏
点赞数
分类专栏： 通式定理 文章标签： 逆元

逆元

它是一个可以取消另一给定元素运算的元素。
对于正整数a和m，如果有a⋅x≡1(mod  m)，那么把这个同余方程中x的最小正整数解叫做a模m的逆元。

前提

求 a(modm)意义下的逆元,要求a与m互质,否则不存在乘法逆元

定理

欧拉定理(费马小定理)
  • 欧拉定理： 若a与m互质，那么有aφ(m)≡1(mod  m)

方法

1.欧拉定理

根据欧拉定理

aϕ(m)a⋅aϕ(m)−1a−1≡≡≡11aϕ(m)−1(modm)(modm)(modm)

所以 aϕ(m)−1为a的逆元
时间复杂度 O(n−−√) 即求出单个欧拉函数的值
2.exgcd

应用exgcd
我们假设a的逆元是x

a⋅xa⋅x+m⋅y≡=11(modm)

用exgcd求出x即为a的逆元
时间复杂度 O(loga)
3.需要线性处理1~n的逆元

更正:本方法需在模数为素数情况下才能使用！！！
我们假设 y=a⋅x+b, b<i, 1<x<y
在将这个式子放在 mody  意义下

a⋅x+b≡0(mody)

两边同时乘上 x−1⋅b−1 得到
a⋅b−1+x−1x−1≡≡0−a⋅b−1(mody)(mody)

再将 y=a⋅x+b 带入得到
x−1≡−⌊yx⌋⋅(ymodx)−1(mody)

所以我们定义 a[i]为x的mody 意义下的逆元,根据上式得到
a[i]=−(y  div  x)∗a[ymodx]
1 在模任何意义下逆元都是 1
同时也就得到了一种 O(logN) 级别的递归求单个逆元的方法
由于每次取模,所以每次都相当于折半,复杂度就降到了 O(logN)

最后贴上代码

1.欧拉定理
<code class="hljs oxygene has-numbering"><span class="hljs-keyword">const</span>
    maxn=<span class="hljs-number">1000</span>;
<span class="hljs-keyword">var</span>
    prime:<span class="hljs-keyword">array</span>[<span class="hljs-number">0</span>..maxn]<span class="hljs-keyword">of</span> longint;
    check:<span class="hljs-keyword">array</span>[<span class="hljs-number">0</span>..maxn]<span class="hljs-keyword">of</span> boolean;
    i,j,k:longint;
    n,m,tt,len,ans:longint;
<span class="hljs-function"><span class="hljs-keyword">procedure</span> <span class="hljs-title">prepare</span>;</span>
<span class="hljs-keyword">begin</span>
    len:=<span class="hljs-number">0</span>;
    <span class="hljs-keyword">for</span> i:=<span class="hljs-number">2</span> <span class="hljs-keyword">to</span> trunc(sqrt(maxn)) <span class="hljs-keyword">do</span>
        <span class="hljs-keyword">begin</span>
            <span class="hljs-keyword">if</span> check[i]=<span class="hljs-keyword">false</span>
            <span class="hljs-keyword">then</span> <span class="hljs-keyword">begin</span> inc(len); prime[len]:=i; <span class="hljs-keyword">end</span>;
            <span class="hljs-keyword">for</span> j:=<span class="hljs-number">1</span> <span class="hljs-keyword">to</span> len <span class="hljs-keyword">do</span>
                <span class="hljs-keyword">begin</span>
                    <span class="hljs-keyword">if</span> prime[j]*i>trunc(sqrt(maxn)) <span class="hljs-keyword">then</span> <span class="hljs-keyword">break</span>;
                    check[i*prime[j]]:=<span class="hljs-keyword">true</span>;
                    <span class="hljs-keyword">if</span> i <span class="hljs-keyword">mod</span> prime[j]=<span class="hljs-number">0</span> <span class="hljs-keyword">then</span> <span class="hljs-keyword">break</span>;
                <span class="hljs-keyword">end</span>;
        <span class="hljs-keyword">end</span>;
<span class="hljs-keyword">end</span>;

<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">f</span><span class="hljs-params">(a,b,m:longint)</span>:</span>longint; <span class="hljs-comment">{a^b mod m}</span>
<span class="hljs-keyword">var</span> t,y:int64;
<span class="hljs-keyword">begin</span>
    t:=<span class="hljs-number">1</span>; y:=a;
    <span class="hljs-keyword">while</span> b<><span class="hljs-number">0</span> <span class="hljs-keyword">do</span>
        <span class="hljs-keyword">begin</span>
            <span class="hljs-keyword">if</span> b <span class="hljs-keyword">and</span> <span class="hljs-number">1</span><><span class="hljs-number">0</span> <span class="hljs-keyword">then</span> t:=(t*y)<span class="hljs-keyword">mod</span> m;
            y:=(y*y)<span class="hljs-keyword">mod</span> m;
            b:=b>><span class="hljs-number">1</span>;
        <span class="hljs-keyword">end</span>;
    <span class="hljs-keyword">exit</span>(t);
<span class="hljs-keyword">end</span>;

<span class="hljs-keyword">begin</span>
    prepare;
    readln(n,m); tt:=m;
    ans:=m;
    <span class="hljs-keyword">for</span> i:=<span class="hljs-number">1</span> <span class="hljs-keyword">to</span> len <span class="hljs-keyword">do</span>
        <span class="hljs-keyword">begin</span>
            <span class="hljs-keyword">if</span> m=<span class="hljs-number">1</span> <span class="hljs-keyword">then</span> <span class="hljs-keyword">break</span>;
            <span class="hljs-keyword">if</span> m <span class="hljs-keyword">mod</span> prime[i]=<span class="hljs-number">0</span> <span class="hljs-keyword">then</span> ans:=(ans <span class="hljs-keyword">div</span> prime[i])*(prime[i]-<span class="hljs-number">1</span>);
            <span class="hljs-keyword">while</span> m <span class="hljs-keyword">mod</span> prime[i]=<span class="hljs-number">0</span> <span class="hljs-keyword">do</span>
                m:=m <span class="hljs-keyword">div</span> prime[i];
        <span class="hljs-keyword">end</span>;
    <span class="hljs-keyword">if</span> m<><span class="hljs-number">1</span> <span class="hljs-keyword">then</span> ans:=(ans <span class="hljs-keyword">div</span> m)*(m-<span class="hljs-number">1</span>);
    writeln(f(n,ans-<span class="hljs-number">1</span>,tt));
<span class="hljs-keyword">end</span>.</code>
2.exgcd
<code class="hljs delphi has-numbering"><span class="hljs-keyword">var</span>
    n,m,a,b,c,x,y:longint;
<span class="hljs-function"><span class="hljs-keyword">procedure</span> <span class="hljs-title">exgcd</span><span class="hljs-params">(a,b:longint; <span class="hljs-keyword">var</span> x,y:longint)</span>;</span>
<span class="hljs-keyword">var</span> c:longint;
<span class="hljs-keyword">begin</span>
    <span class="hljs-keyword">if</span> b=<span class="hljs-number">0</span>
    <span class="hljs-keyword">then</span> <span class="hljs-keyword">begin</span> x:=<span class="hljs-number">1</span>; y:=<span class="hljs-number">0</span>; <span class="hljs-keyword">exit</span>; <span class="hljs-keyword">end</span>
    <span class="hljs-keyword">else</span> exgcd(b,a <span class="hljs-keyword">mod</span> b,x,y);
    c:=x; x:=y; y:=c-(a <span class="hljs-keyword">div</span> b)*x;
<span class="hljs-keyword">end</span>;

<span class="hljs-keyword">begin</span>
    readln(n,m);
    exgcd(n,m,x,y);
    x:=(x+((x <span class="hljs-keyword">div</span> m)+<span class="hljs-number">1</span>)*m+m)<span class="hljs-keyword">mod</span> m;
    writeln(x);
<span class="hljs-keyword">end</span>.
</code>
线性处理1~n
<code class="hljs delphi has-numbering"><span class="hljs-keyword">const</span>
    maxn=<span class="hljs-number">1000</span>;
<span class="hljs-keyword">var</span>
    x:<span class="hljs-keyword">array</span>[<span class="hljs-number">0</span>..maxn]<span class="hljs-keyword">of</span> longint;
    i,j,k:longint;
    n,m:longint;
<span class="hljs-keyword">begin</span>
    readln(n,m);
    x[<span class="hljs-number">1</span>]:=<span class="hljs-number">1</span>;
    <span class="hljs-keyword">for</span> i:=<span class="hljs-number">2</span> <span class="hljs-keyword">to</span> n <span class="hljs-keyword">do</span>
        x[i]:=(-(m <span class="hljs-keyword">div</span> i)*x[m <span class="hljs-keyword">mod</span> i])<span class="hljs-keyword">mod</span> m;
    writeln(x[i]);
<span class="hljs-keyword">end</span>.    </code>
线性处理转求单个
<code class="hljs actionscript has-numbering"><span class="hljs-keyword">var</span>
    n,m:longint;
<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">f</span><span class="hljs-params">(a:longint)</span><span class="hljs-type">:longint</span>;</span>
begin
    <span class="hljs-keyword">if</span> a=<span class="hljs-number">1</span>
    then exit(<span class="hljs-number">1</span>)
    <span class="hljs-keyword">else</span> exit((-(m div a)*f(m mod a))mod m);
end;

begin
    readln(n,m);
    writeln(f(n));
end.</code>
不归路___
关注
专栏目录
密码学——欧几里得扩展算法（求模逆）_欧几里得算法求模逆元
2401_83621426的博客
04-16 339
刚刚咱们已知k = 19 求 k^(-1)的情况叫做求k的逆元求逆元的方法就叫做欧几里得扩展算法我这里还有几个k和它对应的k^(-1) 你们可以计算一下。
求逆元的C程序（算法）
01-28
用c语言实现逆元的计算，通过自己设计算法代码实现。
求逆元（三种方法）
M_Y_Y_的博客
07-20 1406
证明：http://www.cnblogs.com/linyujun/p/5194184.html#4010311 方法一： 费马小定理 复杂度O(logn) inv(a) = a^(p-2) (mod p) LL pow_mod(LL a, LL b, LL p){//a的b次方求余p LL ret = 1; while(b){ if(b &amp;...
逆元的求法
fuzekun的博客
10-11 658
#什么是逆元 a #逆元的作用是什么 #怎么求逆元 1.扩展欧几里得 2.费马小定理 3.线性筛选 4.阶乘逆元的线性筛选
无数种求逆元的方法总结
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 然后套用求二...
模意义下求乘法逆元的各种姿势
SDFZspli的博客
08-11 2799
乘法逆元 定义 若ax≡1modpax≡1modpax\equiv1 \mod p,则称xxx是aaa在modpmodp\mod p意义下的逆元，记为x≡a−1modpx≡a−1modpx\equiv a^{-1}\mod p 当然，aaa也是xxx在modpmodp\mod p意义下的逆元 ab=a⋅b−1ab=a⋅b−1\frac{a}{b}=a\cdot b^{-1} 几乎所有...
es求平均值_es查询，聚合、平均值、值范围、cardinality去重查询
weixin_35489311的博客
02-15 2535
普通查询GET ana-apk/_search{"query": {"match_all": {}}}查询不重复的mac地址GET ana-apk/_search{"size": 10,"aggs": {"MAC": {"cardinality": {"field": "MAC.keyword"}}},"_source":{"include":["MAC","ProbeOUI","RTPLossR...
离散数学题目大汇总.doc
06-21
- 验证H是否满足群的定义，特别是闭包性和逆元的存在性。 #### 三、图论基础 **知识点8：图的基本概念** - **定义**：图是由顶点和边组成的数学结构。 - **应用**：题目涉及无向图和有向图中顶点度数的相关问题。...
武汉大学《线性代数》期末复习资料汇总.pdf
08-24
理解线性空间的性质，例如封闭性、零元、单位元、加法逆元、标量乘法的分配律等，是理解线性代数的基础。 3. **线性映射**：线性映射是将一个线性空间映射到另一个线性空间的函数，保持了加法和标量乘法的性质。...
CPP求逆元代码 扩展欧几里得
06-04
用递归实现的求逆元的代码，使用中的算法是扩展的欧几里得算法。输入本元和模数，得到乘法逆元。
乘法逆元代码实现 （C语言版）
12-08
试试吧！对于很多一直邱乘法逆元函数的人来说是一个非常好的选择
密码学考试复习（关于快速指数算法和扩展欧几里得求逆元）
09-23
密码学考试复习（关于快速指数算法和扩展欧几里得求逆元），之前考试自己整理的，今天又要学了。里面的算法还能看，还整理的比较透彻当时。备用了留在这。不知道为什么之前上传的xmind一点就跳转到别的页面了，这次压缩下。
【代码】 四法求逆元
Aeolusw的博客
07-21 835
本文应该真的差不多就只有代码 不要脸地说一句其实要学的话只看代码也能知道方法了，还是写得比较结构化的#include <cstdio>typedef long long ll; ll Qpow(ll x, ll n, ll p){ ll ans = 1; while (n){ if (n & 1) ans = ans * x % p; x = x * x % p;
求逆元
weixin_46563439的博客
12-30 153
众说周知，逆元是算法竞赛数论中逃不开的点，下面，便总结一下常用的求逆元的及几种方法，适用于不同情景。 扩欧（扩展欧几里得） 扩欧为大家所熟知且应用及其广泛的一种方法。直接上代码。 void extend_gcd(int a,int b,int &x,int &y) //扩展欧几里得 { if (b==0) { x = 1, y = 0; return; } extend_gcd(b, a % b, x, y);
【逆元】
热门推荐
Hi_jiaxinwei的博客
07-17 1万+
逆元（inv） 1.什么是逆元 当求解公式：(a/b)%m 时，因为b可能会过大，会出现爆精度的情况，所以可以变除法为乘法： 设c时b的逆元，有b*c≡1(mod m)； 则(a/b)%m = (a/b)*1%m = (a/b)*b*c%m = a*c(mod m); 即a/b的模等于a*b的逆元的模； 所以逆元就时这样应用的了； 2.求逆元的方法 (1).费马小定理 在
求逆元的方法 （三种）
henucm的博客
04-02 1595
首先对逆元不太了解的 强推这篇 可爱风 的博客 （反正我jio得太TM可爱了）https://www.cnblogs.com/linyujun/p/5194184.html 注释: inv 为逆元 方法一：费马小定理 a^(p-1) ≡1 (mod p) 两边同除以a a^(p-2) ≡1/a (mod p) 什么(,,• ₃ •,,)，这可是数论，还敢写1/a 应该写a^(p-2)...
逆元的应用
qq_52093121的博客
11-16 756
1.逆元解释: 逆元定义: 来自一个大佬的通俗解释: 什么是逆元
代码收集0008——求逆元
Beginner_SNORLAX的博客
04-03 495
扩展欧几里得算法可以求解ax+by=gcd(a,b)这样一个不定方程的同时求出gcd(a,b) C语言 long long Extended_Euclid(long long a,long long b,long long *x,long long *y) { if(b==0) { *x=1; *y=0; return a; ...
扩展欧几里得求逆元python
最新发布
09-20
扩展欧几里得算法是一种求解两个整数a、b的最大公约数的同时，能找到整数x、y（其中一个很可能是负数），使它们满足贝祖等式ax+by=gcd(a,b)的算法。在求解乘法逆元时，我们可以使用扩展欧几里得算法来求解。假设a和n是两个互质的整数，那么a在模n意义下的逆元就是满足ax≡1(mod n)的x。根据扩展欧几里得算法，我们可以求出ax+ny=gcd(a,n)的一组解(x,y)，那么ax≡1(mod n)的解就是x mod n。因此，我们可以使用扩展欧几里得算法来求解a在模n意义下的逆元。 以下是求解乘法逆元的Python代码： def gcd(a,b,s): if a%b == 0: return b,s q = a//b temp = s s = s-q*s s = temp return gcd(b,a%b,s) def ModReverse(a,n): s = [1,0] gcd(a,n,s) if s==0: return -1 elif s<0: return n+s else: return s%n 其中，gcd函数是扩展欧几里得算法的实现，ModReverse函数是求解乘法逆元的实现。在ModReverse函数中，我们首先调用gcd函数求解ax+ny=gcd(a,n)的一组解(x,y)，然后判断是否存在逆元。如果不存在逆元，则返回-1；如果存在逆元且x为负数，则返回n+x；否则，返回x mod n。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值