标签：贪婪 time bin lang margin oid ott msu 表示
想要快速地筛出一定上限内的素数？
下面这种方法可以保证范围内的每个合数都被删掉（在 bool 数组里面标记为非素数），而且任一合数只被：
“最小质因数 × 最大因数（非自己） = 这个合数”
的途径删掉。由于每个数只被筛一次，时间复杂度为 O(n)O(n)O(n)。
先浏览如何实现再讲其中的原理。
bool isPrime[1000001];
//isPrime[i] == 1表示：i是素数
int Prime[1000001], cnt = 0;
//Prime存质数
void GetPrime(int n)//筛到n
{
memset(isPrime, 1, sizeof(isPrime));
//以“全都是素数”为初始状态，逐个删去
isPrime[1] = 0;//1不是素数
for(int i = 2; i <= n; i++)
{
if(isPrime[i])//没筛掉
Prime[++cnt] = i; //i成为下一个素数
for(int j = 1; j <= cnt && i*Prime[j] <= n/*不超上限*/; j++)
{
//从Prime[1]，即最小质数2开始，逐个枚举已知的质数，并期望Prime[j]是(i*Prime[j])的最小质因数
//当然，i肯定比Prime[j]大，因为Prime[j]是在i之前得出的
isPrime[ i*Prime[j] ] = 0;
if(i % Prime[j] == 0)//i中也含有Prime[j]这个因子
break; //重要，见原理
}
}
}
(1)一个数的最小因数（非1）当然是一个质数。毕竟如果是合数的话可以再分。
(2)代码中 PrimePrimePrime 数组中存的质数是递增的。
(3)代码中的 i×Prime[j]i×Prime[j]i×Prime[j] 是尝试筛掉的某个合数，其中，我们期望 Prime[j]Prime[j]Prime[j] 是这个合数的最小质因数 (1)(1)(1)。它是怎么得到保证的？
jjj 的循环中，有一句就做到了这一点：
if(i % Prime[j] == 0)
break; jjj 的循环到这里停止的理由是：
iii 的最小质因数是 Prime[j]Prime[j]Prime[j]（否则更早break）。
i×Prime[<j]i × Prime[<j]i×Prime[<j] 的最小质因数是 Prime[<j]Prime[<j]Prime[<j]。符合筛条件 (1)(1)(1)。
i×Prime[>j]i × Prime[>j]i×Prime[>j] 的最小质因数是 Prime[j]Prime[j]Prime[j]。不符筛条件 (1)(1)(1)。
（如果你立即理解了上面这三点，并且发现任何合数在整个流程中一定被最小质因数筛掉（“那个” iii 内枚举质数不会提前break），那么后面都不用看了）
可以具体说成是：
①：如果 imodPrime[j]==0i \mod Prime[j] == 0imodPrime[j]==0，说明 iii 有 Prime[j]Prime[j]Prime[j] 这个因子。那么 iii 可以表示为 Prime[j]×kPrime[j] × kPrime[j]×k。
②：如果我们再往下，下一个被筛掉的合数将是 i×Prime[j+1]i × Prime[j+1]i×Prime[j+1]（此时我们期望 Prime[j+1]Prime[j+1]Prime[j+1] 是这个合数的最小质因数），
③：根据①，该合数可以表示为 (Prime[j]×k)×Prime[j+1](Prime[j] × k) × Prime[j+1](Prime[j]×k)×Prime[j+1]。
④：看， Prime[j]Prime[j]Prime[j] 明显就是该合数的一个更小的质因数，说明该合数的最小质因数并不是 Prime[j+1]Prime[j+1]Prime[j+1]，那么用 Prime[j+1]Prime[j+1]Prime[j+1] 去筛这个合数是不符合要求的。所以不应该在这里筛掉。
⑤：后面 i∗Prime[j+2]i * Prime[j+2]i∗Prime[j+2] 等等与此相同，他们都一定有更小的质因数 Prime[j]Prime[j]Prime[j]，就不要用 Prime[j+2]Prime[j+2]Prime[j+2] 这个更大的质因数去筛。
注意，imodPrime[j]==0i \mod Prime[j] == 0imodPrime[j]==0 并不影响 Prime[j]Prime[j]Prime[j] 是 i×Prime[j]i×Prime[j]i×Prime[j] 这个数的最小质因数。
小提示：
当 iii 还不大的时候，可能会一层内就筛去大量质数，看上去耗时比较大，但是由于保证了筛去的质数日后将不会再被筛，复杂度是线性的。到 iii 接近 nnn 时，每层几乎都不用做什么事。
建议看下面两个并不烦的证明，便于信任这个筛法和以后扩展学习。
设一合数 CCC 的最小质因数是 p1p_1p1?，设 B=C/p1B = C / p_1B=C/p1?（C=B×p1C = B × p_1C=B×p1?），则 BBB 的最小质因数不小于 p1p_1p1?（否则 CCC 也有这个更小因子）。那么当枚举到 i=Bi = Bi=B 时，我们会从小到大枚举各个质数，因为 i=Bi = Bi=B 的最小质因数不小于 p1p_1p1?，所以 iii 在质数枚举至 p1p_1p1? 之前都不会break，因而就这次而言 CCC 一定会被 B×piB × p_iB×pi? 删去。
核心：亲爱的 BBB 的最小质因数必不小于 p1p_1p1?。
例：315=3×3×5×7315 = 3 × 3 × 5 × 7315=3×3×5×7，其最小质因数是 333。考虑 i=315/3=105i = 315 / 3 = 105i=315/3=105 时，我们从小到大逐个枚举质数，正是因为 iii 的最小质因数也不会小于 333（本例中就是 333），所以当枚举 j=1(Prime[j]=2)j = 1 (Prime[j] = 2)j=1(Prime[j]=2) 时，iii 不包含 222 这个因子，也就不会break，直到 Prime[j]=3Prime[j] = 3Prime[j]=3 之后才退出。
当然质数不能表示成“大于1的某数×质数”，所以整个流程中不会标记。
注意这个算法一直使用“某数×质数”去筛合数，又已经证明一个合数一定会被它的最小质因数 p1p_1p1? 筛掉，所以我们唯一要担心的就是同一个合数是否会被“另外某数 × p1p_1p1? 以外的质数”再筛一次导致浪费时间。设要筛的合数是 CCC，设这么一个作孽的质数为 pxp_xpx?，再设 A=C/pxA = C / p_xA=C/px?，则 AAA 中有 p1p_1p1? 这个因子。当 i=Ai = Ai=A 想要重筛 CCC，却在枚举 Prime[j]=p1Prime[j] = p_1Prime[j]=p1? 时因为 imodPrime[j]==0i \mod Prime[j] == 0imodPrime[j]==0 就退出了。因而 CCC 的任何 p1p_1p1? 外的质因数都不能筛它。
核心：罪恶的 AAA 中必有 p1p_1p1? 这个因子。
例：315=3×3×5×7315 = 3 × 3 × 5 × 7315=3×3×5×7。首先，虽然看上去有两个 333，但我们筛数的唯一一句话就是
isPrime[ i*Prime[j] ] = 0;所以，315315315 只可能用 105×3105 × 3105×3 或 63×563 × 563×5 或 45×745 × 745×7 这三次筛而非四次。然后，非常抱歉，后两个 i=63,i=45i = 63, i = 45i=63,i=45 都因为贪婪地要求对象为 555 或 777 而被迫拥有 333 这个因数，因此他们根本枚举不到对象就break了。
以上两个一证，也就无可多说了。
标签：贪婪 time bin lang margin oid ott msu 表示
原文地址：https://www.cnblogs.com/JCRL/p/9925771.html
