1.试除法

思路分析：利用试除法求一个数的所有约数，思路和判断和求质数的判定类似

一个数N有一个约数d，那么N/d也必然是其约数

约数都是成对出现的，只需要枚举1到$\sqrt{n}$即可，注意不要让一个约数加入两次!

Acwing 869 试除法求约数

实现思路：这里使用vector存储最终结果，便于进行最后的排序输出
具体实现代码（详解版）：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 函数：获取给定整数的所有因子
vector<int> get_divisors(int x) {
    vector<int> res; // 用于存储因子的向量
    for (int i = 1; i <= x / i; i++) { // 遍历1到√x
        if (x % i == 0) { // 如果i是x的因子
            res.push_back(i); // 添加i
            if (i != x / i) // 确保不重复添加平方根
                res.push_back(x / i); // 添加x / i
        }
    }
    sort(res.begin(), res.end()); // 对因子进行排序
    return res; 
}

int main() {
    int n; 
    cin >> n; 
    while (n--) { 
        int x;
        cin >> x; 
        vector<int> divisors = get_divisors(x); // 获取x的因子
        for (auto item : divisors) { // 输出因子
            cout << item << " ";
        }
        puts(""); 
    }

    return 0; 
}

2.求约数个数

$$将一个数N分解质因数为N=P_1^{{\alpha }_1}\times P_2^{{\alpha }_2}\times P_3^{{\alpha }_3}\cdots \times P_n^{{\alpha }_n}$$

$$定理1：约数的个数为({\alpha }_1+1)\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_n+1)$$

对于定理1：N可以分解为以上n个质数的αi次方的乘积，又因为N的每一个约数d都相当于在这n个pi中每个pi分别取0~αi次，每一种选法的各个质因子相乘就是N的一个约数

eg：
$$12=2^2\ast 3^1$$

• 取0 个 2 和 0 个 3 ， 得 约 数 1
• 取1 个 2 和 0 个 3 ， 得 约 数 2
• 取2 个 2 和 0 个 3 ， 得 约 数 4
• 取0 个 2 和 1 个 3 ， 得 约 数 3
• 取1 个 2 和 1 个 3 ， 得 约 数 6
• 取2 个 2 和 1 个 3 ， 得 约 数 12

(2+1)*(1+1)=6种取法，则12有6个约数，即1，2，3，4，6，12

Acwing870. 约数个数

实现思路：对每次输入的整数$a_i$都分解得到其质因数，并得到对应质因数的指数

• 使用一个哈希表来存储对于质因数与其指数对应的关系；
• • unordered_map<int,int> primes:使用map实现哈希表，t.first 是质因数，t.second 是该质因数的幂次

具体实现代码（详解版）：

#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;

typedef long long LL;
const LL mod = 1e9 + 7; // 定义一个大素数mod，用于防止结果过大

int main(){
    int n;
    cin >> n; 
    unordered_map<int, int> primes; // 用哈希表存储质因数及其对应的指数（幂次）

    // 处理n个数，逐个分解质因数
    while (n--) {
        int x;
        cin >> x; 
        // 分解质因数，从2开始尝试，直到i*i <= x
        for (int i = 2; i <= x / i; i++) {
            // 如果x能被i整除，说明i是x的一个质因数
            while (x % i == 0) {
                x /= i; // 不断除以i，直到不能整除为止
                primes[i]++; // 将质因数i的幂次+1
            }
        }
        // 如果x大于1，说明x本身是一个质数
        if (x > 1) primes[x]++; // 将该质数记为x^1
    }

    LL res = 1; 
    // 遍历所有质因数及其幂次，计算 (幂次+1) 的乘积
    for (auto t : primes) {
        // t.first 是质因数，t.second 是该质因数的幂次
        res = res * (t.second + 1) % mod; // 乘以(幂次+1)，并在每一步进行取模运算，防止溢出
    }

    cout << res << endl; 

    return 0; 
}

3.求约数之和

Acwing 871 .约数之和

再在上面的基础上
$$对于12=2^2\ast 3^1来说，其约数之和为2^0\ast 3^0+2^1\ast 3^0+2^2\ast 3^0+2^0\ast 3^1+2^1\ast 3^1+2^2\ast 3^1=(2^0+2^1+2^2)\ast (3^0+3^1)$$
得到定理2：约数之和
$$定理2：所有约数之和为(P_1^0+P_1^1+\cdots +P_1^{{\alpha }_1})\times (P_2^0+P_2^1+\cdots +P_2^{{\alpha }_2})\times \cdots \times (P_n^0+P_n^1+\cdots +P_n^{{\alpha }_n})$$

具体实现代码（详解版）

#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;

typedef long long LL;
const LL mod = 1e9 + 7; // 定义一个大素数mod，用于防止结果过大

int main(){
    int n;
    cin >> n; 
    unordered_map<int, int> primes; // 用哈希表存储质因数及其对应的指数（幂次）

    // 处理n个数，逐个分解质因数
    while (n--) {
        int x;
        cin >> x; 
        // 分解质因数，从2开始尝试，直到i*i <= x
        for (int i = 2; i <= x / i; i++) {
            // 如果x能被i整除，说明i是x的一个质因数
            while (x % i == 0) {
                x /= i; // 不断除以i，直到不能整除为止
                primes[i]++; // 将质因数i的幂次+1
            }
        }
        // 如果x大于1，说明x本身是一个质数
        if (x > 1) primes[x]++; // 将该质数记为x^1
    }

    LL res = 1; // 初始化最终结果为1
    // 遍历所有质因数及其幂次，计算 (p^q + 1) 的乘积
    for (auto t : primes) {
        // t.first 是质因数 p，t.second 是该质因数的幂次 q
        int p = t.first, q = t.second; 
        LL ans = 1; // 用于计算 (p^q + 1) 的结果
        LL p_pow = 1; // 逐步计算 p 的幂次

        // 计算 p^q + p^(q-1) + ... + p + 1
        while (q--) {
            p_pow = p_pow * p % mod; // 计算 p 的幂次，并取模
            ans = (ans + p_pow) % mod; // 计算 (p^q + ... + 1)，并取模
        }

        // 将每个质因数的结果乘入总结果 res，并再次取模
        res = res * ans % mod;
    }

    cout << res << endl; // 输出最终结果

    return 0; 
}

4.最大公约数

根据一个显然的性质：若d能整除b，d能整除a，即d是a和b的公约数，则d能整除a*x+b*y

求a和b的最大公约数-----欧几里得算法（辗转相除法）：gcd(a,b) == gcd(b, a % b)

即a和b的最大公约数=b和a%b的最大公约数，时间复杂度O(logn)

**理解：**可知a mod b= a - [a/b]*b （[a/b]表示取整），这里简便表示，写为 a mod b= a - c*b

• 左到右：设a和b的最大公约数是k。由以上显然的性质可得k能整除a，k能整除b，则k能整除（a-c*b）
• 右到左：设b和a%b的最大公约数是k。因为k能整除b，k能整除a-c*b，则k能整除(a-c*b+c*b)即a

Acwing 872.最大公约数

具体实现代码（详解版）：

#include <iostream>

using namespace std;

//欧几里得法算gcd
int gcd(int a,int b){
    return b ? gcd(b, a % b) : a;
}

int main(){
    int n;
    cin >> n;
    while(n --){
        int a,b;
        cin >> a >> b;
        cout << gcd(a,b) << endl;
    }
    return 0;
}