数论 --- 约数和定理公式推导、最大公约数、欧几里得算法

试除法求约数

和<试除法判断一个数是不是质数>是一个道理

从小到大枚举所有的约数，如果当前数能整除这个数的话，说明这个数就是当前数的约数

优化，与<试除法判断质数>是一样的

如果 d 是 n 的约数，n / d 也一定能整除 n，一个数的约数也一定是成对出现的，在枚举的时候也可以只枚举较小的那个约数，较大的那个约数可以直接计算，只需要枚举到 d ≤ n / d，d ≤ √ n 就可以了

时间复杂度为 O( n × √ a )，100 × ( √ 2 × 10^9 )

4 w^2 = 1.6 × 10^9 ＜ 2 × 10^9 ＜ 5w^2 = 2.5 × 10^9

4 w ＜ √ 2 × 10^9 ＜ 5w

√ 2 × 10^9 介于 4w 到 5w 之间，整个算法的时间复杂度在 400w 到 500w 之间

数论 --- 朴素筛法、埃氏筛法、线性筛法

#include <iostream>
#include <algorithm>
//用 vector 存储一个数的所有约数
#include <vector>using namesapce std;//试除法求 n 的所有约数
vector<int> get_divisors(int n)
{//答案数组vector<int> res;//从小到大枚举 n 的所有约数 但是只枚举每一对约数里面较小的那个for(int i = 1;i <= n / i;i++ )//如果 n % i == 0,i 一定是 n 的约数 if(n % i == 0){res.push_back(i);//n / i 也是约数,但是需要判断边界情况:有可能 n 是 i 的平方,两个约数一样,但是输出的时候不能重复if(i != n / i) res.push_back(n / i); }//给约数排序sort(res.begin(),res.end());return res;
}int main()
{int n;cin >> n;while(n-- ) {int x;cin >> x;//求所有的约数auto res = get_divisors(x);//遍历然后输出for(auto t : res) cout << t << ' ';cout << endl;         }return 0;
}

求一个数的所有约数个数、所有约数之和

基于算术基本定理，对于一个整数 N 分解质因数的结果为 p1^α1 * p2^α2 * . . . * pk^αk
约数个数：(α1 + 1) * (α2 + 1) * . . . * (αk + 1)，N 的约数个数和选法个数是一样的，乘法原理
约数之和：(p1^0 + p1^1 + . . . + p1^α1) * . . . * (pk^0 + pk^1 + . . . + pk^αk)

int 范围内约数个数最多的一个数最多有 1500 个约数

时间复杂度为 O( n )

给定 n 个整数 a1 ~ an，要求统计所有数乘积 a1 × a2 × . . . × an 的约数个数，先求 a1 ~ an 每一个数分解质因数的结果，然后把每一个数的指数累加在一起就可以了，从 a1 开始分解，一直分解到 an，假设求出来 a1 的某一个质因子 pi 的指数是 αi，可以用一个哈希表或者 map 把它存储下来，把每一项都分解完之后，map 中存储了整个乘积的因式分解的底数和指数，最终约数个数就是所有指数加 1 再相乘

#include <iostream>
#include <algorithm>
// 这里选择使用哈希表
#include <unordered_map>using namesapce std;typedef long long LL;
const int mod = 1e9 + 7; int main()
{int n;cin >> n;// 定义哈希表存储所有底数和指数unordered_map<int,int> primes;while(n --){int x;// 读入 x 然后把 x 分解cin >> x;// 从 2 开始枚举 分别分解每一个数,首先对于 a1 来说,把 a1 的所有质因子的次数找出来然后累加就可以了for(int i = 2;i <= x / i;i++ )while(x % i == 0){x /= i;// i 的质因数的指数 + 1 最终 primes 里面存储了所有质因数的指数primes[i] ++;}//特判 x > 1 说明 x 是一个比较大的质因数 把剩下这个质因数加上就可以了if(x > 1) primes[x] ++;}LL res = 1;// 枚举所有质因数 答案就是所有的指数 + 1 再相乘for(auto prime : primes) res = res * (prime.second + 1) % mod;cout << res << endl;return 0;
}

只要能求出一个数质因数分解的结果，就可以分别求出约数个数和约数之和

求约数之和：也需要先分解质因数，然后直接带入求和公式就可以了

#include <iostream>
#include <algorithm>
// 这里选择使用哈希表
#include <unordered_map>using namesapce std;typedef long long LL;
const int mod = 1e9 + 7; int main()
{int n;cin >> n;// 定义哈希表存储所有底数和指数unordered_map<int,int> primes;while(n --){int x;// 读入 x 然后把 x 分解cin >> x;// 从 2 开始枚举 分别分解每一个数,首先对于 a1 来说,把 a1 的所有质因子的次数找出来然后累加就可以了for(int i = 2;i <= x / i;i++ )while(x % i == 0){x /= i;// i 的质因数的指数 + 1 最终 primes 里面存储了所有质因数的指数primes[i] ++;}//特判 x > 1 说明 x 是一个比较大的质因数 把剩下这个质因数加上就可以了if(x > 1) primes[x] ++;}LL res = 1;// 枚举所有质因数 答案就是所有的指数 + 1 再相乘for(auto prime : primes) {//先枚举每一个质数 p表示这个质数的底数 a表示这个质数的指数int  p = prime.first,a = prime.second;//需要求出来 p^0 + p^1 + ... + p^a//用 t 来表示总和,t 从 1 开始LL t = 1;//执行 a 次 t * p + 1 就可以得到 p^0 + p^1 + ... + p^awhile(a -- ) t = (t * p + 1) % mod;res = res * t % mod;}cout << res << endl;return 0;
}

公式推导：约数和定理，约数个数定理

怎么求一个数的约数呢？

利用短除法对 72 进行分解质因数得到 72 = 2^3 × 3^2，2 是质数，3 是质数，2 与 3 都是 72 的质因数

为什么要对 72 进行分解质因数呢？

因为 72 这个合数的任意一个约数，都可以表示成 2^x 3^y

无论多大的数只要能够分解质因数，都能够把它的约数造出来

接下来求 360 的正约数，我们通过短除法把它的正约数造出来，有多少种造法就有多少个正约数

利用原材料 2，可以取零个 2、一个 2、两个 2、三个 2，一共有 4 种方法

利用原材料 3，一共有 3 种方法

利用原材料 5，一共有 2 种方法

把每个质因数上的指数 + 1 再相乘，就得到某一个数的正约数的个数

接下来求所有正约数之和，首先如果要把 360 的正约数全部穷举出来就是一个不小的工程，还需要求和，工程较大，容易出错，因此我们还是用造的思想把约数给造出来

我们可以利用分类讨论的思想，以 2 为原材料可以造出 2^0、2^1、2^2、2^3，以 2 和 3 为原材料，以此类推

第一类方案与第二类方案的总数之和如下

利用 2、3、5 与利用 2、5 来造 360 的约数，可以发现 2、3 已经造好了，只需要乘上一个 5 就可以了

在利用 2、3、5 造约数的过程中，已经把 3、5 的情况包括在内： 2^0 × 3^1、2^0 × 3^2

得到最终所有正约数的总和就是 ( 2^0 + 2^1 + 2^2 + 2^3) × (3^0 + 3^1 + 3^2) × (1 + 5^1)

不穷举，采用提取公因式的方式，先得到 2 和 3 参与的，后得到 2、3、5 参与的

欧几里得算法 / 辗转相除法

数论中的基本性质：

如果 d 能整除 a，并且 d 能整除 b，d 就能整除 a + b，也能整除 a 的若干倍 + b 的若干倍

辗转相除法的核心原理：

利用这个性质，a 和 b 的最大公约数等于 b 和 a mod b 的最大公约数

怎么证明左右两边的最大公约数是相同的呢？

a 和 b 的最大公约数等于 b 和 a - c × b 的最大公约数

证明可以利用如下性质

对于左边的任何一个公约数 d 能整除 a，d 能整除 b，所以 d 能整除 b，所以 d 能整除 a - c × b，所以左边的任何一个公约数都是右边的一个公约数

证明右边的任何一个公约数也是左边的一个公约数

d 能整除 b，d 能整除 a - c × b，所以 d 能整除 b，只需要证明 d 能整除 a 就可以了

d 能整除 a - c × b，所以 d 能整除 a - c × b × 1 + b × c，抵消后 d 能整除 a，所以右边任何一个公约数都是左边的一个公约数

同样左边任何一个公约数都是右边的一个公约数，所以这两个公约数的集合相同的，最终得证左边的最大公约数等于右边的最大公约数，所以可以直接用性质来计算最大公约数

最大公约数

给出 n 组 a、b，求每一组的最大公约数，时间复杂度 O( logn )

#include <iostream>using namespace std;
// 返回 a 和 b 的最大公约数
int gcd(int a,int b)
{// 如果 b 不是 0,返回 gcd(b,a % b),当 b 等于 0 的时候,a 和 0 的最大公约数一定是 a,因为 0 可以整除任何数return b ? gcd(b,a % b) : a;
}int main()
{int n;scanf("%d",&n);while(n-- ){int a,b;//每次读入两个数scanf("%d%d",&a,&b);//返回 a 和 b 的最大公约数printf("%d\n",gcd(a,b));}return 0;
}