素数筛选法（线性筛法模板）

最新推荐文章于 2024-04-27 21:11:05 发布
最新推荐文章于 2024-04-27 21:11:05 发布
阅读量364 收藏 1
点赞数
文章标签： c++ oj系统 素数筛 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoucheng_123/article/details/104020798
版权

线性筛法

#include <bits/stdc++.h>
using namespace std;
const int N=1e7;
bool flag[N+10];
int prime[N+10];
int main()
{
    memset(flag,1,sizeof(flag));//假设全是素数
    flag[0]=0;flag[1]=0;//0和1不是素数
    int index=0;
    for(int i=2;i<=N;i++)
    {
        if(flag[i])prime[index++]=i;//得到素数集合
        for(int j=0;j<index&&prime[j]*i<=N;j++)
        {
            flag[prime[j]*i]=0;//筛合数
            if(i%prime[j]==0)break;//只筛合数的素因子最小的那一个
        }
    }
    return 0;
}

复杂度为O(n),得到素数集合prime[]，flag[i]判断i是不是素数，也可以让flag[i]=index+1，flag的值就保存了i是第几个素数

nefu 1262 五十弦翻塞外声

这题好难哦，解题思路：唯一分解定理：举个例子：18的因子和

素因子为332，因子和为(3^2 + 3^1 + 3^0) * (2^1 +2^0)=39

所以可以用一个二维数组（或者结构体）把素因子及其幂存起来，最后用等比数列求和公式a1*（q^n-1）/(q-1),a1都是1

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int prime[78500];
bool f[1000000];
const int N=1e6;
void data()
{
    int cnt=0;
    memset(f,1,sizeof(f));
    for(int i=2;i<N;i++)
    {
        if(f[i])prime[cnt++]=i;
        for(int j=0;j<cnt&&prime[j]*i<N;j++)
        {
            f[i*prime[j]]=0;
            if(i%prime[j]==0)break;
        }
    }
}
//快速幂不取模
ll quick(ll a,int n)
{
    ll ans=1;
    while(n)
    {
        if(n&1)ans=ans*a;
        n>>=1;
        a=a*a;

    }
    return ans;
}
int main()
{
    data();//很重要，不然data（）函数就没用
    int t,n;
    scanf("%d",&t);
    while(t--)
    {
        int a[20][2],cnt=0,i=0;
        scanf("%d",&n);
        while(n!=1&&i<=3401)
        {
            if(n%prime[i]==0)
            {
                a[cnt][1]=0;
                while(n%prime[i]==0)
                {
                    n/=prime[i];
                    a[cnt][1]++;
                }
                a[cnt++][0]=prime[i];
            }
            i++;
        }
        if(n!=1)
        {
            a[cnt][1]=1;
            a[cnt++][0]=n;
        }
        ll ans=1;
        //等比数列依次累乘求和
        for(int i=0;i<cnt;i++)
        {
            ans*=(quick((ll)a[i][0],a[i][1]+1)-1)/(a[i][0]-1);
        }
        printf("%lld\n",ans);
    }
    return 0;
}

nefu 825 函数版素数判定

变化不大，简单题

