数论（三）——约数（约数个数，约数和，公约数）

试除法求约数

试除法求一个数的所有约数，思路与判断质数的思路一样，优化的方法也是一样的，这里就不再赘述，没有看过我之前关于质数的博客可以点这里。
从小到大枚举所有约数，但是我们只需要枚举每一对儿中较小的一个就可以了。
时间复杂度：O(sqrt(n))

vector<int> get_divisors(int n)
{ 
    vector<int> res;  //vector数组存储一个数的所有约数
    for(int i = 1; i <= n/i; i ++ )
    {
        if(n % i == 0)
        {
            res.push_back(i);
            if(n/i != i) res.push_back(n/i);
        }
    }
    
    sort(res.begin(),res.end()); //排序
    
    return res;
}

求约数个数

基于算数基本定理
约数个数定理

定理证明

也可点击👉：约数个数定理
注：int范围内约数个数最多的一个数，它的约数是1500个左右。

例 给定 n 个正整数 ai，请你输出这些数的乘积的约数个数，答案对 109+7 取模。

#include<iostream>
#include<algorithm>
#include<unordered_map>

using namespace std;

typedef long long LL;

const int mod = 1e9 + 7; 
int main()
{
    int n;
    cin >> n;
    
    unordered_map<int,int> primes; //用hash表存储所有的底数和指数
    while(n -- )
    {
        int x;
        cin >> x;
        
        for(int i = 2; i <= x/i ; i ++ )
            while(x % i == 0)
            {
                x /= i;
                primes[i] ++ ; //i这个质因数的指数＋1
                //primes的下标是质数，存的值是这个质数的指数
            }
        
        if(x > 1) primes[x] ++; //x是大于的sqrt(x)约数 
    }
    
    LL res = 1;
    for(auto prime : primes)
        res = res*(prime.second + 1) % mod;
        
    cout << res;
    
    return 0;
}

约数之和

约数和定理
对于一个大于1正整数n可以分解质因数：n=p1^a1×p2^a2×p3^a3×…×pk^ak,
则由约数个数定理可知n的正约数有(a₁+1)(a₂+1)(a₃+1)…(ak+1)个，
那么n的(a₁+1)(a₂+1)(a₃+1)…(ak+1)个正约数的和为
f(n)=(p1⁰+p1¹+p1²+…p1^a1)(p2⁰+p2¹+p2²+…p2^a2)…(pk⁰+pk¹+pk²+…pk^ak）

证明
证明：若n可以分解质因数：n=p1^a1×p2^a2×p3^a3×…×pk^ak,
可知p1^a1的约数有:p1⁰, p1¹, p1²…p1^a1
…
同理可知，pk^ak的约数有:pk^0, pk^1, pk^2…pkak^ ；
实际上n的约数是在p1^a1、p2^a2、…、pk^ak每一个的约数中分别挑一个相乘得来，
可知共有(a₁+1)(a₂+1)(a₃+1)…(ak+1)种挑法，即约数的个数。
由乘法原理可知它们的和为
f(n)=(p1⁰+p1¹+p1²+…p1^a1)(p2⁰+p2¹+p2²+…p2^a2)…(pk⁰+pk¹+pk²+…pk^ak）

也可以点击👉：约数和定理
例
给定 n 个正整数 ai，请你输出这些数的乘积的约数之和，答案对 109+7 取模。
思路：同样，先分解质因数，带入上面约数和的公式即可。

#include<iostream>
#include<algorithm>
#include<unordered_map>

using namespace std;

typedef long long LL;

const int mod = 1e9 + 7; 
int main()
{
    int n;
    cin >> n;
    
    unordered_map<int,int> primes; //用hash表存储所有的底数和指数
    while(n -- )
    {
        int x;
        cin >> x;
        
        for(int i = 2; i <= x/i ; i ++ )
            while(x % i == 0)
            {
                x /= i;
                primes[i] ++ ; //i这个质因数的指数＋1
                //primes的下标是质数，存的值是这个质数的指数
            }
        
        if(x > 1) primes[x] ++; //x是大于的sqrt(x)约数 
    }
    
    LL res = 1;
    for(auto prime : primes)
    {
        int p = prime.first; //质数的底数
        int a = prime.second; //质数的指数
        LL t = 1;
        while(a -- ) t = (t * p + 1) % mod;
        res = res * t % mod;
    }
    
    cout << res << endl;
    
    return 0;
}

注
while(a- -) t=(t*p+1)%mod;
循环第一次：t=p+1
循环第二次：t=p²+p+1
循环第三次：t=p³+p²+p+1
…
循环第a次：t=p⁰+p¹+p²+…p^a
当然这只是算出了(p1⁰+p1¹+p1²+…p1^a1)，我们还要算p2、p3、…、pk并相乘

欧几里得算法

欧几里得算法，即辗转相除法，是指用于计算两个非负整数a，b的最大公约数。应用领域有数学和计算机两个方面。计算公式gcd(a,b) = gcd(b,a mod b)。
核心原理：gcd(a,b) = gcd(b,a mod b)
一个基本的性质：d | a，d | b，d | (a+b)，d | (ax + by)
（d能整除a，d能整除b，那么d就能整除a+b，也能整除a的若干倍+b的若干倍）

int gcd(int a,int b)
{
    return b ? gcd(b,a % b) : a;
}

b不为0时，最大公约数是gcd(b, a mod b)
b为0时，最大公约数就是a（0可以整除任何数）