线性同余和扩展欧几里得的运用小结

最新推荐文章于 2020-10-25 21:14:13 发布
最新推荐文章于 2020-10-25 21:14:13 发布
阅读量1.8k 收藏
点赞数 3
分类专栏： 数论 文章标签： 个人 总结 练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bright_xl/article/details/10825187
版权

内容回顾：

在数论中，线性同余方程是最基本的同余方程，“线性”表示方程的未知数次数是一次，即形如：
ax≡b (mod n)的方程。此方程有解当且仅当 b 能够被 a 与 n 的最大公约数整除（记作 gcd(a,n) | b）。这时，如果 x0 是方程的一个解，那么所有的解可以表示为：
{x0+kn/d|(k∈z)}
其中 d 是a 与 n 的最大公约数。在模 n 的完全剩余系 {0,1,…,n-1} 中，恰有 d 个解。

扩展欧几里德算法是用来在已知a, b求解一组x，y使得ax+by = Gcd(a, b) =d(解一定存在，根据数论中的相关定理)。扩展欧几里德常用在求解模线性方程及方程组中。

在我具体的做题过程中遇到了一些中国剩余定理的题目，基本上也都是可以用扩展欧几里德算法解决的，而在求解线性同余方程组时，一般用扩展欧几里德解决，而且我习惯只写一个扩展欧几里德调用函数，因为它也可以求得gcd，根本就不需要再用一个欧几里德算法求最大公约数。

中国剩余定理也有一些整理：传送阵


例题：

POJ1061 青蛙的约会

这是一道最简单的线性同余题目，题意中文（目测也没什么外国人看我blog）就不多说了，，，一个扩展欧几里德搞定。。。不过，青蛙的约会确实戳中泪点了，码农的爱情~

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<vector>
#include<stack>
#define mem(a,b) memset(a,b,sizeof(a))
#define FOR(a,b,i) for(i=a;i<=b;++i)
#define For(a,b,i) for(i=a;i<b;++i)
#define N 1000000007
using namespace std;
inline void RD(int &ret)
{
    char c;
    do
    {
        c=getchar();
    }
    while(c<'0'||c>'9');
    ret=c-'0';
    while((c=getchar())>='0'&&c<='9')
    {
        ret=ret*10+(c-'0');
    }
}
inline void OT(int a)
{
    if(a>=10)
    {
        OT(a/10);
    }
    putchar(a%10+'0');
}
__int64 exdgcd(__int64 a,__int64 b,__int64 &x,__int64 &y)//扩展欧几里德
{
    __int64 l,r;
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    r=exdgcd(b,a%b,x,y);
    l=x;
    x=y;
    y=l-a/b*y;
    return r;
}
int main()
{
    __int64 x,y,m,n,l,a,b,xx,yy,p,q;
    scanf("%I64d%I64d%I64d%I64d%I64d",&x,&y,&m,&n,&l);
    p=exdgcd(n-m,l,xx,yy);
    if((x-y)%p!=0)
    {
        printf("Impossible\n");
    }
    else
    {
        xx=xx*(x-y)/p;
        q=l/p;
        xx=(xx%q+q)%q;
        printf("%I64d\n",xx);
    }
    return 0;
}


POJ2891 Strange Way to Express Integers

这题与上题不同的是这次给了多个同余方程组，我们知道，解决多个同余问题可以将其转化到一个方程式中，其余数即为解，所以我们对第一个和第二个式子做扩展欧几里德算法，然后合并成一个式子，然后继续直到合成一个式子，得到最终解。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<vector>
#include<stack>
#define mem(a,b) memset(a,b,sizeof(a))
#define FOR(a,b,i) for(i=a;i<=b;++i)
#define For(a,b,i) for(i=a;i<b;++i)
#define N 1000000007
using namespace std;
inline void RD(int &ret)
{
    char c;
    do
    {
        c=getchar();
    }
    while(c<'0'||c>'9');
    ret=c-'0';
    while((c=getchar())>='0'&&c<='9')
    {
        ret=ret*10+(c-'0');
    }
}
inline void OT(int a)
{
    if(a>=10)
    {
        OT(a/10);
    }
    putchar(a%10+'0');
}
__int64 exdgcd(__int64 a,__int64 b,__int64 &x,__int64 &y)
{
    __int64 l,r;
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    r=exdgcd(b,a%b,x,y);
    l=x;
    x=y;
    y=l-a/b*y;
    return r;
}
int main()
{
    __int64 a1,r1,a2,r2,x,y,p,q,z;
    int i,g,k;
    while(scanf("%I64d",&k)!=EOF)
    {
        scanf("%I64d%I64d",&a1,&r1);
        g=0;
        FOR(1,k-1,i)
        {
            scanf("%I64d%I64d",&a2,&r2);
            if(g==1)
            {
                continue;
            }
            p=exdgcd(a1,a2,x,y);
            if((r2-r1)%p!=0)
            {
                g=1;
                continue;
            }
            q=a2/p;
            z=((r2-r1)/p*x%a2+a2)%q;
            r1=z*a1+r1;
            a1=a1*a2/p;
        }
        if(g==1)
        {
            printf("-1\n");
        }
        else
        {
            printf("%I64d\n",r1);
        }
    }
    return 0;
}

