积性函数和线性筛

线性筛素数，朴素的素数筛同一个数会被他的多个质因子筛到，这里保证只被自己最小的质因子筛到

bool isprim[13000004];
vector<long long>prim;
void getprim()
{
    memset(isprim,true, sizeof(isprim));
    for (int i = 2; i <= 13000000; ++i) {
        if(isprim[i])prim.push_back(i);
        for (int j = 0; j < prim.size()&&i*prim[j]<=13000000; ++j) {
            isprim[i*prim[j]]=0;
            if(i%prim[j]==0)break;
        }
    }
}

所有线性筛积性函数都基于线性筛素数

 

能够线性筛的条件：

（1）积性函数（gcd(a,b)==1   f(a*b)=f(a)*f(b) )

（2）f(1)能快速计算

（3）f(p)能快速计算，p为质数

（4）f(p^k)能快速计算（或由某种关系递推）

#include <bits/stdc++.h>
using namespace std;
bool isprim[13000004];
long long low[13000004];//最小质因子p^a1
long long f[13000004];
vector<long long>prim;
void init()
{
    memset(isprim,true, sizeof(isprim));
    f[1]=;//对1直接定义
    for (int i = 2; i <= 13000000; ++i) {
        if(isprim[i]){
            f[i]=;//直接对质数定义
            prim.push_back(i);
            low[i]=i;
        }
        for (int j = 0; j < prim.size()&&i*prim[j]<=13000000; ++j) {
            isprim[i*prim[j]]=0;
            if(i%prim[j]!=0)
            {
                low[i*prim[j]]=prim[j];//prim[j]肯定小于i的最小质因子
                f[i*prim[j]]=f[i]*f[prim[j]];//积性函数
            } else{
                low[i*prim[j]]=low[i]*prim[j];//此时prim[j]肯定是i的最小质因子
                if(low[i]==i)f[i*prim[j]]=;//i为某个质数的若干次幂，一般由定义得出
                else f[i*prim[j]]=f[i/low[i]]*f[low[i]*prim[j]]%mod;//gcd(i/low[i],low[i]*prim[j])=1
                break;
            }
        }
    }
}
int main (){
    init();
    return 0;
}

线性筛1到N的K次方：（其实f(x)=x^k为完全积性函数，可以更用简便的方法筛出）

#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9+7;
int n,k;
bool isprim[13000004];
long long low[13000004];//最小质因子p^a1
long long f[13000004];
vector<long long>prim;
long long qk(long long a,long long n)
{
    long long ans=1;
    while(n)
    {
        if(n&1)ans=ans*a%mod;
        n>>=1;
        a=a*a%mod;
    }
    return ans;
}
void init()
{
    memset(isprim,true, sizeof(isprim));
    f[1]=1;//对1直接定义
    for (int i = 2; i <= n; ++i) {
        if(isprim[i]){
            f[i]=qk(i,k);//直接对质数定义
            prim.push_back(i);
            low[i]=i;
        }
        for (int j = 0; j < prim.size()&&i*prim[j]<=n; ++j) {
            isprim[i*prim[j]]=0;
            if(i%prim[j]!=0)
            {
                low[i*prim[j]]=prim[j];//prim[j]肯定小于i的最小质因子
                f[i*prim[j]]=f[i]*f[prim[j]]%mod;//积性函数
            } else{
                low[i*prim[j]]=low[i]*prim[j];//此时prim[j]肯定是i的最小质因子
                if(low[i]==i)f[i*prim[j]]=f[i]*f[prim[j]]%mod;//i为某个质数的若干次幂，一般由定义得出
                else f[i*prim[j]]=f[i/low[i]]*f[low[i]*prim[j]]%mod;//gcd(i/low[i],low[i]*prim[j])=1
                break;
            }
        }
    }
}
int main (){
    cin>>n>>k;
    init();
    return 0;
}

线性筛欧拉函数

#include <bits/stdc++.h>
using namespace std;
bool isprim[13000004];
long long phi[13000004];
vector<long long>prim;
void init()
{
    memset(isprim,true, sizeof(isprim));
    phi[1]=1;
    for (int i = 2; i <= 13000000; ++i) {
        if(isprim[i]){
            phi[i]=i-1;
            prim.push_back(i);
        }
        for (int j = 0; j < prim.size()&&i*prim[j]<=13000000; ++j) {
            isprim[i*prim[j]]=0;
            if(i%prim[j]!=0)
            {
                phi[i*prim[j]]=phi[i]*phi[prim[j]];
            } else{
                phi[i*prim[j]]=phi[i]*prim[j];
                break;
            }
        }
    }
}
int main (){
    init();
    return 0;
}

线性筛莫比乌斯函数

#include <bits/stdc++.h>
using namespace std;
bool isprim[13000004];
int mu[13000004];
vector<long long>prim;
void init()
{
    memset(isprim,true, sizeof(isprim));
    memset(mu,0, sizeof(mu));
    mu[1]=1;
    for (int i = 2; i <= 13000000; ++i) {
        if(isprim[i]){
            mu[i]=-1;
            prim.push_back(i);
        }
        for (int j = 0; j < prim.size()&&i*prim[j]<=13000000; ++j) {
            isprim[i*prim[j]]=0;
            if(i%prim[j]==0)break;
            else mu[i*prim[j]]=-mu[i];
        }
    }
}
int main (){
    init();
    return 0;
}