目录
保证给你讲透讲懂
第一种：埃氏筛法
第二种：欧拉筛法
题目：质数率
题目：不喜欢的数
思路：
问题：1~n 中筛选出所有素数（质数）
有两种经典的时间复杂度较低的筛法，即埃氏筛法和欧拉筛法。
既然是筛子，那么核心思想就是：根据当前的数筛掉后面的一些不合法数据，留下的每个数都是质数。
第一种：埃氏筛法
（也是最好理解的筛子，不过速度O(n*loglogn)）
首先2是最小的素数，将表中所有的2的倍数划去。
表中剩下的最小的数字就是3，所以3是素数。再将表中所有的3的倍数划去……
以此类推，如果表中剩余的最小的数是几，几就是素数。然后将其倍数筛掉
核心代码：
第二个for为什么从i*i开始：
答：我们会先筛2的所有倍数，然后是3的倍数，但是后面在筛3的倍数的时候我们还需要从2开始筛吗？筛掉3*2？这个之前在筛2的时候就已经标记过了的，那么直接从3本身筛开始多好啊。
int eprime(int n){
judge[0]=judge[1]=1;
for(int i=2;i<=n;i++){
if(judge[i]==0){
prime[cnt++]=i;
for(int j=i*i;j<=n;j+=i) judge[j]=1;//直接从i本身开始筛
}
}
return cnt;
}重点： 虽然埃氏筛易理解，但是个别时候还是会被卡的。
我们深入理解埃氏筛的思想：
要想得到 n以内的质数，就要把不大于根号n的质数的倍数全部剔除，剩下的就是质数。从 2 开始，把 2 的倍数（不包括本身）标记为合数，然后向后枚举，查到一个未标记为合数的，就把它的倍数（不包括本身）标记为合数。以此类推，查到 n 为止。
例如一个数 24，它会被 2 标记一次，被3标记一次。如果这个数的质因数较多，那么重复的就会更多，每个已经被筛掉的数重复的被筛，这就会导致时间变长
（放心，欧拉来了）
第二种：欧拉筛法
欧拉筛法的原理同埃氏筛法，只不过多了一个判断删除与标记最小质因子的过程。
在埃氏筛法中，一个合数来说可能会被筛多次，比如6可以被2筛去，也可以被3筛去，而欧拉筛要做的事情就是让一个合数只被筛一次。
我们规定这个合数只会被它的最小质因数筛掉。这样能保证每个合数只会被筛一次。
核心代码
int oprime(int n){//线性筛O(n)速度求出小于n的所有质数！！！
judge[0]=judge[1]=1;
for(int i=2;i<=n;i++){
if(!judge[i]) prime[cnt++]=i;//没有被标记过的数必然是质数，加入质数中
for(int j=0;prime[j]*i<=n;j++){//质数性倍增（只枚举当然已放入的质数）
judge[prime[j]*i]=true;//此数的质数倍数加入标记中
if(i%prime[j]==0)break;//保证了一个合数只被它最小的质因子枚举标记，而一个质数只会一直枚举标记到本身
}
}
return cnt;
}过程如下：
从 2开始：2 加入 prime 数组，从小到大枚举质数（现在只有 2），筛掉质数与 2 的乘积（4 被筛掉）。
到了 3： 3 加入 prime 数组，从小到大枚举质数（此时有 2,3），筛掉质数与 3 的乘积（6,9 被筛掉）。
到了 4： 4 没加入 prime 数组，枚举质数（有2,3），筛掉 8 后，因为 4mod2=0，触发退出条件。（不触发，就会筛掉 12，而 12=2×2×3，又会被 2 和 6筛一次，懂了吗）
以此类推，可做出一张表：
不难发现保证一个合数只被它最小的质因子枚举标记，而一个质数只会一直枚举标记到本身。保证了合数只被一次筛掉。
下面是完整代码：
#include <bits/stdc++.h>//线性筛模板
using namespace std;
bool judge[1000000];
int n,cnt,prime[1000];
int oprime(int n){//线性筛O(n)速度求出小于n的所有质数！！！
judge[0]=judge[1]=1;
for(int i=2;i<=n;i++){
if(!judge[i]) prime[cnt++]=i;//没有被标记过的数加入质数中
for(int j=0;prime[j]*i<=n;j++){//1，质数性倍增（只枚举当然已放入的质数）
judge[prime[j]*i]=true;//此数的质数倍数加入标记中（必然不是质数）
if(i%prime[j]==0)break;//2，保证一个合数只被它最小的质因子枚举标记，而一个质数只会一直枚举标记到本身
}
}
return cnt;
}
int eprime(int n){
judge[0]=judge[1]=1;
for(int i=2;i<=n;i++){
if(judge[i]==0){
prime[cnt++]=i;
for(int j=i*i;j<=n;j+=i) judge[j]=1;
}
}
return cnt;
}
int main(){
cin>>n;eprime(n);
//oprime(n);
for(int i=0;i<cnt;i++){
cout<<prime[i]<<' ';
}
return 0;
}以上算法只有两步(已标出)和埃氏筛不同，注意一下即可
最终效果：zhi数组里面全是质数，vis数组里面为true的都不是质数，既方便取质数，又方便判断质数。
下面是练习题
题目：质数率
题意：求1~n的质数占比（n<=1e8）
(这道题还是很友好的，直接让你精确，而不是求逆元，哈哈哈哈哈)
#include <bits/stdc++.h>
using namespace std;
const int N=1e8+7;
int zhi[N],cnt,m;
bool vis[N];//千万不要用int来充当bool了，内存直接超256M了！！！
int getzhi(int n){
for(int i=2;i<=n;i++){
if(!vis[i])zhi[cnt++]=i; //如果你这里想用++cnt，那么后面的j应该从1开始
for(int j=0;zhi[j]*i<=n;j++){
vis[zhi[j]*i]=true;
if(i%zhi[j]==0)break;
}
}
return cnt;
}
int main(){
cin>>m;
getzhi(m);
printf("%0.3lf\n",(double)cnt/m);
}
题目：不喜欢的数
我们不喜欢7的倍数；数字的某一位是7，这个数字的倍数我们也不喜欢。给t个数，如果这个数不是喜欢的数就输出下一个喜欢的数
思路：
注意到一个含7的数的倍数也不行，很明显我们倒着找的话需要找所有的因数来判断，但是t太大了，这样必然超时。只能正着来做！
线性筛思想O(n)：如果此数喜欢，那就加入数组；否则就把此数的倍数全部筛掉
注意到要输出不喜欢数的下一个喜欢的数。对于这种取一个数的后一个数，那就定义一个链表呗（就是跟踪数组嘛）里面存放下标可以，直接存放那个数也可以，感觉你直接存那个数的话更好！
#include <bits/stdc++.h>
using namespace std;//如果是喜欢的数，就输出下一个喜欢的数（大于次数的下一个喜欢的数）（t<=2e5 x<=1e7）
const int N=1e7+7;
int t,x,ans[N],nxt[N],cnt;
bool judge[N]={1};
bool check(int x){
while(x){
if(x%10==7)return true;
x/=10;
}
return false;
}
void getnum(int n){//线性筛思想
int cur=1;//cur是上个喜欢的数，此时是第一个喜欢的数
for(int i=2;i<=n;i++){
if(!judge[i]){//忽略被筛掉的数
bool f=check(i);
if(!f){//喜欢
ans[cnt++]=i;//放入数组，感觉此步骤有点多余
nxt[cur]=i;//更新链表，里面存入这个数的下个数
cur=i;//更新cur
}else{
for(int j=i;j<=n;j+=i)//线性倍增的结果都标记一下（都是不喜欢的数）
judge[j]=true;
}
}
}
}
int main(){
getnum(N);//先对所有范围内的数都打下表格
cin>>t;
while(t--){
cin>>x;
if(judge[x]) cout<<-1<<'\n';//不喜欢则直接输出-1
else cout<<nxt[x]<<'\n';//喜欢则输出这个数的下一个数
}
return 0;
}
