枚举1--求小于n的最大素数

转载

mb5fe55a455f6b0 2017-05-31 10:31:00

枚举1--求小于n的最大素数

总结：

素数是不能被比它小的素数整除。

1 /*
  2 枚举就是基于已有知识镜像答案猜测的一种问题求解策略
  3 
  4 问题：求小于n的最大素数
  5 
  6 分析：
  7     找不到一个数学公式，使得根据N就可以计算出这个素数
  8     
  9     我们思考：
 10     N-1是素数么？N-2是素数吗？...
 11     
 12     所以我们就是判断N-K是否为素数：
 13     N-K是素数的充分必要条件：N-K不能被[2,n-k)中任何一个整除
 14     
 15     判断N-K是否为素数的问题可以转化为：
 16     求小于N-K的全部素数（求“小于N的最大素数”中的条件是“n不能被[2,n)中任意一个素数整除”，而不是整数）
 17     不能被[2,n)中任意一个素数整除的数一定是素数，因为那些整数都是以素数为因子的，
 18     所以没必要检测所有整数，检测所有素数就ok了
 19     
 20 解决方法：
 21     2是素数，记为PRIM 0
 22     根据PRIM 0，PRIM 1，...PRIM K，寻找比PRIM K大的最小素数PRIM K+1（这里是根据素数找素数）
 23     如果PRIM K+1大于N，则PRIM K是我们需要找的素数，否则继续寻找
 24     
 25     枚举：
 26         从可能的集合中一一列举各元素
 27         根据所知道的知识，给一个猜测的答案
 28         比如：2是素数，那2是本问题的解么
 29     
 30     枚举算法：
 31         对问题可能解集合的每一项：
 32             根据问题给定的检验条件判断哪些是成立的
 33             使条件成立的即为问题的解
 34     
 35     枚举过程：
 36         判断猜测答案是否正确
 37             2是小于N的最大素数么？
 38         进行新的猜测：
 39             有两个关键因素要注意：
 40                 1. 猜测的结果必须是前面的猜测中没有出现过的。每次猜测的素数一定要比已经找到的素数大
 41                 2. 猜测的过程中要及早排除错误的答案。比如：除2之外，只有奇数才可能是素数
 42 
 43     枚举过程中需要考虑的问题：
 44         1. 给出解空间，建立简介的数学模型
 45             可能的情况是什么？
 46             模型中变量数尽可能的少（使规模尽量小），他们之间相互独立
 47                 求“小于N的最大素数”中的条件是“n不能被[2,n)中任意一个素数整除”
 48                 而不是“n不能被[2,n)中任意一个整数整除”
 49         2. 减少搜索的空间
 50             利用知识缩小模型中各变量的取值范围，避免不必要的计算
 51             比如：较少代码中循环体执行的次数
 52                 除2之外，只有奇数才可能是素数，{2,2*i+1|1<=i,2*i+1<n}
 53         3. 采用合适的搜索顺序
 54             搜索空间的遍历顺序要与模型中条件表达式一致
 55             例如：对{2,2*i+1|1<=i,2*i+1<n}，按照从小到大的顺序
 56             
 57 
 58     枚举关键字（枚举核心）：
 59         减少规模
 60 
 61 */
 62 
 63 #include <iostream>
 64 using namespace std;
 65 int prim[50000];//用来存所有素数 
 66 int primNum=0;//用来记录 prim数组中已经存入的素数的数量 
 67 int times=0; //用于记录求解问题的总共判断次数 
 68 int primLessN(int n);
 69 int primLessN_2(int n);
 70 bool isPrimMothed(int n); //判断一个数是否为素数 
 71 
 72 /*
 73     方法一：由前往后用素数判断的枚举法：
 74     求“小于N的最大素数”中的条件是“n不能被[2,n)中任意一个素数整除”，而不是整数
 75      
 76     当n=10 0000时，
 77     ans=99991
 78     times=4626 4478次 
 79     primNum=9592 
 80     
 81     我每一个素数被判断出来，都要遍历一下之前的素数表
 82     而判断10 0000的时候，外层循环走了50000，里层每一个素数就是一次之前素数表的遍历
 83     50000*（1+2+3+...+9592)=50000* 4600 8082
 84     前面那个数没有50000，还要减去那些非素数 
 85     从 50000* 4600 8082可以看出，主要是之前那些素数花的时间，非素数几乎没花时间
 86     非素数= 4626 4478-4600 8082= 25 6450 
 87     只有25万，虽然还是要比下面多很多，因为是从前往后比较的 
 88 */
 89 int primLessN(int n)
 90 {
 91     prim[0]=2; //2是最小的素数
 92     primNum++; 
 93     for(int i=3;i<n;i+=2){
 94         bool isPrim=1; //isPrim用来判断一个数是否为素数
 95         for(int j=0;j<primNum;j++){
 96             times++;
 97             if(i%prim[j]==0){
 98                 isPrim=0;
 99                 break;  //没加break之前， 当n=10 0000时，times=2 5239 6936次 （2.5亿） ，加了之后times=4626 4478次 （4.5千万次）  
100             }
101             
102         } 
103         if(isPrim) prim[primNum++]=i;//如果是素数，则存入prim素数数组 
104     } 
105     return prim[primNum-1];
106 } 
107 
108 /*
109     方法二： 由后往前的整数枚举法
110     而且方法二的空间消耗也少 
111      
112     当n=10 0000时，
113     ans=99991
114     times=346次 
115 
116     当n=100 0000时，用方法一的话，根本算不出来 
117     ans=99 9983
118     times=1811次 
119     
120     当n=1 0000 0000(一亿)时， 
121     ans=9999 9989
122     times=11314次 
123     
124     当n=10 0000 0000(十亿)时， 
125     ans=9 9999 9937
126     times=52537次 
127 */
128 bool isPrimMothed(int n){
129     bool isPrim=1; //isPrim用来判断一个数是否为素数
130     if(n==2||n==3) return 1;
131     for(int i=2;i*i<=n;i++){
132         times++;
133         if(n%i==0) return 0;
134     } 
135     return 1;
136 } 
137 
138 int primLessN_2(int n){
139     for(int i=n;i>=2;i--){
140         if(isPrimMothed(i)) return i;
141     } 
142 }
143 int main(){
144     int n;
145     scanf("%d",&n);
146     //int ans=primLessN(n);
147     int ans=primLessN_2(n);
148     cout<<ans<<endl; 
149     printf("总判断次数times:%d\n",times); 
150     printf("总素数数primNum:%d\n",primNum); 
151     return 0;
152 }