wenbao与筛法素数及判断模板

#define ll long long 
const int maxn = 1000000;
int vis[maxn],prime[maxn];
void isprime()
{   
    memset(vis,0,sizeof(vis));
    ll cot=0,i,j;
    for( i=2;i<=1000000;i++)
    {
        if(!vis[i])
        {
            prime[cot++]=i;
            for( j=i*i;j<1000000;j+=i)
            vis[j]=1;
        }
    }
}

 判断模板

bool prime(int x)
{
    if(x==2)
        return true;
    if(x%2==0||x==1)
        return false;
    bool flag=true;
    int t=(int )sqrt((double)x);
    for(int i=3; i<=t; i+=2)
        if(x%i==0)
        {
            flag=false;
            break;
        }
    return flag;
}

http://blog.csdn.net/lerenceray/article/details/12420725

#include<cstring>
#include<iostream>
#include<ctime>
using namespace std;
#define N 100000005

bool vis[N];
int p[N], cnt, phi[N];

int Euler(int n){
    int i, j, k;
    phi[1] = 1;
    for (i = 2; i < n; ++i){
        if (!vis[i]){
            p[cnt++] = i;
            phi[i] = i - 1;
        }
        for (j = 0; j < cnt && i * p[j] < n; ++j){
            vis[i * p[j]] = true;
            if (i % p[j]) phi[i * p[j]] = phi[i] * phi[p[j]];
            else {
                phi[i * p[j]] = phi[i] * p[j];
                break;
            }
        }
    }
    return cnt;
}

int Eratosthenes (int n){
        int i, j, k;
        phi[1] = 1;
        for (i = 2; i < n; ++i){
                if (!vis[i]) p[cnt++] = i;
                for (j = i; j < n; j += i) {
                        if (!phi[j]) phi[j] = j;
                        phi[j] = phi[j] / i * (i - 1);
                        vis[j] = true;
                }
        }
        return cnt;
}

int main(){
        clock_t st, en;
        int num;
        double sec;
        for (int t = 10; t < N; t *= 10){
                cout << t << ':' << endl;
                st = clock();
                num = Euler(t);
                en = clock();
                sec = (double)(en - st) / (double) CLOCKS_PER_SEC;
                //cout << "Euler : " << cnt << ' ' << sec << endl;
                printf("Euler :		%8d	%.8lf
", num, sec);
                memset(vis, 0, sizeof(vis)), memset(p, 0, sizeof(p)), memset(phi, 0, sizeof(phi)), cnt = 0;
                st = clock();
                num = Eratosthenes(t);
                en = clock();
                sec = (double)(en - st) / (double) CLOCKS_PER_SEC;
                //cout << "Eratosthenes : " << cnt << ' ' << sec << endl;
                printf("Eratosthenes :	%8d	%.8lf
", num, sec);
        }
        return 0;
}

http://www.bubuko.com/infodetail-837565.html

我们先来看一下最经典的埃拉特斯特尼筛法。时间复杂度为O(n loglog n)

int ans[MAXN];
void Prime(int n)
{
    int cnt=0;
    memset(prime,1,sizeof(prime));
    prime[0]=prime[1]=0;
    for(int i=2;i<n;i++)
    {
        if(vis[i])
        {
           ans[cnt++]=i;//保存素数 
           for(int j=i*i;j<n;j+=i)//i*i开始进行了稍微的优化
           prime[j]=0;//不是素数 
        }
    }
    return ;
}

显然，当一个数是素数的时候，那么他的倍数肯定是合数，筛选标记即可。从i*i而不从i*2开始，是因为已经i*3，i*2早已经被2，3筛过了。

由此，我们也可以发现有的合数被重复筛除，例如30，2*15筛了一次，5*6重复筛除，所以也就有了我们下面要提到的欧拉线性筛法。

不会重复筛除，是线性O（n）的复杂度。

const int MAXN=3000001;
int prime[MAXN];//保存素数 
bool vis[MAXN];//初始化 
void Prime(int n)
{
    int cnt=0;
    memset(vis,0,sizeof(vis));
    for(int i=2;i<n;i++)
    {
        if(!vis[i])
        prime[cnt++]=i;
        for(int j=0;j<cnt&&i*prime[j]<n;j++)
        {
            vis[i*prime[j]]=1;
            if(i%prime[j]==0)//关键 
            break;
        }
    }
    return cnt;//返回小于n的素数的个数 
}

void prime(){
    a[0] = a[1] = 1;
    for(int i = 2; i < maxn; i++){
        if(!a[i]){
            b[num] = i, num++;
        }
        for(int j = 0; j < num && i*b[j] < maxn; j++){
            a[i*b[j]] = 1;
            if(i%b[j] == 0) break;
        }
    }
}

只有不断学习才能进步！