素数算法优化
c++ 10000以内素数算法
c++ 10000以内素数算法一、概述本算法是一种用于寻找10000以内素数的C语言程序。
素数是指只有两个正因数（1和它自身）的自然数。
寻找素数的方法通常包括筛选法和埃拉托斯特尼筛法等。
本算法采用筛选法，通过循环遍历每个数，判断是否为素数，最终输出所有素数。
二、算法实现1. 初始化一个数组用来存储已检查过的数（初始化为0），以及一个计数器记录当前正在检查的数。
2. 从2开始循环到10000，每次循环将计数器加1。
3. 如果当前数是素数（即除了1和它自身以外没有其他因数），则将该数添加到已检查过的数数组中，并继续检查下一个数。
4. 如果当前数不是素数，则跳过该数，继续检查下一个数。
5. 检查完所有数后，输出已检查过的数数组中所有不重复的数，即为10000以内的素数。
以下是C语言代码实现：```c#include <stdio.h>int main() {int i, j, flag;int primes[100] = {0}; // 存储已检查过的数的数组int count = 0; // 当前正在检查的数的计数器for (i = 2; i <= 10000; i++) {count++; // 初始化计数器为1flag = 1; // 假设当前数为素数for (j = 2; j < count; j++) {if (i % j == 0) { // 如果存在除1和自身以外的因数，则不是素数flag = 0; // 不是素数，将标记设为0break;}}if (flag) { // 如果最后标记为1，说明是素数primes[count-1] = i; // 将素数添加到数组中}}printf("Prime numbers between 1 and 10000 are: ");for (i = 0; i < count; i++) {printf("%d ", primes[i]);}return 0;}```三、算法评估与优化本算法采用循环遍历的方式查找素数，时间复杂度为O(n^2)，在输入规模较小时表现较好。
python求素数个数最优方法
python求素数个数最优方法素数是指只能被1和自身整除的正整数，如2、3、5、7等。
求解素数个数是一个常见的问题，对于给定的范围内的整数，我们需要判断每个数是否为素数，并统计素数的个数。
本文将介绍使用Python 编程语言实现求解素数个数的最优方法。
一、暴力法最简单的方法是使用暴力法进行判断。
对于给定的范围内的每个整数，判断其是否能被范围内的其他整数整除。
如果没有能整除的数，则该整数为素数。
使用暴力法的代码如下所示：```pythondef is_prime(n):if n < 2:return Falsefor i in range(2, n):if n % i == 0:return Falsereturn Truedef count_primes(n):count = 0for i in range(n):if is_prime(i):count += 1return count```这种方法的时间复杂度为O(n^2)，效率较低。
在范围较大时，会耗费大量的时间进行判断。
二、埃氏筛法埃氏筛法是一种较为高效的筛选素数的方法。
该方法的基本思想是从2开始，将每个素数的倍数标记为合数。
具体步骤如下：1. 创建一个长度为n的布尔数组prime，初始值全为True。
2. 从2开始遍历数组，如果该元素为True，则将其所有倍数标记为False。
3. 遍历完成后，剩下的为True的元素即为素数。
使用埃氏筛法的代码如下所示：```pythondef count_primes(n):prime = [True] * ncount = 0for i in range(2, n):if prime[i]:count += 1for j in range(i*i, n, i):prime[j] = Falsereturn count```该方法的时间复杂度为O(nloglogn)，相较于暴力法有了显著的提升。
判断素数的算法流程图
判断素数的算法流程图素数，又称质数，是指在大于1的自然数中，除了1和自身外没有其他因数的数。
判断一个数是否为素数是数论中的一个重要问题，也是计算机科学中常见的算法问题。
本文将介绍判断素数的算法流程图，帮助读者更好地理解素数判断的过程。
首先，我们需要明确素数的定义，即除了1和自身外没有其他因数的数。
因此，判断一个数是否为素数，就是判断这个数能否被除了1和自身外的其他数整除。
为了简化问题，我们可以只考虑2到这个数的平方根之间的数，因为如果一个数可以被大于它的数整除，那么它一定也可以被小于它的数整除。
接下来，我们将介绍判断素数的算法流程图。
首先，我们需要输入一个待判断的数n，然后从2开始，依次判断n能否被2到sqrt(n)之间的数整除。
如果存在一个数能整除n，则n不是素数；如果所有的数都不能整除n，那么n是素数。
具体算法流程如下：1. 输入待判断的数n；2. 初始化变量i为2；3. 判断i是否小于等于sqrt(n)，如果是，则执行步骤4；如果不是，则执行步骤7；4. 判断n能否被i整除，如果能，则执行步骤6；如果不能，则执行步骤5；5. i加1，跳转到步骤3；6. 输出“n不是素数”，结束算法；7. 输出“n是素数”，结束算法。
通过以上算法流程图，我们可以清晰地看到判断素数的具体步骤。
首先，我们从2开始，依次判断n能否被2到sqrt(n)之间的数整除，如果存在能整除n的数，则n不是素数；如果所有的数都不能整除n，那么n是素数。
需要注意的是，为了提高算法的效率，我们可以在判断n能否被i整除时，将i的步长设为2，这样可以减少一半的判断次数。
另外，我们还可以对2进行特殊处理，因为2是素数中唯一的偶数素数，其他偶数均不是素数。
总之，判断素数是一个重要的数学和计算机科学问题，掌握判断素数的算法流程图对于理解素数的特性和算法设计具有重要意义。
希望本文能够帮助读者更好地理解判断素数的算法流程，同时也希望读者能够在实际问题中灵活运用这一算法。
大素数判断算法
大素数判断算法大素数判断算法是一个非常重要的算法，它在密码学、加密、网络安全等领域中都有广泛的应用。
本文将从定义、性质、常见算法和优化等方面进行介绍，旨在为读者提供全面指导，更好地理解和应用大素数判断算法。
一、定义素数，又称质数，指在大于1的自然数中，除了1和它本身，没有其他因数的数。
大素数就是指比较大的素数，一般指几百位或者几千位的素数。
二、性质1. 每个大素数的位数都很长，因此它们在计算机算法中的处理显然更为困难；2. 每个大素数都能保证一定的安全性，所以大素数在密码学和加密中被广泛使用；3. 大素数的产生是一项极其困难的任务，因为素数在自然数中的分布是相当稀疏的。
三、常见算法1. 暴力算法：该算法最简单，但效率较低，指一次次进行素数相除的过程。
当判断的数字特别大时，时间成本将十分高昂；2. 费马测试法（Fermat test）：该算法基于费马小定理，其基本思想是可以使用费马小定理检验一个数是否为素数，但存在错误的概率。
该算法的时间复杂度较低，适用于大素数的简单验证；3. 米勒-拉宾算法（Miller-Rabin test）：该算法是一种随机算法。
该算法通过实验测试一定规律的概率得出答案，且误差概率很小。
由于算法的速度较快，因此在一些应用中得到广泛的应用；4. 埃拉托斯特尼筛法（Sieve of Eratosthenes）：该算法利用了埃拉托斯特尼筛法，通过逐渐筛除不是素数的数，逐步加快了筛选的速度。
四、优化方法1. 同余法：该方法常用于有规律的素数的判断中。
例如，素数通常具有1或6余数，也就是说，如果大于等于5的整数是以1或6结尾，则可能是素数。
2. 大整数分解法：该方法利用可分解为两个较小整数的素数进行判断。
例如，对于一个大整数n，如果其能被两个素数p和q整除，则n也为素数。
3. 素数筛选法：该方法通过生成一张素数表，然后根据表中已有的素数进行筛选。
该方法的效率较高，但对于较大的整数来说，生成素数表的时间会很长。
素数常见的算法
求素数的三种方法
素数的定义：
素数也叫质数。
一个大于1的自然数，除了1和它本身之外，不能被其它自然数整除的数叫做素数；能被其它自然数整除的数叫做合数。
规定，1既不是质数也不是合数。
法一：试除法（判断素数）
让N被2如果N能被其中任何一个整数整除，则提前结束循环，N不是素数；如果N不能被其中任何一个整数整除，则N是素数。
代码实现：
法二：埃氏筛法（求一个范围中所有素数）
试除法可以用来判断一个数是否为素数，如果用来求某一范围内所有素数的话，效率就比较低。
埃氏筛法是用来解决这类问题的古老而简单高效的方法，可以快速找到[2,]n中的所有素数。
具体操作是这样的：从2开始寻找素数，每次找到一个素数后就将它的倍数全部筛掉，并将该素数存储到另一个数组中，不断循环，直到原数组为空。
法三：欧拉筛法（埃氏筛法的优化版）
埃氏筛法中，由于一个数可以既是一个素数的倍数，又是另一个素数的倍数，可以发现这会出现重复标记的情况，即同一个数被筛掉了不止一次，浪费操作了。
欧拉筛法就是在埃氏筛法的基础上多了判断的步骤，从而消失了这种重复标记的情况，核心思想是用合数中的一个因数筛掉这个合数。
具体操作为：利用已经求得的素数，第一重循环将区间内的数从小到大遍历，第二重循环将以求得的素数从小到大遍历，将这个数和素数的乘积标记为合数。
如果一个数能被素数整除，跳出循环。
素数的算法原理和应用
素数的算法原理和应用概述素数是指只能被1和自身整除的正整数。
素数在密码学、计算机科学和数学研究等领域具有重要的应用。
本文将介绍素数的算法原理以及在实际应用中的一些常见场景。
素数的判断算法判断一个数是否为素数是素数算法的基础。
常用的素数判定算法有两种：试除法和素数筛法。
试除法试除法是最简单直观的素数判定方法。
对于一个待判断的正整数n，只需从2开始遍历到sqrt(n)（即n的平方根）的整数m，检查是否有任何m能整除n。
若能找到能整除n的m，则n不是素数；否则，n是素数。
试除法的时间复杂度为O(sqrt(n))，适用于判断大部分整数是否是素数。
然而，对于非常大的数，这种方法的效率较低。
素数筛法素数筛法通过筛选法来判断素数。
其中最常用的是埃拉托斯特尼筛法。
首先，生成一个长度为n+1的布尔类型数组，将其初始值都设为true。
然后从2开始遍历到sqrt(n)的整数m，在数组中将2的倍数、3的倍数、4的倍数…全部标记为false。
最后，数组中值为true的索引对应的数就是素数。
素数筛法的时间复杂度为O(nloglogn)，虽然比试除法高效，但由于需要生成一个长度为n+1的数组，对于非常庞大的数，也存在一定的限制。
素数的应用素数在密码学、计算机科学和数学研究等领域有广泛的应用。
以下是一些常见的素数应用场景。
密码学中的应用素数在密码学中起到至关重要的作用，特别是在公钥密码学中。
其中一个常见的应用是RSA加密算法。
在RSA算法中，首先需要生成两个大素数p和q，然后计算它们的乘积n=p*q。
n被用作加密和解密过程中的模数，而p和q用于生成公钥和私钥。
素数的随机性应用素数的随机分布属性使其成为生成随机数的重要组成部分。
例如，质数的随机分布性质被广泛应用在随机数生成算法中，确保生成的随机数能够满足安全性和随机性的要求。
整数因子分解素数在整数因子分解中也有重要应用。
由于素数只能被1和自身整除，因此在将一个大数分解成其因子时，可以使用素数的概念来加快计算过程。
求100以内的素数（质数）算法梳理
求100以内的素数（质数）算法梳理质数定理：1、从2开始到⾃⾝的-1的数中找到⼀个能整除的（从2开始到⾃⾝开平⽅的数中找到⼀个能整除的）。
2、⼀个合数⼀定可以分解成⼏个质数的乘积，也就是说，⼀个数如果能被⼀个质数整除就是合数。
(使⽤列表保存质数）使⽤定理1的基本写法：（1）n = 100for i in range(2, n):for j in range(2, i):if i % j == 0:breakelse:print(i, end='')这种基本写法效率不⾼，有2点可以改进的地⽅：1、第⼀层循环的i取值时，因为偶数确定不是质数，所以排除偶数，使⽤range()函数排除偶数，range(3, n, 2)这样就减少了⼀半的数。
2、第⼆层循环j取值时，考虑从2开始到i开平⽅取值，同时也把偶数排除range(3, int(i**0.5)+1, 2)这样也可减少⼀半的数。
2就是质数，单独打印。
（2）改进（1）n = 100print(2)for i in range(3, n, 2):for j in range(3, int(i**0.5)+1, 2):if i % j == 0:breakelse:print(i, end='')(3)再（2）的基础上还有优化的点，发现第⼀层循环i取值时，当i>10时，5的倍数也可排除n = 100print(2)for i in range(3, n, 2):if i > 10 and i % 5 == 0:continuefor j in range(3, int(i**0.5)+1, 2):if i % j == 0:breakelse:print(i, end='')（4）利⽤定理2，⽤列表保存上⼀次的运算结果n = 100L = [2]for i in range(3, n, 2):for j in L:if i % j == 0:breakelse:L.append(i)print(L)此种写法的效率不⾼，第⼀层循环的i没必要与列表中的每⼀个元素取余，与从2开始到i的开平⽅处之间的数取余即可。
Miller-Rabin素数检测优化算法研究与实现
中图分 类号 ：ＴＮ９１８ 文献标识码 ：Ａ 文章编 号 ：１００９—２５５２（２０ｏ８）１２—０１４１—０３
Ｍｉｌｌｅｒ—Ｒａｂｉｎ素 数检 测 优 化 算 法 研 究 与 实 现
刘学军 ，邢玲玲 ，林和平 ，粟 浩然
（１．东北师范大学计算 机学院 ，长春 １３０１１７；２．吉林省 教育信息 中心 ，长春 １３００２２）
所 谓 的随机 搜索法 就是 对 随机产 生 的一个整 数 进 行素 ｌ生检测 ，如果是 素数 ，那么 活动 结束 ；否则 ，再 次随机产生一个 整数 ，对其进行 素性检测 ，如此循 环 ，直 至找 到一个 素数 为止 。
所 渭的 随 机 递 增 搜 索法 就 是 随 机 产 生 一 个 整 数 ，以它为起 点 ，采用 或递增 或递 减 的方式对 各个 整 数 依次 进行 检测 ，直 至找到 一个素 数 。
密 码破译 技术 的快 速 发 展 ，一 方 面促 进 了学 者 们 对加 密算 法 的深 入 研 究 ，另 一 方 面 对 现 有算 法 的 密钥长度 ，提出了更高的要求。一般来讲 ，在未来相 当长 的一 段 时期 内 ，使 用 ３００位 长 的大 整 数 做 密 钥 对 于像 ＲＳＡ这样 的算法 来说 是 比较 安全 的 ＿１ Ｊ。
实验结果表 明，随机 递增搜 索法 的搜索次 数是 随 机搜 索法 的 ８５％ ，从 整体来看 前者 优于 后者 ５ 作者简介 ：刘学军（１９６８一），男，工学博士，主要从事智能通信及信息安
全技 术 研 究 的工作 。
一
１４１ —
本文采取随机递 增搜索 法完成大素数的搜索过程 。
Ａｂｓｔｒａｃｔ： Ｔｏ ｓｏｌｖｅ ｔｈｅ ｓｅｒｉｏｕｓ ｐｒｏｂｌｅｍｓ ｓｕｃｈ ａｓ ｌｏｎｇ ｔｉｍｅ ｔｅｓｔｉｎｇ，ｌｏｗ ｔｅｓｔｉｎｇ ｅｆｉｃｉｅｎｃｙ ａｎｄ ＳＯ ｏｎ ｗｈｅｎ ｔｈｅ ｄｉｇｉｔ ｏｆ ｐｒｉｍｅ ｎｕｍｂｅｒ ｉｓ ｉｎｃｒｅａｓｉｎｇ，ｔｈｉｓ ｐａｐｅｒ ｐｒｅｓｅｎｔｓ ａ ｍｅｔｈｏｄ ｏｆ ａｄ￣ｎｇ ｐｒｅ—ｐｒｏｃｅｓｓｉｎｇ ｂｅｆｏｒｅ ｒｕｎｎｉｎｇ Ｍｉｌｌｅｒ－Ｒａｂｉｎ ａｌｇｏｒｉｔｈｍ ｔｏ ｉｍｐｒｏｖｅ ｔｈｅ ｓｐｅｅｄ ｏｆ ｔｅｓｔｉｎｇ ｂｙ ｒｅｄ ｕｃｉｎｇ ｔｈｅ ｔｉｍｅｓ ｏｆ ｐｏｗｅｒ－ｍｏｄｕｌｅ ｏｐｅ ｒａｔｉｏｎ ｉｎ ｏｒｉｇｉｎａｌ ａｌｇｏｒｉｔｈｍ ． Ｋｅｙ ｗｏｒｄｓ： ｐｒｉｍｅ ｎｕｍｂｅｒ；Ｍｉｌｌｅｒ－Ｒａｂｉｎ ａｌｇｏｒｉｔｈｍ；ｐｒｅ—ｐｒｏｃｅｓｓｉｎｇ
素数筛选法 欧拉筛选法
素数筛选法欧拉筛选法素数筛选法是一种用于快速找出一定范围内的素数的算法。
该算法的基本思想是从小到大依次遍历所有数，将其所有的倍数标记为合数，剩下的未被标记的数即为素数。
欧拉筛选法是一种改进的素数筛选法，其核心思想是对每个数仅标记它的最小质因数，并同时处理掉其所有的合数。
这样，每个合数都会被它的最小质因数筛掉，避免了重复标记的问题，提高了效率。
欧拉筛选法的具体步骤如下：1. 初始化一个布尔数组is_prime，大小为n+1，is_prime[i]表示数i是否为素数。
2. 初始化一个整数数组prime，用于存储筛选得到的素数。
3. 遍历2到n的每个数i：- 如果is_prime[i]为true，则将i加入prime数组，并将i的最小质因数设为i。
- 遍历prime数组中的素数p：- 如果i * p大于n，则退出循环。
- 将i * p标记为合数，并将其最小质因数设为p。
- 如果i能整除p，即i是p的最小质因数，退出循环。
4. 返回prime数组中的素数。
欧拉筛选法相较于传统的素数筛选法，在时间复杂度上有所提升。
原因在于，欧拉筛选法避免了对每个数重复标记合数的步骤，并且使用了最小质因数将每个合数筛掉，避免了重复工作。
对于欧拉筛选法的优化，还可以进一步使用升序遍历质数的方法，即i从小到大遍历时，除数p也按从小到大的顺序遍历。
这样能够进一步提高效率，因为对于每个数i，i * p最早被标记为合数的因子p一定是i的最小质因数。
通过欧拉筛选法可以快速得到一定范围内的素数，并且可以处理大范围的素数筛选。
素数在很多领域中都有重要应用，比如密码学、算法设计等。
因此，欧拉筛选法是一种非常实用和高效的算法。
总结起来，欧拉筛选法是一种基于素数筛选的算法，通过优化标记合数和使用最小质因数的方法，能够更加高效地找出一定范围内的素数。
该算法的特点是简单易懂、实现方便，使用广泛，并且在时间复杂度上有所提升。
这使得欧拉筛选法成为一种常用的素数筛选算法，对于解题和算法设计具有重要意义。
素数的算法原理及应用
素数的算法原理及应用简介素数，也称质数，是指除了1和它本身之外没有其他约数的自然数。
素数一直以来都在密码学、计算机科学和数论等领域有着重要的应用。
本文将介绍素数的算法原理及其在实际应用中的重要性。
素数的定义1.素数是只能被1和自身整除的自然数。
2.素数大于1，因为1既不是素数也不是合数。
素数的判断算法方法一：试除法试除法是最简单、直观的判断一个数是否为素数的方法，其基本原理是将待判断的数分别除以小于这个数的平方根的所有素数，如果能整除则不是素数，否则是素数。
这个方法的时间复杂度为O(sqrt(n))。
方法二：埃拉托斯特尼筛法埃拉托斯特尼筛法是一种筛选素数的方法，其基本思想是从2开始，将每个素数的倍数标记为合数，直到筛选完所有范围内的数。
这个方法的时间复杂度为O(n log log n)。
方法三：米勒-拉宾素性测试米勒-拉宾素性测试是一种概率性的素性测试方法，其基本原理是通过对一个数进行多次随机的测试，如果都通过了测试，则该数很大概率上为素数。
这个方法的时间复杂度较低，适用于大整数的素性测试。
素数的应用密码学在密码学中，素数常常用于生成加密密钥。
RSA加密算法就是基于大素数的乘法运算原理，将两个大素数相乘得到的乘积难以分解，从而保证了数据的安全性。
哈希算法在哈希算法中，素数经常被用作哈希函数的取模数。
素数的使用可以减小冲突的概率，提高哈希算法的效率。
赌博游戏素数在赌博游戏中也有着应用。
例如，轮盘赌游戏中，赌注的数值常常被选取为素数，这样可以降低赌客破解出赌注的概率，增加游戏的刺激性。
素数分布猜想素数的分布一直是数论中的一个重要问题。
素数定理是素数分布的基本描述，它给出了小于等于一个正整数x的素数的个数约为x/ln(x)。
这个猜想对于数论研究以及应用具有重要的参考价值。
总结素数作为数学中的重要概念，具有广泛的应用领域。
了解素数的算法原理以及其在实际应用中的重要性，可以帮助我们更好地理解和应用素数。
无论是在密码学、哈希算法还是赌博游戏中，素数都起着重要的作用。
素数判定算法
素数判定算法1. 素数判定问题素数判定问题是⼀个⾮常常见的问题，本⽂介绍了常⽤的⼏种判定⽅法。
2. 原始算法素数的定义是，除了能被1和它本⾝整除⽽不能被其他任何数整除的数。
根据素数定义只需要⽤2到n-1去除n，如果都除不尽，则n是素数，否则，只要其中有⼀个数能整除则n不是素数。
bool is_primer1(int num) {int i;for(i = 2; i < num; i++) {if(num % i == 0) {return true;}}return false;}3. 改进算法n不是素数，则n可表⽰为a*b，其中2<=a<=b<=n-1,则a，b中必有⼀个数满⾜：1<x<=sqrt(n)，因⽽，只需要⽤2~sqrt(n)去除n，这样就得到⼀个复杂度为O(sqrt(n))的算法bool is_primer2(int num) {int i;int upper = sqrt(num);printf("primer2:%d\n", upper);for(i = 2; i <= upper; i++) {if(num % i == 0) {return true;}}return false;}4. 筛选算法更⾼效地素数判断⽅法应该是将素数预先保存到⼀个素数表中，当判断⼀个数是否为素数时，直接查表即可。
这种⽅法需要解决两个问题：(1) 怎样快速得到素数表？（采⽤筛选⽅法）(2) 怎样减少素数表的⼤⼩？（采⽤位图数据结构）对于1到n全部整数，逐个判断它们是否是素数，找出⼀个⾮素数，就把它挖掉，最后剩下的就是素数。
具体⽅法是：<1> 定义is_primer[i] = true;<2> 从2开始，依次遍历整个is_primer(直到sqrt(N))，如果is_primer[i]=true,则is_primer[n*i]=false如1,2,3,4,5,6,7,8,9,10，则从2开始遍历：is_primer[2]=true，则is_primer[4]= is_primer[6]= is_primer[8]= is_primer[10]= trueis_primer[3]=true，则is_primer[6]= is_primer[9]= true为了减少内存使⽤率，算法使⽤了位图数据结构，关于位图，可参考：/structure/bitmap/bool load_primer_table1() { //保存素数表int i;for(i = 1; i < INT_MAX; i++) {if(i % 2 != 0 //偶数⼀定不是素数&& is_primer2(i)) {set(i);}}}bool load_primer_table2() {//另⼀种更快的⽅法保存素数表int i, j;for(i = 1; i <= INT_MAX; i++) {if( i % 2) {set(i);} else {clear(i);}}int upper = sqrt(INT_MAX);for(i = 1; i <= upper; i++) {if(test(i)) {for(j = i + i; j < INT_MAX; j += i)set(i);}}}bool is_primer3(long num) { //查表判断是否为素数if(test(num))return true;return false;}5. 优化的筛选算法(1) 存储⽅式优化仍然采⽤位图⽅式存储，只不过是位图中只存储奇数，这样⼀下⼦节省了⼀半空间（需要的空间仅为4G/(32*2)=64MB）存储空间优化后，算法效率也会提升很多，如：1,2，…,30只需存储3,5,7,9,11,13,15,17,19,21,23,25,27,29i=0, is_primer[0] =true, 把下标[3][6][9][12]，即9,15,21,27,标为falsei=1, s_primer[0] =true,把下标为[6][11],即15,25标为falsei=2, 2*i+3>sqrt(30),结束即：i=s, 把下标为s(2*t+1)+3t,其中，t=1,2,3，…中所有的的is_primer置为false(2) 优化删选算法a是素数，则下⼀个起点是a*a,把后⾯的所有的a*a+2*i*a筛掉。
DSA加密算法中素数选取的优化设计
（ ） 据 完 整性 服 务 １数 １ ２ 不等 式 验 证 ， ３＿ 目前 比较 知 名 的只 有 一 个 ， Ｅ Ｉ Ｎ 方案 。 即 ＳＧ 用 来 防 止 法用 户 的主 动攻 击 ， ｛ ＃ 以保 证 数 据 接 收方 收 到 的信 息 与 １ ． 公 钥 加 密 技 术 ４ 发送 方 发 送 的信 息 完 全 一 致 。 Ｄ Ａ 签名 算 法 ： Ｓ （ ） 据 源鉴 别 服 务 ２数 Ｄ Ａ（ｉｔ ｉ ａ ｒ ｔｍ ｔ １ Ｓｈ ｏ 和 ＥＧ ｍ ｌ 法 的 变 型， Ｓ Ｄｇ ｇ ｔ ｅＡ ｉ ｏｉ 是 ｃｎ￣ ｉＳｎ ｕ ｒｈ ｃ Ｉａ ａ 算 用 来 确 保 数 据 由合 法 实 体 发 出． 供 对 数 据 源 的 对 等 实 体 进 行 鉴 提
要 】 字签 名技 术是 电子 签章 系统 的技 术基 础 。 中对 数 字 签 名原 理 、 成 和公 钥 加 密 算 法做 了大 量 比较 研 究 ， 此基 础 上 设 计 了一 数 文 构 在
款 适 用 有 效 的数 字签 名 算 法 ， 对 算 法 中 用到 的 大 素数 选 取 方 法进 行 了优 化 。 并 通过 优 化 算 法 大 大提 高 了数 字 签名 加 密 的 效 率 。 实验 证 明 该 算 法 有效 可 行 。 【 关键 词 】 字签 名 ： 法 ； 数 算 密钥 ： 素数
【 ｙｗｏｄ 】 ｉｉ ｌ ｉ ａｕｅ Ａｇｒｈ Ｋ ｙＰ ｍｅｎ ｍ ｅｓ Ｋｅ ｒｓ Ｄｇａ ｓ ｎｔｒ ； ｌ ｉ ｍ； ｅ ；ｒ ｕ ｂｒ ｔ ｇ ｏｔ ｉ
１ 数字 签 名 技术
１２ 数字 签 名 技 术 的安 全 性 ． 数 宁签 名 方 案 是安 全 的 ，因为 这 些 方 案 通 常是 基 于加 密 技 术 的 。
c++判断素数的算法
c++判断素数的算法C++中常用的判断素数的算法有多种，下面我将从多个角度给出几种常见的算法。
1. 基本算法，遍历2到n-1的所有数，判断n是否能被这些数整除。
若存在能整除n的数，则n不是素数；反之，n是素数。
这种算法的时间复杂度为O(n)。
c++。
bool isPrime(int n) {。
if (n <= 1) {。
return false;}。
for (int i = 2; i < n; i++) {。
if (n % i == 0) {。
return false;}。
}。
return true;}。
2. 优化算法1，在基本算法的基础上，我们可以观察到，如果一个数n不是素数，那么它的最小因子肯定不会超过sqrt(n)。
因此，我们只需要遍历2到sqrt(n)的数即可。
这种算法的时间复杂度为O(sqrt(n))。
c++。
bool isPrime(int n) {。
if (n <= 1) {。
return false;}。
for (int i = 2; i <= sqrt(n); i++) {。
if (n % i == 0) {。
return false;}。
}。
return true;}。
3. 优化算法2，进一步优化，我们可以观察到，一个数n如果不是素数，那么它的最小因子肯定是一个质数。
因此，我们可以先生成一组质数，并用这些质数来判断n是否是素数。
这种算法被称为埃拉托斯特尼筛法（Sieve of Eratosthenes）。
c++。
bool isPrime(int n) {。
if (n <= 1) {。
return false;}。
vector<bool> isPrime(n + 1, true); isPrime[0] = false;isPrime[1] = false;for (int i = 2; i i <= n; i++) {。
if (isPrime[i]) {。
DSA加密算法中素数选取的优化设计
DSA加密算法中素数选取的优化设计论文摘要：数字签名技术是电子签章系统的技术基础。
文中对数字签名原理、构成和公钥加密算法做了大量比较研究，在此基础上设计了一款适用有效的数字签名算法，并对算法中用到的大素数选取方法进行了优化。
通过优化算法大大提高了数字签名加密的效率。
实验证明该算法有效可行。
论文关键词：数字签名,算法,密钥,素数1数字签名技术近几年，政务电子化成为了社会数字化的一个新的进展方向，电子签章系统是政府部门用于电子文件安全认证的首选，而数字签名是电子签章系统的技术基础。
数字签名，是为了使接收方能够向第三方证明其收到消息的真实性和发送源的真实性而采取的一种加密措施。
数字签名作为一个手写签名的代替方案,必须提供以下安全服务：(1)数据完整性服务；用来防止非法用户的主动攻击，以保证数据接收方收到的信息与发送方发送的信息完全一致。
(2)数据源鉴别服务；用来确保数据由合法实体发出,提供对数据源的对等实体进行鉴别,以防假冒。
(3)禁止否认服务；又称不可否认性,这种服务用来防止发送数据方发送数据后否认自己发送过数据,或接收方接收数据后否认自己收到过数据。
1.1数字签名的原理流程数字签名体系的目的在于保证数据来源的可靠性和其输入时刻的不可否认性，一样由数字信封结构、签名算法、公钥基础设施PKI等部分组成。
签名算法一样由公布密钥密码算法（RSA、ELGamal、DSA、ECDSDA等），对称密钥密码算法（DES，AES等）和单向散列函数（MD2、MD4、MD5或SHA等）构成。
具体的数字签名的原理如下：（1）被发送文件采纳哈希算法对原始报文进行运算，得到一个固定长度的数字串，称为报文摘要(MessageDigest)，不同的报文所得到的报文摘要各异，但对相同的报文它的报文摘要却是唯独的。
（2）发送方生成报文摘要，用自己的私钥对摘要进行加密形成发送方的数字签名。
（3）那个数字签名将作为报文的附件和报文一起发送给接收方。
C++求素数的算法
C++求素数的算法
素数是指只能被1和自身整除的正整数。
其在数学和计算机科学中扮演着重要角色。
求解素数的算法也因此被广泛使用。
一、朴素算法
朴素的算法是最基本的一种算法。
它的核心思想就是从2开始，一直到目标数n，如果当前这个数能被前面的数整除，那么说明它不是素数，否则它就是素数。
这种算法显然是非常简单粗暴的，但也最容易实现。
C++代码：
优点：实现简单，易于理解。
缺点：效率低下。
对于大的n，必须要检测n/2个数，效率很低。
二、厄拉多塞筛法
欧拉在18世纪提出了一种更加高效的寻找素数的方法，也就是所谓的“欧拉筛”或“厄拉多塞筛法”。
具体思路是从2开始，将每个素数的倍数都标记成合数，以达到筛选素数的目的。
具体实现可以使用一个bool数组来进行标记。
当然，在实际使用中，可以根据需求进行一些优化。
优点：比朴素算法效率更高，通过标记可以减少循环次数。
缺点：需要额外的空间用于存储标记数组。
三、素数定理
素数定理是一种利用数学方法求解素数的算法。
该定理由欧拉和高斯等人提出，并被证明是正确的。
它的表述是：小于x的素数个数约为x/ln(x)。
这个定理是通过数学分析和数学公式的推导所得出的。
优点：不需要额外的空间存储数组，而且计算量很小，只需要一次循环即可。
缺点：无法直接求出所有的素数，只能求出小于n的素数个数。
质数算法
质数算法质素，又称素数，只能被1和自身整除。
判定一个数n是否为质数的简单方案：将n对i（2<=i<=n-1）逐一检查是否能整除。
优化（一）若i为n的因子，则n/i也必为n的因子，所以，若n没有<=n的因子，必定不会有>n的因子，所以i的范围可以缩小为(2<=i<=n)优化（二）若n为偶数，必不是质数，若n为奇数，其因子必不可能为偶数，所以i的范围可以再次缩小为(3<=i<=n；i=i+2;)优化后的判定质数的函数算法如下：int prime(int n){int i,k;if(n==1) return 0;if(n==2) return 1;if(n%2==0) return 0;k=(int)sqrt(n);for(i=3;i<=k;i=i+2)if(n%i==0) return 0;return 1;}若想判定一个区间[1,a]内有多少质数，用上述方法会超时，此时可选用筛选法例：求1到20中质数的个数将1删去，余下最小的数2为质数，将所有大于2的2的倍数删除以此类推，将整个表全部过一遍就完成了筛选。
剩余的必定全为质数#define N 10001bool isprime[N]; //布尔型，true为真，false为假int i,j;isprime[0]=isprime[1]=false;for(i=2;i<=N;i++)isprime[i]=true; //初始化原表for(i=2;i<=N;i++)if(isprime[i])for(j=i+i;j<=N;j=j+i)isprime[j]=false;若想判定区间[a,b]内（1<=a<b<=2.1*109,b-a<=1000000)，此时可用双重筛法，即在<=b的小范围内筛出质数k的同时，筛选[a,b]内>k的k倍数。
难点1：已知某质数k，[a,b]最小的大于k的k倍数为Max((a+k-1)/k,2)*k 难点2：[a,b]中的某数m，对应的big数组中的元素下标为m-a#define N 1000001bool small[50000],big[N];for(i=2;i<=sqrt(b);i++)small[i]=true;for(i=0;i<=b-a;i++)big[i]=true;for(i=2;i<=sqrt(b);i++)if(small[i]){for(j=i+i;j<=sqrt(b);j=j+i)small[j]=false;for(j=(Max(a+i-1)/i,2)*i;j<=b;j=j+i)big[j-a]=false;}。
素数表算法
素数表算法一、介绍素数（Prime Number）是指大于1且只能被1和自身整除的正整数。
素数在数论和计算机科学中具有重要的应用价值，如密码学、质因数分解等领域。
素数表是一种将素数按顺序排列并列出的表格。
素数表算法就是用来生成素数表的数学方法和计算机程序。
二、素数的判断方法为了生成素数表，我们首先需要能够判断一个数是否为素数。
以下是常用的素数判断方法：1.试除法：将待判断的数n与2到√n之间的数逐一相除，如果存在能整除n的数，n就不是素数；否则，n是素数。
这种方法简单易懂，但对于大数效率较低。
2.费马检测：费马定理指出，如果一个数n是素数，那么对于任意不为0的整数a，都有a的n次方与a模n同余。
费马检测就是基于这个理论，通过随机取一个数a，对n进行多次的模幂运算，如果有一个结果不满足费马定理，那么n就不是素数。
这种方法适用于大数，但可能会有伪素数的情况。
3.米勒-拉宾检测：米勒-拉宾检测是费马检测的改进版，在费马基础上引入了确定性检测，通过多次的模幂运算来判断一个数是否为素数。
这种方法即适用于大数，又能够排除伪素数的情况。
三、生成素数表的算法生成素数表的算法可以应用上述素数判断方法，通过循环判断每个数是否为素数，并将素数加入素数表中。
以下是一种常用的素数表生成算法：1.埃拉托斯特尼筛法：也称作埃氏筛法，是一种通过排除法生成素数表的算法。
算法的基本思想是首先将2到n之间的所有数列出来，然后在2的倍数、3的倍数、以此类推直到√n的倍数处进行标记，最后留下没有被标记的数，即为素数。
这种算法在时间复杂度上较低，适用于生成较小的素数表。
–步骤：1.初始化一个长度为n的标记数组，将所有元素初始化为true。
2.从2开始，将标记数组中对应的所有倍数位置为false，表示不是素数。
3.当遍历到√n时停止。
4.遍历标记数组，将值为true的位置对应的数字加入素数表。
5.输出素数表。
四、示例代码以下是使用埃拉托斯特尼筛法生成素数表的示例代码（Python）：def generate_prime_table(n):# 初始化标记数组is_prime = [True] * (n + 1)is_prime[0] = is_prime[1] = False# 标记倍数位置为Falsefor i in range(2, int(n**0.5) + 1):if is_prime[i]:for j in range(i*i, n+1, i):is_prime[j] = False# 输出素数表prime_table = [i for i in range(n + 1) if is_prime[i]]return prime_table# 生成100以内的素数表prime_table = generate_prime_table(100)print(prime_table)五、应用和优化素数表算法不仅可以用于生成素数表，还可以解决一些与素数有关的问题，如质因数分解、最大公约数、欧拉函数等。
素数的计算方式
素数的计算方式
素数，也叫质数，是指只能被1和自身整除的正整数，如2、3、5、7、11等。
计算素数的方法有很多种，以下介绍一些常见的方法。
1.试除法：试除法是最简单的一种判断素数的方法，即对于一个数n，只需用从2到√n的所有整数去除一遍n，如果都不能整除，则n为素数。
但是试除法的缺点是当n非常大时，需要判断的数也相应增加，计算量非常大。
2. 埃拉托色尼筛法：埃拉托色尼筛法是一种可以找出一定范围内素数的高效算法。
该算法的基本思想是：从2开始到n，所有的数都标记为素数，然后从2开始，将每个素数的倍数标记为合数，直到所有小于n的素数都被标记。
这样，未被标记的数即为素数。
该算法的时间复杂度为O(nloglogn)，比试除法要快很多。
3. 米勒-拉宾素性检验：米勒-拉宾素性检验是一种概率性的素性测试算法。
该算法的基本思想是利用费马小定理：如果p是素数，那么对于所有的a，a^(p-1) ≡1(mod p)。
该算法的步骤是：先把n-1分解成2^k * q的形式，然后随机选择a(2≤a≤n-2)并计算a^q mod n，如果结果为1或者n-1，则n极有可能是素数，否则继续计算a^2q, a^4q, …, a^(2^(k-1)q)，若其中某一项为n-1，则n也有可能是素数；
若所有计算结果都不是1或n-1，则n一定不是素数。
该算法的时间复杂度为O(k * log^3n)，是一种较快的素性测试算法。
以上是一些常见的计算素数的方法，当然也有更多其他的方法，选择适合的方法取决于具体的应用场景和需求。
自然科学史与方法论 素数
自然科学史与方法论一、素数的定义和特性1.1 素数的定义素数是指只能被1和自身整除的正整数。
换句话说，素数没有除了1和它本身以外的因子。
例如，2、3、5、7等都是素数。
1.2 素数的特性素数具有以下重要特性： 1. 素数无法被分解为其他两个较小数的乘积。
2. 素数的个数是无限的。
3. 素数分布并不规律，没有明显的规律性可寻。
二、素数的历史2.1 古希腊时代在古希腊时代，素数首次被严格地研究。
著名的古希腊数学家欧几里得（Euclid）在其著作《几何原本》中，提出了一种著名的证明方法，称为欧几里得算法。
这一方法可以用来判断一个数是否为素数，以及寻找两个数的最大公约数。
2.2 古代中国古代中国的数学家也对素数进行了深入研究。
他们通过试除法、排除法等方法来判断和寻找素数。
中国古代数学家陶谦（Tao Qian）提出了一种寻找素数的算法，被称为陶谦筛。
这一算法在寻找素数方面具有一定的实用性。
2.3 中世纪欧洲在中世纪欧洲，数学的发展进一步推动了对素数的研究。
著名数学家费马（Fermat）提出了一个著名的素数判定定理，即费马小定理。
这一定理可以用来判断一个数是否为素数，虽然并非完全准确，但在实际应用中仍然具有一定的价值。
2.4 现代数学随着现代数学理论的发展，对素数的研究进入了一个新的阶段。
数论作为数学的一个重要分支，专门研究整数的性质和关系，对素数的研究也成为数论的核心内容之一。
著名数学家哥德巴赫（Goldbach）、欧拉（Euler）、狄利克雷（Dirichlet）等人在素数的研究方面做出了重要的贡献。
三、素数的应用3.1 加密算法素数在现代密码学中具有重要作用。
著名的RSA加密算法就是基于素数的乘法运算原理。
RSA加密算法的安全性基于分解大数的困难性，而分解大数的过程依赖于素数分解。
因此，素数的研究与应用对于保障信息安全具有重要意义。
3.2 数学建模素数在数学建模中有广泛应用。
例如，在通信领域中，素数序列经常用于数据传输和信号处理。
最优素数域的优化蒙哥马利算法:设计、分析与实现
最优素数域的优化蒙哥马利算法：设计、分析与实现刘哲;王伊蕾;徐秋亮【期刊名称】《密码学报》【年(卷),期】2014(0)2【摘要】蒙哥马利算法是公钥密码实现的基础算法,在椭圆曲线加密中的标量乘法和RSA算法中的模幂运算以及基于双线性对的密码中都有重要的应用.在基本的素数域运算中,高效实现多精度模乘法对于基于RSA和椭圆曲线的相关协议的效率至关重要.最优素数域是在2006年提出的一种特殊的素数域,所有的最优素数域都有一个为M=m.2k+l的形式,其中m和l的取值远远小于2k.这种低汉明重量的素数域使得基于该域的域运算非常快.本文提出了几种特别为最优素数域设计的新的优化蒙哥马利算法,我们命名为最优素数域蒙哥马利算法,并且从理论上分析了新提出的最优素数域蒙哥马利算法的计算复杂性.为了评估新提出算法的性能,我们用C语言在AVR8位微处理器上进行了实验.实验结果表明:与标准的蒙哥马利算法比较(操作数长度为160位到256位),最优素数域蒙哥马利算法最多可以节省36.5％到41.5％的执行时间.【总页数】13页(P167-179)【作者】刘哲;王伊蕾;徐秋亮【作者单位】卢森堡大学算法、密码学与安全实验室,卢森堡L-1359;山东大学计算机科学与技术学院,济南250101;山东大学计算机科学与技术学院,济南250101【正文语种】中文【中图分类】TP309.7【相关文献】1.遗传算法在风险分析最优化系统中的实现 [J], 王家华;廖方茵2.基于编码算法的组合逻辑电路最优化软件的设计与实现 [J], 王波;管致锦;刘维富;顾晖;邱建林3.基于均匀设计与Powell算法的全局最优化算法及并行实现 [J], 汪文英;沈斌;陆忠华;迟学斌;余慧4.简化的最优解算法实现--高校分班程序设计分析 [J], 刘现国;汪永高5.约束数据域三角剖分算法构建DTM的优化设计与实现 [J], 李鹤元;王轩;罗斌因版权原因，仅展示原文概要，查看原文内容请购买。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
我们可以发现一个规律，那就是3（即i=0）是从下标为[3]的开始筛的，5（即i=1）是从下标为[11]开始筛的（因为[6]
已经被3筛过了）。然后如果n很大的话，继续筛。7（i=2）本来应该从下标为[9]开始筛，但是由于[9]被筛过了，而
第 1 步过后2 4 ... 28 30这15个单元被标成false,其余为true。
第 2 步开始：
i=3; 由于prime[3]=true, 把prime[6], [9], [12], [15], [18], [21], [24], [27], [30]标为false.
原理很简单，就是当i是质(素)数的时候，i的所有的倍数必然是合数。如果i已经被判断不是质数了，那么再找到i后面的质数来把这个质
数的倍数筛掉。
一个简单的筛素数的过程：n=30。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
1.高斯猜测，n以内的素数个数大约与n/ln(n)相当，或者说，当n很大时，两者数量级相同。这就是著名的素数定理。
2.十七世纪费马猜测，2的2^n次方+1，n=0，1，2…时是素数，这样的数叫费马素数，可惜当n=5时，2^32+1就不是素数，
至今也没有找到第六个费马素数。
3.18世纪发现的最大素数是2^31-1，19世纪发现的最大素数是2^127-1，20世纪末人类已知的最大素数是2^859433-1，用十进制表示，这是一个258715位的数字。
i=4; 由于prime[4]=false,不在继续筛法步骤。
i=5; 由于prime[5]=true, 把prime[10],[15],[20],[25],[30]标为false.
i=6>sqrt(30)算法结束。
第 3 步把prime[]值为true的下标输出来：
在程序设计竞赛中就必须要设计出一种更好的算法要求能在几秒钟甚至一秒钟之内找出n以内的所有素数。于是就有了素数筛法。
（我表达得不清楚的话不要骂我，见到我的时候扁我一顿我不说一句话。。。）
素数筛法是这样的：
1.开一个大的bool型数组prime[]，大小就是n+1就可以了.先把所有的下标为奇数的标为true,下标为偶数的标为false.
for(i=2; i<=30; i++)
if(prime[i]) printf("%d ",i);
结果是 2 3 5 7 11 13 17 19 23 29
这就是最简单的素数筛选法，对于前面提到的10000000内的素数，用这个筛选法可以大大的降低时间复杂度。把一个只见黑屏的算法
if( prime[i] )printf("%d ",i);
return 0;
}
装了vc的同学上机跑一下这两个程序试一试。这个差别，绝对是天上地下。前面那个程序绝对是n分钟黑屏的说。
另外，对于这样的筛法，还可以进一步优化，就是bool型数组里面只存奇数不存偶数。如定义prime[N],则0表示
至今为止，没有任何人发现素数的分布规律，也没有人能用一个公式计算出所有的素数。关于素数的很多的有趣的性质或者科学家的努力
我不在这里多说，大家有兴趣的话可以到或google搜一下。我在下面列出了一个网址，上面只有个大概。更多的知识需要大家一点一点
地动手收集。
/discovery/universe/home01.html
return 0;
}
//o.h>
#include<math.h>
#define N 10000001
bool prime[N];
int main()
{
int i, j;
for(i=2; i<N; i++)
接触过程序竞赛之前我也只会这一种求n以内素数的方法。-_-~）不会耗时很多.
但是当n很大的时候，比如n=10000000时，n*sqrt(n)>30000000000,数量级相当大。在一般的机子它不是一秒钟跑不出结果，它是好几分钟都跑不
出结果，这可不是我瞎掰的，想锻炼耐心的同学不妨试一试~。。。。
则由于只存3 5 7 9 11 13 15 17 19 21 23 25 27 29，只需要14个单元
第 1 步 把14个单元赋为true (每个单元代表的数是2*i+3,如第0单元代表3，第1单元代表5...)
第 2 步开始：
i=0; 由于prime[0]=true, 把 [3], [6], [9], [12]标为false.
if( j%i==0 ) break;
if( j>sqrt(i) ) prime[num++] = i; //这个prime[]是int型，跟下面讲的不同。
}
这就是最一般的求解n以内素数的算法。复杂度是o(n*sqrt(n))，如果n很小的话，这种算法（其实这是不是算法我都怀疑，没有水平。当然没
i=1; 由于prime[1]=true, 把 [6], [11]标为false
i=2 2*i+3>sqrt(30)算法结束。
这样优化以后总共只走6个单位时间。
当n相当大以后这样的优化效果就更加明显，效率绝对不仅仅是翻倍。
出了这样的优化以外，另外在每一次用当前已得出的素数筛选后面的数的时候可以一步跳到已经被判定不是素数的
优化到立竿见影，一下就得到结果。关于这个算法的时间复杂度，我不会描述，没看到过类似的记载。只知道算法书上如是说：前几年比
较好的算法的复杂度为o(n),空间复杂度为o(n^(1/2)/logn).另外还有时间复杂度为o(n/logn),但空间复杂度为O(n/(lognloglogn))的算法。
我水平有限啦，自己分析不来。最有说服力的就是自己上机试一试。下面给出这两个算法的程序：
[16]也已经被5（i=1）筛过了。于是7（i=2）从[23]（就是2*23+3=49）开始筛。
于是外围循环为i时，内存循环的筛法是从 i+(2*i+3)*(i+1)即i*(2*i+6)+3开始筛的。
这个优化也对算法复杂度的降低起到了很大的作用。
相比于一般的筛法，加入这两个优化后的筛法要高效很多。高兴去的同学可以试着自己编写程序看一看效率。我这里
4.孪生素数猜想：差为2的素数有无穷多对。目前知道的最大的孪生素数是1159142985×2^2304－1和1159142985×2^2304＋1。
5.歌德巴赫猜想：大于2的所有偶数均是两个素数的和，大于5的所有奇数均是三个素数之和。其中第二个猜想是第一个的自然推论，因此歌德巴赫猜想又被称为1+1问题。我国数学家陈景润证明了1+2，即所有大于2的偶数都是一个素数和只有两个素数因数的合数的和。国际上称为陈氏定理。
3，1表示5，2表示7，3表示9...。如果prime[0]为true,则表示3时素数。prime[3]为false意味着9是合数。
这样的优化不是简单的减少了一半的循环时间，比如按照原始的筛法，数组的下标就对应数。则在计算30以内素
数的时候3个步骤加起来走了15个单位时间。但是用这样的优化则是这样：
if(i%2) prime[i]=true;
else prime[i]=false;
for(i=3; i<=sqrt(N); i++)
{ if(prime[i])
for(j=i+i; j<N; j+=i) prime[i]=false;
}
for(i=2; i<100; i++)//由于输出将占用太多io时间，所以只输出2-100内的素数。可以把100改为N
//最普通的方法：
#include<stdio.h>
#include<math.h>
#define N 10000001
int prime[N];
int main()
{
int i, j, num = 0;
for(i=2; i<N; i++)
{ for(j=2; j<=sqrt(i); j++)
有程序，需要的可以向我要。不懂得也可以问我。
上面的素数筛法是所有程序设计竞赛队员都必须掌握的，而后面加了两个优化的筛法是效率很高的算法，是湖南大学
huicpc39同学设计的（可能是学来的，也可能是自创的。相当强悍）。在数量级更大的情况下就可以发现一般筛法和
优化后的筛法的明显区别。
另外，台湾的ACMTino同学也给我介绍了他的算法：a是素数，则下一个起点是a*a,把后面的所有的a*a+2*i*a筛掉。
关于搜寻一定范围内素数的算法及其复杂度分析
——曾晓奇
关于素数的算法是信息学竞赛和程序设计竞赛中常考的数论知识，在这里我跟大家讲一下寻找一定范围内素数的几个算法。看了以后相信
if( j%i==0 ) break;
if( j>sqrt(i) ) prime[num++] = i;
}
for(i=2; i<100; i++) //由于输出将占用太多io时间，所以只输出2-100内的素数。可以把100改为N
if( prime[i] )printf("%d ",i);