#include <bits/stdc++.h>
using namespace std;
const int N=1e7;
bool flag[N+10];
int prime[N+10];
int main()
{
    memset(flag,1,sizeof(flag));//假设全是素数
    int index=0;
    flag[1]=0;
    flag[0]=0;
    for(int i=2;i<=N;i++)
    {
        if(flag[i])prime[index++]=i;//得到素数集合
        for(int j=0;j<index&&prime[j]*i<=N;j++)
        {
            flag[prime[j]*i]=0;//筛合数
            if(i%prime[j]==0)break;//只筛合数的素因子最小的那一个
        }
    }
    int n;
    while(~scanf("%d",&n))
    {
        if(flag[n])printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

nefu 585 最大素因子

也变化不大，依次去掉最高位，判断是不是素数

#include <bits/stdc++.h>
using namespace std;
int a[1000005],b[1000005];
int main()
{
    int n,m,cnt;
    memset(a,1,sizeof(a));
    for(int i=2;i<=1000000;i++)
    {
        if(a[i]!=0)
        for(int j=2;i*j<=1000000;j++)a[i*j]=0;
    }
    cnt=0;
    for(int i=2;i<=1000000;i++)
    {
        if(a[i]!=0)b[++cnt]=i;
    }
    while(cin>>n)
    {
        int sum=0;
        if(n==1){cout<<"0"<<endl;continue;}
        for(int i=cnt;i>=1;i--)
        {
            if(n%b[i]==0){cout<<i<<endl;break;}
        }
    }
    return 0;
}

nefu 586 纯素数

发现组数多的时候，cin和cout都挺占时间的，一开始用cout都tle了

#include <bits/stdc++.h>
using namespace std;
const int N=1e6;
bool flag[N+10];
int prime[N+10];
int main()
{
    int n;
    memset(flag,1,sizeof(flag));//假设全是素数
    int index=0;
    for(int i=2;i<N;i++)
    {
        if(flag[i])prime[index++]=i;//得到素数集合
        for(int j=0;j<index&&prime[j]*i<N;j++)
        {
            flag[prime[j]*i]=0;//筛合数
            if(i%prime[j]==0)break;
        }
    }
    flag[0]=0,flag[1]=0;

    while(~scanf("%d",&n))//当输入组数大于10000时，cout cin一般都很占时间
    {
        if(!flag[n]){printf("NO\n");continue;}
        int A=1e5;
        int flag0=1;
        for(int i=0;;i++)
        {
            n=n%A;
            if(!flag[n]){flag0=0;break;}
            A=A/10;
            if(n<10)break;
        }
        if(flag0==1)printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}
}

nefu 587 半素数

这题卡时间，思路：两个素数相乘小于N，用数组标记，一重循环小于sqrt（N），可以避免重复，减少时间

#include <bits/stdc++.h>
using namespace std;
const int N=1e6;//为啥是2e6才行呢1e6居然不行
int flag[N+10];
int prime[N+10];
int flag0[N];
int main()
{
    memset(flag,1,sizeof(flag));//假设全是素数
    int index=0;
    for(int i=2;i<N;i++)
    {
        if(flag[i]){prime[index++]=i;flag[i]=index;}
        for(int j=0;j<index&&prime[j]*i<N;j++)
        {
            flag[prime[j]*i]=0;//筛合数
            if(i%prime[j]==0)break;//只筛合数的素因子最小的那一个
        }
    }
    flag[1]=0;
    int n;
    for(int i=0;prime[i]<sqrt(N*1.0);i++)
    {
        for(int j=i;prime[j]*prime[i]<N;j++)
        {
            flag0[prime[j]*prime[i]]=1;
        }
    }
    while(~scanf("%d",&n))
    {
        if(flag0[n])printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

nefu781 素数与数论

用到一个小技巧flag[n]本来是用来判断是否是素数的，可以让flag也存上这个素数是第几个素数，然后找x开始为素数的下标与y+1开始的下标，相减就是之间的素数个数

#include <bits/stdc++.h>
using namespace std;
const int N=2e6;//为啥是2e6才行呢1e6居然不行
int flag[N+10];
int prime[N+10];

int main()
{
    memset(flag,1,sizeof(flag));//假设全是素数
    int index=0;
    for(int i=2;i<N;i++)
    {
        if(flag[i]){prime[index++]=i;flag[i]=index;}
        for(int j=0;j<index&&prime[j]*i<N;j++)
        {
            flag[prime[j]*i]=0;//筛合数
            if(i%prime[j]==0)break;//只筛合数的素因子最小的那一个
        }
    }
    flag[1]=0;
    int x,y,sum;
    while(~scanf("%d %d",&x,&y))
    {
        sum=0;
        int i,j;
        for(i=x;;i++)
        {
            if(flag[i]){i=flag[i];break;}
        }
        for(j=y+1;;j++)if(flag[j]){j=flag[j];break;}
        sum=j-i;
        cout<<sum<<endl;
    }
    return 0;
}

nefu1704 知否知否，应是绿肥红瘦

判断1e14大小的素数的方法：用线性筛求出1e7以内的素数再判断这个数能否被前面的素数整除，不能则是素数

#include <bits/stdc++.h>
using namespace std;
const int N=1e7;
bool flag[N+10];
int prime[N+10];
int su(long long n)//对1e7内素数，能整除不是素数
{
    int flag=0;//假设是素数
    for(int i=0;prime[i]<=sqrt(1.0*n);i++)
    {
        if(n%prime[i]==0){flag=1;break;}
    }
    if(n==1)flag=1;
    return flag;
}
int main()
{
    memset(flag,1,sizeof(flag));//假设全是素数
    int index=0;
    for(int i=2;i<N;i++)
    {
        if(flag[i])prime[index++]=i;//得到素数集合
        for(int j=0;j<index&&prime[j]*i<N;j++)
        {
            flag[prime[j]*i]=0;//筛合数
            if(i%prime[j]==0)break;//只筛合数的素因子最小的那一个
        }
    }
    int n;
    scanf("%d",&n);
    long long a,b,c,sum;
    while(n--)
    {
        scanf("%lld %lld %lld",&a,&b,&c);
        sum=a+b-c;
        if(su(sum)==0)printf("yes\n");
        else printf("no\n");
    }
    return 0;
}

nefu 2113 素数线性筛

这题非常简单就是套模板就行

#include <bits/stdc++.h>
using namespace std;
const int N=1e7;
bool flag[N+10];
int prime[N+10];
int main()
{
    memset(flag,1,sizeof(flag));//假设全是素数
    int index=0;
    for(int i=2;i<N;i++)
    {
        if(flag[i])prime[index++]=i;//得到素数集合
        for(int j=0;j<index&&prime[j]*i<N;j++)
        {
            flag[prime[j]*i]=0;//筛合数
            if(i%prime[j]==0)break;
        }
    }
    int n,q;
    scanf("%d %d",&n,&q);
    int a;
    while(q--)
    {
        scanf("%d",&a);
        printf("%d\n",prime[a-1]);
    }
    return 0;
}
nefu_zc
关注
线性筛法求素数c语言,[算法]素数筛法(埃氏筛法&线性筛法)
weixin_33488806的博客
05-22 845
一、素数筛的定义给定一个整数n，求出[1,n]之间的所有质数(素数)，这样的问题为素数筛(素数的筛选问题)。二、埃氏筛法(Eratosthenes筛法)埃氏筛法又叫做Eratosthenes筛法，一般叫做埃氏筛。埃氏筛的思想是：\(\forall x\in Z\)的倍数\(2x，3x，...\)都不是质数。因此我们可以从2开始有小到大扫描每个数\(x\)，并把\(x\)的倍数\(2x，3x，4x，...
线性筛素数模板——（欧拉筛）
m0_62937331的博客
05-05 920
学个新知识还是拿博客记录一下吧，方便以后再次遇到（思路和图片来源：洛谷学委，Eon_Floating，Lylighter_ P3383线性筛素数 图片转自洛谷网 if(i % Prime[j] == 0) break; 说说这步理由： 、、、 规则：个合数只会被它的最大非自身因数（对应最小质因数）筛。这样能保证每个合数只会被筛一次。 、、、i的最小质因数是Prime[j],如果j继续递增，会导致被多次筛。 、、、但是由于保证了筛去的合数日后将不会再被筛（总共只筛一次），复杂度是线性的。 /.
基于Jupyter 使用列表实现筛选法求素数（python）
12-21
Jupyter 使用列表实现筛选法求素数 使用列表实现筛选法求素数可以极大的提高计算机的运算速率。 maxNumber = int(input("请输入一个大于2的自然数：")) lst = list(range(2,maxNumber)) #最大整数的平方根 m = int(maxNumber**0.5) for index , value in enumerate(lst): #如果当前数字已大于整数的平凡根，结束判断 if value > m: break #对该位置之后的元素进行过滤 lst[index+1:] = filter(lamb
ACM基础知识储备-快速筛法求素数
热门推荐
Charles的博客
12-10 1万+
求素数是程序设计比赛中经常遇到的问题，最基本的方法是通过素数的定义直接判断，只能被1和它本身整除的数就是素数了。这种方法适合判断单个数是否为素数，当要求一个范围内素数而这个范围又比较大时，这种方法就不太使用了，甚至程序要运行几分钟才能算出结果。 筛法的思想是去除要求范围内所有的合数，剩下的就是素数了，而任何合数都可以表示为素数的乘积，因此如果已知一个数为素数，则它的倍数都为合数。 普通的线性筛
筛选法求素数模板
qq_41682681的博客
07-22 618
#include&lt;iostream&gt; #include&lt;cmath&gt; using namespace std; int main() {     int a=1000;///要求的素数的范围     bool flag[10000];     int m=sqrt(a+0.5);     for(int i=2;i&lt;=m;i++)         if(!flag...
线性筛选素数
qq670471201的博客
07-30 449
线性筛选素数 侵删。。。 转自https://www.cnblogs.com/grubbyskyer/p/3852421.html 题目：给出一个正整数n，打印出所有从1~n的素数(即质数); 关键是要找出一个判断一个正整数n是否为素数的方法… 傻瓜解法–n,n/2 1 #include&lt;...
{模板}线性筛法求素数
FarmerJohn
11-17 557
for (int i = 2;i <= n;i ++) { if (!bz[i]) Pri[++ Pri[0]] = i; for (int j = 1;j <= Pri[0];j ++) { bz[i * Pri[j]] = true; if (i % Pri[j] == 0) break;
【数论】埃氏筛法和线性筛法求素数
gzkeylucky的博客
05-13 370
求质数的多种方式
【Python 百练成钢】Python语言解决素数筛选问题的几种方式【朴素素数筛、埃氏筛、欧拉筛
最新发布
2401_84139711的博客
04-27 1936
n=int(1e6)ans=0if n%i==0:ans+=1print(f"阶乘结果{ans}用时{end-start}")💟新手优化筛💞💜问题分析💜优化了一下代码,也就是对循环变量的终止条件开了个方。🥳💜代码实现💜n=int(1e6)ans=0if n%i==0:ans+=1print(f"阶乘结果{ans}用时{end-start}")💟埃氏筛💞🤍问题分析🤍这里内层循环从i_i开始是因为i~i_i之间的合数总会被i之前的数筛选掉,剩余的都是质数。
【模板】线性筛素数题解
ZhuhaoNan134的博客
02-24 246
这里附上题目链接：【模板】线性筛素数。 ~~手动分割~~ 题目 思路解析 欧拉筛法模板题 AC代码 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdbool.h> bool visit[100000000];//visit[i]=false说明i不是素数 int n,q,k[1000002],prime_permutation[5780
~~线性筛法求素数（附模板题）
Running Snail
03-31 409
模板 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; ...
线性筛选素数法
Dafang_Xu的博客
11-16 681
何为线性筛法，顾名思义，就是在线性时间内（也就是O（n））用筛选的方法把素数找出来的一种算法，没用过线性筛素数法的人可能会奇怪，用遍历取余判定素数不是也是线性时间的吗，没错，但是确切的说线性筛法并不是判定素数的，而是在线性时间内求出一个素数表，需要判定是否是素数的时候只要看该数是否在表内就可以瞬间知道是不是素数。 比如想求10000以内的素数，定义表int a[10000]，进行线性筛选后，a[n
【模板】3种素数筛法
Enormous 2018
02-23 267
3种素数筛法的模板 第一种 朴素的素数筛法 试除呗…………不解释。代码如下： P.S：我给的是一个完整程序，一般只需要写成void函数就可以。 //ENOR Prime 1 O(n*sqrt(n)) #include&lt;cstdio&gt; #include&lt;cmath&gt; #define MAXN 10001 using namespace std; int prim...
Goldbach`s Conjecture LightOJ - 1259（素数筛模板题）
Alanrookie的博客
08-10 193
题意：n=a+b，满足a，b(a<=b)都是质数，求a+b=n方案个数。 题解：模板题，有个坑点：bool数组1e7不会MLE，但是int会 AC代码： #include <iostream> #include <cstring> #include <string> #include <cstdio> #include <cmath> #include <queue> #include <algorithm>
素数筛选法(模板)
dreamzuora的博客
10-06 534
#include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;math.h&gt; #define MAX 1000000 int is_prime[MAX+5] = {1}; //is_prime[i]是素数为1，不是素数为0 int prime_num[MAX]; //prime_num[i]是第i个素数 ...
素数筛模板
weixin_51652698的博客
11-15 274
素数筛模板普通判断素数Code埃氏筛Code欧拉筛Code完整代码 普通判断素数 Code bool is_prime(int n) { for(int i=1; i*i<=n; i++) { if(n%i==0) return 0; } return 1; } 埃氏筛 首先将2到n范围内的整数写下来，其中2是最小的素数。将表中所有的2的倍数划去，表中剩下的最小的数字就是3，他不能被更小的数整除，所以3是素数。再将表中所有的3的倍数划去……以此类推，如果表中剩余的最小的数是m，那么m
~~朴素筛法求素数（附模板题）
Running Snail
03-31 461
模版 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 ...
云计算下的素数筛选与合数分解算法详解
这里的代码片段展示了如何实现一个简单的素数筛选方法，通过Sieve of Eratosthenes（埃拉托斯特尼筛法）来找到小于等于MAXN的所有素数。代码首先初始化一个数组prime，用0表示非素数，1表示素数，然后遍历从2到MAXN...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值