简单数论——质数

质数

在 >1 的整数中，如果只包含1和本身两个约数，这个数就被称为质数/素数。

质数的判定——试除法

暴力枚举 \(O(n)\)

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

简单优化 \(O(\sqrt{n})\)

对任意的d能整除n（ d|n ）, 显然n除上d也能整除n （ \(\frac{n}{d}\) | n ）

如n = 12，3是12的约数，4也是12的约数； 2是12的约数，6也是12的约数

所有的约数都是成对出现的，在枚举时可以只枚举每一对中较小的那个，即\(d \leq \frac{n}{d}\)的部分，即\(d \leq \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;
}

分解质因数 \(O(\log_ax\) ~ \(\sqrt{n})\)

hihoCoder 1750

如n = \(2^{k}\),可能他的时间复杂度是O(1)的

质因数：在数论里是指能整除给定正整数的质数。每个合数都可以写成几个质数相乘的形式，如6=2*3，8=\(2^{3}\)，这几个质数就叫做这个合数的质因数。
很轻易就可以得出n中最多只包含一个大于\(O(\sqrt{n})\)的质因子，所以只需要把所有 < \(O(\sqrt{n})\) 的质因子枚举出来。

void divide(int x)
{
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0) // 这步成立，i一定是质数
        {
            int s = 0;
            while (x % i == 0) x /= i, s ++ ;
            cout << i << ' ' << s << endl;
        }
    if (x > 1) cout << x << ' ' << 1 << endl;
    cout << endl;
}

筛选质数

hihoCoder 1295

如
从前往后看，把每一个数的所有倍数全部删掉

第一个数是2，把4，5，8，10，12全部删掉

第二个数是3，把6，9，12全部删掉

第三个数是4，把8，12删掉

如此这么筛选过一遍之后，所有剩下的数就是质数
对于任意一个数x而言，他如果没被删除，就说明p不是2_{p-1的任意一个数的倍数，即2}p-1不存在任何一个p的约数，所以p是一个质数。

朴素做法 O(n\(\ln n\))

当i=2时第一重循环循环了\(\frac{n}{2}\)，当n=3时循环了\(\frac{n}{3}\)，当n=4时循环了\(\frac{n}{4}\)次，以此类推可知
O(n) = \(\frac{n}{2}\) + \(\frac{n}{3}\) + ... + \(\frac{n}{n}\)

   = n(\(\frac{1}{2}\) + \(\frac{1}{3}\) + ... + \(\frac{1}{n}\))

\(\frac{1}{2}\) + \(\frac{1}{3}\) + ... + \(\frac{1}{n}\)是一个调和级数，当n->\({\infty}\)时，这个调和级数\(\approx\ln n\) + c

c是一个欧拉常数，约等于0.58

简单优化 埃式筛法

实际上并不需要将所有数的倍数全部删掉，只把质数的倍数删掉就可以了
假设剩下一个p，我们并不需要将2_{p-1全部枚举一遍来判断p是不是质数，只需要把2}p-1的质数判断一遍就可以了
2~p-1的所有质数只要不是p的约数，那么p就是一个质因数
当一个数不是质数我们就不需要筛掉他所有倍数，只有他是质数才会筛掉他的倍数

质数定理：1~n当中有\(\frac{n}{\ln n}\)个质数
O(n) = O(n\(\ln n\) \ \(\ln n\)) \(\approx\) O(n)
实际复杂度为O(n \(\log_a\ log_a x\))
当n=\(2^32\)时，\(\log_2 32\) = 32, \(\log_2 \log_2 32\) = 5,所以\(\log_a\ log_a x\)是很小的，与O(n)是一个级别的

int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (st[i]) continue;
        primes[cnt ++ ] = i;
        for (int j = i + i; j <= n; j += i)
            st[j] = true;
    }
}

线性筛法

在\(10^7\)以上线性筛法大约比埃式筛法快一倍

核心思路：每一个数n只会被他的最小质因子筛掉
每一个数只有一个最小质因子，即每个数只会被筛一次，所以他是线性的

int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

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 ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break; // 这句话执行证明primes[j]一定是i的最小质因子，因为j是从小到大进行的枚举
        }
    }
}

j是从小到大枚举的所有质数，每一次把当前质数和i的乘积筛掉

i%pj == 0
说明primes[j]一定是i的最小质因子，pj也一定是pji的最小质因子
i%pj != 0
由于我们是从小到大枚举，没有枚举到i的最小质因子
说明pj一定小于i的所有质因子，pj也一定是pji的最小质因子

一共有两种可能：

1. i % primes[j] == 0

   • 说明primes[j]一定是i的最小质因子，pj也一定是pj*i的最小质因子

2. i % primes[j] != 0

   • 由于我们是从小到大枚举，没有枚举到i的最小质因子
   • 说明pj一定小于i的所有质因子，pj也一定是pj*i的最小质因子

不管什么情况，一定有primes[j]是primes[j]*i的最小质因子

任何合数一定会被筛掉，对于任意合数x：

• 假设primes[j]是x的最小质因子，当i枚举到x \ primes[j] 时，x就会被筛掉