素数判定（埃筛，欧拉筛）

一，埃筛（6x孪生素数法）（判断单个素数较优）

1，首先，一个合数必定可由其平方根相乘得到，或者一个大于，一个小于平方根的数得到，利用这个思想，只需考虑是否可以除去平方根一边的数，可以则另一半绝对可以

2，其次，可以被除，那就是合数，不是素数

3，可以证明，在6*n相邻左右边的首先都是奇数，所以有可能是素数，而不是相邻绝对不是素数，因为6*n+(-)2==2*(3*n+(-)1),或者6*n+(-)3==2*(3*n+(-)1),4也是同理

代码如下

#define _CRT_SECURE_NO_WARNINGS 1
#include <bits/stdc++.h>
#define ll long long
using namespace std;

int ai(ll n) {
	if (n < 5) {   //小于5时直接判定
		if (n == 2 || n == 3)return 1;
		else return 0;
	}
	else {
		if (n % 6 != 1 && n % 6 != 5)return 0;//不在6旁边的n不是奇数，绝对不会是素数
		for (ll i = 5; i*i <= n; i += 6) { //6n的左右就是余数1或者5（0或者6的左右），所以以1或者5为起点不断+6，减少计算量（实际只要一个，如5+2就是得1（因为7-6=1）
			if (n % i == 0 || n % (i + 2) == 0)return 0;  //n能被这些可能为素数的奇数整除，那就不是素数
		}
		return 1;//能遍历到最后，就是素数

	}

}

int main() {
	ll c;
	cin >> c;
	while (c--) {
		ll n;
		cin >> n;
		if (ai(n))cout << "YES" << endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}

二，欧拉筛（统计与输出前n个素数较优）

1，首先，每个合数都可以由一个素数和另一个数乘积获得

2，i = m * n，m是最小质因子(素数=质数)，若n为合数，n= x*y，x是一个质数，且x>m，则i = mn = mxy = xmy，且my = k.，则i = x*k，且 x>m

所以，我们可以让每个合数只由其最大素数因子获得，保证不重复标记

#define _CRT_SECURE_NO_WARNINGS 1
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e6 + 100;

ll book[N];
ll in[N];

ll oula(ll n) {
	in[0] = 0;
	memset(book, 0, sizeof(book));//全部为0，表示没有访问过
	for(ll i=2;i<=n;++i){
		if (!book[i]) {  //没有标记，就是素数，进入
			book[i] = 1;
			in[++in[0]] = i;//in[0]是目前素数个数
		}
		for (ll j = 1; j <= in[0] && i * in[j] <= n; ++j) {//j表示第几个素数,所以j小于in[0]，目前已经统计的素数的量，i * in[j] <= n这个条件保证不超出，否则死循环停不下来
			book[i * in[j]] = 1;//素数的倍数全部是合数，直接改为1（表示访问过，不让进入）
			if (i % in[j] == 0)break; //如果i是in[j]的倍数，跳出，不然会重复记录素数，因为如果不跳in[j+1]*i==in[j+1]*in[j]*t(t为i/in[j])，保证了每个合数都是由最大质数得到的
		}         //结果还是in[j]的倍数,虽然这次跳出，但是后面i会以in[j]的倍数出现，如果这里访问，后面就是重复标记了


	}
	cout << in[0] << endl;
}

int main() {
	ll c;
	cin >> c;
	while (c--) {
		ll n;
		cin >> n;
		oula(n);
	}
	return 0;
}

例题：I-最大公约数求和

思路：欧拉筛线性优化积性函数

1. n取到2e7，不把他压成线性，是不可能通过的（少求gcd与快速幂）
2. 我们这可是1~n的求啊，gcd的话欧拉筛不是可以使得快速幂在欧拉筛里面解决。即,即
3. gcd也是可以的，我们如果求一个数x的gcd，设他的最小因子p，如果k/(g[x/p])≡0 ，那么g[x]=g[x/p]*p,否则等于g[x]。
4. 而对于不是最小因子的质数q，有g[x]=g[x/q]*g[q]。等式成立原因，首先，如果gcd[q]不等于1，说明k有因子q，又因为q不是x的因子，所以他的gcd还可以再乘一个k有的因子而x没有的因子q

#include <bits/stdc++.h>
using namespace std;
#define ll               long long
#define endl             "\n"
#define int              long long
const int N = 2e7 + 10;
const int mod=1000000007;
int m[N],g[N],ou[N];
bool vis[N];
ll fastmi(ll base,ll power)
{
	ll ans=1;
	while (power)
		{
			if (power&1)ans=ans*base%mod;
			base=base*base%mod;
			power>>=1;
		}
	return ans;
}

void mysolve()
{
	int n,k;
	cin>>n>>k;
	ll ans=g[1]=m[1]=1;//i为1时
	for (int i=2; i<=n; ++i)
		{
			if (!vis[i])
				{
					ou[++ou[0]]=i;
					g[i]=__gcd(i,k);//求出所有质数的快速幂与gcd
					m[i]=fastmi(i,k);
				}
			for (int j=1; i*ou[j]<=n&&j<=ou[0]; ++j)
				{
					vis[i*ou[j]]=1;
					m[i*ou[j]]=m[i]*m[ou[j]]%mod;
					if (i%ou[j]==0)//ou[j]是i的最小因数时，特判gcd
						{
							g[i*ou[j]]=g[i];
							if ((k/g[i])%ou[j]==0)g[i*ou[j]]*=ou[j];
							break;
						}
					g[i*ou[j]]=g[i]*g[ou[j]];//ou[j]不是x因子时
				}
			ans=(ans+g[i]*m[i])%mod;
		}
	cout<<ans<<endl;
}

int32_t main()
{
	std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	mysolve();
	system("pause");
	return 0;
}