NKOJ 3441 Lucas的數論（杜教篩）

P3441【HN Training 2015 Round5】lucas的數論

問題描述

數據範圍

對於100%的數據:n<=1000000000

---

直接推式子，用到一個公式，這個公式也比較顯然，就是根據定義直接得到，注意到不互質的數對乘積也一定會被乘積相同的一個互質數對算到。

Ans=∑i=1N∑j=1Nτ(i×j)，已知τ(i×j)=∑x|i∑y|j1[gcd(x,y)=1]$$Ans=\sum _{i=1}^N\sum _{j=1}^N\tau (i\times j)，已知\tau (i\times j)=\sum _{x|i}\sum _{y|j}1[gcd(x,y)=1]$$

Ans=∑i=1N∑j=1N∑x|i∑y|j∑p|gcd(x,y)μ(p)=∑i=1N∑j=1N∑p|gcd(i,j)τ(ip)τ(jp)μ(p)$$Ans=\sum _{i=1}^N\sum _{j=1}^N\sum _{x|i}\sum _{y|j}\sum _{p|gcd(x,y)}\mu (p)=\sum _{i=1}^N\sum _{j=1}^N\sum _{p|gcd(i,j)}\tau (\frac{i}{p})\tau (\frac{j}{p})\mu (p)$$

Ans=∑p=1Nμ(p)∑i=1⌊Np⌋τ(i)∑j=1⌊Np⌋τ(j)=∑p=1Nμ(p)[∑i=1⌊Np⌋τ(i)]2$$Ans=\sum _{p=1}^N\mu (p)\sum _{i=1}^{\lfloor \frac{N}{p}\rfloor }\tau (i)\sum _{j=1}^{\lfloor \frac{N}{p}\rfloor }\tau (j)=\sum _{p=1}^N\mu (p)[\sum _{i=1}^{\lfloor \frac{N}{p}\rfloor }\tau (i){]}^2$$

注意到後面是取整的形式，如果知道τ(i)$\tau (i)$ 和μ(i)$\mu (i)$ 的前綴和，那麼可以分塊在O(n−−√)$O(\sqrt{n})$ 內求解
考慮如何快速求出τ(i)$\tau (i)$ 的前綴和與μ(i)$\mu (i)$ 的前綴和，考慮杜教篩。

對於μ(i)$\mu (i)$ ，注意到∑d|nμ(d)=[n==1]$\sum _{d|n}\mu (d)=[n==1]$ ，那麼有∑ni=1∑d|iμ(d)=1$\sum _{i=1}^n\sum _{d|i}\mu (d)=1$ ，於是∑ni=1∑⌊ni⌋d=1μ(d)=1$\sum _{i=1}^n\sum _{d=1}^{\lfloor \frac{n}{i}\rfloor }\mu (d)=1$

∑i=1nμ(d)=1−∑i=2n∑d=1⌊ni⌋μ(d)，令∑i=1nμ(i)=M(n)$$\sum _{i=1}^n\mu (d)=1-\sum _{i=2}^n\sum _{d=1}^{\lfloor \frac{n}{i}\rfloor }\mu (d)，令\sum _{i=1}^n\mu (i)=M(n)$$

那麼M(n)=1−∑i=2nM(⌊ni⌋)$$那麼M(n)=1-\sum _{i=2}^{n}M(\lfloor \frac{n}{i}\rfloor )$$

上式顯然可以分塊迭代處理，預處理一部分後做到O(n23)$O(n^{\frac{2}{3}})$ ，從狄利克雷卷積的角度就是μ∗I=e$\mu \ast I=e$

對於τ(i)$\tau (i)$ ，注意到τ(i)=∑d|i1$\tau (i)=\sum _{d|i}1$ ，即τ=I∗I$\tau =I\ast I$ ，那麼μ∗τ=I∗e=I$\mu \ast \tau =I\ast e=I$ ，即∑d|nμ(nd)τ(d)=1$\sum _{d|n}\mu (\frac{n}{d})\tau (d)=1$ ，同樣有∑ni=1∑d|iμ(nd)τ(d)=∑ni=1∑⌊ni⌋d=1μ(i)τ(d)=1$\sum _{i=1}^n\sum _{d|i}\mu (\frac{n}{d})\tau (d)=\sum _{i=1}^n\sum _{d=1}^{\lfloor \frac{n}{i}\rfloor }\mu (i)\tau (d)=1$ ，於是

∑i=1nτ(i)=1−∑i=2nμ(i)∑d=1⌊ni⌋τ(d)，令T(n)=∑i=1nτ(i)$$\sum _{i=1}^n\tau (i)=1-\sum _{i=2}^n\mu (i)\sum _{d=1}^{\lfloor \frac{n}{i}\rfloor }\tau (d)，令T(n)=\sum _{i=1}^n\tau (i)$$

那麼T(n)=1−∑i=2nμ(i)T(⌊ni⌋)$$那麼T(n)=1-\sum _{i=2}^n\mu (i)T(\lfloor \frac{n}{i}\rfloor )$$

上式顯然還是分塊迭代處理，但是需要用到μ(i)$\mu (i)$ 的前綴和，複雜度不好說，但還是比較快的。

關於預處理一部分tau(i)$tau(i)$ ，線性篩的時候需要增加兩個數組，一個記錄i$i$ 的最小質因子，另一個記錄最小質因子的指數，由於線性篩每次篩掉一個數一定是用他的最小質因數，因此可以方便的轉移，具體可以看代碼。

