[NOI2016]bzoj 4652 循环之美 - 数论 - 杜教筛

本文介绍了一种使用数论分块和莫比乌斯反演解决特定数学问题的方法。该方法利用了莫比乌斯函数的性质和数论中的技巧来优化计算过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

首先题目是在求：

a n s = \sum i = 1 n \sum j = 1 m [i ⊥ j] [j ⊥ k]

$ans=\sum_{i=1}^n \sum_{j=1}^m [i\bot j][j\bot k]$
注意到j和k互质来得简单，因为k只有2000并且是常数.

a n s = \sum j = 1 m [j ⊥ k] \sum i = 1 n [i ⊥ j]

$ans=\sum_{j=1}^m [j\bot k]\sum_{i=1}^n [i\bot j]$

a n s = \sum j = 1 m [j ⊥ k] \sum i = 1 n \sum d | i, d | j μ (d)

$ans=\sum_{j=1}^m [j\bot k]\sum_{i=1}^n \sum_{d|i,d|j}\mu(d)$

a n s = \sum d = 1 m i n (n, m) μ (d) ⌊ n d ⌋ \sum d | j, j \leq m [j ⊥ k]

$ans=\sum_{d=1}^{min(n,m)}\mu(d)\left\lfloor\frac{n}{d}\right\rfloor\sum_{d|j,j\le m}[j\bot k]$
注意到若

j=tdj=td $j=td$ 那么

[j⊥k]=[td⊥k]=[d⊥k][t⊥k][j⊥k]=[td⊥k]=[d⊥k][t⊥k] $[j\bot k]=[td\bot k]=[d\bot k][t\bot k]$

a n s = \sum d = 1 n μ (d) [d ⊥ k] ⌊ n d ⌋ \sum j = 1 ⌊ m d ⌋ [j ⊥ k]

$ans=\sum_{d=1}^n\mu(d)[d\bot k]\left\lfloor\frac{n}{d}\right\rfloor\sum_{j=1}^{\left\lfloor\frac{m}{d}\right\rfloor}[j\bot k]$

= \sum d = 1 n μ (d) [d ⊥ k] ⌊ n d ⌋ f (⌊ m d ⌋)

$=\sum_{d=1}^n\mu(d)[d\bot k]\left\lfloor\frac{n}{d}\right\rfloor f(\left\lfloor\frac{m}{d}\right\rfloor)$
其中

f(n)=∑ni=1[i⊥k]=⌊nk⌋ϕ(k)+f(n mod k)f(n)=∑i=1n[i⊥k]=⌊nk⌋ϕ(k)+f(n mod k) $f(n)=\sum_{i=1}^n [i\bot k]=\left\lfloor \frac n k \right\rfloor \phi(k)+f(n\ \ mod\ \ k)$
因此

f(n)f(n) $f(n)$ 可以在

O(klgk)−O(1)O(klgk)−O(1) $O(klgk)-O(1)$ 内解决
因此对最后的式子做数论分块，那么我们需要求：

g(n,k)=∑nd=1μ(d)[d⊥k]g(n,k)=∑d=1nμ(d)[d⊥k] $g(n,k)=\sum_{d=1}^n \mu(d)[d\bot k]$
这个怎么做呢？设

n=pcqn=pcq $n=p^c q$ ，其中p是n的某个质因子，并且

p⊥qp⊥q $p\bot q$
那么考虑

g(n,q)g(n,q) $g(n,q)$ 中的所有数字，显然除了答案的部分还有和q互质但是不和p互质的部分要减去；
记这些中的数字为

y=tp,t≤⌊np⌋,t⊥qy=tp,t≤⌊np⌋,t⊥q $y=tp,t\le\left\lfloor\frac n p\right\rfloor,t\bot q$ （显然因为p是质数所以不和p互质意味着是p的倍数）
考虑我们求的是这些

yy $y$ 的

μ

$\mu$ 和，那么如果t不和p互质的话

μ(y)=0μ(y)=0 $\mu(y)=0$ ，因此可以认为t也和p互质，因此t就和k互质。

g (n, k) = g (n, q) - \sum t = 1 ⌊ n p ⌋ [t ⊥ k] μ (t p)

