Algorithm on Anfsity

Grinding Codeforces

Thu, 03 Jul 2025 21:43:26 +0800

Index

浅谈筛法

Sun, 25 May 2025 14:07:56 +0800

素数筛法

引入

我们先来看一个最基本的一个判断素数的方法，基于 $6k \pm 1$ 优化。

$Prove$

对于所有正整数，都可以表示为 $6k + i$。

由于以下情况 :

$6k \equiv 0 \pmod{2}$

$6k+2 \equiv 0 \pmod{2}$

$6k+3\equiv 0 \pmod{3}$

$6k+4\equiv 0 \pmod{2}$

也就是说，只有 $6k \pm 1$ 存在可能为质数的可能，所以我们只要检查 $6k \pm 1$ 有没有可能是质数就行了，这种方法也可以进行推广，但是要筛的数的范围也会随之变大，不过时间复杂度也会变得更加优秀。

template <typename type>
bool isPrime(type n) {
    if(n <= 1)
        return false;
    if(n <= 3) 
        return true;
    if(n % 2 == 0 || n % 3 == 0) 
        return false;
    for(type i = 5; i <= n / i; i += 6) {
        if(n % i == 0 || n % (i + 2) == 0) 
            return false;
    }
    return true;
}

这种方法在求较小的质数时相当优秀和简洁，但是在大范围查询的时候，就不够适用了，这个时候，就该引入我们的质数筛法了。

埃拉托斯特尼筛法

朴素版本

std::vector<int> prime;
std::vector<int> vis(N, 0);

void Eratosthenes() {
    for(int i = 2; i <= N; ++i) {
        if(!vis[i]) {
            prime.push_back(i);
            if(1LL * i * i > N) 
                continue;
            for(int j = i * i; j <= N; j += i) {
                vis[j] = 1;
            }
        }
    }
}

时间复杂度为$O(n\log \log(n))$。

平方根优化

std::vector<int> prime;
std::vector<int> vis(N, 0);

void Eratosthenes() {
    for(int i = 2; i * i <= N; ++i) {
        if(!vis[i]) {
            for(int j = i * i; j <= N; j += i) {
                vis[j] = 1;
            }
        }
    }
    for(int i = 2; i <= N; ++i) {
        if(!vis[i]) {
            prime.push_back(i);
        }
    }
}

该版本对比朴素版本，仅仅添加了平方根的优化，时间复杂度为 $O(n\log \log(\sqrt{ n })\ +\ n)$, 然而这样会显著优化时间。

由于我们知道，合数不可能为素数，所以我们只需要对奇数进行检验即可。

std::vector<int> prime;
std::vector<int> vis(N, 0);

void Eratosthenes() {
    prime.push_back(2);
    for(int i = 3; i * i <= N; i += 2) {
        if(!vis[i]) {
            for(int j = i * i; j <= N; j += (2 * i)) {
                vis[j] = 1;        
            }
        }
    }
    for(int i = 3; i <= N; i += 2) {
        if(!vis[i]) {
            prime.push_back(i);
        }
    }
}

虽然这些优化可以让埃筛达到一个很好的优化，甚至在某些场景比欧拉筛还要快捷，但是埃筛的时间复杂度终究不是 $O(N)$。

欧拉筛

void euler(int n) {
    std::vector<bool> vis(n + 1, 0);
    std::vector<int> primes;
    for(int i = 2; i <= n; ++i) {
        if(!vis[i]) {
            primes.push_back(i);
        }
        for(auto &prime : primes) {
            if(1LL * prime * i > n) 
                break;

            vis[prime * i] = true;

            if(i % prime == 0) 
                break;
        }
    }
}

[!hint]- 说明核心：欧拉筛确保每一个合数只被他自己的最小质因数筛去。

$for\ i\ \dots n$ ，维护一个 prime 数组，表示到 $i$ 为止的所有质数。

设 $p_{i}$ 为 $i$ 的最小质因子，在 $prime$ 数组中 : prime: $[\underbrace{\dots\dots}_{\text{p}_{j}}\ , \quad \underset{\substack{\uparrow \\ \text{pi}}}{\boxed{p_i}}, \quad \dots ]$

