【数据结构与算法】最大公约数与最小公倍数

最大公因数（英语：highest common factor，hcf）也称最大公约数（英语：greatest common divisor，gcd）是数学词汇，指能够整除多个非零整数的最大正整数。例如8和12的最大公因数为4。表示：gcd(8,12) = 4

最小公倍数（英语：least common multiple，lcm）是数论中的一个概念。若有一个数X，可以被另外两个数A,B整除，且X同时大于或等于A和B，则X为A和B的公倍数。A和B的公倍数有无限个，而所有正的公倍数中，最小的公倍数就叫做最小公倍数。例如8和12的最小公倍数为24。表示：lcm(8,12) = 24

两个整数的最小公倍数与最大公因数之间有如下的关系：

根据上面的示例：|8*12|/4=24

也就是说，我们掌握了最大公约数的求法，也就能求最小公倍数

那么我们就以最大公约数为例

枚举(穷举)

根据已有的数学知识我们知道，m>n的话，m,n的最大公约数永远不可能是m（因为n/m不能整除），最大只可能是n。所以我们只需要从n开始依次向较小数找到“能同时被n,m整除的第一个整数”即为两数的最大公约数。

代码示例：

#include <stdio.h>
int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    int i;
    int gcd;
    gcd = 1;
    for(i = (a<b?a: b); i > 0; i--)
    {
        if(a % i == 0 && b % i == 0)
        {
            gcd = i;
            break;
        }
    }
    printf("gcd = %d\n", gcd);
    return 0;
}

另一种穷举原理：

求出两数的所有公因子，再把公因子累乘得到最大公约数。

代码示例：

#include <iostream>
using namespace std;
int CommFactor2(int m, int n); 
int main()
{
  int a, b;
  cin >> a >> b;
  cout << "这两个数的最大公约数为：" << CommFactor2(a,b)<< endl;
  return 0;
}
int CommFactor2(int m,int n)
{
  int i;
  int factor = 1;
  for (i=2;i<=m&&i<<n;i++)
  {
    while(m % i == 0 && n % i == 0)  //这里不能用if语句，因为可能会有重复的公因子
    {
      factor = factor * i;
      m = m / i;
      n = n / i;
    }
  }
  return factor;
}

辗转相除法

辗转相除法，又称欧几里得算法。辗转相除法基于如下原理：两个整数的最大公约数等于其中较小的数和两数相除余数的最大公约数。表示：gcd(a,b) = gcd(b,a mod b) (a>b)

代码示例：

#include <stdio.h>
int main(int argc, const char* argv[])
{
    int a,b,temp;
    scanf("%d %d", &a, &b);
    while (b != 0)
    {
        temp = a % b;
        a = b;
        b = temp;
    }
    printf("gcd = %d\n", a);
    return 0;
}

更相减损法

更相减损法，又称辗转相减法。更相减损法出自《九章算术》：“可半者半之，不可半者，副置分母、子之数，以少减多，更相减损，求其等也。以等数约之。”(原本是为了约分而设计的)

具体方法为两个数之间大的数字减小的数字，之后将得到的差作为减数，较小的数作为被减数，再次相减，直到与所得的差相同，此时的差即为两个数之间的最大公约数。

用(a，b)表示a和b的最大公因数：有结论(a，b)=(a，k*a+b)，其中a、b、k都为自然数。

基于上面的原理，就能实现我们的迭代相减法：(78，14)=(64，14)=(50，14)=(36，14)=(22，14)=(8，14)=(8，6)=(2，6)=(2，4)=(2，2)=(0，2)=2

代码示例：

#include<iostream>
using namespace std;
int gcd(int a, int b)
{
    while(a != b)
        if(a > b) a -= b;
        else b -= a;
    return a;
}
int main(){
	int m,n;
	cin>>m>>n;
	cout<<"gcd:"<<gcd(m,n)<<endl;
	return 0;
}

Stein算法

Stein算法是针对欧几里德算法在对大整数进行运算时，需要试商导致增加运算时间的缺陷而提出的改进算法。

欧几里德算法是计算两个数最大公约数的传统算法，无论从理论还是从实际效率上都是很好的。但是却有一个致命的缺陷，这个缺陷在素数比较小的时候一般是感觉不到的，只有在大素数时才会显现出来：一般实际应用中的整数很少会超过64位（当然现在已经允许128位了），对于这样的整数，计算两个数之间的模是很简单的。对于字长为32位的平台，计算两个不超过32位的整数的模，只需要一个指令周期，而计算64位以下的整数模，也不过几个周期而已。但是对于更大的素数，这样的计算过程就不得不由用户来设计，为了计算两个超过64位的整数的模，用户也许不得不采用类似于多位数除法手算过程中的试商法，这个过程不但复杂，而且消耗了很多CPU时间。对于现代密码算法，要求计算128位以上的素数的情况比比皆是，比如说RSA加密算法至少要求500bit密钥长度，设计这样的程序迫切希望能够抛弃除法和取模。

