线性筛——素数筛，莫比乌斯筛，欧拉函数筛

最新推荐文章于 2022-02-22 17:40:20 发布

diandie7589

最新推荐文章于 2022-02-22 17:40:20 发布

阅读量187

点赞数

原文链接：http://www.cnblogs.com/qq2210446939/p/10821537.html

版权

质数筛

暴力版：

1 bool prime(int n)
2 {
3     for(int i=2;i<=sqrt(n);i++)
4         if(n%i==0) return false;
5     
6     return true;
7 }

如果给定区间1到n，判断每一个数是不是质数，每个数都要从2开始暴搜，就某得灵魂。

普通筛：

bool isprime[maxn];//1代表是质数，0代表不是
void judge()
{
    memset(isprime,true,sizeof(isprime))//默认全都是质数
    for(int i=2;i<=maxn;i++)
    {
        if(isprime(i)){//i是质数
            for(int j=2;j*i<=maxn;j++)//那么i乘一个数就不是质数了
                isprime[j]=0;
        }
    }
}

这样就是一个线性的过程，从2开始到n筛，灵魂注入了一点，但弊端还是有，很多数被重复判断了。

真•线性筛（欧拉筛）：

bool isprime[n];//1代表是质数，0代表不是
int  prime[n];//素数数组，从小到大装着1到n的素数
void judge()
{
    memset(isprime,true,sizeof(isprime))//默认全都是质数
    int tot=0
    for(int i=2;i<=n;i++)
    {
        if(isprime(i))//是质数
            prime[tot++]=i;//存到素数数组里


        for(int j=0;j<tot&&prime[j]*i<n;j++)
        {
            isprime[ i * prime[j] ]=false;
            if(i%prime[j]==0)//保证每个合数都被它的最小素数筛掉
                break;       
        }
    }
}

这个的思想和普通筛一样，但却避免了一个合数被多次判断。

慢慢来，首先i无论是不是素数，i乘一个prime[j]肯定就不是素数，如何避免重复筛呢，首先合数是一定有质因子的（合数能分解质因数），所以要找到j的界限，保证一个合数只被判断一次，线性筛是从小到大的，自然是找每个合数的最小质因子了。

结论：如果 i 能整除 prime[j] ，此时j就不能++了， i *prime[j+1] 肯定会被 prime[ j]乘某个数筛掉；

证明：i 若能整除 prime[ j]

　　　则 i=k * prime[j]

　　　则 i *prime[ j+1]=k*prime[ j ] *prime[j+1]

　　　　　则 i * prime[ j + 1] = k^' *prime[ j ]

所以每个合数都只会被它的最小质因数筛掉。

莫比乌斯筛

莫比乌斯函数:

现在如果要预处理处理1到n的莫比乌斯函数值，就可以用到上面的素数筛了；

分析：

　　　　对于mu(x)，x是质数的话，mu(x)=-1；

　　　　如果x%p==0(p是质数),就意味着x有p这个质因子，所以x*p这个数就有p²这个质因子了，于是mu(x*p)=0;

bool isprime[n];
int prime[n],mu[n];
void get()
{
    memset(isprime,1,sizeof(isprime));
    int tot=0;
    for(int i=2;i<n;i++)
    {
        if(isprime(i)) prime[tot++]=i,mu[i]=-1;//如果i是质数，初始化mu为-1
        
        for(int j=1;j<=tot&&i*prime[j]<n;j++){
            
            isprime[i*prime[j]]=0;//和素数筛一样
            
            if(i%prime[j]==0){//素数筛的终止条件，
                mu[i*prime[j]]==0//对含有平方prime[j]因子的数mu值为0
                break;
            }
        }

    }
}

欧拉函数筛

欧拉函数筛：

　　欧拉函数：对整数n，欧拉函数是小于n的正整数中与n互质的数的数目。

　　现在分析一下，如果p是质数，那么phi(p)=p-1;

　　　　　　　　　如果n为质数p的k次方，那么phi(n)=p^k-p^k-1,因为一个数不包含质数p的时候才会与n互质，那么包换p的数有1*p，2*p·····，p^k-1*p共p^k-1个，所以phi(n)=n个减p的k-1次方个。(n本身被p^k-1*p减掉了）；

　　　　　　　　　phi(p1p2)=phi(p1)phi(p2)　，很容易证。

　　所以可以推出一个大结论：phi(n)= p1的k次方 * (1−1/p₁) * p2的k次方 * (1−1p₂)

　　　　　　　　　　　　　　　　 =n*(1−1/p₁)* (1−1p₂);

用上素数筛的思想，如果p是x的因数，那么phi(x*p)=phi(x)*p;

　　　　　　　　　如果p不是x的因数，那么phi(x*p)=phi(x)*(p-1);

于是乎，可以线性了：　　　　

bool isprime[n];
    int prime[n],tot=0;
    int phi[n];
    memset(isprime,1,sizeof(isprime));//默认都是质数
    for(int i=2;i<=n;i++)
    {
        if(sprime[i])
        {
            phi[i]=i-1;
            prime[tot++]=i;
        }
        
        for(int j=1; j<=tot && prime[j] * i<=n;j++)
        {
            isprime[i*prime[j]]=0;
            if(i%prime[j]==0){
                phi[i*prime[j]]=phi[i]*prime[j];//重要结论1
                break;
            }
            else
                phi[i*prime[j]]=phi[i] * (prime[j]-1);//重要结论2
        }
    }