P1829 [国家集训队]Crash的数字表格

P1829 [国家集训队]Crash的数字表格

原题传送门

前置芝士

莫比乌斯反演

乘法逆元

数论分块

正文

//补充：以下式子中的除法均为整除

由题目可以得知，这道题让我们所求的数，用一个式子来表达即为：\(\boxed{ANS=\sum_{i=1}^n \sum_{j=1}^m LCM(i,j)}\)

而根据莫比乌斯反演的内容，我们可以对右边的式子进行进一步的推导：

\[\begin{align}
\sum_{i=1}^n \sum_{j=1}^m LCM(i,j)&=\sum_{i=1}^n \sum_{j=1}^m {ij\over gcd(i,j)}\\
&=\sum_{t=1}^n t \sum_{i=1}^n \sum_{j=1}^m {ij \over {t^2}} [GCD({i\over t},{j \over t})=1]\\
&=\sum_{t=1}^n t \sum_{i=1}^{n\over t} \sum_{j=1}^{m \over t} ij[GCD(i,j)=1]\\
&=\sum_{t=1}^n t f({n\over t},{m\over t})

\end{align}
\]

接下来，令 \(\boxed{K=td}\) ，则有以下推论：

\[\begin{align}
\sum_{t=1}^n t \sum_{d=1}^{n\over t} d^2 \mu(d) *{((1+{n\over td}){n\over td})\over 2}*{((1+{m\over td}){m\over td})\over 2}&=\sum_{K=1}^n *{((1+{n\over td}){n\over td})\over 2}*{((1+{m\over td}){m\over td})\over 2} \sum_{d|K} d^2 \mu(d) {K\over d}\\

\end{align}
\]

然后，我们有定义一个函数：\(\boxed{g(K)=\sum_{d|K} K d \mu (d)}\)，则有：

\[\begin{align}
g(K)&=\sum_{d|K} K d \mu (d)\\
&=K \sum_{d|K} \mu(d) d\\
&=K f(K)\\
\end{align}
\]

这里我们定义了一个函数：\(f\)，其性质为：

\[f(K)=\sum_{d|K} \mu(d)d\\
\]

我们可以立马发现函数 \(f\) 是一个积性函数，若我们设 \(p\) 为一个质数，则会有以下推论：

\[f(p)=1-p\\
f(p^K)=1-p\\
而当K\ge 2 时，有:f(p^K)=f(p^{K-1})
\]

最终，我们便可以通过预处理函数 \(f\) ，从而更快地得到答案。但我们该如何预处理函数 \(f\) 呢？很简单，我们只需要用线性筛处理即可。

请仔细回想一下欧拉函数线性筛和莫比乌斯函数线性筛是如何由普通的线性筛转化而来的，若读者已经完全理解了这两种线性筛的拓展应用，那么对于函数 \(f\) 的线性筛求法，想必读者也能轻易写出。这里将不会对函数 \(f\) 的预处理做过多的介绍。

代码如下：

typedef long long ll;
const int N=10000005;
int tot,phi[N],f[N],prime[N];
ll pre[N];
bool np[N];
void init(int n){
    np[1]=true;
    f[1]=1;
    for (int i=2;i<=n;i++){
        if (!np[i]){
            prime[tot++]=i;
            f[i]=1-i;
        }
        for (int j=0,k;(k=i*prime[j])<=n;j++){
            np[k]=true;
            if (i%prime[j]==0) {
            	f[k]=f[i];
		break;
            }
            f[k]=f[i]*f[prime[j]];
        }
    }
}

现在我们已经完成了 (且时间复杂度为\(O (n)\) ）对函数 \(f\) 的预处理，接下来便是计算答案了。不过，先别着急，我们再来看一看推导后的式子：

\[\sum_{K=1}^n *{((1+{n\over td}){n\over td})\over 2}*{((1+{m\over td}){m\over td})\over 2} \sum_{d|K} d^2 \mu(d) {K\over d}
\]

是不是发现了一个惊喜？相信读者在学习完数论分块的内容后会很容易地发现：这个式子是可以通过数论分块进行进一步优化的。接下来，我们将对这一步的优化进行解释：

既然我们定义了函数 \(g\) ，我们先把 \(g\) 带进上面的式子。

\[\sum_{K=1}^n *{((1+{n\over td}){n\over td})\over 2}*{((1+{m\over td}){m\over td})\over 2} * g（K）
\]

接着，因为我们已经预处理完了函数 \(f\) ，那么便可以用 \(f\) 来表示 \(g\) 。

\[g(K)=f(K)*K
\]

现在已经很明显了：我们可以对这个\(g(K)\)进行数论分块的优化。我们只需算出前缀和，就可以为所欲为愉快地数论分块了。

这里定义前缀和为数组 \(pre\) ,则转移方程为：\(\boxed{pre[i]=pre[i-1]+f[i]*i}\)

最后，在结合乘法逆元的知识(因为题目给定了模数：\(20101009\) ，且式中带有除法)，便可以在不超时的情况下计算出答案。

最终的代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=10000005;
const ll mod=20101009;
int tot,f[N],prime[N];//质数个数+1，第i个f函数的值，第i个质数
ll pre[N];//前缀和
bool np[N];//非质数
void init(int n){
    np[1]=true;
    f[1]=1;
    for (int i=2;i<=n;i++){
        if (!np[i]){
            prime[tot++]=i;
            f[i]=1-i;
        }
        for (int j=0,k;(k=i*prime[j])<=n;j++){
            np[k]=true;
            if (i%prime[j]==0) {
            	f[k]=f[i];
		break;
	      }
	f[k]=f[i]*f[prime[j]];
        }
    }
    for (int i=1;i<=n;i++) pre[i]=pre[i-1]+(ll)f[i]*i;//处理前缀和
}//预处理
int main(){
	int n,m;
	ll ans=0;//最终答案
	scanf("%d %d",&n,&m);
	if (n>m) swap(n,m);//保证n比m小
	init(n);
	int j;
	for (int i=1;i<=n;i=j+1){
	      j=min(n/(n/i),m/(m/i));//开始愉悦地数论分块~~
	      ll a1=(ll)(1+n/i)*(n/i)/2%mod,a2=(ll)(1+m/i)*(m/i)/2%mod;//一定记得加(long long)
	      ans+=(a1%mod*a2%mod*(pre[j]-pre[i-1])%mod+mod)%mod;
	      ans%=mod;
	      //乘法逆元的运用
	}
	printf("%lld\n",ans%mod);
	return 0;
}

最后的题外话：作者一定会想方设法地把莫比乌斯函数的博客更新完的（哭，太难了）。

感谢阅读。

（作者的OI历程:）