$p_{j}$ 表示所有小于 $p_{i}$ 的质数。考虑 $newNum=i \cdot p_{j}$ 。已知 $p_{j}
这就说明了当合数被筛走的时候，必然是被自己的最小质因子筛走的。下面来说明，这样的操作是唯一的。

假设存在一个合数 $N$，他被至少两个不同的操作筛除。设这两个操作为 $(i_{1},p_{1}),\ (i_{2},p_{2})$。由于我们证明了合数必然是被自己的最小质因数筛除，则 $p_{1}=lpf(N)=p_{2}$，那么也就有 $i_{1}=i_{2}$ ，也就是说，这两个操作是等价的。

假设不成立，唯一性得证。

这里的 $lpf(N)$ 是 $Least\ Prime\ Factor\ of\ N$。

筛法求约数个数

用 $d_i$ 表示 $i$ 的约数个数，$num_i$ 表示 $i$ 的最小质因子出现次数。

约数个数定理

定理：若 $n=\prod_{i=1}^m p_i^{c_i}$ 则 $d_i=\prod_{i=1}^m (c_i+1)$。

证明：我们知道 $p_i^{c_i}$ 的约数有 $p_i^0,p_i^1,\dots ,p_i^{c_i}$ 共 $c_i+1$ 个，根据乘法原理，$n$ 的约数个数就是 $\prod_{i=1}^m (c_i+1)$。

 void euler(int n) {
    std::vector<bool> vis(n + 1);
    std::vector<int> primes, d(n + 1), num(n + 1);
    // d 储存约数个数， num 储存最小因子 p 的指数
    for(int i = 2; i <= n; ++i) {
        if (!vis[i]) {
            primes.push_back(i);
            d[i] = 2;
            num[i] = 1;
        }
        for(auto& prime : primes) {
            if(1LL * i * prime > n) 
                break;

            int id = i * prime;
            vis[id] = true;

            if(i % prime == 0) {
                num[id] = num[i] + 1;
                d[id] = d[i] / num[id] * (num[id] + 1);
                break;
            } else {
                num[id] = 1;
                d[id] = (d[i] << 1);
            }
        }
    }
}

欧拉筛求约数个数原理

结合代码，根据之前欧拉筛原理的推导。

设 $d[i]$ 表示 $i$ 的约数个数， $\text{num}[i]$ 表示在 $i$ 中的最小质因子 $p_{i}$ 的指数大小。

$for\ i\ \dots n$ ，维护一个 prime 数组，表示到 $i$ 为止的所有质数。

设 $p_{i}$ 为 $i$ 的最小质因子， $p_{j}$ 为所有小于 $p_{i}$ 的质数，在 $prime$ 数组中 :

prime: $[\underbrace{\dots\dots}_{\text{p}_{j}}\ , \quad \underset{\substack{\uparrow \\ \text{pi}}}{\boxed{p_i}}, \quad \dots ]$

数 $N$ 为质数。

显然，$d[N]=2,\ \text{num}[N]=1$。

数 $N$ 为合数 ($N=i\cdot prime$ 也就是 $N=i\cdot p_{j}$)。

$I.$ $p_{j} \nmid i$ :

我们要求 $d[N]\text{ 和 num}[N]$，有 $N=i\cdot p_{j}$，根据已知结论， $p_{j}\text{ 是 N 的最小质因子}$，得 $\text{num}[N]=1$，由乘法原理，$\text{num}[N]=2\cdot d[i]$。

$II.$ $p_{j}\mid i$ :

此时有 $p_{i}=p_{j}，i=p_{j}\cdot rest，N=p_{j}\cdot i=p_{j}\cdot p_{i}\cdot rest=p_{i}^2\cdot rest$。

这里可以看出来 $N\text{ 里面的 } p_{i}\text{ 的个数比 i 里面的多 1 个}$，由于 $p_{i}$ 是 $N$ 和 $i$ 的最小质因子，所以 $\text{num}[N]=\text{num}[i]+1$。

不妨设 $i=p_{i}^q\cdot remainNum，d[i]=(q+1)\cdot d[remainNum]$ 。