POJ2115 C Looooops

扩展欧几里德好题，一个简单的线性同余题，重点在于你如何将式子转化，cx mod (2^k) = b - a，求最小x，注意数据范围

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<vector>
#include<stack>
#define mem(a,b) memset(a,b,sizeof(a))
#define FOR(a,b,i) for(i=a;i<=b;++i)
#define For(a,b,i) for(i=a;i<b;++i)
#define N 1000000007
using namespace std;
inline void RD(int &ret)
{
    char c;
    do
    {
        c=getchar();
    }
    while(c<'0'||c>'9');
    ret=c-'0';
    while((c=getchar())>='0'&&c<='9')
    {
        ret=ret*10+(c-'0');
    }
}
inline void OT(int a)
{
    if(a>=10)
    {
        OT(a/10);
    }
    putchar(a%10+'0');
}
__int64 pow(__int64 x,__int64 y)//快速幂
{
    __int64 res=1;
    while(y>0)
    {
        if(y%2==1)
        {
            res=res*x;
        }
        x=x*x;
        y/=2;
    }
    return res;
}
__int64 exdgcd(__int64 a,__int64 b,__int64 &x,__int64 &y)
{
    __int64 l,r;
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    r=exdgcd(b,a%b,x,y);
    l=x;
    x=y;
    y=l-a/b*y;
    return r;
}
int main()
{
    __int64 a,b,c,x,y,p,q,z,k;
    while(scanf("%I64d%I64d%I64d%I64d",&a,&b,&c,&k))
    {
        if(a==0&&b==0&&c==0&&k==0)
        {
            break;
        }
        k=pow(2,k);
        p=exdgcd(c,k,x,y);
        if((b-a)%p!=0)
        {
            printf("FOREVER\n");
        }
        else
        {
            q=k/p;
            z=((b-a)/p*x%q+q)%q;
            printf("%I64d\n",z);
        }
    }
    return 0;
}


POJ2142 The Balance

好题，这题的难点在于a，b，c都已给出，要求的是|x|+|y|的最小值，还是一次扩展欧几里德，得到一组解后，分别比较x和y产生的解更小，此题要注意数据范围，最好一直用__in64。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<vector>
#include<stack>
#define mem(a,b) memset(a,b,sizeof(a))
#define FOR(a,b,i) for(i=a;i<=b;++i)
#define For(a,b,i) for(i=a;i<b;++i)
#define N 1000000007
using namespace std;
inline void RD(int &ret)
{
    char c;
    do
    {
        c=getchar();
    }
    while(c<'0'||c>'9');
    ret=c-'0';
    while((c=getchar())>='0'&&c<='9')
    {
        ret=ret*10+(c-'0');
    }
}
inline void OT(int a)
{
    if(a>=10)
    {
        OT(a/10);
    }
    putchar(a%10+'0');
}
__int64 ABS(__int64 x)
{
    if(x<0)
    {
        x=-x;
    }
    return x;
}
__int64 exdgcd(__int64 a,__int64 b,__int64 &x,__int64 &y)
{
    __int64 l,r;
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    r=exdgcd(b,a%b,x,y);
    l=x;
    x=y;
    y=l-a/b*y;
    return r;
}
int main()
{
    __int64 a,b,c,x,y,p,q,z1,z2,w1,w2,m,n;
    while(1)
    {
        scanf("%I64d%I64d%I64d",&a,&b,&c);
        if(a==0&&b==0&&c==0)
        {
            break;
        }
        p=exdgcd(a,b,x,y);
        q=b/p;
        z1=(c/p*x%q+q)%q;//保证解为正数
        z2=ABS((c-z1*a)/b);
        m=z1+z2;
        n=z1*a+z2*b;
        q=a/p;
        w2=(c/p*y%q+q)%q;
        w1=ABS((c-w2*b)/a);
        if(m>(w1+w2)||(m==(w1+w2)&&n<(w1*a+w2*y)))//只要比较x和y分别产生的解就行
        {
            z1=w1;
            z2=w2;
        }
        printf("%I64d %I64d\n",z1,z2);
    }
    return 0;
}

