积性函数的筛法

下面的所有知识均属数论范畴。

---

欧拉筛

可以做到 $O(n)$ 的线性复杂度！

可以筛所有的积性函数（即对于所有的 $a\perp b$ 都满足 $f(ab)=f(a)\ast f(b)$ 的函数)。

举两个例子：

线性筛欧拉函数：

inline void Sieve()
{
    phi[1] = 1;
    for(register int i = 2; i <= MAXN; i++)	//MAXN表示值域
    {
        if(!NotPrime[i])	//是质数
        {
            phi[i] = i - 1;
            Prime[++len] = i;
        }
        for(register int j = 1; j <= len && i * Prime[j] <= MAXN; j++)
        {
            NotPrime[i * Prime[j]] = true;
            if(i % Prime[j] == 0)	//此时 Prime[j] 为 i 的最小质因子
			{
            	phi[i * Prime[j]] = phi[i] * prime[j];
				break;
            }
            phi[i * Prime[j]] = phi[i] * (Prime[j] - 1);
        }
    }
    return;
}

线性筛莫比乌斯函数：

inline void Sieve()
{
    miu[1] = 1;
    for(register int i = 2; i <= MAXN; i++)
    {
        if(!NotPrime[i])
        {
            miu[i] = -1;
            Prime[++len] = i;
        }
        for(register int j = 1; j <= len && i * Prime[j] <= MAXN; j++)
        {
            NotPrime[i * Prime[j]] = true;
            if(i % Prime[j] == 0) break;	//此时 miu 函数值为 0，可以直接跳过
            miu[i * Prime[j]] = -miu[i];
        }
    }
    return;
}

可以发现，每个数最多只会被自己的最小质因子筛到一次，所以时间复杂度是线性的 $O(n)$。

不过要注意，每个数被自己的最小质因子筛到时，对应的 i * Prime[j]仍然是需要计算函数值的！（当然 $\mu$ 函数此时就等于 $0$，可以直接跳过）

---

杜教筛

在非线性时间内求解积性函数的前缀和。

设现在我们要求的是 $f$ 的前缀和，即 $S(n)={\sum }_{i=1}^{n}f(i)$。

我们考虑把 $f$ 卷上一个 $g$ 的前缀和，即：
$$\begin{array}{rl}{S}^{\prime }(n)& =\sum _{i=1}^n(f\ast g)(i)\\ & =\sum _{i=1}^n\sum _{d|i}f(d)g(\frac{i}{d})\\ & =\sum _{d=1}^{n}g(d)\sum _{i=1}^{\lfloor \frac{n}{d}\rfloor }f(i)\\ & =\sum _{d=1}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )\end{array}$$
然后再推导一下，发现：
$$g(1)S(n)=\sum _{d=1}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )-\sum _{d=2}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )$$
即：
$$S(n)=\frac{{\sum }_{i=1}^n(f\ast g)(i)-{\sum }_{d=2}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )}{g(1)}$$
所以，只要我们找到合适的 $g$，就能够快速求出 $S(n)$ 了。

（这个时候建议看看下文的莫反公式）

对于 $\mu$ 的前缀和，我们发现有 $\mu \ast 1=ϵ$，即定义 $g=1$，代入公式有 $S(n)=1-{\sum }_{i=2}^{n}S(\frac{n}{i})$。

对于 $\phi$ 的前缀和，我们发现有 $\phi \ast 1=id$，即定义 $g=1$，代入公式有 $S(n)=\frac{n(n+1)}{2}-{\sum }_{i=2}^{n}S(\frac{n}{i})$。

这些递推式显然可以整除分块做。

不过为了做到非线性复杂度，我们需要先预处理出 $n^{\frac{2}{3}}$ 以内的 $S(n)$，然后剩下的用记忆化搜索。

这样的复杂度据说可以达到最快的 $O(n^{\frac{2}{3}})$。

贴上洛谷模板题（上面举的两个例子）的代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cassert>
#include<unordered_map>

#define MAXN 5000001