则 $N=p_{i}^{q+1}\cdot remainNum，d[N]=(q+1+1)\cdot d[remainNum]$ 。

那么有 $d[N]=(q+2)\cdot \frac{d[i]}{q+1}$，也就是 $d[N]=(\text{num[i]+2})\cdot \frac{d[i]}{\text{num}[i]+1}$。代换 $\text{num}[i]$ 得到 $d[N]=(\text{num}[N]+1)\cdot \frac{d[i]}{\text{num}[N]}$。

$Q.E.D.$

Multiplicative Inverse

Sun, 25 May 2025 13:59:19 +0800

简介

在算法计算中, 常常由于数据原因对答案进行大数取模. 对于加法和减法, 处理起来相对容易, 但是对于除法来说, 就较为复杂. 为了解决这个问题, 我们来探讨一下乘法逆元.

定义

我们把 $a^{-1}$ 叫作 $a \bmod p$ 的乘法逆元, 如果满足 $a\cdot a^{-1} \equiv 1 \pmod p$.

在高中数学中, 如果 $b\cdot b^{-1}=1$, 就把 $b^{-1}$ 叫作 $b$ 的倒数, 即 $\frac{a}{b} = a\cdot b^{-1}$.

乘法逆元的定义与之类似. 只不过作用域在 $\bmod p$ 下.

求解逆元

朴素枚举

由模运算的性质知道 $x \equiv y \pmod p$ 必有 $\ 0\leq y\leq p-1$ 。

我们可以从 $1$ 到 $p-1$ 枚举判断是否有 $i$ 满足 $a\cdot i \equiv 1 \pmod p$。

线性时间复杂度, 方法的优点是简单易想, 缺点嘛, 显而易见.

费马小定理

如果 $gcd(a,p)=1$ 则 $a^{p-1}\equiv 1 \pmod p$。

关于费马小定理的证明有很多种，这里给出一种我认为最优雅的一种证明。

考虑两个序列 :

$i:[1,2,3,\dots,p-1]$

$j:[a,2a,3a, \dots,(p-1)a]$

现在证明 $i,j$ 在 $\bmod p$ 意义下同构。

也就是说, 如果二者都有序, 序列 $i$ 和序列 $j$ 在 $\bmod p$ 意义下是完全相同的.

假设 $j$ 序列中存在 $xa \equiv ya \pmod p \ (1\leq x,y\leq p-1，x \neq y)$，由模运算的性质得 $x \equiv y \pmod p$，由于 $1\leq x,y\leq p-1$ $x$ 一定等于 $y$. 假设不成立，原命题得证。

然后，我们把 $i，j$ 序列乘起来得到 $(p-1)!\cdot a^{p-1} \equiv (p-1)! \pmod p$ ，由于$gcd((p-1)!,p)=1$，化简为 $a^{p-1}\equiv 1 \pmod p$。

看向乘法逆元的定义 $：a\cdot a^{-1} \equiv 1 \pmod p$，对费马小定理进行变形得到 $a\cdot a^{p-2} \equiv 1 \pmod p$，这就说明 $a^{p-2}$ 是 $a$ 的乘法逆元。注意者只有在 $p$ 是质数的时候成立。

对于计算 $a^{p-2}$ ，可以用快速幂做到在 $O(log(p-2))$ 计算。

快速幂 :

i64 qpow(i64 base, i64 exp, i64 mod) {
    if(exp == 0) 
        return 0LL;
    i64 res = 1;
    while(exp) {
        if(exp & 1) 
	        res = static_cast<i128>(res) * base % mod;
        base = static_cast<i128>(base) * base % mod;
        exp >>= 1;
    }
    return res;
}

拓展欧几里得算法

拓展欧几里得算法是对欧几里得算法的拓展. 用来求解满足Bézout’s identity 的不定方程$a\cdot x + b \cdot y=gcd(a, b)$ 的解.

对于这个方程

$$a\cdot x + b \cdot y=gcd(a, b)$$

稍做变形, 有

$$a\cdot x \equiv gcd(a, b) \pmod b$$

在 $b$ 为质数的情况下, $x$ 为 $a$ 的逆元.

