线性筛法

线性筛法

1. 算法分析

关键思想：每个数字都被它的最小质因数筛掉

1.1 线性筛求素数

1. $i\%p_j=0$,说明 $p_j$ 是 $i$ 的最小质因数，因此 $i\ast 质数$ 的最小质因子也是 $p_j$，在 $i$ 递增的时候也会被筛掉，因此不需要在这里判断，可以break
2. $i\%p_j\ne 0$,说明 $p_j$ 是 $i\ast p_j$ 的最小质因数，因此 $p_j$ 可以筛掉 $i\ast pj$

1.2 线性筛求欧拉函数

1. $i\%p_j=0$,说明 $p_j$ 是 $i$ 的最小质因数，$\phi (i\ast p_j)=i\ast p_j\ast {\prod }_{i=1}^s\frac{p_i-1}{p_i}=p_j\ast (i\ast {\prod }_{i=1}^s\frac{p_i-1}{p_i})=p_j\ast \phi (i)$
2. $i\%p_j\ne 0$, 说明$i$ 和 $p_j$ 互质, 那么$\phi (i\ast p_j)=\phi (i)\ast \phi (p_j)=\phi (i)\ast (p_j-1)$

1.3 线性筛求莫比乌斯函数

莫比乌斯函数$\mu (n)$
$\mu(n)= \begin{cases} 1&n=1\ 0&n\text{ 含有平方因子}\ (-1)^k&k\text{ 为 }n\text{ 的本质不同质因子个数}\ \end{cases} $

1. $i\%p_j=0$,说明 $p_j$的幂次为2，因此$\mu (i\ast p_j)=0$
2. $i\%p_j\ne 0$, 说明$i$ 和 $p_j$ 互质, $\mu (i\ast p_j)=\mu (i)\ast \mu (p_j)=-\mu (i)$

1.4 线性筛求约数个数

d(i) 表示 i 的约数个数,num[i] 表示 i 的最小素因子的个数

1. $i\%p_j!=0$, 则$p_j$是$i\ast p_j$的最小质因数，且$p_j$这个质因数第一次出现在$i\ast p_j$内，次数为1，则$num[i\ast p_j]=1,d[i\ast p_j]=d[i]\ast 2$
2. $i\%p_j=0$, 则$p_j$在$i\ast p_j$中的次数加一，对于约数个数，先除以原来的$num[i]+1$，再乘上新的$num[i]+2$，则$num[i\ast p_j]=num[i]+1,d[i\ast p_j]=d[i]/(num[i]+1)\ast (num[i]+2)=d[i]/num[i\ast p_j]\ast (num[i\ast p_j]+1)$

1.5 线性筛求约束和

f[i]表示i的约数和，gi表示i的最小质因数的$p^0+p^1+...+p^k$

1. $i\%p_j!=0$, 则$p_j$是$i\ast p_j$的最小质因数，且$p_j$这个质因数第一次出现在$i\ast p_j$内，次数为1，则$f[i\ast p_j]=f[i]\ast f[p_j],g[i\ast p_j]=1+p_j$
2. $i\%p_j=0$, 则$p_j$在$i\ast p_j$中的次数加一，则$g[i\ast p_j]=g[i]\ast p_j+1,f[i\ast p_j]=f[i]/g[i]\ast g[i\ast p_j]$

2. 模板

2.1 线性筛求素数

// 线性筛素数（以下把prime[j]这个数简写为pj）
// 如何保证线性:一个合数只能被筛掉一次
// 如何保证一个数字只被筛掉一次:这个数字只被它的最小质因数筛掉，当它的其他质因数想要筛掉它时，将无法进行筛除操作
void get_prime(int n) {
    for (int i = 2; i <= n; ++i) {
        if (!st[i]) prime[cnt++] = i; // 如果这个数字没有被记录，那么这个数字必然为素数，记录一下
        for (int j = 0; prime[j] <= n/i; ++j) {
            st[prime[j] * i] = true;  // 筛掉pj*i这个合数
            if (i % prime[j] == 0)  break; // i%pj==0，说明pj是i的最小素因子，因此i*素数的最小素因子也是pj，在i递增的时候也会被筛掉，因此不需要在这里判断
        }                
    }
}

