素数判断(暴力判断，埃式筛法，欧拉筛法)

我们知道素数是指一个数除了1和它本身外再没有其它其他因数的数，判断一个数是否是素数也非常好想，只需要从2枚举到这个数减1，看是否能整除即可，但这样有点慢了。

再次思考一下，如果一个数存在除1和它本身的因数，设这个数为n，因数应是成对存在，并且一个大于sqrt(n)（n的平方根），一个小于sqrt(n)，或者n为平方数，二者都等于sqrt(n),这样时间复杂度就变成了o(sqrt(n)),代码实现如下

bool isprimes(int n)
{ 
   if(n<2)return false;
   for(int i=2;i<=n/i;i++)
   {
     if(n%i==0)return false;
   }
   return true;
}

i<=sqrt(n)可以写成i*i<=n,为了防止溢出又可以写成i<=n/i

例题附上 蓝桥3334疑似素数

AC代码附上

#include<iostream>
using namespace std;
int f(int x)
{
	int res = 0;
	while (x)
	{
		res += x % 10;
		x /= 10;
	}
	return res;
}
bool isprime(int n)
{
	if (n < 2)return false;
	for (int i = 2; i <= n / i; i++)
	{
		if (n % i == 0)return false;
	}
	return true;
}
int main()
{
	int n; cin >> n;
	int ans = 0;
	for (int i = 1; i <= n; i++)
	{
		if (isprime(f(i)))ans++;
	}
	cout << ans << endl;
	return 0;
}

单独判断一个还是太没意思了，如何判断一段区间中有哪些素数呢？

比如需要找到1~1e4中的所有素数呢？

 这时候就可以引入埃式筛法了，对与一个合数，它一定存在一个质数的因子，也就是说它一定是某个质数的倍数，那么我们就可以开一个booll数组vis，来判断哪个数被筛掉了，哪个数被留下了，被筛掉的数标记为true，初始化vis[0]=vis[1]=true,从2开始枚举，碰到vis[i]=false，表明i是素数，但i的倍数一定不是素数，就可筛除1~n内所有为i的倍数的数

实现代码如下

void init(int n)
{
   vis[0]=vis[1]=true;
   for(int i=2;i<=n;i++)
   {
      for(int j=2*i;j<=n;j+=i)vis[j]=true;
   }
}

 例题蓝桥3205小明的素数对

AC代码附上

#include<iostream>
#include<vector>
using namespace std;
const int N = 1e6;
bool vis[N];
vector<int> primes;
void init(int n)
{
	vis[0] = vis[1] = true;
	for (int i = 2; i <= n; i++)
		if (!vis[i])for (int j = 2 * i; j <= n; j += i)vis[j] = true;
	for (int i = 1; i <= n; i++)if (!vis[i])primes.push_back(i);
}

int main()
{
	int n; cin >> n;
	init(n);
	int ans = 0;
	for (int i = 0; i < primes.size(); i++)
	{
		for (int j = 0; j < i; j++)
		{
			if (!vis[primes[i] - primes[j]])ans++;
		}
	}
	cout << ans << endl;
  return 0;
}

 要注意的是埃式筛法还是比较低效的，一般只能筛到1e4

我们可以想想为什么它会比较低效呢？答案是有些数会被不断重复的筛掉，比如30，它会被2，3，5筛掉，重复了好多次，要是更大的数，可能重复的次数更多

那有没有更高效的筛法呢？那就可以引入欧拉筛法了，我们想要一个数只被筛一次，那么时间复杂度就是o(n)，那我就让这个数被它的最小的质因数筛掉，那么i=y(最小质因数)*x，那x要满足什么条件才能保证y是最小质因数呢？

那就是y的最小质因子要大于等于x，才能保证x是i的最小质因子

这里的y是从小到大枚举的质数，x是我们从1~n枚举到的数，当y%x==0时，就表明x以后的质数，不能成为x*y的最小质因子了

实现代码附上

void init(int n)
{
   vector<int> primes;
   vis[0]=vis[1]=true;
   for(int i=2;i<=n;i++)
   {
      if(!vis[i])primes.push_back(i);
      for(int j=0;j<primes.size()&&i*primes[j]<=n;j++)
      {
           vis[i*primes[j]]=true;
           if(i%primes[j]==0)break;
      }
}

欧拉筛法可以筛到1e7

例题附上蓝桥3714一分为二

AC代码附上

 

#include<iostream>
#include<vector>
using namespace std;
using ll = long long;
const int N = 1e6 + 5;
bool vis[N];
vector<ll> primes;
void init(ll n)
{
	vis[0] = vis[1] = true;
	for (ll i = 2; i <= n; i++)
	{
		if (!vis[i])primes.push_back(i);
		for (ll j = 0; j < primes.size() && i * primes[j] <= n; j++)
		{
			vis[i * primes[j]] = true;
			if (i % primes[j] == 0)break;
		}
	}
}
ll prefix[N];
int main()
{
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	ll n, q; cin >> n >> q;
	init(n);
	for (int i = 1; i <= n; i++)prefix[i] += prefix[i - 1] + (int)(!vis[i] && !vis[i / 2]);
	while (q--)
	{
		ll l, r; cin >> l >> r;
		cout << prefix[r] - prefix[l - 1] << endl;
	}
	return 0;
}

例题蓝桥1140最小质因子之和(Hard Version)

 

AC代码附上

#include<iostream>
#include<vector>
using namespace std;
const int N = 2e7 + 5;
using ll = long long;
vector<ll> primes;
ll a[N];
ll prefix[N];
bool vis[N];
void init(ll n)
{
	vis[0] = vis[1] = 1;
	for (ll i = 2; i <= n; i++)
	{
		if (!vis[i])
		{
			primes.push_back(i);
			a[i] = i;
		}
		for (ll j = 0; j < primes.size() && i * primes[j] <= n; j++)
		{
			vis[i * primes[j]] = true;
			a[i * primes[j]] = primes[j];
			if (i % primes[j] == 0)break;
		}
	}
}
int main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t; cin >> t;
	ll k = 2e7 + 5;
	init(k);
	for (ll i = 2; i <= k; i++)prefix[i] += prefix[i - 1] + a[i];
	while (t--)
	{
		ll x; cin >> x;
		cout << prefix[x] << endl;
	}
	return 0;
}

欧克