using LL = long long;
using namespace std;

int t, n;
int len, Prime[MAXN];
LL Phi[MAXN], Miu[MAXN];
bool NotPrime[MAXN];
unordered_map<int, LL> AnsPhi, AnsMiu;

inline void Prework()
{
	Phi[1] = Miu[1] = 1LL;
	for(register int i = 2; i < MAXN; i++)
	{
		if(!NotPrime[i])
		{
			Prime[++len] = i;
			Phi[i] = i - 1LL;
			Miu[i] = -1LL;
		}
		for(register int j = 1; j <= len && i * Prime[j] < MAXN; j++)
		{
			NotPrime[i * Prime[j]] = true;
			if(i % Prime[j] == 0LL)
			{
				Phi[i * Prime[j]] = Phi[i] * Prime[j];
				break;
			}
			Phi[i * Prime[j]] = Phi[i] * (Prime[j] - 1LL);
			Miu[i * Prime[j]] = -Miu[i];
		}
	}
	for(register int i = 1; i < MAXN; i++) Phi[i] += Phi[i - 1], Miu[i] += Miu[i - 1];
	return;
}

inline LL Solve_Phi(int n)
{
	if(n < MAXN) return Phi[n];
	if(AnsPhi.count(n)) return AnsPhi[n];
	LL ans = 1LL * n * (n + 1LL) / 2LL;
	for(register LL l = 2LL, r; l <= n; l = r + 1LL)
	{
		r = n / (n / l);
		ans -= 1LL * (r - l + 1LL) * Solve_Phi(n / l);
	}
	AnsPhi.insert(make_pair(n, ans));
	return ans;
}

inline LL Solve_Miu(int n)
{
	if(n < MAXN) return Miu[n];
	if(AnsMiu.count(n)) return AnsMiu[n];
	LL ans = 1LL;
	for(register LL l = 2LL, r; l <= n; l = r + 1LL)
	{
		r = n / (n / l);
		ans -= 1LL * (r - l + 1LL) * Solve_Miu(n / l);
	}
	AnsMiu.insert(make_pair(n, ans));
	return ans;
}

int main()
{
	#ifdef FILE
		freopen("Input.in", "r", stdin);
	#endif
	Prework();
	scanf("%d", &t);
	while(t--)
	{
		scanf("%d", &n);
		printf("%lld %lld\n", Solve_Phi(n), Solve_Miu(n));
		continue;
	}
	return 0;
}

---

$Min\_25$ 筛

一般用于求积性函数 $f$ 的前缀和。$f$ 要求当 $p$ 为质数时，$f(p)$ 是一个次数较少的简单多项式，它的每一项都必须是完全积性函数。

复杂度众说纷纭，不过当 $n\le 10^{10}$ 时可以轻松跑过。

• $Step1$：

先考虑求质数的前缀和：
$$\sum _{i=1,i\in Prime}^{n}f(i)$$

我们先来看一个神奇的操作：

考虑当 $d$ 为质数时 $f(p)$ 的运算公式。

然后，我们把所有数都当成质数，套用这个运算公式！

我们设这个新的函数为 $h$。

前面提到当 $p$ 为质数时 $f(p)$ 是一个次数较低的多项式，所以，我们可以把 $h$ 拆成几项，分开来算，最后加在一起即可。

我们设 $g(n,j)$ 为 $1\sim n$ 中，所有质数或者最小质因子大于等于第 $j$ 个质数的合数的 $f$ 值的和，设 $p_j$ 为第 $j$ 个质数。

考虑分讨：

1. 如果 $p_j>n$，此时不会再有更多的合数造成负贡献，因此有 $g(n,j)=g(n,j-1)$；
2. 如果 $p_j\le n$，我们发现包含负贡献的数中一定含有质因子 $p_j$，且除掉 $p_j$ 后最小的质因子会大于等于 $p_j$。所以我们考虑减去 $h(p_j)g(\frac{n}{p_j},j-1)$，但 $g(\frac{n}{p_j},j-1)$ 中重复减去了 ${\sum }_{i=1}^{j-1}h(p_i)$ 这些最小质因子小于 $p_j$ 的函数值，所以再把它们加上就好了。

