杜教筛学习笔记

刀尖舞蹈

如果数据很容易爆$longlong$的话，你有几种处理方式：

1：在爆炸的边缘试探

正确写法：$ans=(ULL)n\ast (n+1LL)/2LL;$

错误写法：$ans=(ULL)n\ast (n+1)/2;$

$1LL$表示加一个$longlong$类型的$1$，尽量不要跨类型加。

2：$int\_128$禁术

3：利用语言特性（大数模乘）

$return(LL)a\ast b-(LL)((LDB)a\ast b/p)\ast p)$

4：高精度（最不幸的）

5: 改python

杜教筛

用于在快于线性的时间内求一个函数的前缀和。

你的目标是求$f$的前缀和$F(n)$。

我们寻找一个好求前缀和的函数$g$，（一般是$1$函数）

构造$h=f\ast g$，这里$\ast$是狄利克雷卷积。记$H$是$h$的前缀和。

那么有：

$$F(n)=\frac{H(n)-{\sum }_{i=2}^{n}g(i)F(\frac{n}{i})}{g(1)}$$

我们对$\frac{n}{i}$数论分块来做，这就要求$H,g$是可以快速求出前缀和的。

首先预处理一部分可以线性得到的$F$，一般预处理$n^{\frac{2}{3}}$为宜。

对于每个询问，跑杜教筛。可以用$c++11$特性下的$unordered\_map$来存储求过的$F$。

求$\varphi$的前缀和。

$\varphi \ast 1=I=i{d}_1$

预处理就是一般的$\varphi$筛。

inline LL dlsphi(int n) {
    if (n < N) return F[n];
    if (q1[n]) return q1[n];
    LL res = 0;
    for (register int L = 2, R; R < INF && L <= n; L = R + 1) {
        R = n / (n / L);
        res += (ULL) (R - L + 1) * dlsphi(n / L);
    }
    return q1[n] = (ULL)n * (n + 1LL) / 2LL - res;
}

这里的$n$是$int$级别的，所以要特殊处理下防止越界。

求$\mu$的前缀和

$\mu \ast 1=ϵ$

预处理也就是一般的$\mu$筛。

inline int dlsmu(int n) {
    if (n < N) return F_[n];
    if (q2[n]) return q2[n];
    int res = (n >= 1);
    for (register int L = 2, R; R < INF && L <= n; L = R + 1) {
        R = n / (n / L);
        res -= (ULL) (R - L + 1) * dlsmu(n / L);
    }
    return q2[n] = res;
}

求$F(n)={\sum }_{i=1}^n\varphi (i)\ast i^2$

$f(i)=\varphi (i)\ast i^2$
看到了$i^2$，我们考虑让构造的$g$里面也有$i^2$达到消掉的目的。

令$g(i)=i^2$。$h=f\ast g$。

$h(i)={\sum }_{d|i}g(\frac{i}{d})f(d)=i^2{\sum }_{d|i}\varphi (d)=i^3$

loj6229

目前遇到的最难的推式子题。。。

写一下推导的过程吧。。

要求${\sum }_{i=1}^n{\sum }_{j=1}^i\frac{lcm(i,j)}{gcd(i,j)}$

考虑求${\sum }_{i=1}^n{\sum }_{j=1}^n\frac{lcm(i,j)}{gcd(i,j)}$ 然后$+n$再除以$2$就是答案。

$$=\sum _{i=1}^n\sum _{j=1}^n\frac{ij}{gc{d}^2(i,j)}$$

$$=\sum _{d=1}^n\frac{1}{d^2}\sum _{i=1}^n\sum _{j=1}^{n}ij[gcd(i,j)=d]$$

$$=\sum _{d=1}^n\sum _{i=1}^{\lfloor \frac{n}{d}\rfloor }\sum _{j=1}^{\lfloor \frac{n}{d}\rfloor }ij[gcd(i,j)=1]$$

$$=\sum _{d=1}^n\sum _{i=1}^{\lfloor \frac{n}{d}\rfloor }\sum _{j=1}^{\lfloor \frac{n}{d}\rfloor }ij\sum _{d^{\prime }|gcd(i,j)}\mu (d^{\prime })$$

$$=\sum _{d=1}^n\sum _{d^{\prime }=1}^{\lfloor \frac{n}{d}\rfloor }\mu (d^{\prime })(d^{\prime }{)}^2\sum _{i=1}^{\lfloor \frac{n}{d{d}^{\prime }}\rfloor }\sum _{j=1}^{\lfloor \frac{n}{d{d}^{\prime }}\rfloor }ij$$

