素数的线性筛法
2024年3月GESP编程能力认证C++五级真题(含答案)
2024年3月GESP编程能力认证C++五级真题(含答案)一、单选题（每题2分，共30分）。
1.唯一分解定理描述的内容是（）。
A. 任意整数都可以分解为素数的乘积B. 每个合数都可以唯一分解为一系列素数的乘积C. 两个不同的整数可以分解为相同的素数乘积D. 以上都不对2.贪心算法的核心思想是（）。
A. 在每一步选择中都做当前状态下的最优选择B. 在每一步选择中都选择局部最优解C. 在每一步选择中都选择全局最优解D. 以上都对3.下面的C++代码片段用于计算阶乘。
请在横线处填入（），实现正确的阶乘计算。
A. return n * factorial(n - 1);B. return factorial(n - 1)/ n;C. return n * factorial(n);D. return factorial(n / 2)* factorial(n / 2);4.下面的代码片段用于在双向链表中删除一个节点。
请在横线处填入（），使其能正确实现相应功能。
A. if(current->next !=nullptr)current->next->prev =current->prev;B. current->prev->next =current->next;C. delete current->next;D. current->prev =current->next;5.辗转相除法也被称为（）。
A. 高斯消元法B. 费马定理C. 欧几里德算法D. 牛顿迭代法6.下面的代码片段用于计算斐波那契数列。
该代码的时间复杂度是（）。
int fibonacci(int n){if(n <=1){return n;}else{return fibonacci(n - 1)+fibonacci(n - 2);}}A. O(1)B. O(n)C. O(2n)D. O(log n)7.下面的代码片段用于将两个高精度整数进行相加。
素数（超详细！！！）
素数（超详细）整数惟⼀分解定理素数筛法给定n，求出1~n之间所有的质数。
⼀、Eratosthenes筛法（☒此处本应有⼀幅动图，然鹅我并不知道该如何显⽰动图(｡-ω-)-ω-)-ω-)Eratosthenes筛法思想⼆、欧拉筛法（线性筛）埃⽒筛法中以n=30为例，30这个数被筛了3次，分别是：2*15(p=2)3*10(p=3)5*6(p=5)枚举 2~n 中的每⼀个数 i：如果 i 是素数则保存到素数表中;利⽤ i 和素数表中的素数 prime[j] 去筛除 i*prime[j] ，为了确保i*prime[j] 只被素数 prime[j] 筛除过这⼀次，要确保 prime[j] 是i*prime[j] 中最⼩的素还要⼩的素因⼦。
因⼦，即 i 中不能有⽐ prime[j] 还要⼩的素因⼦写法⼀：（仅⽤于判断）写法⼆：（可求出每个数的最⼩质因⼦）素数筛法优化素因数分解只要在判定素数时记录下每个数值的最⼩素因数即可。
⼀道肥肠简单的模板题——【例 1】Prime Distance（信息学奥赛⼀本通 1619）【题⽬描述】给定两个整数 L,R，求闭区间 [L,R] 中相邻两个质数差值最⼩的数对与差值最⼤的数对。
当存在多个时，输出靠前的素数对。
【输⼊】多组数据。
每⾏两个数 L,R。
【输出】详见输出样例。
【输⼊样例】2 1714 17【输出样例】2,3 are closest, 7,11 are most distant.There are no adjacent primes.。
判断素数的四种方法
判断素数的四种⽅法傻⽠⽅法思路：按照素数的定义，除了1和它本⾝没有其他的因数，就是素数。
#include<stdio.h>int main(){int i,n;while(scanf("%d",&n)!=EOF){for(i=2;i<n;i++)if(n%i==n)break;if(i==n)printf("Yes\n");elseprintf("No\n");}return 0;}缺点：n稍微⼤点，运⾏时间就会很长，容易时间超限。
普通解法思路：⽐如6，23和32效果是⼀样的，所以只需对它的前⼀半进⾏进⾏判断就可以了。
#include<stdio.h>#include<math.h>int main(){int k,i,n;while(scanf("%d",&n)!=EOF){k=sqrt(n);for(i=2;i<k;i++)if(n%i==n)break;if(i==k)printf("Yes\n");elseprintf("No\n");}return 0;}缺点：效率虽提⾼不少，但n稍微⼤点，运⾏时间还是会很长。
普通筛选法（埃拉托斯特尼筛法）思路：所使⽤的原理是从2开始，将每个素数的各个倍数，标记成合数。
⼀个素数的各个倍数，是⼀个差为此素数本⾝的等差数列。
（百度）#include<stdio.h>int a[1000001]={0};//全局数组，初始化为0，便于后⾯标记int main(){long i,j,n;for(i=2;i<=1000000;i++)if(a[i]==0)for(j=i+i;j<=1000000;j+=i)//⼀个素数的倍数，是⼀个素数本⾝为公差的等差数列，所以每次加ia[j]=1;//将⼀个素数的倍数标记为1while(scanf("%ld",&n)!=EOF){if(a[n]==0&&n!=1)//1不是素数printf("Yes\n");elseprintf("No\n");}return 0;}理解：⽐如开始时i=2，那么2的倍数就⼀定不是素数，所以标记所有2的倍数，同理，3是素数，3的倍数就不是素数，标记为1，当i=4的时候，因为之前被标记过，所以if语句不成⽴，跳过。
素数(质数)判断的五种方法
素数（质数）判断的五种方法素数判断是编写程序过程中常见的问题，所以今天我简单梳理一下常用的素数判断方法。
素数的介绍素数定义质数(prime number)又称素数，有无限个。
一个大于1的自然数，除了1和它本身外，不能被其他自然数整除，换句话说就是该数除了1和它本身以外不再有其他的因数;否则称为合数。
根据算术基本定理，每一个比1大的整数，要么本身是一个质数，要么可以写成一系列质数的乘积;而且如果不考虑这些质数在乘积中的顺序，那么写出来的形式是唯一的。
最小的质数是2。
--------360百科第一种：暴力筛选法思路分析根据素数的定义，我们可以简单地想到：若要判断n是不是素数，我们可以直接写一个循环（i从2到n-1，进行n%i运算，即n能不能被i整除，如被整除即不是素数。
若所有的i 都不能整除，n即为素数）。
代码实现booleanisPrime(int n){for(inti=2;i<n;i++){if(n%i==0){returnfalse;break;}}returntrue ;}时间复杂度：O(n)这个时间复杂度乍一看并不乐观，我们就简单优化一下。
booleanisPrime(int n){for( i=2; i<=(int)sqrt(n);i++){if(n%i==0){returnfalse;break;}}returntrue;}时间复杂度：O(sqrt(n))优化原理：素数是因子为1和本身，如果num不是素数，则还有其他因子，其中的因子，假如为a,b.其中必有一个大于sqrt(num) ，一个小于sqrt（num）。
所以必有一个小于或等于其平方根的因数，那么验证素数时就只需要验证到其平方根就可以了。
即一个合数一定含有小于它平方根的质因子。
第二种：素数表筛选法素数表的筛选方法一看就知道素数存储在一个表中，然后在表中查找要判断的数。
找到了就是质数，没找到就不是质数。
思路分析如果一个数不能整除比它小的任何素数，那么这个数就是素数对了，这个方法效率不高，看看就知道思路了。
线性筛法求素数的原理与实现
何为线性筛法，顾名思义，就是在线性时间内（也就是O（n））用筛选的方法把素数找出来的一种算法，没用过线性筛素数法的人可能会奇怪，用遍历取余判定素数不是也是线性时间的吗，没错，但是确切的说线性筛法并不是判定素数的，而是在线性时间内求出一个素数表，需要判定是否是素数的时候只要看该数是否在表内就可以瞬间知道是不是素数。
比如想求10000以内的素数，定义表int a[10000]，进行线性筛选后，a[n]的值就代表n是不是素数，a[n]如果是1，就代表n是素数，a[n]如果是0，就代表n不是素数，这就是查表。
再判定其他的素数也是一样，不用再做任何计算。
而如果用遍历取余，那么每判定一个数都要从头开始再遍历一遍，而线性筛法只在开始一次性运算完，以后只要查表即可，查表通常只需要1条语句。
所以如果你的程序从始至终只需要判定那么几次素数那么用遍历取余即可，但是如果需要多次判定素数，而且这个数还不是很小的话，那么线性筛法就会体现出巨大的优越性来。
线性筛法的核心原理就是一句话：每个合数必有一个最大因子（不包括它本身），用这个因子把合数筛掉，还有另一种说法（每个合数必有一个最小素因子，用这个因子筛掉合数，其实都一样，但是我觉得这种方法不太容易说明，这种方法我会在最后给出简略说明）。
这个很容易证明：这个小学就知道合数一定有因子，既然是几个数，就一定有最大的一个。
最大因子是唯一的，所以合数只会被它自己唯一的因子筛掉一次，把所有合数筛掉后剩下的就全是素数了。
先假设一个数i，一个合数t，i是t最大的因数，t显然可能并不唯一（例如30和45的最大因数都是15）。
那么如何通过i知道t呢，t必然等于i乘以一个比i小的素数。
先来说这个数为什么一定要比i小，这很显然，如果是i乘上一个比它大的素数，那么i显然不能是t最大的因子。
再来说为什么要是素数，因为如果乘上一个合数，我们知道合数一定可以被分解成几个素数相乘的结果，如果乘上的这个合数x=p1*p2*……，那么t = i * x = i * p1 * p2……很显然p1* i也是一个因数，而且大于i。
ACM 筛素数总结
【总结】关于求素数的说【两种筛法】（学习小结，请无视）素数大家都很熟了，不多说了，这里只想说一下求素数。
当然先是唯一素因子分解定理：合数a仅能以一种方式，写成如下的乘积形式：a=p1e1p2e2…prer其中pi为素数，p1<p2<…<pr，且ei为正整数对于一个整数n，当其在小于sqrt（n）范围里有一个约数，那么必然在大于sqrt（n)的范围里有对应的另一个Eratosthenes（埃拉托斯特尼筛法）都是到sqrt（n）的范围。
①。
试除法判素数对于大于1的正整数a，如果a具有小于或等于sqrt（a）的素因子，则a为合数，否则a为素数。
因此，可用区间[2,sqrt(a)]内的数去试除a，只要有一个数能整除a ，则a为合数，否则a为素数。
这种判断素复杂度O(sqrt(n)).IsPrime(a)for(i=2;i*i<=a;i++)if(a%i==0)return a为合数return a为素数②。
Sieve Of Eratosthenes（埃拉托斯特尼筛法）可以筛出2~n 范围里的所有素数。
1)将所有候选数2~n放入筛中;2)找出筛中最小数P，P一定为素数。
3)宣布P为素数，并将P的所有倍数从筛中筛去;4)重复2)至3)直到筛空.其实，当P>sqrt(n)时筛中剩下的数就已经都是素数了。
//用数组prime[MAXN]记录是否为素数；//prime[i]为0表示i为素数，否则为合数int prime[MAXN]={0};for(i=2;i*i<=n;i++){if(prime[i]==0){for(j=i+i;j<=n;j+=i)prime[j]=1;}}③。
线性筛法对于Sieve Of Eratosthenes，普通的筛法如果是一个合数，那么会被多次筛掉，比如6,当2作为素数时筛掉一线性筛法保证所有合数只被筛掉一次具体详见《ftfish利用积性函数的优化》，讲到了积性函数（对于正整数n的一个算术函数f(n)，当中f(1)=1且称它为积性函数。
素数的判断方法
素数的判断方法素数是一种在数学中有重要意义的数，它们只能被1和它本身整除，有很多科学研究都是以素数为基础的，因此，如何正确的判断一个数是否为素数非常重要。
在该文中，我们将介绍几种能够判断一个数是否为素数的算法，以便大家可以以此为基础，进行更深入的研究。
第一种判断素数的方法是“筛选法”。
该方法的简单思想是，从2开始，依次取出每个数，将这些数字放入一个列表中。
接着，从最小的数字开始，移除这个数字的倍数，也就是将该数字的倍数从列表中移除。
依次循环，直至移除到其它数字的2倍，最后，剩下的就是素数。
第二种判断素数的方法是埃氏筛法。
其实，埃氏筛法也是建立在筛选法的基础上的，但是它使用一种更为有效的方法。
它从2开始，将2的倍数（包括2）移除，然后将下一个未被移除的数取出，将它的倍数也移除，依次循环，至除尽所有数字，最后，剩下的数字就是素数。
第三种判断素数的方法是“算术基本定理”。
该定理提出，任何一个大于1的自然数，如果它可以分解为两个整数的乘积，那么这两个整数的乘积肯定可以分解为比乘积小的乘积。
同样，如果一个自然数大于1无法被分解为其它数的乘积，那么这个自然数就是素数。
第四种方法是“Miller-Rabin算法”，也被称为随机素数测试，这是一种概率算法。
它的思想是，通过一个随机过程，来判断一个大数是否为素数。
如果一个数被它判断出是素数，那么它是非常可靠的，但如果一个数被它判断出不是素数，那么还可能是素数，因此，需要对该算法的结果再进行检验。
以上就是素数的判断方法，当然，除了上述介绍的四种方法之外，还有其它方式来判断素数，我们也可以将它们结合起来，以保证结果的准确性。
在实际应用中，我们可以根据需要选择合适的方法，以获得最佳的效果。
总之，素数是数学界重要的概念，因此，如何正确的判断一个数是否为素数十分重要。
本文介绍了几种用于判断素数的算法，即筛选法，埃氏筛法，算术基本定理，Mill-Rabin算法，可以根据实际需要选择一种合适的算法，以便正确的判断一个数是否为素数。
素数筛法算法及其原理
素数筛法算法及其原理引⾔本⽂介绍部分素数筛法的步骤以及原理，并附带 python 算法的实现本⽂介绍的筛法有：厄拉多塞筛法（Eratosthenes Sieve ）Sundaram 筛法欧拉筛法（Euler Sieve ）分段筛法（Segmented Sieve ）增量筛（Incremental sieve ）Atkin 筛法厄拉多塞筛法（Sieve of Eratosthenes ）1. 厄拉多塞筛法步骤给定⼀个数 n，从 2 开始依次将 √n 以内的素数的倍数标记为合数标记完成后，剩余未被标记的数为素数（从 2 开始）算法原理如下：读取输⼊的数 n ，将 2 ⾄ n 所有整数记录在表中从 2 开始，划去表中所有 2 的倍数由⼩到⼤寻找表中下⼀个未被划去的整数，再划去表中所有该整数的倍数重复第(3)步，直到找到的整数⼤于 √n 为⽌表中所有未被划去的整数均为素数2. 厄拉多塞筛法原理⾸先，先证明这种⽅法能够标记所有 2~n 之间的合数。
由整数的唯⼀分解定理知，任意⼀个⼤于1的正整数都可以被分解成有限个素数的乘积。
因此，任意⼀个合数都可以看做是⼀个素数的倍数的形式。
对于任意⼀个合数 n ，存在 p, q ，使得 n = p·q （不妨设 p 为素数）同时可有 min(p, q) ≤ p ≤ √n ，否则会有 p · q ≥ min(p, q)2 ＞ n ，⽭盾故可知，任意合数都能被不⼤于 √n 的素数 p 标记其次，显然，该标记⽅法并不会错误地将素数标记成合数故该⽅法能且仅能标记所有 2~n 之间的合数，所以剩下未被标记的数就是素数（从 2 开始）3. 厄拉多塞筛法代码from math import sqrtdef sieve_of_eratosthenes(n: int):is_prime = [True for _ in range(n + 1)]for i in range(2, int(sqrt(n)) + 1):if is_prime[i]:for j in range(i * i, n + 1, i):is_prime[j] = False # 筛去j# 返回从2开始未被筛去的整数return [i for i in range(2, n + 1) if is_prime[i]]在筛去素数 p 倍数的过程中，我们是从 p 2 开始，⽽不是从 2·p 开始之前厄拉多塞筛法的原理中提到过，任意合数都能被不⼤于 √n 的素数标记。
算法：素数筛、线性筛
算法：素数筛、线性筛问题： 求n以内所有素数，⼀般的做法是： 1. 遍历2-n之间所有的数i 2. 每个数i再遍历所有⼩于它的数看是否能被⼩于它的某个数整除，如果可以者该数i有可以被整除的数则是和数，没有则是素数。
两层for循环，时间复杂度⾼。
解法⼀：素数筛 思想：⽤素数去标记合数，例如，已知最⼩的素数是2，那么2的所有倍数都是合数。
算法步骤： 1. ⽤prime[i]来标记i是否是合数 2. 标记为1的数字为合数，否则为素数 3. 第⼀次知道2是素数，则将2的倍数标记为1 4. 向后找到第⼀个没有被标记的数字i 5. 将i的倍数全部标记为合数 6. 重复4-6步，知道标记完范围内所有数控件复杂度：o(N); 时间复杂度：o(NlogNlongN) #存在重复标记#include<stdio.h>#define MAX_N 100int prime[MAX_N + 5] = {0};void init(){for (int i = 2; i <= MAX_N; i++){if (prime[i] != 0) continue;// ⽤素数标记合数，已经是合数的就不需要标记for (int j = 2 * i; j <= MAX_N; j += i) //i 素数i的倍数，所以从2*i，到每次j+i{prime[j] = 1;}}}int main(){init();for (int i = 2; i <= MAX_N; i++){if (prime[i] != 0) continue;printf("%d\n", i);}return0;}⼩优化：⽤prime[0]这⼀位⽤作计数，后⾯每⼀位记录具体的素数。
（不会和合数的标记冲突，因为此时i已经遍历过了，相当于可以回收利⽤来记录具体的素数了，当然也可以再开⼀个数组记录所有素数，只是没有必要）。
#include<stdio.h>#define MAX_N 100int prime[MAX_N + 5] = {0};void init(){for (int i = 2; i <= MAX_N; i++){if (prime[i]) continue;prime[++prime[0]] = i;// ⽤素数标记合数，已经是合数的就不需要标记for (int j = 2 * i; j <= MAX_N; j += i) // 素数i的倍数，所以从2*i，到每次j+i{prime[j] = 1;}}}int main(){init();for (int i = 1; i <= prime[0]; i++){printf("%d\n", prime[i]);}return0;}再次优化： 仔细想想，上⼀步其实存在这重复标记，举个例⼦： 对于素数2，会标记：4，6，8，10，12。
线性筛法求素数
线性筛法求素数
线性筛法是一种求素数的算法，它是埃拉托斯特尼筛法的简化版本。
其主要思想是：首先用2去筛，然后用3去筛，接下来用5去筛，依次类推，将不大于根号n的所有素数的倍数剔除，最后剩下的就是素数。
1.先把2到n之间的数字从小到大排列好，设定一个变量p等于2；
2.把2这个数字标记为素数，并把它的倍数都标记为非素数；
3.将变量p加1，如果变量p的值不大于根号n，则重复步骤2，否则将p的值作为素数；
4.重复步骤3，直到p的值大于根号n；
5.此时得到了从2到根号n之间的所有素数。
素数筛子算法-概述说明以及解释
素数筛子算法-概述说明以及解释1.引言概述部分的内容（1.1 概述）：在数学领域中，素数筛子算法是一种用于寻找素数（即只能被1和自身整除的数）的有效方法。
该算法通过标记和排除非素数的方式，可以高效地找出一定范围内的所有素数。
素数是一个重要的数学概念，具有广泛的应用价值。
在密码学、计算机科学、统计学等领域中，素数的特性被广泛利用。
因此，了解和掌握有效的素数查找算法对于解决相关问题具有重要意义。
素数筛子算法最早由希腊数学家埃拉托斯特尼（Eratosthenes）在公元前3世纪提出并应用于素数的研究中。
该算法基于一个简单而巧妙的思想：从2开始，逐个排除所有的倍数，最终留下的数即为素数。
通过不断筛选和排除，我们可以在有限的时间内找出指定范围内的素数。
本文将深入探讨素数筛子算法的原理和实现方法。
首先，我们将介绍素数筛子算法的基本原理和核心思想。
然后，我们将详细解析算法的具体实现步骤，包括如何标记和排除非素数，以及如何确定筛选的范围。
最后，我们将总结该算法的特点和局限性，并展望其在未来的应用前景。
通过本文的阅读，读者将对素数筛子算法有一个清晰的认识，并能够理解其在数学和计算领域的重要性。
同时，读者还将了解如何运用素数筛子算法解决实际问题，并对该算法的优化和拓展有一定的启发。
希望该文章能够帮助读者更好地理解和应用素数筛子算法，为数学和计算科学的发展贡献一份力量。
1.2 文章结构本文将从引言、正文和结论三个方面来进行论述素数筛子算法。
引言部分将对素数筛子算法进行概述，介绍其基本原理和应用领域。
同时，对本文的结构进行简单说明，让读者对文章的组织和内容有一个整体的了解。
正文部分将详细介绍素数筛子算法的原理和实现。
在2.1节中，将对该算法的原理进行阐述，包括筛选过程、核心思想和算法优势等内容。
在2.2节中，将展示具体的算法实现，并与其他常见的素数判断算法进行对比分析，以突出素数筛子算法的优势和特点。
结论部分将对整篇文章进行总结，并对素数筛子算法的应用前景进行展望。
线性筛法原理及素数表
线性筛法,即是筛选掉所有合数,留下质数我们知道合数可以由一个质数数与另一个数相乘得到而同时假设合数a=质数b×质数c×一个数d令e=c × d,假设b ≥ e,e为合数,令f=d × ba=f × c ,其中c即比一个合数数大的质数和该合数的乘积可用一个更大的合数和比其小的质数相乘得到这也是if(!( i % prime[j]))break;的含义,这也是线性筛法算质数表的关键所在原理:1. 任何一个合数都可以表示成一个质数和一个数的乘积2. 假设A是一个合数，且A = x * y，这里x也是一个合数，那么有:A = x * y; (假设y质数，x合数)x = a * b; (假设a是质数，且a < x)-> A = a * b * y = a * Z (Z = b * y)即一个合数(x)与一个质数(y)的乘积可以表示成一个更大的合数(Z)与一个更小的质数(a)的乘积这也是理解代码中if(i%primes[j] == 0)break;的关键例如: 如果i = 8; 那么由于i%2 == 0; 因此对于i=8就只需要检查primes[1]即可，因为对于大于primes[1]的质数，像3，有:8*3 = 2*4*3 = 12*2也就是说24(8*3=24)并不需要在8时检查，在12时才检查1#include<iostream>2using namespace std;34const int MAX=100;5bool isPrime[MAX+1];6int total;//计数7int prime[MAX+1];89//线性筛法寻找素数10void makePrime()11{12memset(isPrime,true,sizeof(isPrime));13memset(prime,0,sizeof(prime));14for(int i=2;i<=MAX;i++)15{16if(isPrime[i]) prime[total++]=i;17for(int j=0; j<total&&i*prime[j]<=MAX; j++)18{19isPrime[i*prime[j]]=false;20//i此时不是素数,只是拓展用21if(i%prime[j]==0)break; 22}23}24}2526int main()27{28makePrime();29for(int i=0;i<total;i++)30{31cout<<prime[i]<<"";32if((i+1)%10==0) cout<<endl; 33}34return0;35}。
素数检测算法
素数检测的几种算法素数，又称质素，除了能表示为它本身和1的乘积以为，不能表示为任何其它两个整数的乘积。
一、试除法根据素数的定义，假设要判断的自然数为n，那么最简单的方法便是用2~（n-1）之间的数字依次枚举试除一遍，如果能整除，那说明这个数不是素数，显然，此种算法的效率极低。
初学C语言的人会使用另一种改进的试除法，那便是除数不用取遍2~（n-1），而是取2~(int)sqrt(n)，但是当n很大时，此种算法的时间消耗也很大，也是不可取的。
二、筛选法筛选法事一种比较高校的判断素数的方法，能够一次性的筛选除某个区间的素数。
算法的基本原理也是利用了素数的定义，在某个范围内，依次去掉2的倍数，3的倍数，5的倍数……以此类推，一直到所有小于或等于n的数字的倍数都被去掉为止。
这就像一面筛子，把某个区间范围内满足条件的数留下来，其余的数字去掉，最后判断此区间内的某个数是否为素数时，时间复杂度就为O（1）。
很显然，时间的主要消耗都在于数字的筛选上。
利用给数组单元置零的方法来实现，创建一个数组a[i]，i=1、2、3……，用memset()函数将其全部置1，当i不是素数，则将a[i]置零。
代码实现如下：#define MAX N /*N为设置的某个数，确定一个判断区间*/int isprime[MAX];void is_prime1(){int i,j;memset(isprime,1,sizeof(isprime));for(i=2;i<MAX;i++){if(isprime[i])for(j=2*i;j<MAX;j+=i)isprime[i]=0;}}此种筛选算法可以优化为二次筛选，就是要求n以内的素数，就先把sqrt(n)内的素数求出来，再用已经求得的素数来筛选后面的合数。
2007年，复旦的xreborner将筛选法进一步改进为真正的线性时间复杂度，改进算法是增加了一个数组，记录已经找到的素数，通过这些已经找到的素数，来筛掉后面的数。
python求素数的方法(一)
在Python中，求素数的方法有多种，下面将逐一介绍各种方法及其实现原理。
1. 埃氏筛法埃氏筛法是一种较为常见且高效的求素数方法。
其原理是从2开始，依次将2的倍数标记为非素数，然后找到下一个未被标记的数，将其所有倍数标记为非素数，直到所有的数都被标记。
实现步骤：- 创建一个长度为n+1的布尔型数组prime，初始化所有元素为True- 从2开始遍历数组，如果prime[i]为True，则将i的倍数j标记为False - 遍历完成后，所有prime[i]为True的i就是素数2. 线性筛法线性筛法是对埃氏筛法的优化，通过记录最小质因数来达到去重的目的。
实现步骤：- 创建一个长度为n+1的整型数组prime，用来存储质数- 创建一个长度为n+1的整型数组low，用来存储每个数的最小质因数- 遍历2到n的所有数，如果low[i]为0，则将i加入prime数组- 遍历prime数组，将i的倍数j的最小质因数设为i3. Miller-Rabin算法Miller-Rabin算法是一种概率性算法，用于判断一个数是否为素数。
虽然不是求素数的方法，但可以用来判断一个数是否为素数。
实现步骤：- 将n-1分解为2^s * d的形式，其中d为奇数- 随机选择一个a，将其代入方程a^d % n，若结果为1或n-1，则n可能为素数- 重复k次以上步骤，若都满足条件，则n可能为素数4. 素数判定函数Python的标准库math中提供了素数判定函数isprime，可以用来判断一个数是否为素数。
实现步骤：- 使用(n)判断n是否为素数以上就是几种常见的求素数方法及其实现原理。
每种方法都有其适用的场景和特点，可以根据实际需求选择合适的方法来求解素数问题。
希望本文能够帮助读者更好地理解Python中求素数的方法。
7-1 求n以内最大的k个素数以及它们的和
要求n 以内最大的k 个素数以及它们的和，可以使用如下方法：1.使用线性筛法（例如埃拉托色尼筛法）求出 n 以内的所有素数。
2.将所有素数按从大到小的顺序排序，取前 k 个素数。
3.将取出的 k 个素数求和得到结果。
例如，求 100 以内最大的 3 个素数以及它们的和，可以这样做：1.使用埃拉托色尼筛法求出 100 以内的所有素数。
2.将所有素数按从大到小的顺序排序，取出前 3 个素数，即 97、89 和 83。
3.将取出的 3 个素数求和，得到结果 269。
这样就可以得到 100 以内最大的 3 个素数以及它们的和。
注意：这里的素数是指在大于1 的自然数中，除了1 和它本身以外不再有其他因数的数（也称质数）。
线性筛法线性筛法是一种用于求出某一范围内所有素数的算法，其中素数是指在大于1 的自然数中，除了 1 和它本身以外不再有其他因数的数（也称质数）。
线性筛法可以在线性时间内求出某一范围内所有素数，因此是一种非常高效的算法。
常见的线性筛法有埃氏筛法和埃拉托色尼筛法。
下面介绍埃拉托色尼筛法的具体实现方法：初始化一个布尔数组prime[2..n]，用来存储每个数是否为素数。
默认情况下，对于所有的 i（2≤i≤n），prime[i] 被赋值为 true。
从 2 开始，逐个枚举每个数 i（2≤i≤n）。
如果 prime[i] 为 true，则 i 是一个素数。
此时，将所有数 j（i≤j≤n，j%i=0）的 prime[j] 赋值为 false。
当 i 等于 n 时，算法结束。
此时，prime 数组中为 true 的数就是小于等于 n 的所有素数。
例如，要求 10 以内的所有素数，可以这样做：初始化一个布尔数组prime[2..10]，默认情况下，对于所有的i（2≤i≤10），prime[i] 被赋值为 true。
枚举数字 2，发现 prime[2] 为 true，说明 2 是素数。
此时，将所有数字 j（2≤j≤10，j%2=0）的 prime[j] 赋值为 false，即 prime[4]、prime[6]、prime[8] 和 prime[10] 都被赋值为false。
线性筛法（欧拉筛法）求素数和质因数分解
线性筛法（欧拉筛法）求素数和质因数分解时间复杂度O(n)当n⽐较⼤时欧拉筛法所⽤的时间⽐O(nloglogn)的算法的时间少的会越来越明显为什么呢?因为在欧拉筛法中，每⼀个合数只被访问并将其所对的f[]的值修改了⼀次。
下⾯以求n以内质数为例。
for(i = 2; i <= n; i++){if(f[i] == 0){p[++cnt] = i;}for(j = 1; j <= cnt; j++){if(i * p[j] > n)break;因为求n以内质数。
f[i * p[j]] = 1;if(i % p[j] == 0)break;//这句话是关键。
这句话保证了⼀个数被他最⼤的因数（除⾃⼰本⾝）筛。
也可以说是被最⼩的质因数筛。
}}⼿推⼀下可以清晰理解。
我来写⼀下。
就⽐如12是被2 6 筛掉的，⽽3 4 并没有去筛12 就是因为if(i % p[j] == 0)break;这句话保证了⼀个数被他最⼤的因数（除⾃⼰本⾝）筛。
4筛完8 因为4%2==0；打断当前循环，没有去筛12.延伸⼀下，既然欧拉筛能保证⼀个数是被其最⼩的质因数筛，那么我们就可以利⽤这⼀性质来对⼀个数进⾏质因数分解需要加的就是记录⼀下被哪个质数筛的。
if(f[i] == 0){p[++cnt] = i;s[i]=i;}f[i * p[j]] = 1;s[i*p[j]]=p[j];这两处写为这样，s记录的就是⼀个数的最⼩质因数，那么分解质因数时只需要不断去除当前数的最⼩质因数，知道除到1，质因数便分解完了。
【学习笔记】欧拉筛法（线性筛素数）
【学习笔记】欧拉筛法（线性筛素数）算法介绍：欧拉筛法是在O（N）线性时间内实现素数筛选的优秀算法。
算法思路：总体上与Eratosthenes筛法类似，也是⽤较⼩的数筛去较⼤的合数。
关键思路在于：每⼀个合数都保证是被其最⼩的质因⼦筛去的，下简称称该条件为线性条件。
结合代码分析：inline void Euler_Sieve(){for(register int i=2;i<=n;i++){if(isPrime[i]) pri[++cnt]=i;for(register int j=1;j<=cnt&&i*pri[j]<=n;j++){isPrime[i*pri[j]]=false;if(i%pri[j]==0) break;}}}对每⼀个数i，⽆论其是否为质数，都可以⽤其筛去其他数。
j 循环到 i % Prime[j] = 0就恰好需要break的理由是：设1<=s<j<t引理：的最⼩质因⼦必为。
证明：若最⼩质因⼦⽐pri[j]⼩，则在循环到j之前就已break，不可能循环⾄pri[j]。
引理：的最⼩质因⼦必为。
证明：引理1已证i的最⼩质因⼦为pri[j]，故i*pri[j]最⼩质因⼦也应为pri[j]。
引理2保证了被pri[j]筛掉的所有合数都满⾜线性条件。
引理：的最⼩质因⼦必为。
证明⽅法如引理1。
引理3保证了j之前所有被筛掉的合数都满⾜线性条件。
：的最⼩质因⼦必为。
证明⽅法：由引理1可易证。
故若j继续循环增⼤，则i*pri[t]将被pri[t]筛掉，但pri[t]并⾮其最⼩质因⼦，故不满⾜线性条件，故需break。
综上，当i%pri[j]==0的时候实⾏break操作可保证满⾜线性条件，实现线性筛。
线性筛素数（欧拉筛）
线性筛素数（欧拉筛）线性筛是⼀个很基础的算法，但是我⼀直没学。
直到⼀次考试，因为O（n√n）会超时，⽤了表筛，结果被卡了代码长度，于是开始学习欧拉筛。
算法思路：对于每⼀个数（⽆论质数合数）x，筛掉所有⼩于x最⼩质因⼦的质数乘以x的数。
⽐如对于77,它分解质因数是7*11，那么筛掉所有⼩于7的质数*77，筛掉2*77、3*77、5*77。
好吧，是不是听起来太简单了。
没事，重点在证明。
算法证明：⾸先我们要明确证明思路。
如果要证明它是对的，只要保证两点：没⽤重复筛、没有漏筛1、没有重复筛。
我们假设⼀个合数分解成p1*p2*p3，并且保证p1<p2<p3。
我们知道，筛掉这个合数的机会有：p1和p2*p3，p2和p1*p3，p3和p1*p2。
但我们知道，我们选择的那个质数必须⼩于那个合数的最⼩质因⼦。
⽐如p2和p1*p3，因为p2>p1,所以这样是筛不到的。
唯⼀会筛的是第⼀种：p1和p2*p3。
2、没有漏筛。
还是假设把这个合数分解质因数a*b*c，保证a<b<c然后我们设s=b*c，s肯定⼩于刚才那个合数，说明肯定对于它已经筛过，然后a肯定⼩于s，因为s=b*c，并且a是最⼩的因⼦。
说明a*s也就是这个合数⼀定筛过。
证明没看懂的直接看代码吧。
挺好背的。
#include <iostream>#include <cstdio>#include <algorithm>#include <cstring>#include <cstdlib>#define in(a) a=read()#define REP(i,k,n) for(int i=k;i<=n;i++)using namespace std;inline int read(){int x=0,f=1;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-1;for(;isdigit(ch);ch=getchar())x=x*10+ch-'0';return x*f;}int prime[1000010],book[1000010];int n,ind;int main(){//计算1~n的素数in(n);REP(i,2,n){if(!book[i]) prime[++ind]=i;//如果没有筛过，记录素数REP(j,1,ind){//其中记录数组⾥的素数保证严格递增if(i*prime[j]>n) break;//保证⼩于n，要不然没有意义book[i*prime[j]]=1;//筛去这个合数if(!i%prime[j]) break;//如果>=这个数的最⼩质因⼦，那就结束}}REP(i,1,ind) printf("%d ",prime[i]);//输出}。
素数的线性筛法
素数的线性筛法//整体思想是从自然数2开始与所有之前已经确定的素数相乘后的数标记为合数就能把素数一个不漏地找出来#include <set>#include <map>#include <queue>#include <stack>#include <math.h>#include <stdio.h>#include <stdlib.h>#include <iostream>#include <limits.h>#include <string.h>#include <string>#include <algorithm>#define MID(x,y) ( ( x + y ) >> 1 )#define L(x) ( x << 1 )#define R(x) ( x << 1 1 )#define FOR(i,s,t) for(int i=(s); i<(t); i++)#define FORD(i,s,t) for(int i=(s-1); i>=t; i--)#define BUG puts("here!!!")#define STOP system("pause")#define file_r(x) freopen(x, "r", stdin)#define file_w(x) freopen(x, "w", stdout)using namespace std;const int SULEN = 1000000;bool flag[SULEN+1];//是否为素数int prime[1000001];//存储的素数int sum[SULEN+1];//n的所有质因子的和void xianxingshai(void){int count,i,j;fill( flag,flag+SULEN,true ); //初始化假设每个都为素数fill( sum ,sum +SULEN, 0 ); //初始化质因子和为0flag[0] = flag[1] = false; //0和1不是素数for( count = 0, i = 2; i <= SULEN; i++ )//从2开始判断是否为素数{if( flag[i] ) //如果是素数{prime[count++] = i;sum[i] = i; //将值传到prime数组中}for( j = 0; j < count && i*prime[j] <= SULEN; j++ ) //将包含该质因数的合数都标为false{flag[ i*prime[j] ] = false;if( i%prime[j] == 0 ) //欧拉函数原理{sum[ i*prime[j] ] = sum[i]; break;}else sum[ i*prime[j] ] = sum[ i ] + prime[j];}}}int judgeprime(int n){int i;for(i=2;i<=sqrt(n);i++){if(n%i==0){return 1;}}return 0;}int main(int argc, char *argv[]){int i;xianxingshai();for(i=0;i<10;i++) //输出前10个质数{printf("%d ",prime[i]);}return 0;}。
C++线性筛素数
C++线性筛素数今天要写⼀篇亲民的博客了，尽⼒帮助⼀下那些不会线性筛素数或者突然忘记线性筛素数的⼤佬。
众所周知，⼀个素数的倍数肯定不是素数（废话）。
所以我们可以找到⼀个⽅法，普通的筛法（其实不算筛，普通的是判断⼀个数是不是素数）判断素数要从2循环到sqrt(这个数)（开跟符号不会打），但线性筛素数根据之前的素数直接就可以知道他后⾯的某个数是不是素数。
⼀个素数的判断⽅法是：如果有⼀个⽐他⼩的数乘上某个数，等于他，那么这个数就不是素数。
由此得知不是素数的数肯定有⼀个数可以被他整除（应该是这么说）。
这样⼀直往下⾛，最⼩的⼀个肯定是素数（细节留给同学们斯烤）。
于是我们从2开始，遇到素数就开始乘，⼀直到上限位置。
中间遇到的所有数⼀定全都是合数（上⾯讲过了的），我们把合数标记为1，遇到标记是0的数就是质数，然后重复上⼀步操作（就是⼀直乘，直到上限位置）。
处理完之后，标记是0的数就是素数，注意特判，0和1不是素数。
这么⼀说感觉不难的样⼦，放个代码#include<iostream>#include<math.h>using namespace std;int a[10000005],b[10000005];int main(){int m,n,s;cin>>m>>n;b[0]=1;b[1]=1;//初始化s=sqrt(m);//到开跟就⾏，在⼤就没必要了（a如果放⼤，⽽且超过上线，假设最多要乘上b，越过开跟后的a都是⼤于b的，在那之前，b已经先和a相乘了，所以⼤于开跟的数就没必要看了） for(int i=0;i<n;i++){cin>>a[i];//没⽤scanf（千古罪⼈啊）}for(int i=1;i<=s;i++)//顺⼿从1开始了，⽆伤⼤雅{if(b[i]==0)//这是⼀个素数{for(int j=i+i;j<=m;j+=i)//加上⾃⼰，注意开始位置是i+i，不然会把这个数标记成合数的。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
素数的线性筛法
//整体思想是从自然数 2 开始与所有之前已经确定的素数相乘后的数标记为合数就能把素数一个不漏地找出来
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <limits.h>
#include <string.h>
#include <string>
#include <algorithm>
#define MID(x,y) ( ( x + y ) >> 1 )
#define L(x) ( x << 1 )
#define R(x) ( x << 1 1 )
#define FOR(i,s,t) for(int i=(s); i<(t); i++)
#define FORD(i,s,t) for(int i=(s-1); i>=t; i--)
#define BUG puts("here!!!")
#define STOP system("pause")
#define file_r(x) freopen(x, "r", stdin)
#define file_w(x) freopen(x, "w", stdout)
using namespace std;
const int SULEN = 1000000;
bool flag[SULEN+1];// 是否为素数
int prime[1000001];// 存储的素数
int sum[SULEN+1];//n 的所有质因子的和
void xianxingshai(void)
{
int count,i,j;
fill( flag,flag+SULEN,true ); // 初始化假设每个都为素数
fill( sum ,sum +SULEN, 0 ); //初始化质因子和为0
flag[0] = flag[1] = false; //0 和 1 不是素数
for( count = 0, i = 2; i <= SULEN; i++ )// 从 2 开始判断是否为素数
{
if( flag[i] ) // 如果是素数
{
prime[count++] = i;sum[i] = i; //将值传到prime 数组中
}
for( j = 0; j < count && i*prime[j] <= SULEN; j++ ) // 将包含该质因数的合数都
标为
false
{
}
flag[ i*prime[j] ] = false;
if( i%prime[j] == 0 ) // 欧拉函数原理
{
sum[ i*prime[j] ] = sum[i]; break;
}
else sum[ i*prime[j] ] = sum[ i ] + prime[j];
}
}
}
int judgeprime(int n)
{
int i;
for(i=2;i<=sqrt(n);i++)
{
if(n%i==0)
{
return 1;
}
}
return 0;
}
int main(int argc, char *argv[])
{
int i;
xianxingshai();
for(i=0;i<10;i++) // 输出前10 个质数
{
printf("%d ",prime[i]);
}
return 0;。