显然, $x=1,\ y=114514$ 是在 $b=0$ 时满足情况的一组解().

现在假设我们已知 $x_{0},y_{0}$ 是当前状态的一组解, 令当前计算的 $gcd$ 为 $gcd(a', b')$ , 上一个方程为 $gcd(a, b)$ . 有 $b'=a\ \bmod \ b,\ a'=b$ .

也就是

$$\begin{aligned} & x \cdot a + y \cdot b = gcd(a,b) \\ & x_{0} \cdot a' + y_{0} \cdot b' = gcd(a', b') \end{aligned}$$

那么

$$x_{0} \cdot b + y_{0} \cdot(a\ \bmod \ b) = gcd(a', b') = gcd(a, b)$$

化简

$$x_{0} \cdot b + y_{0} \cdot\left( a - \left\lfloor \frac{a}{b} \right\rfloor \cdot b \right) =gcd(a, b)$$

移项

$$y_{0} \cdot a + \left( x_{0} - \left\lfloor \frac{a}{b} \right\rfloor \cdot y_{0} \right) \cdot b = gcd(a, b)$$

新的解 $x,y$ 为 $x = y_{0}, \ y = x_{0} - \left\lfloor \frac{a}{b} \right\rfloor \cdot y_{0}$.

template <typename T>
constexpr std::tuple<T, T, T> Exgcd(const T &a, const T &b) {
    if(b == T{}) {
        return {a, T{1}, T{}};
    }
    auto [gcd, x0, y0] = Exgcd(b, a % b);
    T x = y0, y = x0 - (a / b) * y0;
    return {gcd, x, y};
}

template <typename T>
constexpr T normalize(T x, T mod) {
    x %= mod;
    if(x < 0) {
        x += mod;
    }
    return x;
}

template <typename T>
constexpr T Inv(T val, T mod) {
    auto [gcd, x, y] = Exgcd<decltype(mod)>(val, mod);
    assert(gcd == T{1} && "The modular inverse does not exist.");
    return normalize(x);
}

线性递推

想象一下, 如果你的知识储备不够充裕, 你能否凭空想出一种 $O(1)$ 的算法来求解逆元. 这恐怕十分困难.

不过如果有人告诉你，存在一种方法，可以在线性时间内求出连续 $N$ 范围内的逆元，你会怎么去思考？

如果是线性时间的话，那要么我在 $O(1)$ 内求出一个数的逆元，要么我知道一个公式可以直接计算出逆元，要么我可以通过递推方程来得出，要么我可以通过某种方式均摊到 $O(1)$。

明显，直接套公式有点不太现实，费马没想到，欧拉没想到，他们都没想到，我不太认为我自己可能会想到。直觉告诉我，递推是最有可能的方案。

不妨试一试，令 $i\ 是\ 1\dots n$ 里面的任意一个数， $base$ 情况是 $1^{-1} \equiv 1 \pmod p$ 。

$$ i^{-1} \equiv \begin{cases} 1, & \text{if } i = 1, \\ \text{a previous situation}, & \text{otherwise}. \end{cases} \pmod p $$

我们大胆猜测这个已知情况和一个小于 $i$ 的数有关，让我们想一想，哪里可以存在小于 $i$ 的数又和 $i$ 有关呢？

不妨注意到 $p = k\cdot i + r$，这个 $r$ 不就小于 $i$ 吗？ (注意到这个不是没有理由的，我们已知的信息就只有 $p,i$ ，而把一个数写成 $ki+x$ 的形式是一个非常常见的技巧. )

让我们来好好把玩把玩这个等式 $: p=k\cdot i+r$ ，$r=p \bmod i$。

先对等式两边取模得到

$$ 0 \equiv k\cdot i+r \pmod p $$

移项

$$ -k\cdot i \equiv r \pmod p $$

乘 $i^{-1}$

$$ -k \equiv r \cdot i^{-1} \pmod p $$

把 $i^{-1}$ 拆出来

$$ i^{-1} \equiv -k\cdot r^{-1} \pmod p $$

代换 $r$

$$ i^{-1} \equiv -k\cdot (p \bmod i)^{-1} \pmod p $$