$g(n,k)=g(n,q)-\sum_{t=1}^{\left\lfloor\frac n p\right\rfloor}[t\bot k]\mu(tp)$
注意到莫比乌斯函数是积性函数，而

t⊥pt⊥p $t\bot p$ ，因此

μ(tp)=μ(t)μ(p)μ(tp)=μ(t)μ(p) $\mu(tp)=\mu(t)\mu(p)$

g (n, k) = g (n, q) - μ (p) \sum t = 1 ⌊ n p ⌋ [t ⊥ k] μ (t)

$g(n,k)=g(n,q)-\mu(p)\sum_{t=1}^{\left\lfloor\frac n p\right\rfloor}[t\bot k]\mu(t)$
注意到p是质数，所以

μ(p)=−1μ(p)=−1 $\mu(p)=-1$

g (n, k) = g (n, q) + \sum t = 1 ⌊ n p ⌋ [t ⊥ k] μ (t) = g (n, q) + g (⌊ n p ⌋, k)

$g(n,k)=g(n,q)+\sum_{t=1}^{\left\lfloor\frac n p\right\rfloor}[t\bot k]\mu(t)=g(n,q)+g({\left\lfloor\frac n p\right\rfloor},k)$
按照固定的顺序除以p，那么有效的状态只有

d(k)2d(k)2 $d(k)^2$ ，其中

d(k)d(k) $d(k)$ 表示k的因子个数，实现可以记忆化，因此只传k此时的质因子个数，会好些一些。
边界条件，当

n=0n=0 $n=0$ 的时候

g(n,k)=0g(n,k)=0 $g(n,k)=0$ ，当k=1的时候需要杜教筛。综上总复杂度

O(d(k)2+n23)O(d(k)2+n23) $O(d(k)^2+n^\frac23)$ .

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#define lint long long
#define N 6000000
#define hv(n,c) (n*10000ll+c)
#define debug(x) cerr<<#x<<"="<<x
#define sp <<" "
#define ln <<endl
using namespace std;
int ms[N],m[N],pri[N];bool np[N];
map<int,int> sav;
map<lint,int> gs;
int v[50],f[2010];
inline int prelude(int n)
{
    ms[1]=m[1]=1;
    for(int i=2,c=0;i<=n;i++)
    {
        if(!np[i]) pri[++c]=i,m[i]=-1;ms[i]=ms[i-1]+m[i];
        for(int j=1;j<=c&&(lint)i*pri[j]<=n;j++)
        {
            int x=i*pri[j];np[x]=true;
            if(i%pri[j]) m[x]=-m[i];
            else { m[x]=0;break; }
        }
    }
    return 0;
}
inline int S(int n)
{
    if(n<N) return ms[n];int ans=0ll;
    if(sav.count(n)) return sav[n];
    for(int s=2,t;s<=n;s=++t)
        t=n/(n/s),ans+=(t-s+1)*S(n/t);
    return sav[n]=1-ans;
}
inline int g(int n,int c)
{
    lint nc=hv(n,c);if(gs.count(nc)) return gs[nc];
    if(!n) return 0;if(!c) return gs[nc]=S(n);
    return gs[nc]=g(n,c-1)+g(n/v[c],c);
}
inline int g(int a,int b,int c) { return g(b,c)-g(a-1,c); }
inline int F(int n,int k) { return n<=k?f[n]:(n/k)*f[k]+f[n%k]; }
inline int gcd(int a,int b) { return a?gcd(b%a,a):b; }
int main()
{
    int n,m,k,c=0;scanf("%d%d%d",&n,&m,&k);
    prelude(N-1);lint ans=0ll;int ks=k;
    for(int i=2;i<=ks;i++) if(ks%i==0)
    {   v[++c]=i;while(ks%i==0) ks/=i;  }
    for(int i=1;i<=k;i++) f[i]=f[i-1]+(gcd(i,k)==1);
    for(int s=1,t;s<=min(n,m);s=++t)
        t=min(n/(n/s),m/(m/s)),ans+=(lint)F(m/s,k)*(n/t)*g(s,t,c);
    return !printf("%lld\n",ans);
}