算法【质数判断、质因子分解、质数筛】

本文讲解判断值较小的数字是否为质数、判断值较大的数字是否为质数，了解Miller-Rabin测试的大概过程 + 会用模版即可、某个数字所有质数因子的分解，掌握最常用的方法足够了、找出1~n范围内所有的质数，埃氏筛、欧拉筛，其实掌握埃氏筛足够。

判断n是否是质数，Miller-Rabin测试大概过程：

1.每次选择1 ~ n-1范围上的随机数字，或者指定一个比n小的质数，进行测试

2.测试过程的数学原理不用纠结，不重要，因为该原理除了判断质数以外，不再用于别的方面

3.原理：费马小定理、Carmichael(卡米切尔数)、二次探测定理(算法导论31章)、乘法同余、快速幂

4.经过s次Miller-Rabin测试，s越大出错几率越低，但是速度也会越慢，一般测试20次以内即可

重点是用法，因为有乘法同余，所以想验证任意的long类型的数字，需要注意位数的事情。时间复杂度O( s * (logn)的三次方 )，速度很快。

埃氏筛，时间复杂度O(n * log(logn))

欧拉筛，时间复杂度O(n)

其实掌握埃氏筛足够了，因为时间复杂度非常接近线性了，而且常数时间很不错

下面通过题目加深理解。

题目一

判断较小的数字是否是质数

分析：只需要从2到根号n范围内没有整除n的数，那么n就是质数。因为开根运算会导致小数，所以判断条件用i平方和n比较。代码如下。

class Solution {
public:
    bool isPrime(long long n) {
        if(n <= 1){
            return false;
        }
        for(long long i = 2;i * i <= n;++i){
            if(n % i == 0){
                return false;
            } 
        }
        return true;
    }
};

题目二

测试链接：U148828 素数判断(Miller-Rabin模板) - 洛谷

分析：因为有乘法同余，所以想验证任意的long类型的数字，需要注意位数的事情。下面是一个c++模版。

#include <iostream>
#include <vector>
using namespace std;

typedef __int128 ll;
typedef pair<int, int> pii;

template<typename T> inline T read() {
    T x = 0, f = 1; char ch = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
    for(; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch - '0');
    return x * f;
}

template<typename T> inline void write(T x) {
    if(x < 0) putchar('-'), x = -x;
    if(x > 9) write(x / 10);
    putchar(x % 10 + '0');
}

template<typename T> inline void print(T x, char ed = '\n') {
    write(x), putchar(ed);
}

ll t, n;

ll qpow(ll a, ll b, ll mod) {
    ll ret = 1;
    while(b) {
        if(b & 1) ret = (ret * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }
    return ret % mod;
}

vector<ll> p = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};

bool miller_rabin(ll n) {
    if(n < 3 || n % 2 == 0) return n == 2;
    ll u = n - 1, t = 0;
    while(u % 2 == 0) u /= 2, ++ t;
    for(auto a : p) {
        if(n == a) return 1;
        if(n % a == 0) return 0;
        ll v = qpow(a, u, n);
        if(v == 1) continue;
        ll s = 1;
        for(; s <= t; ++ s) {
            if(v == n - 1) break;
            v = v * v % n;
        }
        if(s > t) return 0; 
    }
    return 1;
}

int main() {
    t = read<ll>();
    while(t --) {
        n = read<ll>();
        if(miller_rabin(n)) puts("Yes");
        else puts("No");
    }
    return 0;
}

题目三

测试链接：952. 按公因数计算最大组件大小 - 力扣（LeetCode）

分析：首先，对数进行质因子分解，对于分解出的质因子如果有其他数也有这个质因子，那么将这两个数所属的集合合并，这就需要用到并查集（详情见拙作 算法【并查集】）。遍历完所有数后，找到个数最多的集合，即是答案。代码如下。

class Solution {
public:
    int father[20001];
    int size[20001];
    vector<int> factors;
    void build(int length){
        for(int i = 0;i < length;++i){
            father[i] = i;
            size[i] = 1;
        }
        factors.reserve(100001);
        factors.assign(100001, -1);
    }
    int find(int i){
        if(i != father[i]){
            father[i] = find(father[i]);
        }
        return father[i];
    }
    void Union(int a, int b){
        int fa = find(a);
        int fb = find(b);
        if(fa != fb){
            father[fa] = fb;
            size[fb] += size[fa];
        }
    }
    int maxSize(int length){
        int ans = 0;
        for(int i = 0;i < length;++i){
            ans = max(ans, size[i]);
        }
        return ans;
    }
    int largestComponentSize(vector<int>& nums) {
        int length = nums.size();
        build(length);
        for(int i = 0, x;i < length;++i){
            x = nums[i];
            for(int j = 2;j * j <= x;++j){
                if(x % j == 0){
                    if(factors[j] == -1){
                        factors[j] = i;
                    }else{
                        Union(factors[j], i);
                    }
                    while (x % j == 0)
                    {
                        x /= j;
                    }
                    
                }
            }
            if(x > 1){
                if(factors[x] == -1){
                    factors[x] = i;
                }else{
                    Union(factors[x], i);
                }
            }
        }
        return maxSize(length);
    }
};

题目四

测试链接：204. 计数质数 - 力扣（LeetCode）

分析：对于这类题，只需掌握埃氏筛就足够了。基本原理是默认都是质数，从2开始遍历，如果当前遍历到的数是“质数”，注意，这里的“质数”是默认都是质数之后如果没说它不是质数那它就是质数，从当前数乘当前数开始，每次加当前数直到最大边界，遍历的所有数都更新为不是质数。遍历完后，统计剩下的未被更新为质数的数，就都是质数。代码如下。

class Solution {
public:
    int countPrimes(int n) {
        vector<bool> is;
        is.reserve(n);
        is.assign(n, true);
        int ans = 0;
        for(int i = 2;i * i < n;++i){
            if(is[i]){
                for(int j = i * i;j < n;j += i){
                    is[j] = false;
                }
            }
        }
        for(int i = 2;i < n;++i){
            if(is[i]){
                ++ans;
            }
        }
        return ans;
    }
};