重写 $k$

$$ i^{-1} \equiv -\left\lfloor \frac{p}{i} \right\rfloor\cdot (p \bmod i)^{-1} \pmod p $$

改成正数

$$ i^{-1} \equiv (p-\left\lfloor \frac{p}{i} \right\rfloor)\cdot (p \bmod i)^{-1} \pmod p $$

哈哈，这是什么，我们得到了一个式子，它完美的符合我们的猜想。

$$ i^{-1} \equiv \begin{cases} 1, & \text{if } i = 1, \\ (p-\left\lfloor \frac{p}{i} \right\rfloor)\cdot (p \bmod i)^{-1}, & \text{otherwise}. \end{cases} \pmod p $$

constexpr std::vector<i64> Inv(N, 1);
constexpr int mod = 998244353;
void Inverse() {
    Inv[1] = 1;
    for(int i = 2; i < N; ++i) {
        Inv[i] = ((i64)(mod - mod / i) * Inv[mod % i]) % mod;
    }
}

写出这个 $code$ ，易如反掌。

不过这么写只能求出 $1\dots n$ 的逆元，如果求给定任意 $a_{i}\dots a_{i+n}$ 这 $n$ 个数的逆元，就要稍稍变通一下.

利用类似前缀和的思想，首先计算 $n$ 个数的前缀积，记为 $s_i$，然后使用快速幂或扩展欧几里得法计算 $s_n$ 的逆元，记为 $sv_n$。

因为 $sv_n$ 是 $n$ 个数的积的逆元，所以当我们把它乘上 $a_{i+n}$ 时，就会和 $a_{i+n}$ 的逆元抵消，于是就得到了 $a_i$ 到 $a_{i+n-1}$ 的积逆元，记为 $sv_{n-1}$。

同理我们可以依次计算出所有的 $sv_i$，于是 $a_i^{-1}$ 就可以用 $s_{i-1} \times sv_i$ 求得。

所以我们就在 $O(n + \log p)$ 的时间内计算出了 $n$ 个数的逆元。

i64 modInv(i64 t) {
    return binpow(t, mod - 2, mod);
}

void Inverse(int n) {
    std::vector<i64> S(n + 1, 1), sInv(n + 1, 0);
    for(int i = 1; i <= n; ++i) {
        S[i] = S[i - 1] * arr[i - 1] % mod;
    }
    sInv[n] = modInv(S[n]);
    for(int i = n; i >= 1; --i) {
        sInv[i - 1] = sInv[i] * arr[i - 1] % mod;
    }

    for(int i = 0; i < n; ++i) {
        inv[i] = sInv[i + 1] * S[i] % mod;
    }
}

模板化

显然每次都重新编写这些是没有必要的, 而且这些内容十分适合模板化.

编写成静态类 $ModInt$.

template <auto mod>
class ModInt {
private :
    static_assert(mod >= 1LL, "The modulus must be a positive integer.");
    using T = decltype(mod);
    T value;
    static constexpr std::tuple<T, T, T> Exgcd(const T &a, const T &b) {
        if(b == T{}) {
            return {a, T{1}, T{}};
        }
        auto [gcd, x0, y0] = Exgcd(b, a % b);
        T x = y0, y = x0 - (a / b) * y0;
        return {gcd, x, y};
    }
public :
    constexpr ModInt() : value(T{}) {}

    template <typename V>
    constexpr ModInt(const V &v) {
        value = (static_cast<T>(v % mod) + mod) % mod;
    }

    constexpr ModInt inv() const {
        auto [gcd, x, y] = Exgcd(value, mod); // It could be hold that -mod < x < mod.
        assert(gcd == T{1} && "The modular inverse does not exist.");
        return ModInt(x);
    }

    // calculation operator overloading
    constexpr ModInt operator-() const {
        return ModInt(value == 0 ? 0 : mod - value);
    }

    constexpr ModInt& operator+=(const ModInt &rhs) {
        value += rhs.value;
        value %= mod;
        return *this;
    }

    constexpr ModInt& operator-=(const ModInt &rhs) {
        value += mod;
        value -= rhs.value;
        value %= mod;
        return *this;
    }