令$q=d^{\prime }d$。

$$\sum _{q=1}^n\sum _{d^{\prime }|q}\mu (d^{\prime })(d^{\prime }{)}^2(\sum _{i=1}^{\lfloor \frac{n}{q}\rfloor }i{)}^2$$

令$f(i)={\sum }_{d|i}\mu (d)d^2$，发现后面那坨是个数论分块的东西。
所以任务就是求$f(i)$的前缀和。

构造$g(i)=i^2,t(i)=\mu (i)i^2$，发现直接求$h=f\ast g$不太好搞

接下来就是见证奇迹的时刻。

$f=t\ast 1h=f\ast g=t\ast g\ast 1$

发现 $t\ast g=ϵ$

证明：假设$l=t\ast g$

$l(i)={\sum }_{d|i}t(d)\ast g(\frac{i}{d})={\sum }_{d|i}\mu (d)i^2=i^2[i==1]=ϵ$

所以：$h=t\ast g\ast 1=1$。

所以我们可以在$O(1)$的时间内算出$H(n)={\sum }_{i=1}^{n}h(i)=n$

根据杜教筛的式子：

$$F(n)=\frac{H(n)-{\sum }_{i=2}^{n}g(i)F(\frac{n}{i})}{g(1)}$$

$F(n)=H(n)-{\sum }_{i=2}^n{i}^{2}F(\frac{n}{i})$，平方和的区间和可以通过两个通项公式倒腾出来。

复杂度的话，简单分析来就外层是一个大数论分块$O(n^{0.5})$，里面杜教筛的$n$依赖于外层数论分块的$L,R$。

这个东西可以归结成一类的复杂度分析：

${\sum }_{i=1}^{n}f(\frac{n}{i})\times g(i)$，其中$g$可以使用杜教筛求前缀和。

考虑在求$g$的值的时候，杜教筛里面是有记忆化的。也就是一个数论分块，所以这次恰好会访问到那些上次外层调用杜教筛的地方。复杂度还是$O(n^{\frac{2}{3}})$。

$codes:$

#include <cstdio>
#include <map>
using namespace std;
typedef long long LL;
map<int, LL> q;
const int N = 1e6 + 5, P = 1e9 + 7;
int prime[N], vis[N], tot;
LL F[N], mu[N], inv2, inv6;
int n;
inline LL q_p(LL a, LL b, LL p) {
    LL res = 1;
    while (b) {
        if (b & 1) res = res * a % p;
        a = a * a % p;
        b >>= 1;
    }
    return res;
}
inline void eluer() {
    vis[1] = 1; mu[1] = 1;
    inv2 = q_p(2, P - 2, P);
    inv6 = q_p(6, P - 2, P);
    for (int i = 2; i < N; ++i) {
        if (!vis[i]) {
            prime[++tot] = i;
            mu[i] = ((1 - 1LL * i * i) % P + P) % P;
        }
        for (int j = 1; j <= tot; ++j) {
            LL cur = 1LL * i * prime[j];
            if (cur >= N) break;
            vis[cur] = 1;
            if (i % prime[j] == 0) {
                mu[cur] = mu[i];
                break;
            }
            else mu[cur] = (mu[i] * mu[prime[j]]) % P;
        }
    }
    for (int i = 1; i < N; ++i) F[i] = (F[i - 1] + mu[i]) % P;
}
inline LL calc(int n) {
    return inv6 * n % P * (n + 1) % P * (2 * n + 1) % P;
}
inline LL dls(int n) {
    if (n < N) return F[n];
    if (q[n]) return q[n];
    LL res = n;
    for (int L = 2, R; L <= n; L = R + 1) {
        R = n / (n / L);
        res = ((res - ((calc(R) - calc(L - 1)) % P + P) % P * dls(n / L) % P) % P + P) % P;
    }
    return q[n] = res;
}
int main() {
    scanf("%d", &n);
    eluer();
    LL ans = 0;
    for (int L = 1, R; L <= n; L = R + 1) {
        R = n / (n / L);
        LL res = ((dls(R) - dls(L - 1)) % P + P) % P;
        res = res * (1 + (n / L)) % P * (1 + (n / L)) % P;
        res = res * (n / L) % P * (n / L) % P;
        res = res * inv2 % P * inv2 % P;
        ans = (ans + res) % P;
    }
    printf("%lld\n", (ans + n) % P * inv2 % P);
    return 0;
}