此时有递推式：
$$g(n,j)=g(n,j-1)-h(p_j)(g(\lfloor \frac{n}{p_j}\rfloor ,j-1)-\sum _{i=1}^{j-1}h(p_i))$$
最后我们可以求出 $g(n,|Prime|)$，这就是前缀和中所有质数的贡献。

• $Step2$：

类⽐ $g$，设 $S(n,j)$ 表⽰最⼩质因⼦不⼩于第 $j$ 个素数的所有 $f$ 的函数值和。

初始时有 $S(n,|Prime|)=g(n,|Prime|)$。

对于质数，我们已经算出答案；对于合数，我们考虑枚举最小质因子及其指数即可递推：

（注意当 $f(p_k^{t+1})$ 超出范围时，我们定义其为 $0$。）
$$S(n,j)=g(n,|Prime|)-\sum _{i=1}^{j-1}f(p_i)+\sum _{k=j}^{p_k^2\le n}\sum _{t=1}^{p_k^t\le n}(f(p_k^{t+1})+f(p_k^t)S(\lfloor \frac{n}{p_k^t}\rfloor ,k+1)))$$
前面的 $g(n,j)-{\sum }_{i=1}^{j-1}f(p_i)$ 即为质数部分，注意要减去所有质数 $d(d<p_j)$ 的 $f(d)$ 的贡献；

枚举合数时，我们需要考虑所有最小质因子为 $d(d\ge p_j)$ 的数 $k$ 对应的 $f(k)$ 的贡献。由于质数我们在前面已经计算过，因此对于 $f(d^{t+1})$ 这一项，我们从 $t=1$ 而非 $t=0$ 开始枚举。而后面的合数部分，我们类似 $g$ 的处理，利用积性函数的性质把 $f(d^t)$ 这一项提出来，同时把 $d^t$ 这一项消掉，再递归求解所有最小质因子大于 $d$ 的 $S$。

最后 $S(n,0)$ 即为答案，不过注意要考虑一下 $f(1)$ 的贡献。

---

说了那么多，拿洛谷的模板题讲解一下吧：

定义积性函数 $f(x)$，当 $p$ 为质数时有 $f(p^k)=p^k(p^k-1)$。

给定 $n(n\le 10^{10})$，求：
$$\sum _{i=1}^{n}f(i)$$
对 $10^9+7$ 取模。

题解：

• $Step1$：

显然对于质数 $p$，有 $f(p)=p(p-1)=p^2-p$。可以发现，这正是上面提到的 “次数较少的简单多项式”。不看符号，它的每一项都是完全积性函数。

所以我们把 $f(p)$ 拆成 $p^2$ 和 $p$ 两项计算，最后相减即可。

我们再次回顾递推式：
$$g(n,j)=g(n,j-1)-h(p_j)(g(\lfloor \frac{n}{p_j}\rfloor ,j-1)-\sum _{i=1}^{j-1}h(p_i))$$
可以发现两件事情：

1. $\lfloor \frac{n}{p_j}\rfloor$ 最多会有 $\sqrt{n}$ 种取值，可以考虑整除分块预处理；
2. $n$ 以内的质因子个数也是 $\sqrt{n}$ 级别的，所以说 ${\sum }_{i=1}^{j-1}h(p_i))$ 也可以预处理。

所以我们先考虑把所有的素数筛出来，同时维护后面的那一项 ${\sum }_{i=1}^{j-1}h(p_i))$：

inline void Sieve()
{
	NotPrime[1] = true;
	for(register int i = 2; i <= s; i++)	//s = sqrt(n)
	{
		if(!NotPrime[i])
		{
			Prime[++len] = i;
			sum1[len] = GetMOD(sum1[len - 1] + i) % MOD;
			sum2[len] = GetMOD(sum2[len - 1] + 1LL * i * i % MOD) % MOD;
		}
		for(register int j = 1; j <= len && i * Prime[j] <= s; j++)
		{
			NotPrime[i * Prime[j]] = true;
			if(i % Prime[j] == 0LL) break;
		}
	}
	return;
}