    constexpr ModInt& operator*=(const ModInt &rhs) {
        value = static_cast<T>((static_cast<i128>(value) * rhs.value) % mod);
        return *this;
    }

    constexpr ModInt& operator/=(const ModInt &rhs) {
        *this *= rhs.inv();
        return *this;
    } 

    friend constexpr ModInt operator+(const ModInt &a, const ModInt &b) {
        ModInt res = a;
        res += b;
        return res;
    }

    friend constexpr ModInt operator-(const ModInt &a, const ModInt &b) {
        ModInt res = a;
        res -= b;
        return res;
    }

    friend constexpr ModInt operator*(const ModInt &a, const ModInt &b) {
        ModInt res = a;
        res *= b;
        return res;
    }

    friend constexpr ModInt operator/(const ModInt &a, const ModInt &b) {
        ModInt res = a;
        res /= b;
        return res;
    }

    // bool operator overloading 
    friend constexpr bool operator>(const ModInt &a, const ModInt &b) {
        return a.value > b.value;
    }

    friend constexpr bool operator>=(const ModInt &a, const ModInt &b) {
        return a.value >= b.value;
    }

    friend constexpr bool operator<(const ModInt &a, const ModInt &b) {
        return a.value < b.value;
    }

    friend constexpr bool operator<=(const ModInt &a, const ModInt &b) {
        return a.value <= b.value;
    }

    friend constexpr bool operator==(const ModInt &a, const ModInt &b) {
        return a.value == b.value;
    }
 
    friend constexpr bool operator!=(const ModInt &a, const ModInt &b) {
        return a.value != b.value;
    }

    // stream operator overloading
    friend std::ostream& operator<<(std::ostream &os, const ModInt &x) {
        os << x.value;
        return os;
    }
 
    friend std::istream& operator>>(std::istream &is, ModInt &x) {
        T v;
        if(is >> v) {
            x = ModInt(v);
        }
        return is;
    }
};

constexpr i64 mod = 1'000'000'007LL;
using Z = ModInt<mod>;

template <typename T>
Z mpow(Z base, T exp) {
    assert(exp >= 0);
    Z res = 1;
    while(exp > 0) {
        if(exp & 1) 
            res *= base;
        base *= base;
        exp >>= 1;
    }
    return res;
}

动态模数还没写 …

本文部分内容参考自 OIwiki

GCD and LCM

Mon, 21 Apr 2025 22:35:59 +0800

[!quote] A fine quotation is a diamond on the finger of a man of wit, and a pebble in the hand of a fool. — Joseph Roux

我们要证明的等式是：

$$ \gcd(\operatorname{lcm}(a,b), \operatorname{lcm}(a,c)) = \operatorname{lcm}(a, \gcd(b,c)) $$

基础：唯一分解定理（算术基本定理）

证明的关键在于使用唯一分解定理。该定理指出，任何大于 1 的整数都可以唯一地分解为素数的乘积（不考虑顺序）。

形式一： 对于 $\forall n \in \mathbb{Z}, n > 1$，存在唯一的不同素数集合 $\{p_1, \dots, p_k\}$ 和唯一的正整数指数集合 $\{\alpha_1, \dots, \alpha_k\}$ 使得：

$$ n = p_1^{\alpha_1} p_2^{\alpha_2} \cdots p_k^{\alpha_k} = \prod_{i=1}^{k} p_i^{\alpha_i} $$

形式二（更适用于证明）： 对于 $\forall n \in \mathbb{Z}, n > 1$，其分解可以写成包含所有素数的形式：

$$ n = \prod_{p \text{ prime}} p^{\nu_p(n)} $$

其中 $\nu_p(n)$ 是素数 $p$ 在 $n$ 分解中的（非负）指数。对于给定的 $n$，只有有限个 $\nu_p(n)$ 大于 0。

使用素数指数表示 GCD 和 LCM

根据唯一分解定理，我们可以通过比较整数分解中每个素数 $p$ 的指数来计算最大公约数 (gcd) 和最小公倍数 (lcm)：

