一、普通做法
暴力做法,直接遍历每个数,检验每个数是否是素数。
对于检验数字 m m m是否是素数,暴力做法是,检查 m m m是否能被 [ 2 , m ] [2,\sqrt{m}] [2,m]范围内的任意一个整数整除。
bool check(int m) {
for (int i = 2; i < sqrt(m); i++) {
if (m % i == 0) return false;
}
return true;
}
这里贴一个更优的做法(具体是链接中的方法4):四种方法判断一个数是否是素数—是杰夫呀
直接暴力求解每个数是否是素数。
vector<bool> isPrime(int n) {
vector<bool> ans(n + 1, false); // ans[i]表示数字i是否是素数
for (int i = 2; i <= n; i++) {
ans[i] = check(i);
}
return ans;
}
二、埃氏筛法
埃氏筛法的核心思想就是,一个数的倍数肯定不能是素数,所以当遍历到一个数的时候,将该数的倍数直接标记为非素数。
细节:如何进行迭代?
我们先假设将
[
2
,
N
]
[2,N]
[2,N]中所有的数放入一个集合,集合中的数都是待判断的数。
我们每次选取集合中的最小的数,该数一定是素数,然后将该数以及该数的倍数从集合中删去;下一步继续取集合中最小的数,重复该过程,直至集合中没有数字留存。
那么,为什么集合中最小的数一定是素数呢?
看上图,假设现在集合中最小的数是K,那么绿色部分(包括2)就已经根据前面迭代的规则从集合中删去。此时,绿色部分由两个子集组成——素数集合A以及他们的倍数集合B。显然,K不可能是A中元素的倍数(因为如果是倍数的话,K就需要从集合中删去),也不可能是B中元素的倍数(因为如果是B中元素的倍数的话,那么肯定就是A中某个元素的倍数)。所以,可以得到结论——数字K不能被小于他的数整除。那么K一定就是素数了。
程序:
vector<bool> isPrime(int n) {
vector<bool> set(n + 1, true);
set[0] = false;
set[1] = false;
int idx = 2;
while (idx <= n) {
while (!set[idx]) {
idx++;
}
for (int i = idx * 2; i <= n; i += idx) {
set[i] = false;
}
idx++;
}
return set;
}
三、欧拉筛法
埃氏筛法还有一定的缺点存在——时间复杂度不是线性的。
为什么?
考虑数字20。20 = 2 * 10, 20 = 5 * 4。那么,20就会被2和5都标记为非素数,这就导致了,一个数可能会被多个素数所标记,从而使得时间复杂度不是线性的。
这里就再介绍一种时间复杂度是线性的筛法——欧拉筛法。欧拉筛法也是借助筛掉素数的倍数这一原则来工作的,只不过更加细化——欧拉筛法要求一个数只能被它的最小质因数所筛除。
首先,我们迭代的外层循环形式虽然和埃氏筛法一样,但是含义并不相同,欧拉筛法的外层循环是由小到大枚举倍数,通过用倍数乘以已筛选出来的素数来标记合数。
由于比较抽象,这里先给出代码
vector<bool> isPrime(int n) {
vector<bool> set(n + 1, true);
vector<int> primes;
set[0] = false;
set[1] = false;
int multiple = 2;
while (multiple <= n) {
// 记录已经筛选出来的素数
if (set[multiple]) primes.push_back(multiple);
// 枚举已经筛选出来的素数
for (int i = 0; i < primes.size() && multiple * primes[i] <= n; i++) {
set[multiple * primes[i]] = false; // 筛掉素数倍数
if (multiple % primes[i] == 0) break; // 保证每个合数由最小质因数所筛除
}
multiple++; // 倍数+1
}
return set;
}
如何保证数字K只能被他的最小质因数筛除呢?
由于每个合数都可以写成几个质数(也可称为素数)相乘的形式,这几个质数就都叫做这个合数的质因数。所以,K可以表示为(假设K能够写成3个质数相乘的形式)
K
=
p
1
p
2
p
3
K=p_{1}p_{2}p_{3}
K=p1p2p3
其中
p
1
<
p
2
<
p
3
p_{1} < p_{2} < p_{3}
p1<p2<p3。
那么,K就有可能被三个质数筛掉,分别可以表示为
K
=
p
1
(
p
2
p
3
)
K=p_{1} (p_{2}p_{3})
K=p1(p2p3) 、
K
=
p
2
(
p
1
p
3
)
K=p_{2} (p_{1}p_{3})
K=p2(p1p3) 、
K
=
p
3
(
p
1
p
2
)
K=p_{3} (p_{1}p_{2})
K=p3(p1p2)三种形式。需要注意,括号中的是外层循环所遍历的倍数。
由大小关系可知,我们在迭代的时候外层循环必定先碰到后两种形式 (因为我们枚举的是倍数,而
p
1
p
2
<
p
1
p
3
<
p
2
p
3
p_{1}p_{2} < p_{1}p_{3} < p_{2}p_{3}
p1p2<p1p3<p2p3,所以我们必定先碰到后两种形式) 。
我们可以发现,后两种形式的倍数中,都存在着
p
1
p_{1}
p1。且由于我们二层循环也是从小到大遍历素数,所以在对于后两种形式来说,必然在二层循环中先遍历到
p
1
p_{1}
p1,这时候只需要判断当前倍数能否被
p
1
p_1
p1整除,即multiple % primes[i] == 0
,就能保证K不会被后两种形式所筛掉。
同时,由于我们的倍数是递增的:multiple++
,且multiple
能够枚举到n
,所以能够保证所有的合数都能被筛掉。
如有任何问题,欢迎在评论区指正!!!