素数的性质

素数的性质

         素数又称为质数。一个大于1 的自然数，除了1 和它本身外，不能被其他自然数整除，换句话说就是该数除了1和它本身以外不再有其他的因数；否则称为合数。
    素数有无限个，欧几里德的《几何原本》对素数进行了详细的讨论，并给出了“素数有无穷多个”的证明。素数是数论中一个基本元素，并且由于很难寻觅到规律，它又似乎是一个非统一的领域。

【性质】任何一个大于1的自然数都可以分解成几个素数连乘积的形式，而且这种分解是唯一的。
大于1且第一个能被该自然数整除的数肯定是该分解中最小的素因子。

【性质】n!中质因子k的个数 == [n/5] + [n/52] + [n/53] + ……

        例如100!中含质因子2的个数为：
  100/2 + 100/4 + 100/8 + 100/16 + 100/32 + 100/64
= 50 + 25 + 12 + 6 + 3 + 1
= 97

【程序】阶乘末尾0的个数 

一、素数的判定

        我们在判定素数时，一般采用素数的定义。即：除了1和它本身以外不再有其他因数的数。

bool prime(long k){
	for(int i=2;i*i<=k;i++)  //注意优化到n的开方
	    if (n % i==0) return 0;
	if (k==0 || k==1) return 0;
	else return 1;
}

【程序】素数

        直接利用素数的定义即可求解。

 读入n;
  for i=2 -> n
     if prime(i) then 输出i; 

二、筛法求素数

        用筛法求素数的基本思想是：把从1开始的、某一范围内的正整数从小到大顺序排列， 1不是素数，首先把它筛掉。剩下的数中选择最小的数是素数，然后去掉它的倍数。依次类推，直到筛子为空时结束。如有：
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不是素数，去掉。剩下的数中2最小，是素数，去掉2的倍数，余下的数是：
3 5 7 9 11 13 15 17 19 21 23 25 27 29
剩下的数中3最小，是素数，去掉3的倍数，如此下去直到所有的数都被筛完，求出的素数为：
2 3 5 7 11 13 17 19 23 29

一般的筛法求素数：
void sieve() {
    memset(prime, 1, sizeof(prime));
    prime[0] = false;
    prime[1] = false;
    int m=31700;
    for (int i=2; i<m; i++)
        if (prime[i]) {
            primes[++cnt] = i;
            for (int k= i*i; k<m; k+=i) prime[k] = false;
        }
    return;
} 

        下面介绍一种线性筛法求素数。顾名思义，其时间复杂度为O(n)。