SGU106 The equation

第一次上这个网站做题，发现好多大牛都做这个，给个链接：传送阵

这题应该算是一个线性同余的好题目，和上面一样也都是一个扩展欧几里德解决问题，但要考虑的情况比较多：

1.a=0&&b=0，这时就要看c了，c=0时，解随意为(x2-x1+1)*(y2-y1+1)，c!=0，无解

2.a=0时，这时(-c)%b=0，解为(y2-y1+1)，否则无解

3.b=0时，同理，解为(x2-x1+1)，否则无解

4.a!=0&&b!=0时，就是扩展欧几里德算出一个解，然后根据这个解得到它解可控的范围，从而得到答案。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<vector>
#include<stack>
#define mem(a,b) memset(a,b,sizeof(a))
#define FOR(a,b,i) for(i=a;i<=b;++i)
#define For(a,b,i) for(i=a;i<b;++i)
#define N 1000000007
using namespace std;
inline void RD(int &ret)
{
    char c;
    do
    {
        c=getchar();
    }
    while(c<'0'||c>'9');
    ret=c-'0';
    while((c=getchar())>='0'&&c<='9')
    {
        ret=ret*10+(c-'0');
    }
}
inline void OT(int a)
{
    if(a>=10)
    {
        OT(a/10);
    }
    putchar(a%10+'0');
}
__int64 exdgcd(__int64 a,__int64 b,__int64 &x,__int64 &y)
{
    __int64 l,r;
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    r=exdgcd(b,a%b,x,y);
    l=x;
    x=y;
    y=l-a/b*y;
    return r;
}
int main()
{
    __int64 a,b,c,x1,x2,y1,y2,p,sum,x,y,x0,y0,lx,ly,rx,ry,l,r;
    scanf("%I64d%I64d%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&x1,&x2,&y1,&y2);
    if(a==0&&b==0)
    {
        if(c==0)
        {
            sum=(x2-x1+1)*(y2-y1+1);
        }
        else
        {
            sum=0;
        }
    }
    else if(a==0)
    {
        if((-c)%b==0)
        {
            y0=(-c)/b;
            if(y0>=y1&&y0<=y2)
            {
                sum=(x2-x1+1);
            }
            else
            {
                sum=0;
            }
        }
        else
        {
            sum=0;
        }
    }
    else if(b==0)
    {
        if((-c)%a==0)
        {
            x0=(-c)/a;
            if(x0>=x1&&x0<=x2)
            {
                sum=(y2-y1+1);
            }
            else
            {
                sum=0;
            }
        }
        else
        {
            sum=0;
        }
    }
    else
    {
        p=exdgcd(a,b,x,y);
        if((-c)%p!=0)
        {
            sum=0;
        }
        else
        {
            x=(x*(-c))/p;
            y=(y*(-c))/p;
            lx=(x1<=x||(x1-x)*p%b==0)?((x1-x)*p/b):((x1-x)*p/b+1);
            rx=(x2>=x||(x2-x)*p%b==0)?((x2-x)*p/b):((x2-x)*p/b-1);
            ly=(y1<=y||(y-y1)*p%a==0)?((y-y1)*p/a):((y-y1)*p/a-1);
            ry=(y2>=y||(y-y2)*p%a==0)?((y-y2)*p/a):((y-y2)*p/a+1);
            if(lx>rx)
            {
                swap(lx,rx);
            }
            if(ly>ry)
            {
                swap(ly,ry);
            }
            if(ry>=lx&&rx>=ly)
            {
                l=max(lx,ly);
                r=min(rx,ry);
                sum=r-l+1;
            }
            else
            {
                sum=0;
            }
        }
    }
    printf("%I64d\n",sum);
    return 0;
}

最后附上Matrix67神犇的线性同余和扩展欧几里德解析，很有意思： mod&& exdgcd

Bright-xl
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
扩展欧几里得求解线性同余方程
Pandauncle的博客
02-03 628
求解ax+by=c之前首先要知道一个定理。 定理1：对于方程a*x+b*y=c，该方程等价于a*x≡c(mod b)，有整数解的充分必要条件是： c%GCD(a,b)=0。 根据定理1，对于方程a*x+b*y=c，我们可以先用扩展欧几里得算法求出一组x0，y0，也就是a*x0+b*y0=GCD(a,b)，然后两边同时除以GCD(a,b)，再乘以c。这样就得到方程a*x0*c/GCD(a,b)+
扩展欧几里得算法-线性同余方程
ai_XZP_master
03-01 327
扩展欧几里得算法-线性同余方程 概念：给定a, b, m，求整数x,使得： ax = b(mod m)； 举例：2x = 3 (mod 6) 无解 4x = 3 (mod 5) :4*某一个数 同于于4*某一个数/5的余数是3. x可以等于 2，7等。 等式变形： ax = b(mod m) 等价于 存在一个整数y属于z，使得 ax = m*y + b --&gt...
扩展欧几里德算法求解线性同余方程
BananaTree
05-05 8319
转自http://hi.baidu.com/sunhaowenprime/item/5626e3e69858afaec10d7522       欧几里德算法 　　欧几里德算法又称辗转相除法，用于计算两个整数a,b的最大公约数。其计算原理依赖于下面的定理： 　　定理：gcd(a,b) = gcd(b,a mod b) 　　证明：a可以表示成a = kb + r，则r = a mod
线性同余方程+扩展欧几里得(poj1061)
mumei的博客
08-22 222
题目链接：http://poj.org/problem?id=1061 两只青蛙在网上相识了，它们聊得很开心，于是觉得很有必要见一面。它们很高兴地发现它们住在同一条纬度线上，于是它们约定各自朝西跳，直到碰面为止。可是它们出发之前忘记了一件很重要的事情，既没有问清楚对方的特征，也没有约定见面的具体位置。不过青蛙们都是很乐观的，它们觉得只要一直朝着某个方向跳下去，总能碰到对方的。但是除非这两只青蛙在...
[学习笔记] #扩展欧几里得算法 ——— 求线性同余方程
仅仅是笔记。
10-25 278
扩展欧几里得算法 扩展欧几里得算法 AcWing 877. 扩展欧几里得算法 00\ 线性同余方程 AcWing 878. 线性同余方程
扩展欧几里得算法求逆元
12-09
扩展欧几里得算法求逆元
C语言 扩展欧几里得算法代码
09-05
介绍了扩展欧几里得算法的实现代码，有需要的朋友可以参考一下
扩展欧几里得
01-20
朴素欧几里得： gcd(a,b)=gcd(b,a mod b) 。 这个是比较好证明的： 假设 a=k∗b+r ，有 r=a mod b 。不妨设 d 为 a 和 b 的一个任意一个公约数，则有 a≡b≡0(mod d) 。 由于同余的性质 a−kb ≡ r ≡ 0(mod d) 因此...
扩展欧几里得算法
04-17
在编写扩展欧几里得算法的前提下，计算了两个数的最大公因数，判断两数是否互素。
初步数论-扩展欧几里得&线性同余方程
姬小野的博客
01-04 702
这篇博客我将介绍数论中的扩展欧几里得算法(extended Euclidean algorithm ),以及其在解线性同余方程(乘法逆元)中的运用. 首先要了解几个概念: 欧几里得算法 扩展欧几里得算法 线性同余方程 欧几里得算法是一种求解两个正整数a, b的最大公因子(一般记为gcd,gcd(a, b) )的方法,这个方法最早被记载在欧几里得的&lt;&lt;几...
线性同余方程-扩展欧几里得算法
渣渣
07-16 4671
线性同余方程定义对于线性同余方程这个式子的意思即 （ax)%n = b  如果 x0 是方程的一个解，那么所有的解可以表示为：其中d = gcd(a,n)性质此方程有解当且仅当 b 能够被 a 与 n 的最大公约数整除（记作 gcd(a,n) | b）用算法表示即 b%gcd(a,n) == 0  解法推理（扩展欧几里得算法求特解）由上面可知我们只要求出一个特解即可得通解。由裴蜀定理（对任何整数a...
欧几里得算法与同余方程
afwq12112的博客
07-25 819
欧几里得算法 　　说起数学家不得不提起欧几里得，而欧几里得的欧几里得算法（gcd）直到现在仍在计算机与数学领域有着卓越的贡献 　　欧几里得算法非常简单，简而言之就是gcd（a，b）=gcd（b，a%b）。如果你是小升初时学奥数的受害者，那你一定会很眼熟：这不是辗转相除法吗！！　　是的其实你早就接触过这个算法了，而求出最小公约数只是这个算法的最最基本的用法（当然也用的最多），但在算...
扩展欧几里得(exgcd)与同余详解
qq_42701791的博客
08-22 1975
exgcd入门以及同余基础 gcd，欧几里得的智慧结晶，信息竞赛的重要算法，数论的...（编不下去了 讲exgcd之前，我们先普及一下同余的性质： 若，那么 若，，且p1，p2互质， 若，k和c为整数，而且k&gt;0，那么 若，那么就可以推出，则有  有了这三个式子，就不用怕在计算时溢出了。 下面我会用与分别表示a与b的最大公约数与最小公倍数。 首先会来学扩欧的同学肯...
求解线性同余方程--扩展欧几里得
二喵君的博客
08-07 2856
资料来源：https://blog.csdn.net/ //求解ax=b(mod m) 返回0为无解，否则返回gcd(a,m)个mod m意义下的解,用X[]存 int mod(int a, int b, int m) { return equation(a, m, b); } 先看一道题目： ...
【算法学习】欧几里得算法详解（包括扩展、同余方程）
moX980的博客
12-07 2424
欧几里得算法详解（包括扩展）1.普通欧几里得算法（求最大公约数）2.扩展欧几里得算法（求解a*x+b*y=c） 1.普通欧几里得算法（求最大公约数） 欧几里得算法又称辗转相除法，可以用于快速的求取两个数的最大公约数 原理如下： 综上，gcd(a,b)=gcd(b,a%b)=…当b=0（即后一项为0时），a为gcd（前一项）。 最小公倍数 = a * b / gcd(a, b) 代码实现： 2.扩展...
男人八题系列
Bright-XL
07-20 7917
男人之路。。。还差最后一题，敬请期待~
数论四大定理小结（初级）
Bright-XL
08-03 3704
数论四大定理小练小结
十个利用矩阵乘法解决的经典题目(个人小结)
Bright-XL
08-28 3557
看了Matrix67大神的博客做的一个小结。也让我对矩阵有了一个全新的认识。 传送阵 经典题目1 给定n个点，m个操作，构造O(m+n)的算法输出m个操作后各点的位置。操作有平移、缩放、翻转和旋转     这里的操作是对所有点同时进行的。其中翻转是以坐标轴为对称轴进行翻转（两种情况），旋转则以原点为中心。如果对每个点分别进行模拟，那么m个操作总共耗时O(mn)。利用矩阵乘法可以在O(m)
生成函数练习小结
Bright-XL
08-30 2338
传送阵 Matrix67大神的总结：跟着大神学，也不喜欢叫母函数，都称生成函数。 在数学中，某个序列 的生成函数是一种形式幂级数，其每一项的系数可以提供关于这个序列的信息。使用生成函数解决问题的方法称为母函数方法。 生成函数可分为很多种，包括普通生成函数、指数生成函数、L级数、贝尔级数和狄利克雷级数。对每个序列都可以写出以上每个类型的一个生成函数。构造生成函数的目的一般是为了解决某个特定的问题
扩展欧几里得acwing
最新发布
05-28
扩展欧几里得算法是欧几里得算法的扩展，用于求解形如ax + by = gcd(a, b)的不定方程。其中a、b为整数，x、y为整数解。该算法可以用于求最大公约数，判断两个数是否互质，以及求解同余方程等问题。 算法流程如下： 1. 若b=0，则gcd(a,b)=a，此时x=1,y=0； 2. 若b≠0，则gcd(a,b)=gcd(b,a mod b)，令d=gcd(b,a mod b)，则存在整数x1和y1，使得b*x1+(a mod b)*y1=d； 3. 根据同余方程的求解方法，可以得到a*x+b*y=gcd(a,b)的一组整数解：x=y1,y=x1-floor(a/b)*y1。 扩展欧几里得算法可以用递归或迭代方式实现，递归方式代码如下： ```python def exgcd(a, b): if b == 0: return a, 1, 0 d, x1, y1 = exgcd(b, a % b) x = y1 y = x1 - (a // b) * y1 return d, x, y ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值