Stein算法很好的解决了欧几里德算法中的这个缺陷，Stein算法只有整数的移位和加减法。下面就来说一下Stein算法的原理：

1. 若a和b都是偶数，则记录下公约数2，然后都除2（即右移1位）
2. 若其中一个数是偶数，则偶数除2，因为此时2不可能是这两个数的公约数了
3. 若两个都是奇数，则a = |a-b|，b = min(a,b)，因为若d是a和b的公约数，那么d也是|a-b|和min(a,b)的公约数

这里对3.进行简单的证明：
不妨设奇数A>B，A和B的公约数为X，即A=jX，B=kX，其中j，k均为正整数且j>k。
A−B=(j−k)X
因为j，k均为整数，所以X也是A-B的公约数。
min(A,B)=B
所以A-B与min(A,B)公约数相同，因为A，B都是奇数，所以A-B必然是偶数，偶数又可以二除移位了。

代码示例1：

#include<iostream>
using namespace std;
int SteinGCD(int a, int b) {
    if (a < b) { int t = a; a = b; b = t; }
    if (b == 0) return a;
    if ((a & 1) == 0 && (b & 1) == 0)
        return SteinGCD(a >> 1, b >> 1) << 1;
    else if ((a & 1) == 0 && (b & 1) != 0)
        return SteinGCD(a >> 1, b);
    else if ((a & 1) != 0 && (b & 1) == 0)
        return SteinGCD(a, b >> 1);
    else
        return SteinGCD(a - b, b);
}
int main()
{
    int m,n;
    cin>>m>>n;
    cout<<"gcd:"<<SteinGCD(m,n)<<endl;
    return 0;
}

代码示例2：

#include<iostream>
using namespace std;
int gcd(int u, int v)
{
    if (u == 0)	return v;
    if (v == 0)	return u;
    if (~u & 1)
    {
        if (v & 1)
            return gcd(u >> 1, v);
        else
            return gcd(u >> 1, v >> 1) << 1;
    }
    if (~v & 1)
        return gcd(u, v >> 1);
    if (u > v)
        return gcd((u - v) >> 1, v);
    return gcd((v - u) >> 1, u);
}
int main()
{
    int m,n;
    cin>>m>>n;
    cout<<"gcd:"<<gcd(m,n)<<endl;
    return 0;
}

Stein算法非递归方式

代码示例：

#include<iostream>
using namespace std;
int SteinGCD(int a, int b) {
    int acc = 0;
    while ((a & 1) == 0 && (b & 1) == 0) {
        acc++;
        a >>= 1;
        b >>= 1;
    }
    while ((a & 1) == 0) a >>= 1;
    while ((b & 1) == 0) b >>= 1;
    if (a < b) { int t = a; a = b; b = t; }
    while ((a = (a - b) >> 1) != 0) {
        while ((a & 1) == 0) a >>= 1;
        if (a < b) { int t = a; a = b; b = t; }
    }
    return b << acc;
}
int main()
{
    int m,n;
    cin>>m>>n;
    cout<<"gcd:"<<SteinGCD(m,n)<<endl;
    return 0;
}

库函数

__gcd(a,b)——库algorithm

注意：gcd前面有两个下划线

gcd(a,b)——库numeric

注意：仅作扩展，如无必要，不要使用

位运算

利用位运算的特性，将两数交换改成位运算。
inline可加可不加。我实际试验中，在1e8次执行后，加与不加的时间差在80ms左右，而两者本来的运行时间均在3000ms上下，即差别不大

代码示例：

inline int gcd(int a, int b)
{
    while(b ^= a ^= b ^= a %= b);    
    return a;
}

利用取模特点

很快，几乎与__gcd(a,b)的时间一致

代码示例：

int gcd(int a, int b){
    if(!a || !b)
        return max(a, b);
    for(int t; t = a % b; a = b, b = t);
    return b;
}

以上方法都为最大公约数的求法，若要求最小公倍数，利用关系计算即可。

迭乘法(求最小公倍数)

由公倍数的定义出发，如果一个数k是a和b的公倍数，那么k可以表示成 a*m或 b*n，而当(a*m) % b == 0时，k是最小公倍数

代码示例：

#include<stdio.h>
int main(){
    int a,b;
    scanf("%d %d", &a, &b);
    int i = 1;
    while((a*i) % b != 0){
        i++;
    }
    printf("最小公倍数是：%d\n", a * i);
    return 0;
}

参考博文：

https://blog.csdn.net/Hsuesh/article/details/111992593

https://blog.csdn.net/ly_6699/article/details/90719315

https://blog.csdn.net/JH13thpig/article/details/124362053

https://blog.csdn.net/weq2011/article/details/127953257

https://blog.csdn.net/Holmofy/article/details/76401074

https://blog.csdn.net/wyd_333/article/details/126111037