51nod1188最大公约数之和V2（欧拉函数+线性筛）

题目：51nod1188.
题目大意：给定一个数$n$，求：
$$\sum _{i=1}^n\sum _{j=i+1}^{n}gcd(i,j)$$

$1\le n\le 5\ast 10^6$，数据组数$\le 5\ast 10^4$.

直接推导下去：
$$\begin{gathered} \sum _{i=1}^n\sum _{j=i+1}^{n}gcd(i,j) \\ =\sum _{i=1}^n\sum _{j=1}^{i}gcd(i,j)-\sum _{i=1}^{n}i \\ =\sum _{i=1}^n\sum _{j=1}^{i}gcd(i,j)-\frac{n(n+1)}{2} \end{gathered}$$

到这一步我们开始推导前半个式子：
$$\begin{gathered} \sum _{i=1}^n\sum _{j=1}^{i}gcd(i,j) \\ =\sum _{i=1}^n\sum _{k=1}^{i}k\ast \sum _{j=1}^i[gcd(i,j)=k] \end{gathered}$$

设$m=\frac{i}{k}$，那么我们就可以把式子变为：
$$\begin{gathered} \sum _{i=1}^n\sum _{j=1}^{i}gcd(i,j) \\ =\sum _{i=1}^n\sum _{k|i}k\ast \sum _{j=1}^m[gcd(j,m)=1] \\ =\sum _{i=1}^n\sum _{k|i}k\varphi (m) \end{gathered}$$

将$m$代回式子中，即可得到：
$$\sum _{i=1}^n\sum _{j=1}^{i}gcd(i,j)=\sum _{i=1}^n\sum _{k|i}k\varphi (\frac{i}{k})$$

也就是说：
$$\sum _{i=1}^n\sum _{j=i+1}^{n}gcd(i,j)=\sum _{i=1}^n\sum _{k|i}k\varphi (\frac{i}{k})-\frac{n(n+1)}{2}$$

仔细一思考，发现我们得到的式子大概是这样的：
$$\sum _{i=1}^n(\epsilon \times \varphi )(i)$$

这不就是两个积性函数的dirichlet卷积嘛，直接用dirichlet卷积预处理，然后前缀和一下就可以做到$O(n\log n+T)$解决这个问题.

但是我们知道两个积性函数的dirichlet卷积也是一个积性函数，而一般积性函数是可以用线性筛筛的，如果用线性筛预处理的话这道题就可以做到$O(n+T)$解决了.

那么怎么线性筛呢？我们可以构造一个函数$f$：
$$f(i)=\sum _{k|i}\frac{i}{k}\varphi (k)$$

考虑使用线性筛筛这个函数$f$了：
1.当$i$为素数时，$f(i)=2i-1$.
2.当$gcd(i,pr[j])=1$时，由于这个函数是积性函数，所以$f(i\ast pr[j])=f(i)f(pr[j])$.
3.当$pr[j]|i$时，那么：
$$f(i\ast pr[j])=\sum _{k|i\ast pr[j]}\frac{i\ast pr[j]}{k}\varphi (k)$$

我们设$mul[i]$表示$i$的所有最小素因子之积，那么：
$$\begin{gathered} f(i\ast pr[j])=\sum _{k|i}\frac{i\ast pr[j]}{k}\varphi (k)+\sum _{k|\frac{i}{mul[i]}}\frac{i\ast pr[j]}{k\ast mul[i]}\varphi (k\ast mul[i]) \\ =pr[j]\ast f(i)+\sum _{k|\frac{i}{mul[i]}}\frac{i\ast pr[j]}{k\ast mul[i]}\varphi (k)\ast \varphi (mul[i]) \\ =pr[j]\ast f(i)+\sum _{k|\frac{i}{mul[i]}}\frac{i\ast pr[j]}{k\ast mul[i]}\varphi (k)\ast mul[i]\ast \frac{pr[j]-1}{pr[j]} \\ =pr[j]\ast f(i)+(pr[j]-1)\sum _{k|\frac{i}{mul[i]}}\frac{i}{k}\varphi (k) \\ =pr[j]\ast f(i)+mul[i](pr[j]-1)\sum _{k|\frac{i}{mul[i]}}\frac{i}{mul[i]\ast k}\varphi (k) \\ =pr[j]\ast f(i)+mul[i](pr[j]-1)f(\frac{i}{mul[i]}) \end{gathered}$$