线性筛法求素数：
#include<iostream>  
using namespace std;  
const long MAXP = 200000;  
long prime[MAXP] = {0},num_prime = 0;  
int isNotPrime[MAXP] = {1, 1};  
int main() {  
    for(long i = 2 ; i <  MAXP ; i++) {  
        if(! isNotPrime[i]) prime[num_prime ++]=i;  
        for(long j = 0 ; j < num_prime && i * prime[j] < MAXP ; j ++){  
            isNotPrime[i * prime[j]] = 1;  
            if( !(i % prime[j])) break;  
        }
    }  
    return 0;  
}  

        其难点在于：
        if( !(i % prime[j])) break;
    为什么这里要break？先可以得出一个结论，此时的prime[j]为（i*prime[j]）的最小质因数。现设x=p1*a为合数，且p1为其最小的质因子，a为质数或合数，若为质数，则设a=1*p`（a`=1），否则设a=a`*p`，p`为质数（因为任意一个合数都可以表示成一个质数和另一个数的乘积）。则x=(p1*a`)*p`=p1*(a`*p`)，且可以知道p1*a`<=p`*a`,即合数（p1*a`）小于合数（p`*a`），且p1<=p`,故得出结论，即比一个合数数大的质数和该合数的乘积可用一个更大的合数和比其小的质数相乘得到。

    上面实现代码中，i在1~maxp间循环，在i=p1*a时，若满足 !(i % prime[j])而不break的话，有可能在后面遇到一个prime[k],使得某个数x`=p1`*a`*prime[k]，在之后i=(a`*prime[k])时，还会再和p1`相乘重新进行isNotPrime[i * prime[j]] = 1; 赋值，这样就造成了重复赋值，降低了效率，如果break了，则不会出现这样的情况。

    考虑完上面的问题，还有个问题需要考虑，即省去的i*prime[k]在后来的过程中一定会再出现从而使得将isNotPrime[i * prime[k]]赋值为1么？答案是肯定的，因为上面提到了任意一个合数都可以表示成一个质数和另一个数的乘积，所以任意一个数总能表示成其最小质因子与另一个数相称的形式，因为我们枚举了所有可能的i，故“另一个数”的所有可能性我们都有考虑，所以，只要我们找到其最小质因子则就不会漏掉任意一个数。

三、哥德巴赫猜想

        1742年6月7日，德国数学家哥德巴赫在写给大数学家欧拉的信中提出了以下的猜想：
    （1）任何一个大于4的偶数，都可以表示成两个奇素数之和；
    （2）任何一个大于7的奇数，都可以表示成三个奇素数之和。
    这就是著名的哥德巴赫猜想，显然它是一个关于素数性质的问题。欧拉在1742年6月30日的回信中说，他相信这个猜想是正确的，但他不能证明。
    这道著名的数学难题引起了世界上成千上万的数学家关注。然而两个半世纪过去了任然没有得到彻底解决。而且，其实质性的进展还发生在20世纪的来临。
    1920年，英国数学家哈代和李特尔伍德首先将他们创造的圆法应用于数论问题，哥德巴赫猜想研究长期停滞的问题出现了松动。1937年前苏联数学家维诺格拉多夫利用改进的圆法和自己创造的指数估计法证明了奇数哥德巴赫猜想，即每个充分大的奇数都是三个奇素数之和。
    从1919年挪威数学家布朗用自己改进的筛法证明了“9+9”，数学家们开始研究命题“r+s”：每个充分大的偶数都是不超过r个素因子的乘积与不超过不超过s个素因子的乘积之和。此后半个世纪的时间里，数学家们利用各种改进的筛法逐步向“1+1”逼近。到1996年中国数学家陈景润证明了“1+2”，即陈氏定理，被认为“是筛法理论的光辉顶点”。

【程序】哥德巴赫猜想 

读入n;
  s=0;
  for i=2 -> n / 2
     if prime(i) && prime(n-i) then s++;  //prime(i)为判断i是否为素数的函数
  输出s;

四、孪生素数

        1849年，波林那克提出孪生质数猜想（the conjecture of twin primes），即猜测存在无穷多对孪生质数。猜想中的“孪生质数”是指一对质数，它们之间相差2。例如3和5，5和7，11和13，10,016,957和10,016,959等等都是孪生质数。

【定理】
     若自然数Q与Q+2都不能被不大于根号Q+2的任何质数整除，则Q与Q+2是一对质数，称为相差2的孪生质数。

【程序】孪生素数 

 读入n;
  s=1;
  for i=3 -> n-2
     if prime(i) && prime(i+2) then s++; 
  输出s;

五、麦森数

        麦森数又叫梅森数。所谓梅森数，是指形如2p－1的素数，其中指数p一定也是素数。2p－1不一定是素数。

【性质】如果2P-1是素数，那么P一定也是个素数。

【程序】麦森数 

C++ code：
#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
#define N 100   //压5位
using namespace std;
int ans[N];
void  mult(int t){
  int i,temp,last=0;
      for (i=N-1; i>=0; i--){ 
        temp = (ans[i] << t) + last;   //乘2^t，加进位
        last = temp / 100000; 
        ans[i] = temp - last * 100000;  //temp%100000
    } 
}
void output(){
   for(int i=1;i<=N;i++){
		printf("%05d",ans[i-1]);
        if (i % 10 == 0)cout << endl;   
   } 
}
int main(){
	int P,times;
	cin >> P
    memset(ans,0,sizeof(ans));
    ans[N-1] = 1;
    cout << (int)(P * log10(2) + 1) << endl;
/***********************关键部分*****************
  2^P=2^(14*times)*2^(P%14) 用移位
  之所以取14的原因 2^14*(99999)=1.638382*10^9 在（int）
  范围，15以后都会超int，主要体现在mult()中      
 **********************************************/
    times = P / 14;  //只能到14 15以后压缩时会超范围
    while(times--) mult(14);
    mult(P % 14);
    --ans[99];
    output();
	return 0;
}