迭代法 详解 ,最大公约数和最小公倍数

迭代法（iteration）也称辗转法，是一种不断用变量的旧值递推出新值的解决问题的方法，迭代算法一般用于数值计算。累加，累乘都是迭代算法的基础应用。

利用迭代法解题的步骤：

1）确定迭代模型

   根据问题描述，分析出前一个（或几个）值与下一个值的迭代关系数学模型。

2）建立迭代关系式

  递推数学模型一般是带下标的字母，算法设计中要将其转化为“循环不变式”----迭代关系式，迭代关系式就是一个直接或间接地不断由旧值递推出新值的表达式，存储新值的变量称为迭代变量。

3）对迭代过程进行控制。

  确定在什么时候结束迭代过程。

 

迭代过程是通过小规模问题的解逐步求解大规模问题的解，表面上看正好与递归相反，但也找到了大规模问题与小规模问题的关系。

本节的例子是用迭代完成的，也都可以用递归完成。相信尝试后，定能体会到递归的简便之处。

 

1，递推法 （recursion）是迭代算法的最基本表现形式。一般来讲，一种简单的递推方法，就是从小规模的问题解出大规模问题的一种方法，也称其为“正推“。如”累加“。

 

兔子繁殖问题： 一对兔子从出生后第三个月开始，每月生一对兔子，小兔子每到第三个月有开始生兔子，问一年中每个月各有多少兔子？

我们通常用的迭代：

print(a,b)

for(i=1;i<=10;i++)

 {

    c=a+b;

　　print(c);

　　a=b;

　　b=c;

}

 

另一种构造不变式的方法：

1　　2　　　　3　　　　4　　　　5　　　　6　　　　7　　　　8

a　　b　　c=a+b　　 a=b+c　　b=a+c   c=a+b

 

这样，一次循环其实是递推了三步，循环次数就要减少了。

#include<stdio.h>

int main()
{
    
    int i,a=1,b=1;
    int c;
    printf("%d %d ",a,b);
    for(i=1;i<=4;i++)
    {
        c=a+b;
        a=b+c;
        b=c+a;
        printf("%d %d  %d  ",c,a,b); //注意输出顺序是c,a,b
    }
}

上面输出的共2+3*4=14项，这样的算法不太完美。

另一种思路，

1     2 　　3　　　　4　　　　5

a　　b　　a=a+b  b=a+b　　 a=a+b

#include<stdio.h>

int main()
{
    
    int i,a=1,b=1;
    int c;
    printf("%d %d ",a,b);
    for(i=1;i<=5;i++)
    {
        a=a+b;
        b=a+b;
        printf("%d %d  ",a,b);
    }
}

 

2.倒推法（inverted recursion)对某些特殊问题所采用的违反通常习惯的，从后向前推解问题的方法。

 

猴子吃桃问题： 一只小猴子摘了若干桃子，每天吃现有的桃的一半多一个，到第十天时就只有一个桃子了，求原有多少个桃？

数学模型

a10=1,a9=(1+a10)*2 ,a8=(1+a9)*2...

递推公式为：

ai=(1+a(i+1) )*2 ; i=9 ,8  .. .1

由于每一天的桃子树只依赖前一天的桃子数，所以只用一个迭代变量代表桃子数就可以了。

int main()
{
    int i,a;
    a=1;
    for(i=9;i>=1;i--)
        a=(a+1)*2;
    printf("%d",a);
}

 

输出如图所示的杨辉三角形（限定用一个一维数组完成）

 　　   1                         　　1

     1 　　　1                        1　　1

1         2　　 1                     1        2      1  杨辉三角存储格式

#include<iostream>
using namespace std;

int main()
{

    int n,i,j,a[100];
    cin>>n;
    cout<<1<<endl;
    a[1]=a[2]=1;
    cout<<a[1]<<ends<<a[2]<<endl;
    for(i=3;i<=n;i++)
    {
        a[1]=a[i]=1;
        for(j=i-1;j>1;j--)
             a[j]=a[j]+a[j-1];
        for(j=1;j<=i;j++)
            cout<<a[j]<<ends;
        cout<<endl;
    }
}

若求n层的杨辉三角，则数组最多存储n个数据（第n层有n个数据）就可以了。

第i层有i列需要求解i个数据，若从第一列向后计算，求第i行时，由于用一个一维数组存储，每求出一个数将覆盖第i-1行对应列存储的

值，这将导致下一个数无法计算，而从第i个元素倒着向前计算就能正常进行，则可避免这种情况出现。

a[j]=a[j]+a[j-1]; j=i-1,i-2, ... 2

求 最大公约数和最小公倍数

2012-04-27 16:32 by 有心故我在, 24 阅读, 0 评论, 收藏, 编辑

  　　最大公约数（greatest common divisor，简写为gcd。最简单的是求2个整数的最大公约数。常见的算法是辗转相除法。

