【数论】莫比乌斯反演

一、引言

莫比乌斯反演（Möbius Inversion）是数论中一个非常重要的工具，广泛应用于组合数学、数论函数、容斥原理、算法竞赛等领域。它能够将某些复杂的求和问题转化为更易处理的形式。

在算法竞赛中，莫比乌斯反演常用于解决涉及最大公约数（GCD）、最小公倍数（LCM）、整除关系的计数问题。

二、前置知识

1. 数论函数（Arithmetic Function）

定义在正整数集上的函数称为数论函数。常见的有：

• 恒等函数：$I(n)=1$
• 单位函数：$ϵ(n)=[n=1]$（当 $n=1$ 时为1，否则为0）
• 恒等函数：$id(n)=n$
• 因子个数函数：$d(n)={\sum }_{d|n}1$
• 因子和函数：$\sigma (n)={\sum }_{d|n}d$
• 欧拉函数：$\varphi (n)$：小于等于 $n$ 且与 $n$ 互质的正整数个数

2. 狄利克雷卷积（Dirichlet Convolution）

对于两个数论函数 $f$ 和 $g$，其狄利克雷卷积定义为：
$$(f\ast g)(n)=\sum _{d|n}f(d)g\left(\frac{n}{d}\right)$$

狄利克雷卷积满足：

• 交换律：$f\ast g=g\ast f$
• 结合律
• 单位元是 $ϵ(n)$，即 $f\ast ϵ=f$
• 若 $f(1)\ne 0$，则 $f$ 存在逆元 $f^{-1}$，使得 $f\ast f^{-1}=ϵ$

三、莫比乌斯函数（Möbius Function）

1. 定义

莫比乌斯函数 $\mu (n)$ 是一个重要的数论函数，定义如下：