对于任意素数 $p$：
- $p$ 在 $\gcd(x, y)$ 中的指数是 $\nu_p(\gcd(x, y)) = \min(\nu_p(x), \nu_p(y))$
- $p$ 在 $\operatorname{lcm}(x, y)$ 中的指数是 $\nu_p(\operatorname{lcm}(x, y)) = \max(\nu_p(x), \nu_p(y))$

例子： 设 $a = 12 = 2^2 \cdot 3^1 \cdot 5^0$ 设 $b = 30 = 2^1 \cdot 3^1 \cdot 5^1$

计算 $\gcd(12, 30)$:
- 素数 2: 指数 $\min(2, 1) = 1$
- 素数 3: 指数 $\min(1, 1) = 1$
- 素数 5: 指数 $\min(0, 1) = 0$
- 所以 $\gcd(12, 30) = 2^1 \cdot 3^1 \cdot 5^0 = 6$
计算 $\operatorname{lcm}(12, 30)$:
- 素数 2: 指数 $\max(2, 1) = 2$
- 素数 3: 指数 $\max(1, 1) = 1$
- 素数 5: 指数 $\max(0, 1) = 1$
- 所以 $\operatorname{lcm}(12, 30) = 2^2 \cdot 3^1 \cdot 5^1 = 60$

证明过程

我们的策略是证明对于任意素数 $p$，它在等式左边 (LHS) 和右边 (RHS) 的指数都相等。根据唯一分解定理，如果所有素数的指数都对应相等，则这两个数必然相等。

设对于任意素数 $p$，其在 $a, b, c$ 中的指数分别为 $\alpha = \nu_p(a)$, $\beta = \nu_p(b)$, $\gamma = \nu_p(c)$。

1. 计算 LHS 中 $p$ 的指数： LHS = $\gcd(\operatorname{lcm}(a,b), \operatorname{lcm}(a,c))$

$p$ 在 $\operatorname{lcm}(a,b)$ 中的指数为 $\max(\alpha, \beta)$。
$p$ 在 $\operatorname{lcm}(a,c)$ 中的指数为 $\max(\alpha, \gamma)$。
根据 gcd 的指数规则， $p$ 在 LHS 中的指数为： $$ \nu_p(\text{LHS}) = \min(\max(\alpha, \beta), \max(\alpha, \gamma)) $$

2. 计算 RHS 中 $p$ 的指数： RHS = $\operatorname{lcm}(a, \gcd(b,c))$

$p$ 在 $\gcd(b,c)$ 中的指数为 $\min(\beta, \gamma)$。
根据 lcm 的指数规则，$p$ 在 RHS 中的指数为： $$ \nu_p(\text{RHS}) = \max(\alpha, \min(\beta, \gamma)) $$

3. 证明指数相等： 我们需要证明 $\nu_p(\text{LHS}) = \nu_p(\text{RHS})$，即：

$$ \min(\max(\alpha, \beta), \max(\alpha, \gamma)) = \max(\alpha, \min(\beta, \gamma)) $$

这个等式是 $\min$ 和 $\max$ 运算的一个基本性质，称为分配律。这里用到的是 max 对 min 的分配律:

$$ \max(x, \min(y, z)) = \min(\max(x, y), \max(x, z)) $$

令 $x = \alpha$, $y = \beta$, $z = \gamma$，我们直接应用此分配律：

$$ \max(\alpha, \min(\beta, \gamma)) = \min(\max(\alpha, \beta), \max(\alpha, \gamma)) $$

这表明 $\nu_p(\text{RHS}) = \nu_p(\text{LHS})$。

结论： 由于对于任意素数 $p$，它在等式两边的指数都相等，根据唯一分解定理，这两个表达式代表的整数必然相等。

因此，原等式 $\gcd(\operatorname{lcm}(a,b), \operatorname{lcm}(a,c)) = \operatorname{lcm}(a, \gcd(b,c))$ 成立。

$Q.E.D.$

算术基本定理及其证明