很明显$mul[i]$是可以在线性筛的时候顺便筛出来的，所以我们就可以愉快的$O(n+T)$AC这道题啦.

线性筛代码如下：

#include<bits/stdc++.h>
  using namespace std;
 
#define Abigail inline void
typedef long long LL;
 
const int N=5000000;
 
int pr[N+9],b[N+9],tp;
LL mul[N+9],f[N+9],phi[N+9],F[N+9];
 
void sieve(int n){
  for (int i=2;i<=n;++i) b[i]=1;
  mul[1]=1;f[1]=1;phi[1]=1;
  int v;
  for (int i=2;i<=n;++i){
    if (b[i]){
      pr[++tp]=i;
      phi[i]=LL(i-1);
      mul[i]=LL(i);
      f[i]=LL(2*i-1);
    }
    for (int j=1;j<=tp&&i*pr[j]<=n;++j){
      b[v=i*pr[j]]=0;
      if (i%pr[j]==0){
        mul[v]=mul[i]*pr[j];
        phi[v]=phi[i]*pr[j];
        f[v]=f[i]*pr[j]+mul[i]*LL(pr[j]-1)*f[LL(i)/mul[i]];
        break;
      }
      mul[v]=LL(pr[j]);
      phi[v]=phi[i]*phi[pr[j]];
      f[v]=f[i]*f[pr[j]];
    }
  }
  for (int i=1;i<=n;++i)
    F[i]=f[i]+F[i-1];
}
 
Abigail work(){
  sieve(N);
}
 
Abigail getans(){
  int T,n;
  scanf("%d",&T);
  while (T--){
    scanf("%d",&n);
    printf("%lld\n",F[n]-LL(n)*LL(n+1)/2LL);
  }
}
 
int main(){
  work();
  getans();
  return 0;
} 

emmm…顺便也写了一个dirichlet卷积的代码，如果实在看不懂线性筛做法的就参考dirichlet卷积的代码吧：

#include<bits/stdc++.h>
  using namespace std;
 
#define Abigail inline void
typedef long long LL;
 
const int N=5000000;
 
int pr[N+9],b[N+9],tp;
LL phi[N+9],F[N+9];
 
void sieve(int n){
  for (int i=2;i<=n;++i) b[i]=1;
  phi[1]=1;
  for (int i=2;i<=n;++i){
    if (b[i]) pr[++tp]=i,phi[i]=LL(i-1);
    for (int j=1;j<=tp&&pr[j]*i<=n;++j){
      b[i*pr[j]]=0;
      if (i%pr[j]) phi[i*pr[j]]=phi[i]*phi[pr[j]];
      else {phi[i*pr[j]]=phi[i]*pr[j];break;}
    }
  }
}
 
void dirichlet(int n){
  for (int i=1;i<=n;++i)
    for (int j=1;i*j<=n;++j)
      F[i*j]+=phi[i]*j;
  for (int i=1;i<=n;++i)
    F[i]+=F[i-1];
}
 
Abigail work(){
  sieve(N);
  dirichlet(N);
}
 
Abigail getans(){
  int T,n;
  scanf("%d",&T);
  while (T--){
    scanf("%d",&n);
    printf("%lld\n",F[n]-LL(n)*LL(n+1)/2LL);
  }
}
 
int main(){
  work();
  getans();
  return 0;
}

貌似也有一个除法分块的做法可以做到$O(n+T\sqrt{n})$，比较慢但是好推一些，原理与上面的式子其实也差不多，这里就不写了.