sdut1468求素数

意思就是给一个数字，让求小于这个数字的所有素数的个数。范围是比较大的，所以普通的办法就gg了
这是第一种gg的办法：

#include<iostream>
#include<algorithm>
#include<string>
#include<map>
using namespace std;
int isprime(int n) {
    int sum = 0;
    if (n >= 2)sum = 1;
    else return 0;
    for (int i = 3; i <= n; i++) {
        int flag = 1;
        for (int j = 2; j <= sqrt(i); j++) {
            if (i % j == 0) {
                flag = 0;
                break;
            }
        }
        flag ? sum += flag : sum = sum;
    }
    return sum;
}
int main(void) {
    int n; 
    while (cin >> n) {
        if (n == 0)break;
        cout << isprime(n) << endl;
    }
    //system("pause");
    return 0;
}

/***************************************************
User name: 
Result: Time Limit Exceeded
Take time: 110ms
Take Memory: 0KB
Submit time: 
****************************************************/

下面是ac过的用的是欧拉筛选的办法。但是时限还是比较高

#include<stdio.h>  
#include<string.h>
#include<iostream>
using namespace std;  
#define max 1000000  
int prime[max/3];  
bool flog[max];//只存在一真一假  

void getprime()  
{  
 int k=0;  
 for(int i=2;i<max;i++)  
 {  
  if(!flog[i])prime[k++]=i;//若没被标记成true,则为素数，进入数组。  
  for(int j=0;j<k&&i*prime[j]<max;j++)//&&后面的条件表示比max大的数不用判断，不再范围内。  
  {  
   flog[i*prime[j]]=true;//重点：每个素数的倍数肯定不是素数。  
   if(i%prime[j]==0)break;/*重点：当 i 能整除 prime[j]，那么 i*prime[j+1] 这个合数 
                                             肯定被 prime[j] 乘以某个数(比i大)筛掉。 
                                            因为i中含有prime[j], prime[j] 比 prime[j+1] 小。 
                                           /接下去的素数同理。所以不用筛下去了*/  
  }  
 }  
}  
int main()  
{  

int n;  
while(~scanf("%d",&n),n!=0)  
{  
int c=0;  
memset(flog,false,sizeof(flog));//初始化为false  
 getprime();  
 for(int i=2;i<n;i++)  
 {  
  if(flog[i]==false)  
  {  
    c++;  
  }  
 }  
 printf("%d\n",c);  
}  
return 0;  

} 

/***************************************************
User name: 
Result: Accepted
Take time: 80ms
Take Memory: 1448KB
Submit time: 
****************************************************/

第三种也是我目前知道的比较快的，但是空间也消耗的比较多

#include <stdio.h>       
#include <math.h>       

#define SIZE 1000000       

int Prime[SIZE];      

void JudgePrime();        

int main()      
{      
    int n;      
    int i;      
    int sum;      

    JudgePrime();    

    while (scanf("%d", &n))      
    {      
        if (n == 0)      
        {      
            break;      
        }      

        if (n <= 2)      
        {      
            printf("0\n");      
            continue;      
        }      

        sum = 0;      
        for (i=2; i<n; i++)      
        {      
            if (Prime[i] == 1)      
            {      
                sum++;      
         }      
        }      
        printf("%d\n", sum);      
    }      
    return 0;      
}      

void JudgePrime()      
{      
    Prime[0] = 0;      
    Prime[1] = 0;      
    int i, j;      
    for (i=2; i<SIZE; i++)      
    {      
        Prime[i] = 1;      
    }      

    for (i=2; i<SIZE; i++)      
    {      
        if (Prime[i] == 1)      
        {      
            for (j=i*2; j<SIZE; j+=i)      
            {      
                Prime[j] = 0;      
            }      
        }      
    }      
} 

/***************************************************
User name: 
Result: Accepted
Take time: 20ms
Take Memory: 2020KB
Submit time: 
****************************************************/

在里面我还看见了某些大佬的时限是16ms的空间也就500左右，很好奇是什么算法这么好用，但是楼主并没找到源码，若是有知道的道友还望赐教