一文搞懂质数以及质数的筛法

唯一分解定理：$对于任何一个数n={\prod }_{i=1}^s{p}_i^{k_i}$

1. 质数：

大于1的整数中，如果只包含1和本身的这两个约数，那么就被叫做质数（素数）

找质数的方法：

1. 质数的判定 – 试除法； 暴力
2. 优化版， 对于 d | n , 那么n / d | n, 这些约数是成对出现的， 推导 对于所有存在的d 都有$d\le \frac{n}{d}$ 得出 $d^2\le n$ ，即$d\le \sqrt{n}$

试除法

function devide(n){
    for(let i = 2;i <= n;i ++){
        if(n % i === 0){
            let s = 0;
            while(n % i === 0){
                n /= i;
                s ++;
            }
            console.log(i, s);
        }
    }
}

一些推论： n中最多只包含一个大于sqrt（n）的质因子

因此只需要枚举到sqrt(n)， 然后再判断是否n> 1(即看有没有除尽), 有则剩余的这个数一定是那个大于sqrt（n）的质因子

优化后的代码：

function devide(n){
    for(let i = 2;i <= n / i;i ++){
        let s = 0;
        while(n % i === 0){
            n /= i;
            s ++;
        }
        console.log(i, s);
    }
    if(n > 1) console.log(n, 1);
}

筛素数的方法：

2. 筛质数

1. 朴素筛法

核心思想就是用当前数把他的倍数全部删掉

const primes = [];
const st = new Array(100).fill(false);


function get_primes(n){
    for(let i = 2;i <= n;i ++){
        if(!st[i]) {
            primes.push(i);
        }

        for(let j = 2; i * j <= n;j ++){
            st[i * j] = true;
        }
    }
}

2. 埃氏筛法

(这种算法的思想很重要， 用已经得到的结论去消除未来的部分不定数)

一个合数一定是由质数的多少次方构成的形式 x = p₁^s1p₂^s2 p₃^s3… p_k^sk， 因此只需要拿质数去筛即可。

const primes = [];
const st = new Array(100).fill(false);

const rl = require("readline").createInterface({
    input: process.stdin,
    output: process.stdout
});

function get_primes(n){
    for(let i = 2;i <= n;i ++){
        if(!st[i]) {
            primes.push(i);
            for(let j = 2; i * j <= n;j ++){
                st[i * j] = true;
            }
        }        
    }

    return primes.length;
}

rl.on('line', str => {
    console.log(get_primes(+str))
})

3. 线性筛法

核心思想： 就是用质数去把当前的合数筛掉，并且保证是用当前最小的素数筛掉的

线性筛法的证明：

对于当前的数i， 我们得到了所有2-i的质数的primes数组

然后从小到大去枚举primes数组，$i\times primes[j]$ 一定是合数，我们标记为true.

我们要遵循每一个合数只被最小的质数筛掉。(下面所有的primes[j] 都写成pj)

• $i\%pj\ne 0$； 说明i和pj是互质的，并且pj一定是小于i的(因为primes数组中的数是2-i当中所有的质数)，因此i * pj的最小质因数是pj。
• $i\%pj=0$; 由于从小到大枚举的primes，pj是i的最小质因子，$i\times pj$的最小质因子是pj。然后我们再往下枚举$i\times p_{j+1}$的时候，i的最小的质因子是pj， $p_{j+1}>pj$ ， $i\times p_{j+1}$的最小质因子是pj,，因此该数应该被pj所筛掉，也就是该数在之前就被晒掉了。所以j之后的数不做处理。

const primes = [];
const st = new Array(100).fill(false);

function get_primes(n){
    for(let i = 2;i <= n;i ++){
        if(!st[i]) primes.push(i);
        for(let j = 0;primes[j] <= n / i;j ++){
            st[primes[j] * i] = true;
            if(i % primes[j] === 0) break; 
        }
    }
}
枚举

3. 筛约数

1. 试除法求所有的约数

function get_divisors(n){
    const res = [];
    for(let i = 2;i <= n / i;i ++){
        if(n % i === 0){
            res.push(i);
            i != n / i && res.push(n / i);
        }
    }
    console.log(res.sort((a, b) => a - b))
}

get_divisors(300);

4. 约数个数

由于唯一分解定理$n=p_1^{s_1}\times p_2^{s_2}\times ...\times p_k^{s_k}$， 对于$p_1^{s_1}$的约数有$p_1^0$, $p_1^1$, …, $p_1^{s_1}$共s1 + 1个，根据乘法原理得到$n$的约数个数为${\prod }_{i=1}^k(s_i+1)$

5. 约数之和

这个原理如出一辙，不多赘述 ，记公式。

$(p_1^0+p_1^1...+p_1^{s_1})(p_2^0+p_2^1...+p_2^{s_2})...(p_k^0+p_k^1...+p_k^{s_k})$