关于杜教筛

杜教筛

  这个东西的前置芝士有点多啊~~

  这个东西差不多就是拿来求函数前缀和的一个东西，他能做到在 $O(n^{\frac{2}{3}})$ 的时间复杂度内求出答案：

$$S(n)=\sum _{i=1}^{n}f(i)$$

欧拉函数前缀和

  我们先通过求欧拉函数的前缀和来感受一下杜教筛的思想，记答案为：

$$S(n)=\sum _{i=1}^n\phi (n)$$

  然后根据众所周知的一个公式 $(\phi \ast I)(n)=id(n)$，我们可以进行一下的推导：

$$\begin{array}{rl}n=\phi \ast I& =\sum _{d|n}\phi (d)=\phi (n)+\sum _{d|n\wedge d<n}\phi (d)\\ \phi (n)& =n-\sum _{d|n\wedge d<n}\phi (d)\\ S(n)=\sum _{i=1}^n\phi (i)& =\sum _{i=1}^n\left(i-\sum _{d|i\wedge d<i}\phi (d)\right)=\sum _{i=1}^{n}i-\sum _{i=1}^n\sum _{d|i\wedge d<i}\phi (d)\\ & =\frac{1}{2}n(n-1)-\sum _{\lfloor \frac{i}{d}\rfloor =2}^n\sum _{d=1}^{\lfloor \frac{n}{\frac{i}{d}}\rfloor }\phi (d)=\frac{1}{2}n(n-1)-\sum _{i=2}^n\sum _{d=1}^{\lfloor \frac{n}{i}\rfloor }\phi (d)\\ & =\frac{1}{2}n(n-1)-\sum _{i=2}^{n}S\left(\lfloor \frac{n}{i}\rfloor \right)\end{array}$$

  这样我们就得到了：

$$S(n)=\frac{1}{2}n(n-1)-\sum _{i=2}^{n}S\left(\lfloor \frac{n}{i}\rfloor \right)$$

  我们发现这个式子就是一个 $S(n)$ 的递推式，而且 $\frac{1}{2}n(n-1)$ 这一项的时间复杂度是 $O(1)$ 的，所以我们只用要计算复杂度的时候可以把这一项略去。所以我们只需要计算这个式子的时间复杂度：

$$S(n)=\sum _{i=2}^{n}S(\lfloor \frac{n}{i}\rfloor )$$

  然后我们发现右边可以整出分块，就是有 $\sqrt{n}$ 个 $S(\frac{n}{i})$ 的取值，最后加起来还有 $O(\sqrt{n})$，所以，我们设 $S(n)$ 的时间复杂度是 $T(n)$，那我们就有：

$$T(n)=O(\sqrt{n})+O(\sum _{i=2}^{\sqrt{n}}T(\frac{n}{i}))$$

  再展开一层（中间的第二项太小了直接略去）：

$$T\left(\frac{n}{i}\right)=O(\sqrt{\frac{n}{i}})+O(\sum _{k=2}^{\sqrt{\frac{n}{i}}}T(\frac{\frac{n}{i}}{k}))=O(\sqrt{\frac{n}{i}})$$

  所以我们将这个式子带回：