然后我们整除分块，把对应的值存储下来编号，这样可以节省空间。同时我们预处理出 $g(1\sim n,0)$：

for(register LL l = 1, r; l <= n; l = r + 1)
{
	r = n / (n / l), val[++m] = n / l;
	g1[m] = GetMOD(Prefix1(val[m]) - 1LL + MOD), g2[m] = GetMOD(Prefix2(val[m]) - 1LL + MOD);	//注意要减去 f(1) 的贡献
	if(val[m] <= s) pos1[val[m]] = m; else pos2[n / val[m]] = m;
}

接着我们考虑求解 $g$，这里可以发现后面的值只会由前面推导过来，所以可以考虑把数组滚动：

for(register int i = 1; i <= len; i++)
{
	for(register int j = 1; j <= m && Prime[i] * Prime[i] <= val[j]; j++)
	{
		g1[j] = GetMOD(g1[j] - 1LL * Prime[i] * GetMOD(g1[GetPos(val[j] / Prime[i])] - sum1[i - 1] + MOD) % MOD + MOD); 
		g2[j] = GetMOD(g2[j] - 1LL * Prime[i] * Prime[i] % MOD * GetMOD(g2[GetPos(val[j] / Prime[i])] - sum2[i - 1] + MOD) % MOD + MOD);
	}
}

完毕。

• $Step2$：

接下来考虑求解 $S$。实际上没有那么麻烦，直接暴力枚举然后递归即可：

inline LL S(LL k, int p)
{
	if(Prime[p] > k) return 0LL;
	LL res = GetMOD(GetMOD(g2[GetPos(k)] - g1[GetPos(k)] + MOD) - GetMOD(sum2[p] - sum1[p] + MOD) + MOD);
	for(register int i = p + 1; i <= len && Prime[i] * Prime[i] <= k; i++)
	{
		LL pw = Prime[i];
		for(register int j = 1; pw <= k; pw = pw * Prime[i], j++) res = GetMOD(res + pw % MOD * GetMOD(pw % MOD - 1LL + MOD) % MOD * GetMOD(S(k / pw, i) + (j > 1)) % MOD);
	}
	return res;
}

贴上完整代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cassert>
#include<cmath>

#define MAXN 200005

using LL = long long;
using namespace std;

int len, m, pos1[MAXN], pos2[MAXN];
LL n, s, Prime[MAXN], sum1[MAXN], sum2[MAXN], val[MAXN], g1[MAXN], g2[MAXN];
bool NotPrime[MAXN];
const LL MOD = 1000000007LL, Inv2 = 500000004LL, Inv6 = 166666668LL;

inline LL GetMOD(LL k) { if(k >= MOD) k -= MOD; return k; }
inline LL Prefix1(LL k) { k %= MOD; return k * (k + 1LL) % MOD * Inv2 % MOD; }
inline LL Prefix2(LL k) { k %= MOD; return k * (k + 1LL) % MOD * GetMOD(k * 2LL % MOD + 1LL) % MOD * Inv6 % MOD; }
inline int GetPos(LL k) { if(k <= s) return pos1[k]; return pos2[n / k]; }

inline void Sieve()
{
	NotPrime[1] = true;
	for(register int i = 2; i <= s; i++)
	{
		if(!NotPrime[i])
		{
			Prime[++len] = i;
			sum1[len] = GetMOD(sum1[len - 1] + i) % MOD;
			sum2[len] = GetMOD(sum2[len - 1] + 1LL * i * i % MOD) % MOD;
		}
		for(register int j = 1; j <= len && i * Prime[j] <= s; j++)
		{
			NotPrime[i * Prime[j]] = true;
			if(i % Prime[j] == 0LL) break;
		}
	}
	return;
}

