【模板】求最大公因数

唠嗑

这是up主模板库的第一篇文章，在模板库这个专栏里，你将会学习到各种各样的算法函数模板，可以用于刷题和开发小程序，强烈建议订阅一波，持续更新中~~~

求最大公因数

最大公因数，即两个数的公因数(两个数共有的因数,能同时被两个数整除的数)中最大的那个，有化简求解数学问题等等作用。

暴力枚举法

顾名思义，从1开始枚举两个数的最大公因数，直到没有为止，输出。

//C++
#include<iostream>
#include<cmath>
using namespace std;
int mygcd(int x,int y){
    int i;
    for(i=max(x,y);i>=1;i--){ //从最大值开始枚举
        if(x%i==0&&y%i==0)    break;
    }
    return i;
}
int main(){
    int a,b;
    cin>>a>>b;
    cout<<mygcd(a,b);
    return 0;
}

#Python
def mygcd(x,y):
    if(x>y):
        t=y;
    else:
        t=x
    for i in range(1,t+1):
        if (x%i==0) and (y%i==0) :
            ans=i
    return ans
def main():
    a=int(input())
    b=int(input())
    print(mygcd(a,b))

if __name__=='__main__':
    main()

辗转相除法(欧几里得算法)

by BlizzardCan的博客 - 《欧几里得算法（辗转相除法） c++》

大体思路：

欧几里得算法又称辗转相除法，是指用于计算两个非负整数a，b的最大公约数。应用领域有数学和计算机两个方面。计算公式gcd(a,b) = gcd(b,a mod b)。
欧几里得算法是用来求两个正整数最大公约数的算法。古希腊数学家欧几里得在其著作《The Elements》中最早描述了这种算法,所以被命名为欧几里得算法。
扩展欧几里得算法可用于RSA加密等领域。
假如需要求 1997 和 615 两个正整数的最大公约数,用欧几里得算法，是这样进行的：
1997 / 615 = 3 (余 152)
615 / 152 = 4(余7)
152 / 7 = 21(余5)
7 / 5 = 1 (余2)
5 / 2 = 2 (余1)
2 / 1 = 2 (余0)
至此，最大公约数为1
以除数和余数反复做除法运算，当余数为 0 时，取当前算式除数为最大公约数，所以就得出了 1997 和 615 的最大公约数 1。

//C++
#include<iostream>
#include<cmath>
using namespace std;
//采用辗转相除法
int mygcd(int x,int y){
    int tmp;
    while(tmp=x%y){
        x=y;
        y=tmp;
    }
    return y;
}
int gcd(int x,int y){ //类似递归搜索
    if(y==0)    return x;
    else    return gcd(y,x%y);
}
int main(){
    int a,b;
    cin>>a>>b;
    cout<<gcd(a,b)<<" "<<mygcd(a,b);
    return 0;
}

#Python
def mygcd(x,y):
    tmp=x%y;
    while tmp:
        x=y
        y=tmp
        tmp=x%y
    return y

def gcd(x,y):
    if y==0:
        return x
    else:
        return gcd(y,x%y)

def main():
    a=int(input())
    b=int(input())
    print(str(mygcd(a,b))+'  '+str(gcd(a,b)))

if __name__=='__main__':
    main()

辗转相减法

辗转相减法，若两个正整数都为偶数，则用2约简，直到不能约简为止。然后用大数减小数，将差与较小的数比较，再以大数减小数，直到减数和差相等为止。

//C++
#include<iostream>
using namespace std;
//辗转相减
int mygcd(int x,int y){
    while(x!=y){
        if(x<y)    y-=x;
        else    x-=y;
    }
    return x;
}
int main(){
    int a,b;
    cin>>a>>b;
    cout<<mygcd(a,b);
    return 0;
}

#Python
def mygcd(x,y):
    while x!=y:
        if x>y:
            x-=y;
        else:
            y-=x;
    return y

def main():
    a=int(input())
    b=int(input())
    print(mygcd(a,b))

if __name__=='__main__':
    main()

进阶篇——最大公因数类的实现

用类进行函数的封装声明

//C++
#include<bits/stdc++.h>
using namespace std;

class Mygcd{
private:
    int x,y;
public:
    Mygcd():x(0),y(0){}
    Mygcd(int a,int b){ x=a,y=b; }
    void mygcd1(),mygcd2(),mygcd3();
};

//枚举法
void Mygcd::mygcd1(){
    int x=this->x,y=this->y;
    for(int i=max(x,y);i>=1;i--) //从最大值开始枚举
        if(x%i==0&&y%i==0){
            cout<<i<<endl;
            return;
        }
}

//采用辗转相除法
void Mygcd::mygcd2(){
    int x=this->x,y=this->y,tmp;
    while(tmp=x%y){
        x=y;
        y=tmp;
    }
    cout<<y<<endl;
}

//辗转相减法
void Mygcd::mygcd3(){
    int x=this->x,y=this->y;
    while(x!=y){
        if(x<y)    y-=x;
        else    x-=y;
    }
    cout<<x<<endl;
}

int main(){
    int a,b;
    cin>>a>>b;
    Mygcd g(a,b);
    g.mygcd1(); g.mygcd2(); g.mygcd3();
    return 0;
}

#Python
class Mygcd:
    '''求最大公因数的类'''
    def __init__(self):
        self.__x=0
        self.__y=0
    def __init__(self,a,b):
        self.__x=a
        self.__y=b
    def mygcd1(self): #枚举法
        a=self.__x
        b=self.__y
        if(a>b):
            t=b
        else:
            t=a
        for i in range(1,t+1):
            if (a%i==0) and (b%i==0) :
                ans=i
        print(ans)
    def mygcd2(self):
        a=self.__x
        b=self.__y
        tmp=a%b;
        while tmp:
            a=b
            b=tmp
            tmp=a%b
        print(b)
    def mygcd3(self): #辗转相减法
        a=self.__x
        b=self.__y
        while a!=b:
            if a>b:
                a-=b;
            else:
                b-=a;
        print(b)

def main():
    a=int(input())
    b=int(input())
    n=Mygcd(a,b)
    n.mygcd1()
    n.mygcd2()
    n.mygcd3()
    
if __name__=='__main__':
    main()

以上为求最大公因数类的C++和Python实现，大家可以参考改进。

总结

那么今天的分享就到这里啦！如果大家有问题或程序中的错误的话可以留言指出，up主看到及时回复、修改，再见啦！

掰掰ヾ(•ω•`)o