$$T(n)=O(\sqrt{n}+O(\sum _{i=2}^{\sqrt{n}}\sqrt{\frac{n}{i}})=O(\sum _{i=2}^{\sqrt{n}}\sqrt{\frac{n}{i}})\approx O({\int }_0^{\sqrt{n}}\sqrt{\frac{n}{x}}dx)=O(n^{\frac{3}{4}})$$

  但是直接递归的做法不是最优的，我们还可以考虑先用线性筛筛出前 $k$ 个 $S(n)$，这样显然可以降低一些复杂度。我们考虑筛出前 $k$ 个 $S(n)$ 且 $k\ge \sqrt{n}$，所以我们现在只用求的是 $k<\lfloor \frac{n}{i}\rfloor \le n$ 的部分就能解决问题了，也就是计算 $1<i\le \frac{n}{k}$ 的部分。那么时间复杂度就是：

$$T(n)=\sum _{i=2}^{\frac{n}{k}}O(\sqrt{\frac{n}{i}})\approx O({\int }_0^{\frac{n}{k}}\sqrt{\frac{n}{k}}dx)=O(\frac{n}{\sqrt{k}})$$

  因为线性筛也要花时间，也就是 $O(k)$ 的时间，所以总的复杂度应该为：

$$T(n)=O(k)+O(\frac{n}{\sqrt{k}})$$

  我们通过一些计算手段可以得到 $k$ 差不多取到 $O(n^{\frac{2}{3}})$ 的时候 $T(n)$ 是最小的，复杂度就是：

$$O(n^{\frac{2}{3}}+O(\frac{n}{\sqrt{n^{\frac{2}{3}}}}))=O(n^{\frac{2}{3}})$$

莫比乌斯函数

  推导公式和计算的过程基本和欧拉函数都是差不多的在这里给出计算过程，不做详细解释：

$$\begin{array}{rl}(\mu \ast I)& (n)=\epsilon (n)=[n=1]\\ [n=1]& =\sum _{d|n}\mu (d)=\mu (n)+\sum _{d|n\wedge d<n}\mu (d)\\ \mu (n)& =[n=1]-\sum _{d|n\wedge d<n}\mu (d)\\ S(n)=\sum _{i=1}^n\mu (i)& =\sum _{i=1}^n\left([i=1]-\sum _{d|i\wedge d<i}\mu (d)\right)=1-\sum _{i=1}^n\sum _{d|i\wedge d<i}\mu (d)\\ & =1-\sum _{\lfloor \frac{i}{d}\rfloor =2}^n\sum _{d=1}^{\lfloor \frac{n}{\frac{i}{d}}\rfloor }\mu (d)=1-\sum _{i=2}^n\sum _{d=1}^{\lfloor \frac{n}{i}\rfloor }\mu (d)=1-\sum _{i=2}^{n}S\left(\lfloor \frac{n}{i}\rfloor \right)\\ S(n)& =1-\sum _{i=2}^{n}S\left(\lfloor \frac{n}{i}\rfloor \right)\end{array}$$

代码

  传送门：luogu4213 杜教筛

#include<bits/stdc++.h>
using namespace std;
#define MAXN 100001000
#define ll long long

int T = 0; int n = 0;
bool vi[MAXN] = { 0 };
int pri[MAXN] = { 0 }; int m = 0;
ll   ph[MAXN] = { 0 };
int  mu[MAXN] = { 0 };
unordered_map<int, ll> P, M;

void Sieve(int n){
	mu[1] = ph[1] = 1;
	for(int i = 2; i <= n; i++){
		if(!vi[i]) pri[++m] = i, ph[i] = i - 1, mu[i] = -1;
		for(int j = 1; j <= m; j++){
			if(i * pri[j] > n) break;
			vi[i * pri[j]] = 1;
			if(i % pri[j] == 0){
				ph[i * pri[j]] = ph[i] * pri[j];
				mu[i * pri[j]] = 0; break;
			}
			mu[i * pri[j]] = -mu[i];
			ph[i * pri[j]] = ph[i] * (pri[j] - 1);
		}
	}
	for(int i = 2; i <= n; i++)
		mu[i] += mu[i - 1], ph[i] += ph[i - 1];
}

ll Phi(ll n){
	if(n <= 1e7) return ph[n];
	if(P.count(n)) return P[n];
	ll x = 1ll * n * (n + 1) / 2;
	for(ll l = 2, r; l <= n; l = r + 1){
		int v = n / l; r = n / v;
		x -= 1ll * (r - l + 1) * Phi(v);
	}
	return P[n] = x;
}

ll Mu(ll n){
	if(n <= 1e7) return mu[n];
	if(M.count(n)) return M[n];
	ll x = 1;
	for(ll l = 2, r; l <= n; l = r + 1){
		int v = n / l; r = n / v;
		x -= 1ll * (r - l + 1) * Mu(v);
	}
	return M[n] = x;
} 

int main(){
	cin >> T;
	Sieve(1e7);
	while(T--){
		cin >> n;
		M.clear(); P.clear();
		cout << Phi(n) << ' ' << Mu(n) << '\n';
	}
	return 0;
}