inline LL S(LL k, int p)
{
	if(Prime[p] > k) return 0LL;
	LL res = GetMOD(GetMOD(g2[GetPos(k)] - g1[GetPos(k)] + MOD) - GetMOD(sum2[p] - sum1[p] + MOD) + MOD);
	for(register int i = p + 1; i <= len && Prime[i] * Prime[i] <= k; i++)
	{
		LL pw = Prime[i];
		for(register int j = 1; pw <= k; pw = pw * Prime[i], j++) res = GetMOD(res + pw % MOD * GetMOD(pw % MOD - 1LL + MOD) % MOD * GetMOD(S(k / pw, i) + (j > 1)) % MOD);
	}
	return res;
}

int main()
{
	#ifdef FILE
		freopen("Input.in", "r", stdin);
	#endif
	scanf("%lld", &n), s = (LL)sqrt(n), Sieve();
	for(register LL l = 1, r; l <= n; l = r + 1)
	{
		r = n / (n / l), val[++m] = n / l;
		g1[m] = GetMOD(Prefix1(val[m]) - 1LL + MOD), g2[m] = GetMOD(Prefix2(val[m]) - 1LL + MOD);
		if(val[m] <= s) pos1[val[m]] = m; else pos2[n / val[m]] = m;
	}
	for(register int i = 1; i <= len; i++)
	{
		for(register int j = 1; j <= m && Prime[i] * Prime[i] <= val[j]; j++)
		{
			g1[j] = GetMOD(g1[j] - 1LL * Prime[i] * GetMOD(g1[GetPos(val[j] / Prime[i])] - sum1[i - 1] + MOD) % MOD + MOD); 
			g2[j] = GetMOD(g2[j] - 1LL * Prime[i] * Prime[i] % MOD * GetMOD(g2[GetPos(val[j] / Prime[i])] - sum2[i - 1] + MOD) % MOD + MOD);
		}
	}
	printf("%lld\n", GetMOD(S(n, 0) + 1LL));
	return 0;
}

---

$PowerfulNumber$

对正整数 $k$ 唯一分解为 ${\sum }_{p_i\in Prime}{p}_i^{{\alpha }_i}$，如满足 $\forall p_i\in Prime，{\alpha }_i\ge 2$，则称其为 $PowerfulNumber$。

每一个 $PowerfulNumber$ 都可以表示成 $a^2{b}^3$ 的形式。由此我们也可以证明：$1\sim n$ 内 $PowerfulNumber$ 的数量在 $O(\sqrt{n})$ 级别。

它有什么用处呢？

假设我们要求积性函数 $f$ 的前缀和，考虑构造一个前缀和很好求的函数 $g$，满足两函数在质数处值相等。

再设函数 $h$ 使得 $f=h\ast g$，$\ast$ 为狄利克雷卷积。

可以发现，当 $d$ 为质数时，有 $f(d)=h(d)+g(d)=g(d)$。换句话说，当 $d$ 不为 $PowerfulNumber$ 时，$h(d)$ 取值为 $0$。

又有：
$$\begin{array}{rl}\sum _{i=1}^{n}f(i)& =\sum _{i=1}^n(h\ast g)(i)\\ & =\sum _{i=1}^n\sum _{d|i}h(d)g(\frac{i}{d})\\ & =\sum _{d=1}^{n}h(d)\sum _{i=1}^{\lfloor \frac{n}{d}\rfloor }g(i)\end{array}$$
由于后者前缀和很好求，因此可以考虑暴力找出 $n$ 以内的 $PowerfulNumber$，直接暴力加就行。

---

非特殊函数的筛法

一般思路：

1. 如果函数满⾜类积性，也就是满⾜对于所有的 $a\perp b$ 都有 $f(ab)=f(a)\otimes f(b)$（$\otimes$ 是⼀种运算符）时，可以套⽤积性函数的筛法解决；
2. 如果函数和其约数密切相关，则试着先从素数整次幂⽅⾯推导，然后拓展到含多种素数的合数上。最后根据推导得到的式⼦进⾏计算。

---

$ToBeContinued\cdots \cdots$