素数判定 筛法+米勒罗宾素性测试

//本文于2020/12/2日 做出一定更正
筛法模板：

#include<bits/stdc++.h>
using namespace std;
#define set(x) (b[x>>5]|=(1<<(x&0x1F)))
#define get(x) (b[x>>5]&(1<<(x&0x1F)))
#define N 10000005
#define ll long long
int b[N];
int primes[N];
int main()
{
	ll n;
	cin >> n;
	int j = -1;
	for (int i = 2; i <= n; i++)
	{
		if (!get(i))primes[++j] = i;
		for (int t = 0; t <= j && i * primes[t] <= n; t++)
		{
			set(i * primes[t]);
			if (i % primes[t] == 0)break;
		}
	}
	for (int i = 0; i <= j; i++)cout << primes[i] << endl;
	return 0;
}

关于：

#define get(x) (b[x>>5]&(1<<(x&0x1F)))
#define set(x) (b[x>>5]|=(1<<(x&0x1F)))

的解释可以参考文章：位标记
这里也感谢邱叔的细心指导。
运用这个筛法可以解决绝大部分的题目，但我说的解决不是简单意义上的直接套模板，而是以此种筛法为基础来解决问题。
举个例子：
洛谷P1835

#include<bits/stdc++.h>
using namespace std;
#define set(x) (s[x>>5]|=(1<<(x&0x1F)))
#define get(x) (s[x>>5]&(1<<(x&0x1F)))
#define N 1000000
#define ll long long
int s[N];
int primes[N];
int flag[N];
int find()
{
	int j=-1;
	for(int i=2;i<=50000;i++)
	{
		//cout<<i<<endl;
		if(!get(i))
		{
		primes[++j]=i;
		}
		for(int t=0;t<=j&&i*primes[t]<=50000;t++)
		{
			set(i*primes[t]);
			if(i%primes[t]==0)break;
		}
	}
	return j;
}
int main()
{
	ll l,r;
	ll sum=0;
	cin>>l>>r;
	int ans=find();
	 for(int i=0;i<=ans;i++)
    {
        ll p=primes[i];
		ll start=(l+p-1)/p*p>2*p?(l+p-1)/p*p:2*p;
        for(ll int j=start;j<=r;j+=p)
		{
		flag[j-l+1]=1;
	    }
    }
    for(int i=1;i<=r-l+1;i++)
	{
	if(!flag[i])sum++;
    }
	cout<<sum<<endl;
	return 0;
 } 

此题的解法就是将50000内的所有素数记录下来，在用已经知道的素数去筛出范围内的素数。
那么为什么可以这样做呢？这就要提到算数基本定理了：合数可以表示成素数的乘积，且其表达顺序唯一。
所以 一个合数N 一定可以拆分成两个素数 p,q 且 p,q 中至少有一个小于 sqrt(N) 。
那么回到此题：题目给出的最大范围是1e10 那么我们只用筛出 1e5 的所有素数，再用找出的素数去筛1e10 的素数就可以了。
此题比较有意思的是这段代码：

 for(int i=0;i<=ans;i++)
    {
        ll p=primes[i];
		ll start=(l+p-1)/p*p>2*p?(l+p-1)/p*p:2*p;
        for(ll int j=start;j<=r;j+=p)
		{
		flag[j-l+1]=1;
	    }
    }

假设我们已经筛出了素数 a,b,c,d ，而我们要找出这段区间 [L,R] 的素数 ，那么我们就要找到这段范围内的所有的 a,b,c,d 的倍数。而为了加速，就要找到一个数，使它即是 a 的倍速，又是最小大于 L 的数。

ll start=(l+p-1)/p

这就可以保证选取的数最小是 [L-1] ,虽然他不符合范围要求，但只要把他放入 flag[0] 就行了。（因为之后是从flag[1] 开始筛的）。

---

米勒罗宾素性检验：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int times = 10;
ll quickpow(ll a, ll t, ll mod)
{
	ll ans = 1;
	while (t)
	{
		if (t % 2)ans = (ans * a)%mod;
		a = a * a % mod;
		t >>= 1;
	}
	return ans;
}
bool isprimes(ll n)
{
	if (n == 2)return true;
	if (!(n & 1))return false;//注意一定要用括号括起来，应为！的优先级不小于&的优先级
	ll mod = n;
	ll t = n - 1;
	int q = 0;
	while (!(t & 1))//同上
	{
		t >>= 1;
		q++;
	}
	for (int i = 0; i < times; i++)
	{
		ll a = rand() % (n - 2) + 2;//排除 1 这种情况,即随机数是从2开始到n-1的。
		ll x = quickpow(a, t, mod);
		if (x == 1)continue;
		int j;
		for (j = 0; j < q&&x*x%mod!=n-1; j++)//这里的判断条件一定要%mod,不然会错
		{            //其实在判断里直接写x！=n-1就行
			x = x * x % mod;
		}
		if (j >= q)return false;
	}
	return true;

}
int main()
{
	ll n;
	cin >> n;
	if (isprimes(n))cout << "YES!" << endl;
	else cout << "NO!" << endl;
	return 0;
}

这段代码的核心知识点就是下面的内容：（摘取于米勒罗宾素数检验）

米勒罗宾的苏醒检验可以在很短的时间检验出该数是否为素数。且该判断原理本身是一种概率判断，有出错的可能性，但只要测试的次数多一点，rand()找的数好一点，出错的可能性比火星撞地球还小。所以这种判断是一种很高效的判断方法。
在网上可以找到很多关于米勒罗宾判断素数的讲解，这里我就不多聊原理了。就简要讲一下过程：
判断一个数 n 是否为素数，首先找到一个 a 这个 a 是小于n 且 大于 1 的任意的数。所以我们用rand()%(n-2)+2来随机生成 a 。之后我们要将 a 的 n 次方转换为 a 的 m 次方（不知道m是什么的快看图）如果 a 的 m 次方取余 n 的结果不为1 那这个数就有可能不是素数（如果是1就continue,因为是概率检验，所以检验的次数越多，出错的可能性就越小），这时候就要进行二次检验。这时候要循环检验 r 次，每次pow()一下，如果在这 r 次里，没有一次（只要有一次就成立）可以使 a 的pow(2,r)*m次方取余n的值为n-1，就一定不是素数。
以上就是检验素数的最常用的方法。