算术基本定理 (Fundamental Theorem of Arithmetic): 任何大于 1 的整数 $n$ 都可以被唯一地分解成有限个素数的乘积（不考虑因子的顺序）。即：对于任意整数 $n > 1$，存在唯一的不同素数集合 $\{p_1, \dots, p_k\}$ 和唯一的正整数组 $\{\alpha_1, \dots, \alpha_k\}$ 使得：
$$ n = p_1^{\alpha_1} p_2^{\alpha_2} \cdots p_k^{\alpha_k} = \prod_{i=1}^{k} p_i^{\alpha_i} $$

证明

证明分为两部分：存在性和唯一性。

第一部分：存在性证明（强归纳法）

我们要证明任何整数 $n > 1$ 都可以写成素数的乘积。

基础情况: 当 $n=2$ 时，2 本身是素数，已是素数乘积。成立。
归纳假设: 假设对于所有满足 $1 < k < n$ 的整数 $k$，$k$ 都可以表示成素数的乘积。
归纳步骤: 考虑整数 $n$：
- 情况 A: 如果 $n$ 是素数，则它已是素数乘积。
- 情况 B: 如果 $n$ 是合数，则 $n = a \cdot b$，其中 $1 < a < n$ 且 $1 < b < n$。根据归纳假设，$a$ 和 $b$ 都可以写成素数乘积： $$ a = p_1 p_2 \cdots p_r $$ $$ b = q_1 q_2 \cdots q_s $$ 其中所有 $p_i, q_j$ 都是素数。那么： $$ n = a \cdot b = (p_1 \cdots p_r)(q_1 \cdots q_s) $$ 这表明 $n$ 也可以写成素数的乘积。

根据强归纳法，存在性得证。

第二部分：唯一性证明（使用欧几里得引理和反证法）

我们需要用到一个关键引理：

欧几里得引理 (Euclid’s Lemma): 如果素数 $p$ 整除乘积 $ab$ (记作 $p | ab$)，那么 $p$ 必须整除 $a$ 或 $p$ 必须整除 $b$ (即 $p | a$ 或 $p | b$)。 推论: 如果素数 $p$ 整除 $a_1 a_2 \cdots a_k$，则 $p$ 至少整除其中一个 $a_i$。

证明唯一性（反证法）：

假设: 假设存在大于 1 的整数拥有至少两种不同的素数分解。根据良序原则（最小数原理），必然存在一个最小的这样的整数，记为 $n$。
分析 $n$: 设 $n$ 有两种不同的分解： $$ n = p_1 p_2 \cdots p_r = q_1 q_2 \cdots q_s $$ 其中 $p_i$ 和 $q_j$ 都是素数，并且作为多重集（考虑重复次数） $\{p_1, \dots, p_r\} \neq \{q_1, \dots, q_s\}$。由于 $n$ 是最小的反例，任何小于 $n$ 的整数 $m > 1$ 的素数分解是唯一的。
应用引理: 考虑 $p_1$。显然 $p_1 | n$，所以 $p_1 | (q_1 q_2 \cdots q_s)$。根据欧几里得引理的推论，$p_1$ 必须整除某个 $q_j$。因为 $p_1$ 和 $q_j$ 都是素数，这只可能在 $p_1 = q_j$ 时发生。
约去公共因子: 不失一般性，重排 $q$ 使得 $p_1 = q_1$。等式两边同除以 $p_1$： $$ \frac{n}{p_1} = p_2 p_3 \cdots p_r = q_2 q_3 \cdots q_s $$
导出矛盾: 令 $m = n/p_1$。因为 $n$ 是合数（否则分解唯一），所以 $1 < m < n$。我们得到了整数 $m$ 的两种分解 $p_2 \cdots p_r$ 和 $q_2 \cdots q_s$。由于 $\{p_1, \dots, p_r\}$ 和 $\{q_1, \dots, q_s\}$ 不同，去掉相同的 $p_1=q_1$ 后，$\{p_2, \dots, p_r\}$ 和 $\{q_2, \dots, q_s\}$ 也必定不同。这表明 $m$ 是一个比 $n$ 更小的、拥有不同素数分解的整数。这与 $n$ 是具有此性质的最小整数的假设相矛盾！
结论: 初始假设错误。因此，任何整数 $n > 1$ 的素数分解是唯一的（在不考虑顺序时）。

$Q.E.D.$