质数与合数

---

一、基本定义

1.约数与倍数

设 a,b 是两个整数，且 a != 0，如果存在另一个整数 q，使得 b = aq，那么就说 b 可被 a 整除，记作 a | b，且称 b 是 a 的 倍数，a 是 b 的约数。

【整除的3个常用性质】

（1）若 a | b 且 b | c，那么 a | c.
（2）若 a | b 且 a | c，那么对任意的整数 x, y，有 a | (bx + cy).
（3）设整数 m != 0，那么 a|b 等价于 ma | mb.

2.质数

设正整数 p != 0,1，如果它除了 1 和 p 本身外没有其他的约数，那么就称 p 为质数。

3.合数

若正整数 a != 0,1，且 a 不是质数，则称 a 为合数。

---

二、质数的判定

1.朴素试除法

时间复杂度为O(n). 如下所示：

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

2.优化后的试除法

优化：当一个数不是质数时，必定存在两个约数，一个大于等于sqrt(n)，另一个小于sqrt(n)，所以可以优化，只判断能否被小于sqrt(n)的数整除。

由于 sqrt() 函数运行比较慢，而 i * i <= n 可能会带来溢出，所以最佳写法是 i <= n / i 。时间复杂度为O(sqrt(n)). 如下所示：

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

---

三、分解质因数——试除法

思路：从小到大尝试 n 的所有因数，每个正整数都能够以唯一的方式表示成它的质因数的乘积。

结论：n 中最多只包含一个大于 sqrt(n) 的因子。
反证法证明：如果有两个大于sqrt(n) 的因子，那么相乘会大于 n。于是我们发现只有一个大于sqrt(n)的因子，可以对其进行优化。如果最后 n 还是 >1，说明这就是大于 sqrt(n) 的唯一质因子，输出即可。

时间复杂度为 O(log n) ~ O(sqrt(n)). 如下所示：

void divide(int x){
    for (int i = 2; i <= x / i; i++){
        if (x % i == 0)
        {
            int s = 0;
            while (x % i == 0)
            {
                x /= i;
                s++;
            }
            
            printf("%d %d\n", i, s);
        }
    }
    
    if (x > 1)
        printf("%d %d\n", x, 1);
    puts("");
}

---

四、筛质数

1.朴素筛法

思路：从 2 到 n 枚举，（一个数的倍数一定是合数）筛掉它的倍数，如果该数没有被筛掉，那它就是一个质数。

时间复杂度为 O(n log n). 如下所示：

int primes[N]；//存素数
int cnt;//记录素数个数
bool st[N];//标记该数是否被筛掉，默认为false，没有被筛掉

void get_primes(int n){
    for (int i = 2; i <= n; i++){
        if (!st[i])//如果没有被筛掉
        {
            //把素数存起来
            primes[cnt++] = i;
        }
        
        for (int j = i; j <= n; j += i)//不管是合数还是质数，都用来筛掉它后面的倍数
            st[j] = true;
    }
}

2.埃氏筛法

（1）调和级数：当 n 趋于无穷大时，1 + 1/2 + 1/3 + … + 1/n = ln n + C.

（2）对朴素筛法的优化：任何一个合数都能写成几个质数相乘的形式。只需要判断 2~n-1 中的所有质数，只要它不是 n 的约数，那么 n 就是一个质因数。

（3）质数定理：1~n 当中有 n/ln n 个质数。

（4）思路：从小到大枚举所有的质数，然后删去它们的所有的倍数，就删去了所有的合数，剩下的就是质数。

时间复杂度为 O(n ln ln n). 如下所示：

int primes[N];//存素数
int cnt;//记录素数个数
bool st[N];//标记该数是否被筛掉，默认为false，没有被筛掉

void get_primes(int n){
    for (int i = 2; i <= n; i++){
        if (!st[i]){
            primes[cnt++] = i;
            for (int j = i; j <= n; j += i)//用质数把所有的合数都筛掉
                st[j] = true;
        }
    }
}

3.欧拉筛法（线性筛）

核心思路：用最小质因子去筛合数。

当 i % primes[j] != 0 时，
说明此时遍历到的 primes[j] 不是 i 的质因子，只可能是此时 primes[j] 的最小质因子，
所以 primes[j] * i 的最小质因子就是 primes[j].

当有 i % primes[j] == 0 时，
因为我们是从小到大遍历的，说明此时的 prime[j] 是满足条件的第一个数，即找到了primes[j] 就是 i 的最小质因子，
因此 primes[j] * i 的最小质因子也就是 primes[j]，
之后用 st[primes[j + 1] * i] = true 去筛合数时，就不是用最小质因子去更新了，
所以此时应该退出循环，避免重复筛选。

如下所示：

int primes[N];//存质数
int cnt;//记录素数个数
bool st[N];//i为质数则为false否则为true

void get_primes(int n){
    for (int i = 2; i <= n; i++){
        if (!st[i])
            primes[cnt++] = i;
        for (int j = 0; primes[j] <= n / i; j++){
            //标记，pj一定是pj*i的最小质因子
            st[primes[j] * i] = true;
            //从小到大遍历，如果 i%pj=0，则pj一定是i的最小公因子
            if (i % primes[j] == 0)
                break;
        }
    }
}

---