2.2 线性筛求欧拉函数

void init(int n) {
    phi[1] = 1;
    for (int i = 2; i <= n; ++i) {
        if (!st[i]) prime[cnt++] = i, phi[i] = i - 1;  // i是质数，phi[i] = i - 1
        for (int j = 0; prime[j] <= n / i; ++j) {
            st[prime[j] * i] = 1;
            if (i % prime[j] == 0) {
                phi[i * prime[j]] = phi[i] * prime[j];  // i % pj == 0, phi[i * pj] = phi[i] * pj
                break;
            }
            phi[i * prime[j]] = phi[i] * (prime[j] - 1);  // i % pj != 0, phi[i * pj] = phi[i] * (pj - 1)
        }
    }
    return;
}

2.3 线性筛求莫比乌斯函数

// 预处理得到莫比乌斯函数
void init(int n) {
    mu[1] = 1;
    for (int i = 2; i <= n; ++i) {
        if (!st[i]) prime[cnt++] = i, mu[i] = -1;  // i是质数，mu[i] = -1
        for (int j = 0; prime[j] <= n / i; ++j) {
            st[prime[j] * i] = 1;
            if (i % prime[j] == 0) {
                mu[i * prime[j]] = 0;  // i % pj==0, mu[i*pj] = 0
                break;
            }
            mu[i * prime[j]] = -mu[i];  // i % pj!=0, mu[i * pj] = -mu[i]
        }
    }
    return;
}

2.4 线性筛求约数个数

// d(i) 表示 i 的约数个数,num[i] 表示 i 的最小素因子的个数 
void init(int n) {
    d[1] = 1;
    for (int i = 2; i <= n; ++i) {
        if(!st[i]) prime[cnt++] = i, d[i] = 2, num[i] = 1;  //i是质数，d[i] = 2, num[i] = 1
        for (int j = 0; prime[j] <= n / i; ++j) {
            st[i * prime[j]] = 1;
            if (i % prime[j] == 0) {  // i % pj == 0, num[i * pj] = num[i] + 1, d[i *pj] = d[i] / num[i * pj] * (num[i * pj] + 1)
                num[i * prime[j]] = num[i] + 1;
                d[i * prime[j]] = d[i] / num[i * prime[j]] * (num[i * prime[j]] + 1);
                break;
            }
            // i % pj ！= 0， num[i * pj] = 1, d[i * pj] = d[i] * 2
            num[i * prime[j]] = 1;
            d[i * prime[j]] = d[i] * 2;
        }
    }
    return;
}

2.5 线性筛求约数和

// f[i] 表示i的约数和，g[i]表示i的最小质因数的p^0 + p^1 + ... + p^k
void init(int n) {
    g[1] = f[1] = 1;
    for (int i = 2; i <= n; ++i) {
        if (!st[i]) prime[cnt++] = i, g[i] = 1 + i, f[i] = i + 1;  // i是质数，g[i] = 1 + i, f[i] = i + 1
        for (int j = 0; prime[j] <= n / i; ++j) {
            st[i * prime[j]] = 1;
            if (i % prime[j] == 0) {  // i % pj == 0, g[i * pj] = g[i] * pj + 1, f[i * pj] = f[i] / g[i] * g[i * pj]
                g[i * prime[j]] = g[i] * prime[j] + 1;
                f[i * prime[j]] = f[i] / g[i] * g[i * prime[j]];
                break;
            }
            // i % pj != 0, f[i * pj] = f[i] * f[pj], g[i * pj] = 1 + pj
            f[i * prime[j]] = f[i] * f[prime[j]];
            g[i * prime[j]] = 1 + prime[j];
        }
    }
    return ;
}