数论入门学习

探索质数世界：判断、分解与高效算法

最新推荐文章于 2024-08-21 21:29:24 发布

原创最新推荐文章于 2024-08-21 21:29:24 发布 · 1.3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

算法专栏收录该内容

16 篇文章

订阅专栏

本文详细介绍了质数的概念、判断方法（包括朴素法和优化版）、分解质因数、质数筛法（包括朴素筛、埃氏筛和线性筛）、试除法求解约数、以及约数个数和和的计算。同时涵盖了欧几里得算法的应用。适合初学者理解质数基础及其在编程中的应用。

一、什么是质数

质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

算数基本定理，也叫唯一分解定理。任何一个大于1的自然数 N,如果N不为质数，那么N可以唯一分解成有限个质数的乘积N=P1a1P2a2P3a3......Pnan，这里P1<P2<P3......<Pn均为z质数，其中指数ai是正整数。

二、如何判断质数

1.朴素法（暴力枚举）

暴力遍历[2,x）之间的所有数字，判断能否整除，时间复杂度O(n)

bool is_prime(int x) {
    if (x < 2) return false;
    for (int i = 2; i < x; i++) {
        if (x % i == 0) return false;
    }
    return true;
}

2.优化

对于一个整数n, 如果n整除p，那么n也整除 n /p，因此可以将枚举的范围从[0, n]降到[0, $\sqrt{n}$ ];时间复杂度O( $\sqrt{n}$ )

bool is_prime(int x) {
    if (x < 2) return false;
    for (int i = 2; i <= x / i; i++) {
        if (x % i == 0) return false;
    }
    return true;
}

三、分解质因数

问题：获取给定的数字n的所有质因数以及质因数的数量；即分解定理中的p和正整数a

void divide(int x) { 
    for (int i = 2; i <= x; i++) {
        if (x % i == 0) { // i一定是一个质数
            int res = 0;
            while (x % i == 0) {
                x /= i;
                res ++;
            }
            cout << i << " " << res << endl;
        }
    }
    cout << endl;
}

对于 x % i == 0此时的i一定是质数；当处理这段话的时候，x此时一定处理了[2, i - 1]之间的所有质数，即当前x不能被[2, i - 1]中的质数整除；假设i不是质数，那么肯定[2, i - 1]中的某个质数，假设不成立；所以此时 i 一定是一个质数

时间复杂度O(n)

- 如何优化？考虑将范围降到[2, $\sqrt{n}$ ], 更改循环条件： i <= x / i

存在结论：至少存在一个质数i >= $\sqrt{n}$ ; 假设存在两个大于 $\sqrt{n}$ 的质数的情况，那么这两个数的乘积一定大于n，假设不成立。

void divide(int x) { // logn ~ 根号n之间的时间复杂度
    for (int i = 2; i <= x / i; i++) {
        if (x % i == 0) { // i一定是一个质数
            int res = 0;
            while (x % i == 0) {
                x /= i;
                res ++;
            }
            cout << i << " " << res << endl;
        }
    }
    if (x > 1) cout << x << " 1" << endl; 
    cout << endl;
}

时间复杂度O( $\sqrt{n}$ ), 但是实际上时间复杂度并不会这么高，如果n是2的整数次幂，那么在2的时候n就可以被整除，所以时间复杂度降为O(logn)；因此实现的时候，只需要在最后额外判断一次就可以

四、质数筛法

1.朴素筛法

循环[2, n], 每次将i的整数倍直接筛掉

void attainPrime(int n) {
    // 朴素版
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) primes[res ++] = i; // primes用来记录质数
        // 删掉i的倍数
        for (int j = i + i; j <= n; j += i) vis[j] = true;
    }
}

当 $n \to$ $\infty$ 时，筛选次数为 $\sum ({1/2 + 1/3 + .... + 1/ n})$ , 调和级数发散，趋近于O(logn)

2. 埃式筛法

思想：相比于朴素筛，埃式筛法并不是筛掉所有[2, n]数字的倍数，而是仅仅筛掉质数的倍数

将2到n范围内的所有整数写下来。其中最小的数字2是素数。将表中所有2的倍数都划去。表中剩余的最小数字是3，它不能被更小的数整除，所以是素数。再将表中所有3的倍数都划去。依此类推

void attainPrime(int n) {
    // 埃式筛法
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) {
            primes[res ++] = i;
            // 只删除质数的倍数
            for (int j = i + i; j <= n; j += i) vis[j] = true;
        }
    }
}

时间复杂度O(nlognlogn)

3.线性筛

在埃式筛法的思想基础上，每次只用最小质因子删除，保证每个数只被删除一次，这样就将时间复杂度降到了O(n)

void attainPrime(int n) {
    // 埃式筛法
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) {
            primes[res ++] = i;
        }
        // 用最小质因子筛
        for (int j = 0; primes[j] <= n / i; j++) {
            vis[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

算法正确性在于：i % primes[j] (后面使用pj）

由于pj是从小到大排序的，所以pj一定是当前数的最小质因子

五、试除法求解约数

如果 d | a，那么 d / i | a，因此可以缩小范围

stack<int> st;
    for (int i = 1; i <= x / i; i++) {
        if (x % i == 0) {
            cout << i << " ";
            if (x / i != i) st.push(x / i);
        }
    }
    // i 是从小到大枚举的，所以通过stack将 x / i 逆序
    while (st.size()) {
        cout << st.top() << " ";
        st.pop();
    }

六、约数的个数以及约数之和

约数个数： 根据唯一分解定理，每一个x都可以分解成质因子的整数次幂的乘积。相应的每一个质因子的整数次幂就是个数，乘积的约数个数就是（a1 + 1）* (a2 + 1) * ... * (an + 1)

    LL res = 1;
    unordered_map<int, int> um;
    while (n --) {
        int x;
        cin >> x;
    
        for (int i = 2; i <= x / i; i++) {
            while (x % i == 0) {
                x /= i;
                um[i] ++;
            }
        }
        if (x > 1) um[x] ++;
    }
    for (auto m : um) {
       res = res * (m.second + 1) % MOD;
    }

约数之和：根据唯一分解定理，每一个x都可以分解成质因子的整数次幂的乘积。相应的每一个质因子的整数次幂就是个数，乘积的约数之和就是（a1^0 + a1 ^ 1 + ... + a1 ^ n）* （a2^0 + a2 ^ 1 + ... + a2 ^ n）* （an^0 + an ^ 1 + ... + an ^ n）

    LL res = 1;
    unordered_map<int, int> um;
    while (n --) {
        int x;
        cin >> x;
    
        for (int i = 2; i <= x / i; i++) {
            while (x % i == 0) {
                x /= i;
                um[i] ++;
            }
        }
        if (x > 1) um[x] ++;
    }
    for (auto m : um) {
       int p = m.first, number = m.second;
       LL res1 = 1;
       while (number --) res1 = (p * res1 + 1) % MOD;
       res = res * res1 % MOD;
    }

七、欧几里得算法（辗转相除法）

关键公式：gcd(a, b) = gcd(b, a % b)

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

总结

emmm，简单整理下质数的学习，判断质数，分解质因子以及几种筛法，数学证明自己也并没完全掌握，希望在整理过程中能够加深理解。书写中还会存在不严谨的地方，还望指正。

描述的都是一些模板题，我还在初学当中

题目均来自Acwing官网，可以参考学习 AcWing一个专属于程序员的平台，为大家在漫漫的刷题之旅中，提供最优质的解答https://www.acwing.com/about/