素数,又称质数,定义是:除了1和它本身以外不再有其他的除数整除。
方法一
按照定义,从2到n-1判断有没有能整除n的数。如果有,则不是素数,否则,是素数
bool is_prime(int n){ if (n < 2){ return false; } int i; for (i = 2; i < n; i++){ if (n%i == 0){ return false; } } return true; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
算法复杂度:O(n)
方法二
还是按照定义,不过是从2一直算到sqrt(n),这样算法复杂度降低了很多
bool is_prime(int n){ if (n < 2){ return false; } int i; for (i = 2; i*i <= n; i++){ if (n%i == 0){ return false; } } return true; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
方法三
米勒拉宾素数测试的方法
米勒拉宾证明起来很麻烦(准确的说是博主也不会 -_-#)
直接上模板吧
int tab[]={2, 3, 5, 7}; long long qpow(int a, int b, int r) //(a^b)%r 快速幂取模 { long long ret = 1, tmp = a; while(b) { if (b&1) ret = ret*tmp%r; tmp = tmp*tmp%r; b >>= 1; } return ret; } bool Miller_Rabbin(int n, int a)//米勒拉宾素数测试 { int r = 0, s = n-1, j; long long k; if(n%a == 0) return false; while((s&1) == 0) { s >>= 1; r++; } k = qpow(a, s, n); if(k == 1) return true; for (j = 0; j < r; j++, k=k*k%n) if (k == n-1) return true; return false; } bool Isprime(int n)//判断是否是素数 { for (int i = 0; i < 4; i++) { if (n == tab[i]) return true; if (!Miller_Rabbin(n, tab[i])) return false; } return true; }
- 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
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
方法四
上面几种方法都只能判断一个数是不是素数,当需要判断1-n里面有多少素数时,就会很麻烦,有一种较为简单的方法就是Eratosthenes筛法
如果一个数是素数,那么这个数的倍数一定不是素数,就是这个思想,把所有的非素数都去掉
bool flag[N]; void fun(){ long long i, j; for (i = 0; i < N; i++){ flag[i] = true; } flag[0] = flag[1] = false; for (i = 2; i < N; i++){ if (!flag[i]) continue; for (j = i*i; j < N; j += i){ flag[j] = false; } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
算法复杂度O(n*log log n)
但是这个算法有一个冗余的地方:比如合数10,在枚举2的时候我们判定了一次,在枚举5的时候我们又判定了一次。因此使得其时间复杂度比O(n)要高。
方法五
我们可以知道,任意一个正整数k,若k≥2,则k可以表示成若干个质数相乘的形式。Eratosthenes筛法中,在枚举k的每一个质因子时,我们都计算了一次k,从而造成了冗余。因此在改进算法中,只利用k的最小质因子去计算一次k。
与Eratosthenes筛法不同的是,对于外层枚举i,无论i是质数,还是是合数,我们都会用i的倍数去筛。但在枚举的时候,我们只枚举i的质数倍。比如2i,3i,5i,…,而不去枚举4i,6i…,原因我们后面会讲到。
此外,在从小到大依次枚举质数p来计算i的倍数时,我们还需要检查i是否能够整除p。若i能够整除p,则停止枚举。
利用该算法,可以保证每个合数只会被枚举到一次。我们可以证明如下命题:
假设一个合数k=M*p1,p1为其最小的质因子。则k只会在i=M,primeList[j]=p1时被筛掉一次。
首先会在i=M,primeList[j]=p1时被筛掉是显然的。因为p1是k的最小质因子,所以i=M的所有质因子也≥p1。于是j循环在枚举到primeList[j]=p1前不会break,从而一定会在i=M,primeList[j]=p1时被筛掉
其次不会在其他时候被筛掉。否则假设k在i=N, primeList[j]=p1时被筛掉了,此时有k=N*p2。由于p1是k最小的质因子,所以p2 > p1,M > N且p|N。则i=N,j枚举到primeList[j]=p1时(没到primeList[j]=p2)就break了。所以不会有其他时候筛掉k。
同时,不枚举合数倍数的原因也在此:对于一个合数k=M*2*3。只有在枚举到i=M*3时,才会计算到k。若我们枚举合数倍数,则可能会在i=M时,通过M*6计算到k,这样也就造成了多次重复计算了。
综上,Eular筛法可以保证每个合数只会被枚举到一次,时间复杂度为O(n)。当N越大时,其相对于Eratosthenes筛法的优势也就越明显。
int primelist[N], primecount = 0; bool isprime[N]; void eular(int n){ int i, j; for (i = 0; i <= n; i++){ isprime[i] = true; } isprime[0] = isprime[1] = false; for (i = 2; i <= n; i++){ if (isprime[i]){ primelist[primecount++] = i; } for (j = 0; j < primecount; j++){ if (i*primelist[j] > n){ break; } isprime[i*primelist[j]] = false; if (i%primelist[j]==0){ break; } } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22