事實上，求τ(i)$\tau (i)$ 的前綴和有更快的方法，因爲∑ni=1τ(i)=∑ni=1∑d|i1=∑ni=1∑⌊ni⌋d=11=∑ni=1⌊ni⌋$\sum _{i=1}^n\tau (i)=\sum _{i=1}^n\sum _{d|i}1=\sum _{i=1}^n\sum _{d=1}^{\lfloor \frac{n}{i}\rfloor }1=\sum _{i=1}^n\lfloor \frac{n}{i}\rfloor$ ，直接分塊+預處理可以做到O(n−−√)$O(\sqrt{n})$ ，最終複雜度O(n34)$O(n^{\frac{3}{4}})$ ，複雜度並不會證，看看就好。

---

代碼（杜教篩求τ(i)$\tau (i)$ ）：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<cmath>
#define N 12345678
#define ll long long
using namespace std;
const ll mod=1e9+7;
map<ll,ll>Mu,G;
ll n,K,tot,P[N],g[N],mu[N],pc[N],pd[N];
void EU()
{
    ll i,j;mu[1]=g[1]=1;
    for(i=2;i<=K;i++)
    {
        if(!g[i])P[++tot]=i,mu[i]=-1,g[i]=2,pc[i]=1,pd[i]=tot;
        for(j=1;j<=tot&&i*P[j]<=K;j++)
        {
            if(i%P[j])
            {
                pc[i*P[j]]=1;
                pd[i*P[j]]=j;
                mu[i*P[j]]=-mu[i];
                g[i*P[j]]=g[i]<<1;
            }
            else
            {
                pc[i*P[j]]=j==pd[i]?pc[i]+1:1;
                pd[i*P[j]]=j;
                g[i*P[j]]=j==pd[i]?(g[i]/(pc[i]+1)*(pc[i]+2)):(g[i]<<1);
            }
        }
    }
    for(i=2;i<=K;i++)g[i]+=g[i-1],mu[i]+=mu[i-1],g[i]%=mod;
}
ll Gmu(ll x)
{
    if(x<=K)return mu[x];
    if(Mu[x])return Mu[x];
    ll i,j,ans=1;
    for(i=2;i<=x;i=j+1)
    {
        j=x/(x/i);
        ans-=(j-i+1)*Gmu(x/i);
    }
    return Mu[x]=ans;
}
ll Gg(ll x)
{
    if(x<=K)return g[x];
    if(G[x])return G[x];
    ll i,j,ans=x;
    for(i=2;i<=x;i=j+1)
    {
        j=x/(x/i);
        ans-=(Gmu(j)-Gmu(i-1))*Gg(x/i)%mod;ans%=mod;
    }
    return G[x]=ans;
}
int main()
{
    ll ans=0,i,j;
    scanf("%lld",&n);
    K=pow(n,0.66);EU();
    for(i=1;i<=n;i=j+1)
    {
        j=n/(n/i);
        ans+=(Gmu(j)-Gmu(i-1))*Gg(n/i)%mod*Gg(n/i)%mod;ans%=mod;
    }
    printf("%lld",(ans+mod)%mod);
}

另附O(n−−√)$O(\sqrt{n})$ 求τ$\tau$ 做法，實測並快不了多少，但如果是算單個應該快很多。

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<cmath>
#define N 12345678
#define ll long long
using namespace std;
const ll mod=1e9+7;
map<ll,ll>Mu,G;
ll n,K,tot,P[N],g[N],mu[N],pc[N],pd[N];
void EU()
{
    ll i,j;mu[1]=g[1]=1;
    for(i=2;i<=K;i++)
    {
        if(!g[i])P[++tot]=i,mu[i]=-1,g[i]=2,pc[i]=1,pd[i]=tot;
        for(j=1;j<=tot&&i*P[j]<=K;j++)
        {
            if(i%P[j])
            {
                pc[i*P[j]]=1;
                pd[i*P[j]]=j;
                mu[i*P[j]]=-mu[i];
                g[i*P[j]]=g[i]<<1;
            }
            else
            {
                pc[i*P[j]]=j==pd[i]?pc[i]+1:1;
                pd[i*P[j]]=j;
                g[i*P[j]]=j==pd[i]?(g[i]/(pc[i]+1)*(pc[i]+2)):(g[i]<<1);
            }
        }
    }
    for(i=2;i<=K;i++)g[i]+=g[i-1],mu[i]+=mu[i-1],g[i]%=mod;
}
ll Gmu(ll x)
{
    if(x<=K)return mu[x];
    if(Mu[x])return Mu[x];
    ll i,j,ans=1;
    for(i=2;i<=x;i=j+1)
    {
        j=x/(x/i);
        ans-=(j-i+1)*Gmu(x/i);
    }
    return Mu[x]=ans;
}
ll Gg(ll x)
{
    if(x<=K)return g[x];
    if(G[x])return G[x];
    ll ans=0,i,j;
    for(i=1;i<=x;i=j+1)
    {
        j=x/(x/i);
        ans+=(j-i+1)*(x/i)%mod;ans%=mod;
    }
    return G[x]=ans;
}
int main()
{
    ll ans=0,i,j;
    scanf("%lld",&n);
    K=pow(n,0.66);EU();
    for(i=1;i<=n;i=j+1)
    {
        j=n/(n/i);
        ans+=(Gmu(j)-Gmu(i-1))*Gg(n/i)%mod*Gg(n/i)%mod;ans%=mod;
    }
    printf("%lld",(ans+mod)%mod);
}