蒟蒻君的数学学习之路2——质数相关算法

⭐前言

质数，是数学里很重要的东东。若$p$为质数，$p$为$>1$的整数且$p$有且仅有$1$和$p$两个因数。
今天，蒟蒻君将和大家一起学习质数相关算法（难度递增qwq）。

⭐一、质数判定

$1.1$ 试除法

思路

最常用的算法。

1. 假设$n$不是质数，则必有$a,b$使得$n=a\times b$；
2. 令$a<b$, 则 $a\le \sqrt{n}$；
3. 枚举$a=1-\sqrt{n}$，若所有$a$均不被$n$整除，则$n$为质数，否则为合数。
4. 注意特判$0$和$1$。

时间复杂度：$O(\sqrt{n})$；
空间复杂度：$O(1)$。

代码

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

$1.2$ 卡常写法

思路

在法一的基础上可以进行以下优化：
若$n$为质数，则$n\mathrm{m}\mathrm{o}\mathrm{d}2\ne 0$且$n\mathrm{m}\mathrm{o}\mathrm{d}3\ne 0$，则$n\mathrm{m}\mathrm{o}\mathrm{d}6=1/5$。跳过$2-4$,时间复杂度可提高到之前的$\frac{1}{3}$。
注意特判$n=2/3/5/7/11$还有$n=2/3/5k(k\in N)$。

时间复杂度：$O(\sqrt{n})$，只是常数有些变化；
空间复杂度：$O(1)$。

代码

inline bool isprime(int n) {
     
	if (n < 2) {
     
		return false;
	}
	if (n == 2 || n == 3 || n == 5 || n == 7 || n == 11) {
     
		return true;
	}
	if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0) {
     
		return false;
	}
	for (int i = 1; i <= n / 6 + 1; ++i) {
     	// 枚举n = 6 * i +/- 1 
		if (i * 6 >= sqrt(n) + 5) {
     
			break;
		}
		if ((n % (i * 6 + 1) == 0) || (n % (i * 6 + 5) == 0)) {
     
			return false;
		}
	}
	return true;
}

如果让你从$1-100$这些数里筛出质数，那你还会一个一个数地试除吗 （当然你没有背过）？
质数筛法适用于先预处理，然后多次查询的条件下。
下面我们来学习质数的两种筛法叭~
注意，质数筛法标程以洛谷P3383【模板】线性筛素数为例。

$1.3$ 埃氏筛法

思路

相信大家也都对这种方法不陌生。
比如我们要判断$1-100$中选出所有质数，那么我们可以这样做：

1. 先将$1-100$写在纸上。
2. 我们在$2$上画一个小圈圈，然后叉掉所有$2$的倍数；
3. 再在$3$上画一个小圈圈，删掉所有$3$的倍数；
4. 现在你发现$4$已经被删掉了，那么就可以在$5$上画一个圈圈，然后删掉所有$5$的倍数。
5. 以此类推，直到$1-100$中所有数都被划掉或圈起为止，质数为所有被圈出来的数。

接下来我们来分析一下ta的时间复杂度。
因为所有数要么都被删除或圈出一次，则时间复杂度为$O(n)$。
nonono
仔细思考可知，有些数会被删除多次，如$6$被$2$和$3$删除，则：

$T(n)=O(\sum _{p\le n}\frac{n}{p})=O(\sum _{p\le n}\frac{1}{p})=O(nloglogn)$；
时间复杂度：$O(nloglogn)$；
空间复杂度：$O(n)$。

代码

注意：此方法时间复杂度较高，需使用scanf/printf/ios :: sync_with_stdio(0)方可AC。

#include 
using namespace std;
const int N = 1e8 + 5;
bool vis[N];
int p[N], cnt;
void init(int n) {
     
	vis[1] = true;
	for (int i = 2; i <= n; ++i) {
     
		if (vis[i]) {
     
			continue;
		}
		p[++cnt] = i;
		for (long long j = 1ll * i * i; j <= n; j += i) {
     
			vis[j] = true;
		}
	}
}
int main() {
     
	int n, q;
	scanf("%d %d", &n, &q);
	init(n);
	while (q--) {
     
		int k;
		scanf("%d", &k);
		printf("%d\n", p[k]);
	}
	return 0;
} 

$1.4$ 欧拉筛法

思路