辗转相除法，又称欧几里得算法。结果为非零的除数即为最大公约数。

原理及其详细证明

　　设两数为a、b(b<a），用gcd(a,b）表示a，b的最大公约数，r=a mod b 为a除以b以后的余数，辗转相除法即是要证明gcd(a,b)=gcd(b,r）。

　　第一步：令c=gcd(a,b），则设a=mc，b=nc

　　第二步：根据前提可知r =a-kb=mc-knc=(m-kn)c

     第三步：根据第二步结果可知c也是r的因数

   第四步：可以断定m-kn与n互素【否则，可设m-kn=xd，n=yd，（d>1），则m=kn+xd=kyd+xd=(ky+x)d，则a=mc=(ky+x)dc，b=nc=ycd，故a与b最大公约数成为cd，而非c】

  从而可知gcd(b,r)=c，继而gcd(a,b)=gcd(b,r）。

  　证毕。

非递归算法如下：

int gcd(int m,int n)
{
    if(m<n) //m为最大的
    {
        int tmp=m;
        m=n;
        n=tmp;
    }
    if(n==0)
        return m; //除了0以外的所有自然数都是0的约数。
    while(n!=0)
    {
        int tmp=m%n;
        m=n;
        n=tmp;
    }
    return m;
}

要考虑0 的约数问题。看定义：整数a除以整数b(b≠0) 除得的商正好是整数而没有余数，我们就说a能被b整除，或b能整除a。a叫b的倍数，b叫a的约数（或因数）。从这个来看0可以任何非0自然数的倍数，

递归算法：

int gcd2(int m,int n)
{
    if(m<n)
    {
        int tmp=m;
        m=n;
        n=tmp;
    }
    if(n==0)
        return m;  //这个很关键
        
    else
        return gcd(n,m%n);

}

gcd(6,4)
　　|
　　gcd(4,2)
　　　　|
　　　　gcd(2,0)
　　　　　　|
　　　　　　n==0,返回2 ，程序最终返回2

 

　　欧几里德算法是计算两个数最大公约数的传统算法，无论从理论还是从实际效率上都是很好的。但是却有一个致命的缺陷，这个缺陷在素数比较小的时候一般是感觉不到的，只有在大素数时才会显现出来。，和欧几里德算法算法不同的是，Stein算法只有整数的移位和加减法。

为了说明Stein算法的正确性，首先必须注意到以下结论：

 　gcd(a,a)=a，也就是一个数和其自身的公约数仍是其自身。

 

   gcd(ka,kb)=k gcd(a,b)，也就是最大公约数运算和倍乘运算可以交换。特殊地，当k=2时，说明两个偶数的最大公约数必然能被2整除。

 

　当k与b互为质数，gcd(ka,b)=gcd(a,b)，也就是约掉两个数中只有其中一个含有的因子不影响最大公约数。特殊地，当k=2时，说明计算一个偶数和一个奇数的最大公约数时，可以先将偶数除以2。

有了上述规律就可以给出Stein算法如下：

1.如果A=0，B是最大公约数，算法结束
2.如果B=0，A是最大公约数，算法结束
3.设置A1 = A、B1=B和C1 = 1
4.如果An和Bn都是偶数，则An+1 =An /2，Bn+1 =Bn /2，Cn+1 =Cn *2(注意，乘2只要把整数左移一位即可，除2只要把整数右移一位即可)
5.如果An是偶数，Bn不是偶数，则An+1 =An /2，Bn+1 =Bn ，Cn+1 =Cn (很显然啦，2不是奇数的约数)
6.如果Bn是偶数，An不是偶数，则Bn+1 =Bn /2，An+1 =An ，Cn+1 =Cn (很显然啦，2不是奇数的约数)
7.如果An和Bn都不是偶数，则An+1 =|An -Bn|，Bn+1 =min(An,Bn)，Cn+1 =Cn
8.n++，转4

 

   特别注意 看看两个奇数的情况：设有两个奇数x和y，似乎x和y直接向小转化没有什么太好的办法，我们可以绕个道，把x和y向偶数靠拢去化小。不妨设x>y，我们注意到x+y和x-y是两个偶数，则有 g_c_d( x+y,x-y ) = 2 * g_c_d( (x+y)/2,(x-y)/2 )，那么 g_c_d( x,y ) 与 g_c_d( x+y,x-y ) 以及 g_c_d( (x+y)/2,(x-y)/2 ) 之间是不是有某种联系呢？为了方便我设

          m=(x+y)/2 ，n=(x-y)/2 ，

        有   m+n=x ，m-n=y 。

设 a = g_c_d( m,n )，则 m%a=0,n%a=0 ，所以 (m+n)%a=0，(m-n)%a=0 ，即 x%a=0 ，y%a=0 ，所以a是x和y的公约数，有 g_c_d( m,n )<= g_c_d(x,y)。再设 b = g_c_d( x,y )肯定为奇数，则 x%b=0,y%b=0 ，所以 (x+y)%b=0 ，(x-y)%b=0 ，又因为x+y和x-y都是偶数，跟前面一奇一偶时证明a是x的约数的方法相同，有 ((x+y)/2)%b=0,((x-y)/2)%b=0 ，即 m%b=0 ，n%b=0 ，所以b是m和n的公约数，有 g_c_d( x,y ) <= g_c_d( m,n )。所以 g_c_d( x,y ) = g_c_d( m,n ) = g_c_d( (x+y)/2,(x-y)/2 )。

我们来整理一下，对两个正整数 x>y ：
1.均为偶数 g_c_d( x,y ) =2g_c_d( x/2,y/2 )；
2.均为奇数 g_c_d( x,y ) = g_c_d( (x+y)/2,(x-y)/2 )；
2.x奇y偶   g_c_d( x,y ) = g_c_d( x,y/2 )；
3.x偶y奇   g_c_d( x,y ) = g_c_d( x/2,y )  或 g_c_d( x,y )=g_c_d( y,x/2 )；
现在我们已经有了递归式，还需要再找出一个退化情况。注意到 g_c_d( x,x ) = x ，我们就用这个。

 int gcd(int a,int b)
{
    if(a<b)
    {
        int tmp=a;
        a=b;
        b=tmp;
    }
    if(b==0)//the base case
        return a;
    if(a%2==0&&b%2==0) //a b are even
        return 2*gcd(a/2,b/2);
    if(a%2==0) //only a is even
        return gcd(a/2,b);
    if(b%2==0) //only b is even
        return gcd(a,b/2);
    return gcd( (a+b)/2, (a-b)/2 ); //a b are odd
}

快速的版本：http://blog.csdn.net/ztj111/article/details/1905015

unsigned int stein( unsigned int x, unsigned int y )
/* return the greatest common divisor of x and y */
{
unsigned int factor = 0;
unsigned int temp;
if ( x < y ){
temp = x;
x = y;
y = temp;
}
if ( 0 == y ) return 0;
while ( x != y )
{
if ( x & 0x1 )
{/* when x is odd */
if ( y & 0x1 )
{/* when x and y are both odd */
y = ( x - y ) >> 1;
x -= y;
}
else
{/* when x is odd and y is even */
y >>= 1;
}
}
else
{/* when x is even */
if ( y & 0x1 )
{/* when x is even and y is odd */
x >>= 1;
if ( x < y )
{
temp = x;
x = y;
y = temp;
}
}
else
{/* when x and y are both even */
x >>= 1;
y >>= 1;
++factor;
}
}
}
return ( x << factor );
}

 

更相减损术

转载文章：

更相减损术,又称"等值算法"

关于约分问题,实质是如何求分子,分母最大公约数的问题。《九章算术》中介绍了这个方法,叫做”更相减损术”,数学家刘徽对此法进行了明确的注解和说明,是一个实用的数学方法。

例：今有九十一分之四十九,问约之得几何?

我们用(91,49)表示91和49的最大公约数.按刘徽所说,分别列出分子,分母。

“以少减多,更相减损,求其等也,以等数约之,等数约之,即除也,其所以相减者皆等数之重叠,故以等数约之。”

译文如下：

约分的法则是：若分子、分母均为偶数时，可先被2除，否则，将分子与分母之数列在它处，然后以小数减大数，辗转相减，求它们的最大公约数，用最大公约数去约简分子与分母。

其与古希腊欧几里德所著的《几何原本》中卷七第一个命题所论的相同。列式如下:

91 49

42 49

42 7

35 7

28 7

21 7

14 7

7  7

这里得到的7就叫做“等数”,91和49都是这等数的重叠(即倍数),故7为其公约数.而7和7的最大公约数就是7,(7,7)=7,所以(91,49)=(42,7)=(7,7)=7

更相减损术在现代仍有理论意义和实用价值.吴文俊教授说:“在我国,求两数最大公约数即等数,用更相减损之术,将两数以小减大累减以得之,如求24与15的等数,其逐步减损如下表所示:(24,15)->(9,15)->(9,6)->(3,6)->(3,3)

每次所得两数与前两数有相同的等数,两数之值逐步减少,因而到有限步后必然获得相同的两数,也即所求的等数,其理由不证自明。

这个寓理于算不证自明的方法,是完全构造性与机械化的尽可以据此编成程序上机实施”.吴先生的话不仅说明了此法的理论价值,而且指明学习和研究的方向.

更相减损法很有研究价值,它奠定了我国渐近分数,不定分析,同余式论和大衍求一术的理论基础.望能仔细品味。

代码如下：

int gcd(int a,int b)
{
     while(a != b)
     {
          if(a>b) a -= b;
          else b -=a;
      }
       return a;
}