洛谷-P1829 Crash的数字表格--积性函数

推式子

$$\begin{array}{r}ans=\sum _{i=1}^N\sum _{j=1}^{M}lcm(i,j)=\sum _{i=1}^N\sum _{j=1}^M\frac{i\ast j}{\gcd (i,j)}\end{array}$$
很明显出现了$\gcd$，我们枚举$\gcd (i,j)=d$
$$\begin{array}{r}ans=\sum _{d=1}^{\min (N,M)}\sum _{i=1}^N\sum _{j=1}^M\frac{i\ast j}{d}[\gcd (i,j)==d]\end{array}$$
$$\begin{array}{r}ans=\sum _{d=1}^{\min (N,M)}\sum _{i=1}^{\lfloor \frac{N}{d}\rfloor }\sum _{j=1}^{\lfloor \frac{M}{d}\rfloor }d\ast i\ast j[\gcd (i,j)==1]\end{array}$$
接下来我们有很多方法去化简这个式子，我使用${\sum }_{x\mid gcd(i,j)}\mu (x)$替换$[\gcd (i,j)==1]$
$$\begin{array}{r}ans=\sum _{d=1}^{\min (N,M)}\sum _{i=1}^{\lfloor \frac{N}{d}\rfloor }\sum _{j=1}^{\lfloor \frac{M}{d}\rfloor }d\ast i\ast j\sum _{x\mid gcd(i,j)}\mu (x)\end{array}$$
然后我们枚举x
$$\begin{array}{r}ans=\sum _{d=1}^{\min (N,M)}d\sum _{x=1}^{\min (\frac{N}{d},\frac{M}{d})}\mu (x)\sum _{xi=1}^{\lfloor \frac{N}{d}\rfloor }\sum _{xj=1}^{\lfloor \frac{M}{d}\rfloor }{x}^2\ast i\ast j\end{array}$$
$$\begin{array}{r}ans=\sum _{d=1}^{\min (N,M)}d\sum _{x=1}^{\min (\frac{N}{d},\frac{M}{d})}\mu (x)\ast x^2\sum _{i=1}^{\lfloor \frac{N}{xd}\rfloor }\sum _{j=1}^{\lfloor \frac{M}{xd}\rfloor }i\ast j\end{array}$$
推到这里就可以写了，两次分块时间复杂度接近O(n)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
template <typename T>
void out(T x) { cout << x << endl; }
const int N = 1e7 + 6;
const ll mod = 20101009;
const ll inv2 = 10050505;
ll fast_pow(ll a, ll b, ll p) {ll c = 1; while(b) { if(b & 1) c = c * a % p; a = a * a % p; b >>= 1;} return c;}
int mu[N], prime[N], tot;
ll sum[N];
bool mark[N];
void get_mu()
{
    tot = 0;
    mark[0] = mark[1] = true;
    mu[1] = 1;
    for(int i = 2; i < N; i ++)
    {
        if(!mark[i])
        {
            prime[tot ++] = i;
            mu[i] = -1;
        }
        for(int j = 0; j < tot && i * prime[j] < N; j ++)
        {
            mark[i * prime[j]] = true;
            if(i % prime[j] == 0)
                break;
            mu[i * prime[j]] = -mu[i];
        }
    }
    for(int i = 1; i < N; i ++)
        sum[i] = (sum[i - 1] + mu[i] * i % mod * i % mod) % mod;
}
int main()
{
    ios::sync_with_stdio(false);
    get_mu();
    ll n, m;
    cin >> n >> m;
    if(n > m)
        swap(n, m);
    ll ans = 0;
    for(ll d = 1, t = 1; d <= n; d = t + 1)
    {
        t = min(n / (n / d), m / (m / d));
        ll bns = 0, dn = n / d, dm = m / d;
        for(ll i = 1, j = 1; i <= dn; i = j + 1)
        {
            j = min(dn / (dn / i), dm / (dm / i));
            bns = (bns + (sum[j] - sum[i - 1]) * (dn / i) % mod * (dn / i + 1ll) % mod * inv2 % mod * (dm / i) % mod * (dm / i  + 1ll) % mod * inv2 % mod + mod) % mod;
        } 
        ans = (ans + (t - d + 1) * (t + d) % mod * inv2 % mod * bns % mod + mod) % mod;
    }
    cout << ans << endl;
}

