暴力解法（显然是会TLE的）#

最暴力的判断素数的方法无非逐个判断质因数：

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

这段代码很好理解，但是O（n）的时间复杂度还是需要一些优化的。

事实上，我们观察任意一个合数，以24为例，分解质因数对可以得到 <1,24><2,12><3,8><4,6>，可以发现，质因数对的first是一定小于 sqrt(24)的，所以可以修改为：

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

当然，由于sqrt函数运行起来很慢，我们也可以把for循环改写成：

for(int i=2;i<=n/i;i++)

但是即使如此，isprime函数的时间复杂度仍然高达O（sqrt(n)），我们思考一下还能如何优化，先打个表看看：

不难看出，除了2，3两个数之外的 所有素数都可以写作6的倍数的相邻数 ，但并不是所有相邻数都可以满足素数条件，不难发现，这些数都可以由已知素数相乘得到，例如25=6*4+1，但是 25=（6*1-1）*（6*1-1），所以它不是素数。

即判断素数有两重前提：

1. 可以写作6的倍数的相邻数
2. 不能分解为已知素数

依此我们可以设计如下算法：

bool isprime(int n) {
	if (n == 0 || n == 1)return false;//0，1的特判
	else if (n == 2 || n == 3)return true;//2和3的特判
	if (n % 6 != 1 && n % 6 != 5)return false;//若不满足前提1，则不可能是素数
	else {                                    //满足前提1，再继续判断
		for (int i = 5; i <= sqrt(n); i += 6) {
			if (n % i == 0 || n % (i + 2) == 0)return false;//如果不满足前提2，也不是素数
		}
	}
	return true;//通过全部测试，是素数
}

应用此算法打表提交，最后也是TLE，这个时候就需要引入更加高级的算法了。

Eratosthenes质数算法#

埃拉托斯特尼筛法，俗称“ 埃氏筛 ”，原理其实很简单，遍历n之前的所有数，如果某个数n是素数，那么把它扩大i（i>1）倍，n*i一定不是素数。

看个动画：

仅以此题为例，我们在埃氏筛的isprime函数上使用上面讲的“除6法”，就能通过这道题了（虽然题解里的大佬好像说没有优化的埃氏筛是过不了这道题的？）

代码如下：

#include<iostream>
#include<cmath>
using namespace std;
bool isprime(int n) {
	if (n == 0 || n == 1)return false;
	else if (n == 2 || n == 3 || n == 5 || n == 7)return true;
	if (n % 6 != 1 && n % 6 != 5)return false;
	else {
		for (int i = 5; i <= sqrt(n); i += 6) {
			if (n % i == 0 || n % (i + 2) == 0)return false;
		}
	}
	return true;
}
int main() {
	bool status[100000005] = { 0 };
	int cur=1,n, q, k, prime[6000010] = { 0 };
	cin >> n >> q;
	for (int i = 2; i <= n/i; i++) {
		if (isprime(i)) {
			for (int j = i * i; j <= n; j += i)status[j] = 1;
		}
	}
	for (int i = 2; i <= n; i++) {
		if (!status[i])prime[cur++] = i;
	}
	while (q--) {
		cin >> k;
		cout << prime[k] << endl;
	}
	return 0;
}

当然了，埃氏筛也不是最优的，毕竟时间复杂度是O（n*loglogn），显然是比不过线性复杂度的欧拉筛的，但是用来解决大部分题目都应该是足够的了。

欧拉筛法#

欧拉筛，又称为“ 线性筛 ”。不需要isprime函数判断素数，通过status数组和prime数组的交替运算就能存入范围内的所有素数，属于是来自数学的降维打击了，代码十分精简，而且速度也是惊人的快啊。。。。具体讲解不做赘述，直接上代码：

#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
int main() {
	int count=1,n, q, k, prime[6000010] = { 0 };
	bool status[100000010] = { 0 };//bool数组可以换成bitset，节省大约60%的空间
	scanf("%d %d", &n, &q);
	status[1] = 1;
    //一定要仔细理解这个for循环！！！！！
	for (int i = 2; i <= n; ++i) {
		if (!status[i]) prime[count++] = i;
		for (int j = 1; j <= count && i * prime[j] <= n; j++) {
			status[prime[j] * i] = 1;
			if (i % prime[j] == 0)break;
		}
	}
	while (q--) {
		scanf("%d", &k);
		printf("%d\n", prime[k]);
	}
	return 0;
}

这里还是给出一个动画辅助理解：

当然可能还有其他素数算法，大佬们可以指点以下~