$$\mu (n)=\{\begin{array}{ll}1,& n=1\\ (-1{)}^k,& n=p_1{p}_2\cdots p_k\text{（}k\text{个不同质因子）}\\ 0,& \text{其他情况（即 }n\text{ 有平方因子）}\end{array}$$

换句话说：

• 如果 $n=1$，$\mu (n)=1$
• 如果 $n$ 是 $k$ 个不同质数的乘积（无平方因子），$\mu (n)=(-1{)}^k$
• 如果 $n$ 含有平方因子（如 $4,8,9,12$ 等），$\mu (n)=0$

2. 性质

性质1：狄利克雷卷积性质

$$\sum _{d|n}\mu (d)=[n=1]=ϵ(n)$$
即：$\mu \ast I=ϵ$

证明：

• 当 $n=1$：${\sum }_{d|1}\mu (d)=\mu (1)=1$
• 当 $n>1$，设 $n=p_1^{a_1}{p}_2^{a_2}\cdots p_k^{a_k}$，只考虑无平方因子的 $d$（即 $d$ 是 $p_1,\dots ,p_k$ 的子集乘积），则：
  ∑d∣nμ(d)=∑S⊆{1,…,k}(−1)∣S∣=∑i=0k(ki)(−1)i=(1−1)k=0 \sum_{d|n} \mu(d) = \sum_{S \subseteq \{1,\dots,k\}} (-1)^{|S|} = \sum_{i=0}^k \binom{k}{i} (-1)^i = (1-1)^k = 0 d∣n∑​μ(d)=S⊆{1,…,k}∑​(−1)∣S∣=i=0∑k​(ik​)(−1)i=(1−1)k=0

性质2：莫比乌斯函数是积性函数

若 $a\perp b$（互质），则 $\mu (ab)=\mu (a)\mu (b)$

四、莫比乌斯反演公式

1. 经典形式（标准形式）

设有两个数论函数 $f(n)$ 和 $F(n)$，满足：
$$F(n)=\sum _{d|n}f(d)$$
则有反演公式：
$$f(n)=\sum _{d|n}\mu (d)F\left(\frac{n}{d}\right)$$

等价地，若 $F=f\ast I$，则 $f=F\ast \mu$

2. 另一种形式（倍数形式）

设有两个数论函数 $f(n)$ 和 $F(n)$，满足：
$$F(n)=\sum _{n|d}f(d)$$
则有：
$$f(n)=\sum _{n|d}\mu \left(\frac{d}{n}\right)F(d)$$

这个形式在处理“倍数”问题时非常有用。

注：两种形式的本质是相同的，取决于你定义 $F$ 的方式是“因子和”还是“倍数和”。

五、莫比乌斯反演的直观理解

莫比乌斯反演本质上是一种容斥原理的代数表达。

例如，考虑：
$$F(n)=\sum _{d|n}f(d)$$
你想从 $F$ 恢复 $f(n)$。由于 $F(n)$ 包含了所有 $f(d)$（$d|n$），你可以用容斥的思想逐步“减去”其他项。

而 $\mu (d)$ 的值正好对应了容斥中的符号（正负交替）和是否参与（为0则跳过）。

六、经典应用举例

例1：欧拉函数的莫比乌斯表示

我们知道：
$$\sum _{d|n}\varphi (d)=n$$
即 $id=\varphi \ast I$

由莫比乌斯反演得：
$$\varphi (n)=\sum _{d|n}\mu (d)\cdot \frac{n}{d}=n\sum _{d|n}\frac{\mu (d)}{d}$$

这个公式可用于快速计算 $\varphi (n)$，尤其是在筛法中。

例2：求 ${\sum }_{i=1}^n{\sum }_{j=1}^m[\gcd (i,j)=1]$

即：有多少对 $(i,j)$ 满足 $\gcd (i,j)=1$

解法：
设 $f(k)={\sum }_{i=1}^n{\sum }_{j=1}^m[\gcd (i,j)=k]$

我们要求 $f(1)$

令 $F(k)={\sum }_{k|d}f(d)={\sum }_{i=1}^n{\sum }_{j=1}^m[k|\gcd (i,j)]=\lfloor \frac{n}{k}\rfloor \lfloor \frac{m}{k}\rfloor$

由莫比乌斯反演（倍数形式）：
$$f(k)=\sum _{k|d}\mu \left(\frac{d}{k}\right)F(d)=\sum _{k|d}\mu \left(\frac{d}{k}\right)\lfloor \frac{n}{d}\rfloor \lfloor \frac{m}{d}\rfloor$$

令 $t=d/k$，则 $d=kt$，得：
$$f(k)=\sum _{t=1}^{\min (n/k,m/k)}\mu (t)\lfloor \frac{n}{kt}\rfloor \lfloor \frac{m}{kt}\rfloor$$

当 $k=1$ 时：
$$f(1)=\sum _{t=1}^{\min (n,m)}\mu (t)\lfloor \frac{n}{t}\rfloor \lfloor \frac{m}{t}\rfloor$$

这可以使用数论分块在 $O(\sqrt{n})$ 时间内计算。

七、莫比乌斯函数的计算

1. 线性筛法求莫比乌斯函数

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

const int MAXN = 1e6 + 5;

vector<int> primes;
bool is_prime[MAXN];
int mu[MAXN];  // 莫比乌斯函数
int phi[MAXN]; // 欧拉函数（顺便计算）

void linear_sieve() {
    fill(is_prime, is_prime + MAXN, true);
    is_prime[0] = is_prime[1] = false;
    mu[1] = 1;
    
    for (int i = 2; i < MAXN; i++) {
        if (is_prime[i]) {
            primes.push_back(i);
            mu[i] = -1;   // 单个质数
            phi[i] = i - 1;
        }
        
        for (int p : primes) {
            if (i * p >= MAXN) break;
            
            is_prime[i * p] = false;
            
            if (i % p == 0) {
                // p^2 整除 i*p，所以 mu[i*p] = 0
                mu[i * p] = 0;
                phi[i * p] = phi[i] * p;
                break;
            } else {
                // i 和 p 互质
                mu[i * p] = -mu[i];  // mu[i] * mu[p] = mu[i] * (-1)
                phi[i * p] = phi[i] * (p - 1);
            }
        }
    }
}

2. 使用莫比乌斯函数求欧拉函数（验证）

// 验证 phi(n) = sum_{d|n} mu(d) * (n/d)
int compute_phi_by_mobius(int n) {
    int res = 0;
    for (int d = 1; d * d <= n; d++) {
        if (n % d == 0) {
            res += mu[d] * (n / d);
            if (d * d != n) {
                res += mu[n / d] * d;
            }
        }
    }
    return res;
}

3. 应用：求 [1,n] x [1,m] 中 gcd=1 的对数

long long count_coprime_pairs(int n, int m) {
    long long res = 0;
    int lim = min(n, m);
    
    // 数论分块
    for (int l = 1, r; l <= lim; l = r + 1) {
        r = min(n / (n / l), m / (m / l));
        long long sum_mu = 0;
        for (int i = l; i <= r; i++) {
            sum_mu += mu[i];
        }
        res += sum_mu * (n / l) * (m / l);
    }
    
    return res;
}

但上面的 sum_mu 是逐段求的，效率不高。我们可以预处理莫比乌斯前缀和：

int prefix_mu[MAXN]; // prefix_mu[i] = mu[1] + mu[2] + ... + mu[i]

void precompute_prefix_mu() {
    prefix_mu[0] = 0;
    for (int i = 1; i < MAXN; i++) {
        prefix_mu[i] = prefix_mu[i-1] + mu[i];
    }
}

long long count_coprime_pairs_fast(int n, int m) {
    long long res = 0;
    int lim = min(n, m);
    
    for (int l = 1, r; l <= lim; l = r + 1) {
        r = min(n / (n / l), m / (m / l));
        res += (prefix_mu[r] - prefix_mu[l-1]) * (n / l) * (m / l);
    }
    
    return res;
}

八、进阶应用：${\sum }_{i=1}^n{\sum }_{j=1}^m\gcd (i,j)$

这是经典问题。

设 $ans={\sum }_{i=1}^n{\sum }_{j=1}^m\gcd (i,j)$

我们枚举 $g=\gcd (i,j)$：
$$ans=\sum _{g=1}^{\min (n,m)}g\cdot f(g)$$
其中 $f(g)$ 是满足 $\gcd (i,j)=g$ 的对数。

由前面例子：
$$f(g)=\sum _{t=1}^{\min (n/g,m/g)}\mu (t)\lfloor \frac{n}{gt}\rfloor \lfloor \frac{m}{gt}\rfloor$$

代入得：
$$ans=\sum _{g=1}^{\min (n,m)}g\sum _{t=1}^{\min (n/g,m/g)}\mu (t)\lfloor \frac{n}{gt}\rfloor \lfloor \frac{m}{gt}\rfloor$$

令 $k=gt$，则：
$$ans=\sum _{k=1}^{\min (n,m)}\lfloor \frac{n}{k}\rfloor \lfloor \frac{m}{k}\rfloor \sum _{g|k}g\cdot \mu \left(\frac{k}{g}\right)$$

注意到 ${\sum }_{g|k}g\cdot \mu (k/g)=(id\ast \mu )(k)$

而我们知道：$\varphi =id\ast \mu$，即 $\varphi (k)={\sum }_{d|k}d\cdot \mu (k/d)$

所以：
$$ans=\sum _{k=1}^{\min (n,m)}\lfloor \frac{n}{k}\rfloor \lfloor \frac{m}{k}\rfloor \varphi (k)$$

结论：
$$\sum _{i=1}^n\sum _{j=1}^m\gcd (i,j)=\sum _{k=1}^{\min (n,m)}\lfloor \frac{n}{k}\rfloor \lfloor \frac{m}{k}\rfloor \varphi (k)$$

这比枚举 $g$ 和 $t$ 更高效！

C++ 实现：

long long sum_gcd_pairs(int n, int m) {
    long long res = 0;
    int lim = min(n, m);
    
    for (int l = 1, r; l <= lim; l = r + 1) {
        r = min(n / (n / l), m / (m / l));
        long long sum_phi = 0;
        for (int i = l; i <= r; i++) {
            sum_phi += phi[i];
        }
        res += sum_phi * (n / l) * (m / l);
    }
    
    return res;
}

预处理 $\varphi$ 前缀和可进一步优化。

九、完整C++代码示例

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 1e6 + 5;

vector<int> primes;
bool is_prime[MAXN];
int mu[MAXN], phi[MAXN];
long long prefix_mu[MAXN], prefix_phi[MAXN];

void linear_sieve() {
    fill(is_prime, is_prime + MAXN, true);
    is_prime[0] = is_prime[1] = false;
    mu[1] = 1;
    phi[1] = 1;
    
    for (int i = 2; i < MAXN; i++) {
        if (is_prime[i]) {
            primes.push_back(i);
            mu[i] = -1;
            phi[i] = i - 1;
        }
        
        for (size_t j = 0; j < primes.size(); j++) {
            int p = primes[j];
            if (i * p >= MAXN) break;
            
            is_prime[i * p] = false;
            
            if (i % p == 0) {
                mu[i * p] = 0;
                phi[i * p] = phi[i] * p;
                break;
            } else {
                mu[i * p] = -mu[i];
                phi[i * p] = phi[i] * (p - 1);
            }
        }
    }
    
    // 预处理前缀和
    for (int i = 1; i < MAXN; i++) {
        prefix_mu[i] = prefix_mu[i-1] + mu[i];
        prefix_phi[i] = prefix_phi[i-1] + phi[i];
    }
}

// 求 [1,n] x [1,m] 中 gcd=1 的对数
long long count_coprime(int n, int m) {
    long long res = 0;
    int lim = min(n, m);
    for (int l = 1, r; l <= lim; l = r + 1) {
        r = min(n / (n / l), m / (m / l));
        res += (prefix_mu[r] - prefix_mu[l-1]) * (n / l) * (m / l);
    }
    return res;
}

// 求 sum_{i=1}^n sum_{j=1}^m gcd(i,j)
long long sum_gcd(int n, int m) {
    long long res = 0;
    int lim = min(n, m);
    for (int l = 1, r; l <= lim; l = r + 1) {
        r = min(n / (n / l), m / (m / l));
        res += (prefix_phi[r] - prefix_phi[l-1]) * (n / l) * (m / l);
    }
    return res;
}

int main() {
    linear_sieve();
    
    int n = 1000, m = 1000;
    cout << "mu[1..10]: ";
    for (int i = 1; i <= 10; i++) cout << mu[i] << " ";
    cout << "\n";
    
    cout << "phi[1..10]: ";
    for (int i = 1; i <= 10; i++) cout << phi[i] << " ";
    cout << "\n";
    
    cout << "count_coprime(1000,1000): " << count_coprime(n, m) << endl;
    cout << "sum_gcd(1000,1000): " << sum_gcd(n, m) << endl;
    
    return 0;
}