然后就这样我们还可以继续化简
我们令$T=xd$,令$f(x)={\sum }_{i=1}^{x}i$
$$\begin{array}{r}ans=\sum _{d=1}^{\min (N,M)}d\sum _{x=1}^{\min (\frac{N}{d},\frac{M}{d})}\mu (x)\ast x^{2}f(\lfloor \frac{N}{T}\rfloor )f(\lfloor \frac{M}{T}\rfloor )\end{array}$$
然后我们枚举T
$$\begin{array}{r}ans=\sum _{T=1}^{\min (N,M)}f(\lfloor \frac{N}{T}\rfloor )f(\lfloor \frac{M}{T}\rfloor )\sum _{d\mid T}d\ast \mu (\frac{T}{d})\ast (\frac{T}{d}{)}^2\end{array}$$
$$\begin{array}{r}ans=\sum _{T=1}^{\min (N,M)}f(\lfloor \frac{N}{T}\rfloor )f(\lfloor \frac{M}{T}\rfloor )\sum _{d\mid T}\mu (\frac{T}{d})\ast (\frac{T}{d})\ast T\end{array}$$
后面那个式子我们枚举$\frac{T}{d}$，即另$d=\frac{T}{d}$
$$\begin{array}{r}ans=\sum _{T=1}^{\min (N,M)}f(\lfloor \frac{N}{T}\rfloor )f(\lfloor \frac{M}{T}\rfloor )\sum _{d\mid T}d\ast \mu (d)\ast T\end{array}$$
这样似乎并没有改变什么复杂度，但是我们发现后面的${\sum }_{d\mid T}d\ast \mu (d)是个积性函数$
我们分析一下
设$h(T)={\sum }_{d\mid T}d\ast \mu (d)$
当$T\in prime$,$h(T)=1-T$
现有$x=i\ast prime[j]$且i中无prime[j]这个质因子
$h(i\ast prime[j])={\sum }_{d\mid (i\ast prime[j])}d\ast \mu (d)$
我们发现多了个质数会在原有约数的基础上翻一倍，并且一一对应
设z是i的约数，我们有$z\ast prime[j]\ast \mu (z\ast prime[j])=-z\ast \mu (z)\ast prime[j]$
所以这一对的贡献就是$(1-prime[j])\ast z\ast \mu (z)$
对于每一对我们都可以提出个$(1-prime[j])$
$h(i\ast prime[j])=h(i)\ast (1-prime[j])=h(i)\ast h(prime[j])$
发现这玩意是个积性函数
如果$i$中存在$prime[j]$这个质因子
$h(i\ast prime[j])={\sum }_{d\mid (i\ast prime[j])}d\ast \mu (d)$
对于d
如果d中有prime[j]这个质因子，我们会发现$\mu (d)=0$因为存在平方因子
如果d中无prime[j]这个质因子，我们会发现是$h(i)的组成$
最后$h(i\ast prime[j])=h(i)$

这样我们可以用线性筛求出$h(T)$啦，那个T在求前缀和的时候乘上
那前面直接分块，时间复杂度降低到O($\sqrt{n}$)

筛法代码：

int gu[N], prime[N], tot;//gu为积性函数
bool mark[N];
void get_gu()
{
    tot = 0;
    mark[0] = mark[1] = true;
    gu[1] = 1;
    for(int i = 2; i < N; i ++)
    {
        if(!mark[i])
        {
            gu[i] = 1 - i;
            prime[tot ++] = i;
        }
        for(int j = 0; j < tot && i * prime[j] < N; j ++)
        {
            mark[i * prime[j]] = true;
            if(i % prime[j] == 0)
            {
                gu[i * prime[j]] = gu[i];
                break;
            }
            gu[i * prime[j]] = gu[i] * (1 - prime[j]);
        }
    }
}

神仙的是我应该O($\sqrt{n}$)代码居然没我O(n)跑的快