埃氏筛法和欧拉筛法的区别

转自:

点击打开链接


Eratosthenes筛法(Sieve of Eratosthenes)

由于思想非常简单,故只给出实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void eratosthenes_sieve(int n)
{
    totPrimes = 0;
    memset(flag, 0, sizeof(flag));

    int sqrtn = sqrt(n + 0.5);
    for (int i = 2; i <= sqrtn; i++) {
        if (!flag[i]) {
            primes[totPrimes++] = i;
            for (int j = i * i; j <= n; j += i) {
                flag[j] = true;
            }
        }
    }
    for (int i = sqrtn + 1; i <= n; i++) {
        if (!flag[i])
            primes[++totPrimes] = i;
    }
}

时间复杂度  O(nloglogn) O(nlog⁡log⁡n)。(窝不会证明)

Euler筛法(Sieve of Euler)

欧拉筛是一种线性算法,并且同时可以计算出每个数的  φ φ

做法

回顾经典的Eratosthenes筛法,它可能对同一个质数筛去多次。那么如果用某种方法使得每个合数只被筛去一次就变成是线性的了。
不妨规定每个合数只用其最小的一个质因数去筛,这便是欧拉筛了。
不妨先看代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void euler_sieve(int n)
{
    totPrimes = 0;
    memset(flag, 0, sizeof(flag));

    for (int i = 2; i <= n; i++) {
        if (!flag[i])
            primes[totPrimes++] = i;
        for (int j = 0; i * primes[j] <= n; j++) {
            flag[i*primes[j]] = true;
            if (i % primes[j] == 0)
                break;
        }
    }
}

请仔细体会i % primes[j] == 0的含义。
时间复杂度  O(n) O(n)

简单证明

这个看似很简单,其实还是要注意一下细节的。搞清了证明其他的问题也就清楚了。
证明分两部分。首先证每个合数都会被筛到(正确性),其次证每个合数只会被筛到一次(复杂度)。

每个合数都会被筛到

设有一合数  n=pk11...pkmm n=p1k1...pmkm pi pi为质数)
n n一定会在  i=pk111...pkmm i=p1k1−1...pmkm 时被筛去(此时  primes[j]=p1 primes[j]=p1),因为对于小于  p1 p1的质数,一定不会被  i i 整除

每个合数都只会被筛到一次

与上面一样,还是设有一合数  n=pk11...pkmm n=p1k1...pmkm pi pi 为质数)
倘若存在一个质因子  px(x1) px(x≠1) 也筛去了 n n,那么此时  i=pk11...pki1x...pkmm i=p1k1...pxki−1...pmkm

  • i>px i>px,此时在内层循环中已经早早地break掉了,因为  p1i p1∣i
  • i<px i<px,此时 px px还没加进质数表QwQ(顺便一提:这种情况只有可能在  x=m x=m 时发生)

难以理解的地方

i % primes[j] == 0为何不放在前面?

你可以去试试……实践出真知。
放前面的话,所有的“某个质因子的次数不为1”的合数便会被当成质数。至于为什么,请看证明。

j < totPrimes为何不加?

实践才是检验真理的唯一标准。

  • 当  i i 为质数时,内层循环会在最后一个质数(也就是  i i 自己)终止。
  • 当  i i 为合数时,内层循环会在它的第一个质因数终止。

当然加了也没有问题。

顺便把  φ φ 算出来?

其实这是极简单的。
主要基于以下事实:(很容易通过定义推出来,不妨自己试试)

1.n为质数时,phi(n) = n - 1

2.p为质数且p整除n时,phi(n*p) = p* phi(n) 

3.p为质数且p不整除n时,phi(n*p) =(p - 1) * phi(n)


有没有发现简直就是为Euler筛法量身定做的!
代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void euler_sieve_with_phi(int n)
{
    totPrimes = 0;
    phi[1] = 1;
    memset(flag, 0, sizeof(flag));

    for (int i = 2; i <= n; i++) {
        if (!flag[i]) {
            primes[totPrimes++] = i;
            phi[i] = i - 1;
        }
        for (int j = 0; i * primes[j] <= n; j++) {
            flag[i*primes[j]] = true;
            if (i % primes[j])
                phi[i*primes[j]] = phi[i] * (primes[j] - 1);
            else {
                phi[i*primes[j]] = phi[i] * primes[j];
                break;
            }
        }
    }
}

速度比较

你可能会觉得  loglogn log⁡log⁡n 微不足道,那么你错了。
实测结果:(精确到微秒,编译时不打开优化开关)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
when n = 10000
    eratosthenes_sieve(1229):     0(us)
    euler_sieve(1229):            0(us)
when n = 100000
    eratosthenes_sieve(9592):     999(us)
    euler_sieve(9592):            0(us)
when n = 1000000
    eratosthenes_sieve(78498):    13004(us)
    euler_sieve(78498):           7004(us)
when n = 10000000
    eratosthenes_sieve(664579):   185130(us)
    euler_sieve(664579):          79067(us)
when n = 100000000
    eratosthenes_sieve(5761455):  2363692(us)
    euler_sieve(5761455):         842592(us)
when n = 1000000000
    eratosthenes_sieve(50847534): 25535159(us)
    euler_sieve(50847534):        8987385(us)

差距还是蛮大的呢。


  • 9
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值