欧几里德算法贝祖等式扩展欧几里德算法

吴自勉 — Sat, 02 Jun 2012 09:53:00 GMT

计算机程序设计艺术开篇便提到了“欧几里德”算法，也就是中国的“辗转相除法”。
这个是个古老、经典的算法。
说的是：两个正整数 a，b（设a>b）求出他们的最大公约数。
算法步骤：
1. r=a mod b    （mod是相除取余数的意思）
2.如果r=0，则b是最大公约数，否则转3
3.a=b ，b=r 转 1
算法的一种证明：
证：
    要证欧几里德算法成立，即证: gcd(a,b)=gcd(b,r),其中 gcd是取最大公约数的意思，r=a mod b
    下面证 gcd（a，b）=gcd（b，r）
    设 c是a，b的最大公约数，即c=gcd（a，b），则有 a=mc，b=nc，其中m，n为正整数，且m，n互为质数
    由 r= a mod b可知，r= a- qb 其中，q是正整数，
    则 r=a-qb=mc-qnc=（m-qn）c
    b=nc,r=(m-qn)c，且n，（m-qn）互质（假设n，m-qn不互质，则n=xd, m-qn=yd 其中x,y,d都是正整数，且d>1
                                                                则a=mc=(qx+y)dc, b=xdc,这时a,b 的最大公约数变成dc，与前提矛盾，
                                                                 所以n ，m-qn一定互质）
    则gcd（b,r）=c=gcd（a,b）
    得证。

定理2：（由法国数学家拉梅证明）欧几里得算法所需除法次数不超过m和n中较小的那个数的十进制位数的5倍

定理3：欧几里得算法所需除法次数不超过2 log(n+1)，其中n为较小的数

由欧几里德算法，衍生出来一个重要的贝祖等式：两数的最大公约数可以用两数的整数倍相加来表示，如21 = gcd(105,252)=5 × 105 + (−2） × 252。
贝祖等式的非严格证明：
证明：
我们可以将辗转相除法的步骤看成：
a      = p(0)b + r(0)
b      = p(1)r(0)+r(1)
r(0)   = p(2)r(1)+r(2)
r(1)   = p(3)r2+r(3)
......
r(n-2)= p(n)r(n-1)+ r(n)
r(n-1)= p(n+1)r(n)+ r(n+1)
r(n)   = p(n+2)r(n+1)
当我们做到最后一个式子的时候，我们就知道 gcd(a，b)=r(n+1);
由倒数第二个式子，我们可知：r(n+1) =gcd(a,b)=r(n-1) - p(n+1)r(n),其中r(n)又可以用上面的式子r(n)=r(n-2)-p(n)r(n-1)代替，就这样不断地用上面的式子代替，
到最后我们就可以得到gcd(a,b)关于a，b的一次的关系式。
得证.

现在我们已经知道存在 x，y使得 ax+by=gcd(a，b)成立了，那么怎样更直接地求x，y呢？
设： a*x1+b*y1=gcd(a,b)
       b*x2+(a mod b)*y2=gcd(b,(a mod b))
我们已经知道了：gcd(a,b)=gcd(b,(a mod b))
那么有：a*x1+b*y1=b*x2+(a mod b)*y2=b*x2+(a-a/b*b)*y2=b*x2 +a*y2- a/b*b*y2=a*y2+b*(x2-a/b*y2)
那么我们有：x1=y2 ;   y1=x2-a/b*y2, 这样就把求x1,y1的问题，转化为求b*x2+(a mod b)*y2=gcd(a,b)中x2,y2的问题。
这个思路是基于递归的思想的。因为 gcd 不断的递归求解一定会有个时候 b=0，所以递归可以结束。
基于递归实现的C++代码：

#include<iostream>
using namespace std;
int x=0,y=0,gcd=0;
void qq(int ,int);
int main()
{
    int a,b;
    cin>>a>>b;//输入的时候保证a>b，a，b是正整数就好了就好了，我这里没再检查a，b的有效性。
    qq(a,b);
    cout<<x<<"*"<<a<<"+"<<y<<"*"<<b<<"="<<x*a+y*b<<"="<<gcd<<endl;

    return 0;
}
void qq(int a,int b)
{
    if(0==b)
    {
        x=1;
        y=0;
        gcd=a;
        return;
    }
    else
    {
        qq(b,a%b);
        int temp=x;
        x=y;
        y=temp-a/b*y;
        return;
    }

}

循环版本：

#include<iostream>
using namespace std;

void qq(int ,int);
int main()
{
    int a,b;
    cin>>a>>b;
    qq(a,b);

    return 0;
}
void qq(int a,int b)
{
    int x=1,y=0,gcd=0; //
    int temp[100][2];    //记录过程中的a，b
    int counter=0;
    while(b!=0)
    {
        temp[counter][0]=a;
        temp[counter][1]=b;
        counter++;
        int tempnum=a;
        a=b;
        b=tempnum%b;
    }

    gcd =a;
    cout<<gcd<<endl;
    for(int i=--counter;i>=0;i--)
    {
        int tempnum=x;
        x=y;
        y=tempnum-temp[i][0]/temp[i][1]*y;
    }
   cout<<x<<"*"<<temp[0][0]<<"+"<<y<<"*"<<temp[0][1]<<"="<<x*temp[0][0]+y*temp[0][1]<<"="<<gcd<<endl;

}

以上求解x，y的过程我们不妨把它称为“扩展欧几里德算法”，当然我这种说法很不好，为什么呢？
在《计算机程序设计艺术》第一卷 1.2 数学准备这个小节里面，Knuth先生给出了一个十分优美的“扩展欧几里德算法”
如下：

扩展的欧几里德算法：给定两个正整数m和n，我们计算它们的最大公约数和两个整数a和b，使am+bn=d；
E1：【初始化】a0=b=1； a=b0=0； c=m；d=n；
E2：【除】q=c/d；r=c%d
E3：【余数为0？】如果 r=0；算法终止，在这种情况下，我们如愿地有：am+bn=d；
E4：【循环】c=d； d=r； t=a0； a0=a; a=t-qa; t=b0; b0=b; b=t-qb, 返回E2
END；

关于这个算法，Knuth先生也给出了优美的证明，我这里不再赘言；
下面给出实现代码：

#include<iostream>

using namespace std;

void qq(int ,int);
int main()
{
    int m,n;
    cin>>m>>n;//这里同样没有检查m、n有效性，自己保证m>n,都是正整数
    qq(m,n);

    return 0;
}
void qq(int m,int n)
{
    int a=0,b=1,a0=1,b0=0;
    int c=m,d=n;

    int q=c/d;
    int r=c%d;

    while(r!=0)
    {
         c=d;
         d=r;
         int t=a0;
         a0=a;
         a=t-q*a;

         t=b0;
         b0=b;
         b=t-q*b;

         q=c/d;
         r=c%d;

    }
    cout<<"a="<<a<<"  b="<<b<<"  d="<<d<<endl;
}

我们可以看到这个算法的实现起来非常的简洁、明了！
求解同样的问题，算法不同，会有相当大的差别。
程序=算法+数据结构

<全文完>

吴自勉 2012-06-02 17:53 发表评论

C++博客-wuzimian-随笔分类-计算机程序设计艺术

欧几里德算法 贝祖等式 扩展欧几里德算法

欧几里德算法贝祖等式扩展欧几里德算法