相当于是埃氏筛法的优化版。
分析可知，$n=p{1}^{a1}\times p{2}^{a2}\times p{3}^{a3}\times ...\times p{m}^{am}$只会被$p{1}^{a1-1}\times p{2}^{a2}\times p{3}^{a3}\times ...\times p{m}^{am}$划掉，不用考虑别的了。
时间复杂度：$O(n)$；
空间复杂度：$O(n)$。

代码

#include 
using namespace std;
const int N = 1e8 + 5, M = 1e6 + 5;
bool P[N];
int n, q;
vector<int> p;
void init() {
     
	memset(P, true, sizeof P);
	P[1] = false;
	p.push_back(0); 
	for (int i = 2; i <= n; ++i) {
     
		if (P[i]) {
     
            p.push_back(i);
        }
		for (int j = 1; j <= p.size() && i * p[j] <= n; ++j) {
     
			P[i * p[j]] = false;
			if (i % p[j] == 0) {
     
				break;
            }
		}
	}
}
int main() {
     
    cin >> n >> q;
    init();
    while (q--) {
     
        int k;
        cin >> k;
        cout << p[k] << '\n';
    }
	return 0;
}

$1.5$ Miller-Rabin测试

思路

巧妙但会出现失误的方法（但非常好用），适用于大数判断。
用到了一点后面的费马小定理。

1. 算出整数$m$使得$n=2^k\times m+1$，随机$1\le a<n$；
2. 对于$i<r(i\in N)$，若$a^{2^i\ast m}\mathrm{m}\mathrm{o}\mathrm{d}n=n-1$或$a^m\mathrm{m}\mathrm{o}\mathrm{d}n=1$，则$n$通过$a$的测试；
3. 选择多个$a$，若全部通过则认为$n$为质数。通过$t$次测试，$n$为合数的概率为$\frac{1}{4^t}$。
4. 虽然还是有一定概率判断失误的，但这惊人的时间复杂度确实令人羡慕。如果你每次都用前7个素数测试，所有不超过341550071728320的数都不会判断失误。

注意：这里没有考虑直接乘会超出范围的情况（考虑的话加一点模拟就可以了）。
时间复杂度：$O(log{n}^2)$；
空间复杂度：$O(1)$。

代码

int qpow(int x, int y, int p) {
     
	int res = 1;
	while (y) {
     
		if (y & 1) {
     
			(res *= x) %= p;
		}
		(x *= x) %= p;
		y >>= 1;
	}
	return res;
}
inline bool isprime(int n) {
     
	if (n <= 2) {
     
		return n == 2;
	}
	for (int i = 0; i < 10; ++i) {
     
		int a = rand() % (n - 2) + 2;	// 最小为2 
		if (qpow(a, n, n) != a) {
     
			return false;
		}
	}
	return true;
}

⭐二、相关定理

$2.1$ 威尔逊定理

结论

$\{\begin{array}{l}若p为质数,(p-1)!\equiv -1(\mathrm{m}\mathrm{o}\mathrm{d}p)\\ 若(p-1)!\equiv -1(\mathrm{m}\mathrm{o}\mathrm{d}p),p为质数\end{array}$

证明

$[2,p-2]$必被$\frac{p-1}{2}$对逆元覆盖。$1$的逆元为$1$，故此定理成立。

$2.2$ 欧拉定理

结论

欧拉函数：$\phi (n)$表示满足$1\le m\le n,m\in N$且$gcd(n,m)=1$时$m$的个数。
欧拉定理： 若$a,m\in N$且$gcd(a,m)=1$，则$a^{\phi (m)}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$。

证明

设$\left\{b_{\phi (m)}\right\}$为$1\to m$中于$m$互质的数的集合。
我们发现$b$数组中所有数$\mathrm{m}\mathrm{o}\mathrm{d}m$余数各不相同，且余数都与$m$互质。
仔细观察后发现，$a\times b_1,a\times b_2,a\times b_3,...a\times b_{\phi (m)}$也符合以上两个条件。
综合以上结论，$\because gcd(a,m)=1,gcd(b_i,m)=1\therefore gcd(a\times b_i,m)=1$。
$\because a\times b_{1\to \phi (m)}\mathrm{m}\mathrm{o}\mathrm{d}n$的结果是$\phi (m)$个不同且与$m$互质的数、
$\therefore$这些数就是$b$了（真香）。
$\therefore a\times b_1\times a\times b_2\times a\times b_3\times ...\times a\times b_{\phi (m)}\equiv b_1\times b_2\times b_3\times ...\times b_{\phi (m)}(\mathrm{m}\mathrm{o}\mathrm{d}m)$
$a^{\phi (m)}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$

$2.3$ 费马小定理

结论

若有$p$为质数，$a\in N$使得$gcd(a,p)=1$，则$a^{p-1}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}p)$。

