51nod - 1188 - 最大公约数之和 V2 - 数论

https://www.51nod.com/Challenge/Problem.html#!#problemId=1188

求\(\sum\limits_{i=1}^{n-1}\sum\limits_{j=i+1}^{n}gcd(i,j)\)

首先交换求和\(\sum\limits_{j=2}^{n}\sum\limits_{i=1}^{j-1}gcd(i,j)=\sum\limits_{j=2}^{n}\sum\limits_{i=1}^{j}gcd(i,j)-j\)

---

像之前那样用莫比乌斯反演搞出

\(\sum\limits_{g=1}^{n}g\sum\limits_{i=1}^{\lfloor\frac{n}{g}\rfloor}{\varphi(i)}, (\varphi(1)=0)\)

或者

\(\sum\limits_{g=1}^{n}g\sum\limits_{i=1}^{\lfloor\frac{n}{g}\rfloor}{\mu(i)}*{\lfloor\frac{n}{i*g}\rfloor}^2\)

都是T了，说明单次回答的复杂度非常感人，原因是因为跟n有关就逃不了分块。

所以分块的复杂度还是太高了。

然后惊人的事情发生了。

这道题和前面的不一样的地方在于，他的n其实没有前面的大，只是多！

分块的意义在于加快单次回答的速度，所以才把g提了出来分块，现在不太合适。

---

正解，先求解：

\(\sum\limits_{i=1}^{n}gcd(i,n)\)

这个东西可以枚举g：

\(\sum\limits_{g=1}^{n}g\sum\limits_{i=1}^{n}[gcd(i,n)==g]\)

\(\sum\limits_{g=1}^{n}g\sum\limits_{i=1}^{\lfloor\frac{n}{g}\rfloor}[gcd(i,\lfloor\frac{n}{g}\rfloor)==1]\)

\(\sum\limits_{g=1}^{n}g\varphi(\lfloor\frac{n}{g}\rfloor)\)

这个有什么不对呢？其实没什么不对，就是不好。因为gcd必定是整除n的，所以可以：

\(\sum\limits_{g|n}g\varphi(\frac{n}{g})\)

这明显就是一个积性函数，记为 \(p(n)\) ，处理好就可以了。原式：

\(\sum\limits_{j=2}^{n}p(j)-j\)

这个式子 \(p(n)\) 用埃筛已经足够了，因为是5e6的数据量，1400ms/2000ms跑过去了。但是我在想会不会有线性的筛法。

2019/6/7早上试了很多种之后，发现还是直接利用积性函数的结论最简单，对于每个合数记录他的最小质因子及其幂次，然后一除就得到两个互质的因数。

问题在于纯p的幂次一除就变成没有了。也就是别人的博客说的 \(p^k\) 要特殊处理，想到上面这个式子是一个狄利克雷卷积，对于纯p的幂次只要从他的低1次转移过来就可以了。

最后套上快读快写狗掉榜首！需要注意的是我准备的线性筛模板里多用了0.25倍空间，其实真的可以充分利用的。比如这个的话pk肯定不是0，那么就用pk来做判断就可以了。

所以说的确是空间换时间，多了0.5倍的空间省去一个logn倍。200ms/2000ms稳得一笔。

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

inline int read() {
    int x=0;
    char c=getchar();
    while(c<'0'||c>'9')
        c=getchar();
    do {
        x=(x<<3)+(x<<1)+c-'0';
        c=getchar();
    } while(c>='0'&&c<='9');
    return x;
}

inline void write(ll x) {
    //printf("%lld\n",x);
    if(x>9) {
        write(x/10);
    }
    putchar(x%10+'0');
    return;
}

const int MAXN=5e6;

int pri[MAXN+1];
int &pritop=pri[0];
ll ans[MAXN+1];
int pk[MAXN+1];//pk(n)=pk的最小因子p的次方

void sieve(int n=MAXN) {
    ans[1]=1;
    pk[1]=1;
    for(int i=2; i<=n; i++) {
        if(!pk[i]) {
            pri[++pritop]=i;
            ans[i]=i+i-1;
            pk[i]=i;
        }
        for(int j=1; j<=pritop&&i*pri[j]<=n; j++) {
            int t=i*pri[j];
            if(i%pri[j]) {
                pk[t]=pk[pri[j]];
                ans[t]=ans[i]*ans[pri[j]];
            } else {
                pk[t]=pk[i]*pri[j];
                if(pk[t]==t) {
                    //纯p的幂次，没有其他因子，这样算不会漏因子
                    //t-t/pri[j]就是phi[t]
                    ans[t]=(t-t/pri[j])+ans[i]*pri[j];
                } else {
                    //积性函数
                    ans[t]=ans[pk[t]]*(ans[t/pk[t]]);
                }
                break;
            }
        }
    }
    for(int i=1; i<=n; i++)
        ans[i]+=ans[i-1]-i;
}

inline void solve() {
    sieve();
    int T=read();
    while(T--) {
        int n=read();
        write(ans[n]);
        putchar('\n');
    }
}

int main() {
#ifdef Yinku
    freopen("Yinku.in","r",stdin);
#endif // Yinku
    solve();
    return 0;
}

---

其他尝试？

现在把g放回去。

\(\sum\limits_{g=1}^{n}\sum\limits_{i=1}^{\lfloor\frac{n}{g}\rfloor}g*{\varphi(i)}, (\varphi(1)=0)\)

这个不就是相当于把每个 \(i*g \leq n\) 的加起来吗？所以当然可以交换求和顺序！

\(\sum\limits_{i=1}^{n}\sum\limits_{g=1}^{\lfloor\frac{n}{i}\rfloor}g*{\varphi(i)}, (\varphi(1)=0)\)

前面是一个干净的前缀和，后面那个式子是nlogn的！

也就是预处理：

\(ans(n)=\sum\limits_{g=1}^{\lfloor\frac{n}{i}\rfloor}g*{\varphi(i)}, (\varphi(1)=0)\)