证明

看完了刚才的欧拉定理，费马小定理的证明应该很简单了叭~
$\because p$为质数 $\therefore \phi (p)=p-1$，然后代入即可证明。
其实，费马小定理就是欧拉定理的一个特例。

⭐三、分解质因数

$3.1$ 试除法

思路

遍历$i=2-\sqrt{n}$，若$i$是质数且$i$是$n$的因数，则让$n$不断除以$i$，不能整除为止，使用常规算法判断质数（筛不筛复杂度都一样qwq）。
时间复杂度：$O(n)$；
空间复杂度：$O(1)$。

代码

#include 
using namespace std;
inline bool isprime(int n) {
     
	if (n < 2) {
     
		return false;
	}
	for (int i = 2; i * i <= n; ++i) {
     
		if (n % i == 0) {
     
			return false;
		}
	}
	return true;
}
int main() {
     
	int n;
	cin >> n;
	for (int i = 1; i * i <= n; ++i) {
     
		if (n % i == 0 && isprime(i)) {
     
			while (n % i == 0) {
     
				cout << i << ' ';
				n /= i;
			}
		}
	}
	if (isprime(n)) {
     
		cout << n << '\n';
	}
	return 0;
} 

$3.2$ Pollard Rho算法

思路

适用于大数分解。
我们每次寻找$n$的任意一个因数$m$，然后递归分解$m$和$\frac{n}{m}$。
最大的问题就是，如何找到一个因数？当然不是去试除，而是有点随机的试验。
我们随机取出一个数$x$，然后构造$y$，使得$m\mid (x-y),n\nmid (x-y)$
则$m=gcd(x-y,n)$。若结果为$1$的话我们就要继续不断调整$y$，否则就成功找到了一个因数。
对于调整$y$，一般策略为$y=y^2+t$（t自定）。
直到$x=y$，需要重新选取$x$。
时间复杂度： $O(n^{\frac{1}{4}})$；
空间复杂度：$O(n)$。

代码

#include 
using namespace std;
int x[1 << 7];
queue<int> q;
int qpow(int x, int y, int p) {
     
	int res = 1;
    while (y) {
     
        if (y & 1) {
     
            (res *= x) %= p;
        }
        (x *= x) %= p;
        y >>= 1;
    }
	return res;
}
bool isprime(int n) {
     
    if (n <= 2) {
     
        return n == 2;
    }
    int t = n - 1, sum = 0;
    int times = 20;
    while (!(t & 1)) {
     
        ++sum;
        t >>= 1;
    }
    while (times--) {
     
        int a = rand() % (n - 2) + 2;
        x[0] = qpow(a, t, n);
        for (int i = 1; i <= sum; ++i) {
     
            x[i] = x[i - 1] * x[i - 1] % n;
            if (x[i] == 1 && x[i - 1] != 1 && x[i - 1] != n - 1) {
     
                return false;
            }
        }
        if (x[sum] != 1) {
     
        	return false;
		}
    }
	return true;	
}
int Pollard_Rho(int n, int t) {
     
    int x = rand() % (n - 1) + 1, y = x;
    int i = 1, j = 2;
	while (true) {
     
        ++i;
        x = (x * x % n + t) % n;
		int m = __gcd((y - x + n) % n, n);
		if (m != 1 && m != n) {
     
            return m;
        }
		if (x == y) {
     
            return n;
        }
		if (i == j) {
     
			y = x;
			j <<= 1;
		}	
	}
}
void calc(int n, int t) {
     
	if (n == 1)	{
     
        return ;
    }
	if (isprime(n)) {
     
		q.push(n);
		return ;
	}
	int m = n, k = t;
	while (m >= n) {
     
		m = Pollard_Rho(m, t--);
	}
	calc(m, k);
	calc(n / m, k);
}
int main() {
     
	int n;
    cin >> n;
	calc(n, 110);
	while (q.size()) {
     
		cout << q.front() << ' ';
		q.pop();
	}
	return 0;
}