高斯整数学习笔记

高斯整数及其应用

高斯整数

高斯整数定义：形如 $a + b \cdot i$ 的复数被称为高斯整数，其中 $a, b \subseteq Z$ ，高斯整数的全体记作 $Z [i]$
四则运算：高斯整数的四则运算规则同复数的四则运算规则。
封闭性：设 $α = a + b \cdot i, β = c + d \cdot i$ 是高斯整数，则 $α + β, α - β, α \cdot β$ 均是高斯整数。
范数：对于高斯整数 $α = a + b \cdot i$ ，记 $N (α) = a^{2} + b^{2}$ 为 $α$ 的范数。显然有 $α \cdot \overset{―}{α} = N (α), N (α \cdot β) = N (α) \cdot N (β)$ 。
整除性：高斯整数 $α$ 整除高斯整数 $β$ 当且仅当 $\exists γ \subseteq Z [i], α \cdot γ = β$ ，记作 $α | β$
单位与相伴：若 $ϵ | 1$ ，则称高斯整数 $ϵ$ 是单位，若 $ϵ$ 是单位，则称 $ϵ \cdot α$ 是 $α$ 的一个相伴。高斯整数的单位有且仅有 $1, - 1, i, - i$ 。
高斯素数定义：若非零的高斯整数 $π$ 不是单位，且只能够被单位和他的相伴整除，则称 $π$ 为高斯素数。
定理1：若高斯整数 $π$ ，满足 $N (π) = p$ ，其中 $p$ 是有理素数，则 $π, \overset{―}{π}$ 是高斯素数。
证明：

\begin{aligned} 假 设 π = α \cdot β \Rightarrow N (π) = N (α) \cdot N (β) = p, 那 么 N (α) = 1 或 N (β) = 1 \\ 这 说 明 α 和 β 中 有 一 个 是 单 位, π 不 能 分 解 成 两 个 非 单 位 的 高 斯 素 数 之 积, 他 是 高 斯 素 数 \end{aligned}

最大公约数和唯一分解

最大公约数：设 $α, β \subseteq Z [i]$ 则称 $α, β$ 的最大公约数 $γ$ 为满足以下两个条件的高斯整数： $(i) γ | α, γ | β (i i) δ | α \land δ | β \Rightarrow δ | γ$
带余除法：设 $α, β \subseteq Z [i]$ 且 $β \neq 0$ ，则存在高斯整数 $γ, ρ$ 满足 $α = β \cdot γ + ρ$ 且 $0 \leq N (ρ) < N (β)$ 我们称 $γ$ 为商， $ρ$ 为余数。
证明：

\begin{aligned} 假 设 α = a + b \cdot i, β = c + d \cdot i, \frac{a + b \cdot i}{c + d \cdot i} = x + y \cdot i 则 z + y \cdot i 为 高 斯 整 数 当 且 仅 当 β | α \\ 令 s = [x + \frac{1}{2}], t = [y + \frac{1}{2}] \Rightarrow x + y \cdot i = (s + f) + (t + g) \cdot i ， 其 中 f, g \subseteq R 且 | f | \leq \frac{1}{2} | g | \leq \frac{1}{2} \\ 现 在 令 γ = s + t \cdot i, ρ = α - β \cdot γ \\ 那 么 N (ρ) = N (β \cdot (x + y \cdot i - γ)) = N (β) \cdot N (f + g \cdot i) \leq \frac{1}{2} \cdot N (β) \end{aligned}

定理2：设 $α, β \subseteq Z [i]$ ， $(i) \exists γ \subseteq Z [i], 满足 γ 是 α, β 的最大公约数 (i i) \exists ν, μ \subseteq Z [i], μ \cdot α + ν \cdot β = γ$ 。
证明：

\begin{aligned} 设 集 合 S = {N (μ \cdot α + ν \cdot β) | μ, ν \subseteq Z [i]}, 那 么 集 合 中 一 定 存 在 最 小 元 \\ 令 γ = μ_{0} \cdot α + ν_{0} \cdot β, 假 设 N (γ) 是 S 中 的 最 小 元, 我 们 证 明 γ 就 是 α, β 的 最 大 公 约 数 \\ 假 设 δ | α, δ | β \Rightarrow α = δ \cdot ο, β = δ \cdot λ \Rightarrow γ = μ_{0} \cdot ο \cdot δ + ν_{0} \cdot λ \cdot δ \Rightarrow δ | γ \\ 假 设 τ = μ_{1} \cdot α + ν_{1} \cdot β ， 将 τ 对 γ 做 带 余 除 法 ， τ = ω \cdot γ + ξ, N (ξ) \leq N (γ) \\ 容 易 知 道 ξ 也 是 形 如 μ \cdot α + ν \cdot β 的 高 斯 整 数 ， 因 此 ξ 只 能 是 0 ， 否 则 将 与 N (γ) 是 集 合 S 中 最 小 元 素 矛 盾 。 \\ 因 此 有 γ | τ \Rightarrow γ | α, γ | β \end{aligned}

欧几里得算法：令 $ρ_{0} = α, ρ_{1} = β$ 为非零高斯整数，若连续使用高斯整数的带余除法，可以得到 $ρ_{j} = ρ_{j + 1} \cdot γ_{j + 1} + ρ_{j + 2}$ 其中 $N (ρ_{j + 2}) < N (ρ_{j + 1}), j = 0, 1, 2, \dots, n - 2$ 并且 $ρ_{n + 1} = 0$ 。则最后一个非零余数 $ρ_{n}$ 就是 $α, β$ 的最大公约数。
引理1：若 $π$ 是高斯素数， $α, β$ 是高斯整数，且有 $π | α \cdot β$ ，那么有 $π | α$ 或者 $π | β$ 。
证明：

\begin{aligned} 假 设 π |̸ β ， 由 于 π 是 高 斯 素 数 ， π 和 β 的 最 大 公 约 数 只 能 是 单 位 \\ 所 以 由 定 理 2 存 在 μ, ν 满 足 μ \cdot β + ν \cdot π = 1 \Rightarrow μ \cdot β \cdot α + ν \cdot π \cdot α = α \Rightarrow π | α \\ 同 理 ， π |̸ α \Rightarrow π | β ， 引 理 得 证 。 \\ 这 个 引 理 还 可 以 推 广 到 多 个 数 的 情 形 ： 高 斯 素 数 π | α_{1} \cdot α_{2} \dots α_{n} \Rightarrow \exists j \subseteq [1, n], π | α_{j} \end{aligned}

唯一分解定理：设 $γ$ 是非零非单位的高斯整数，则 $(i) γ 能分解为一些高斯素数的乘积 (i i) 该分解在某种意义上是唯一的，即若 γ = ρ_{1} \cdot ρ_{2} \dots ρ_{s} = π_{1} \cdot π_{2} \dots π_{t} \Rightarrow s = t, 并且对这些项重新排列，可以使得 ρ_{i} 与 π_{i} 相伴, i = 1, 2, \dots, s$
证明：

\begin{aligned} 当 N (γ) = 2 时 ， 由 定 理 1 可 知 ， γ 是 高 斯 素 数 \\ 现 在 假 设 N (γ) > 2, 且 任 意 范 数 小 于 N (γ) 的 高 斯 整 数 都 能 表 示 为 一 些 高 斯 素 数 的 乘 积 \\ 若 γ 是 高 斯 素 数 ， 则 他 显 然 可 以 表 示 为 高 斯 素 数 的 乘 积 ， 若 他 不 是 高 斯 素 数 \\ 则 γ = θ \cdot μ, 1 < N (θ) < N (γ), 1 < N (μ) < N (γ), 由 归 纳 假 设 ， θ, μ 都 能 分 解 成 一 些 高 斯 素 数 之 积 ， 故 γ 也 能 分 解 成 一 些 高 斯 素 数 之 积 。 \\ 我 们 同 样 使 用 第 二 数 学 归 纳 法 证 明 (i i) \\ 若 γ 是 高 斯 素 数 ， 则 他 的 分 解 显 然 唯 一 ， 若 其 不 是 高 斯 素 数 \\ 假 设 γ = ρ_{1} \cdot ρ_{2} \dots ρ_{s} = π_{1} \cdot π_{2} \dots π_{t} \Rightarrow ρ_{1} | π_{1} \cdot π_{2} \dots π_{t} \Rightarrow \exists 1 \leq j \leq t, ρ_{1} | π_{j} \\ 我 们 对 π_{1} \dots π_{t} 重 新 排 列 ， 使 得 ρ_{1} | π_{1} \Rightarrow ρ_{1} 和 π_{1} 相 伴 。 然 后 两 边 同 时 除 以 π_{1} 对 剩 余 部 分 使 用 归 纳 假 设 。 \\ 这 里 我 们 可 以 看 出 唯 一 分 解 成 立 的 关 键 就 是 引 理 1 的 成 立 。 \end{aligned}

高斯整数与平方和

求出所有的正整数 $a, b$ 满足 $a^{2} + b^{2} = n$

定理3：形如 $4 k + 1$ 的有理质数 $p$ 可以分解为两个有理整数的平方和。
证明：

\begin{aligned} - 1 为 4 k + 1 形 素 数 的 二 次 剩 余 ， 于 是 存 在 有 理 整 数 t 满 足 t^{2} \equiv - 1 (m o d p) \\ p | (t - i) \cdot (t + i) ， 若 p 是 高 斯 素 数 ， 则 由 引 理 1 ， p | t - i 或 p | t + i ， 而 能 整 除 p 的 高 斯 整 数 都 形 如 p \cdot (a + b \cdot i) ， t + i, t - i 显 然 不 满 足 这 种 形 式 。 \\ 于 是 p 不 是 高 斯 素 数 ， 那 么 存 在 α, β \subseteq Z [i], N (α) > 1, N (β) > 1, α \cdot β = p \Rightarrow N (p) = p^{2} = N (α) \cdot N (β) \Rightarrow N (α) = N (β) = p \\ 从 而 p 可 以 写 成 两 个 有 理 整 数 的 平 方 和 。 \\ 假 设 p = a^{2} + b^{2} 则 p = (a + b \cdot i) \cdot (a - b \cdot i) ， 由 定 理 1 ， a + b \cdot i 与 a - b \cdot i 均 是 高 斯 素 数 。 \\ 考 虑 如 何 求 出 a 和 b ， 如 果 能 找 到 t ， 满 足 t^{2} \equiv - 1 (\mod p) ， 那 么 只 需 要 求 出 \gcd (t + i, p) 就 能 得 到 a, b \\ 而 有 一 半 的 数 都 是 p 的 二 次 剩 余 ， 因 此 我 们 可 以 随 机 ， 找 到 p 的 一 个 二 次 非 剩 余 k ， 则 k^{\frac{p - 1}{2}} \equiv - 1 (\mod p) \\ 取 t = k^{\frac{p - 1}{4}} 即 可 。 \end{aligned}

定理4：形如 $4 k + 3$ 的有理素数 $p$ 是高斯素数。
证明：

\begin{aligned} 首 先 对 于 任 意 正 整 数 a ， a^{2} \equiv 0 或 1 (\mod 4) \Rightarrow p 不 能 表 示 为 两 个 有 理 整 数 的 平 方 和 。 \\ 假 设 p 不 是 高 斯 素 数 ， 则 存 在 α, β \subseteq Z [i], N (α) > 1, N (β) > 1, α \cdot β = p \Rightarrow N (p) = p^{2} = N (α) \cdot N (β) \Rightarrow N (α) = N (β) = p \\ 从 而 p 可 以 写 成 两 个 有 理 整 数 的 平 方 和 ， 这 产 生 了 矛 盾 \\ 于 是 p 是 高 斯 素 数 。 \end{aligned}

平方和：

\begin{aligned} 假 设 n 是 正 整 数 ， 且 有 如 下 分 解 形 式 n = 2^{w} p_{1}^{a_{1}} p_{2}^{a_{2}} \dots p_{s}^{a_{s}} q_{1}^{b_{1}} q_{2}^{b_{2}} \dots q_{t}^{b_{t}} ， 其 中 p_{i} 是 形 如 4 k + 1 的 有 理 素 数 ， q_{i} 是 形 如 4 k + 3 的 有 理 素 数 。 \\ 接 下 来 将 n 分 解 为 高 斯 素 数 之 积 n = i^{w} (1 - i)^{2 w} (c_{1} + d_{1} i)^{a_{1}} (c_{1} - d_{1} i)^{a_{1}} \dots (c_{s} + d_{s} i)^{a_{s}} (c_{s} - d_{s} i)^{a_{s}} q_{1}^{b_{1}} q_{2}^{b_{2}} \dots q_{t}^{b_{t}} \\ 将 n 分 解 为 a^{2} + b^{2} 即 将 n 分 解 为 (a + b i) \cdot (a - b i) \\ 设 a - b i = ϵ \cdot (1 - i)^{e} (c_{1} + d_{1} i)^{f_{1}} (c_{1} - d_{1} i)^{g_{1}} \dots (c_{s} + d_{s} i)^{f_{s}} (c_{s} - d_{s} i)^{g_{s}} q_{1}^{h_{1}} q_{2}^{h_{2}} \dots q_{t}^{h_{t}} \\ 则 a + b i = \overset{―}{ϵ} \cdot (1 + i)^{e} (c_{1} - d_{1} i)^{f_{1}} (c_{1} + d_{1} i)^{g_{1}} \dots (c_{s} - d_{s} i)^{f_{s}} (c_{s} + d_{s} i)^{g_{s}} q_{1}^{h_{1}} q_{2}^{h_{2}} \dots q_{t}^{h_{t}} \\ (a - b i) \cdot (a + b i) = 2^{e} (c_{1} + d_{1} i)^{f_{1} + g_{1}} (c_{1} - d_{1} i)^{f_{1} + g_{1}} \dots (c_{s} + d_{s} i)^{f_{s} + g_{s}} (c_{s} - d_{s} i)^{f_{s} + g_{s}} q_{1}^{2 h_{1}} q_{2}^{2 h_{2}} \dots q_{t}^{2 h_{t}} \\ 因 此 需 要 满 足 e = w, f_{i} + g_{i} = a_{i} (i = 1, 2, \dots, s), 2 h_{i} = b_{i} (i = 1, 2, \dots, t), 这 样 我 们 就 得 到 了 要 求 的 a, b \\ 我 们 可 以 看 到 ， 正 整 数 n 要 想 分 解 成 两 个 正 整 数 的 平 方 和 ， 充 要 条 件 是 n 的 形 如 4 k + 3 的 质 因 子 的 次 数 均 为 偶 数 。 \end{aligned}

一些例子

将 $n \times m$ 的矩形放入坐标系中，使得矩形的四个角坐标均为整点，问所有不同的放置方式下矩形包含的完整 $1 \times 1$ 正方形数量之和。两个放置方式相同当且仅当他们之间可以仅通过平移重合。 $n, m \leq 10^{18}$ 2022牛客暑期多校训练营7 D.The Pool

\begin{aligned} 将 矩 形 A B C D 中 顶 点 A 放 置 到 原 点 ， 假 设 A B = n, A D = m \\ 考 虑 B 的 可 行 位 置 ， 即 找 到 整 数 a, b 满 足 a^{2} + b^{2} = n^{2} ， 同 时 需 要 判 断 一 下 对 应 的 D 点 是 否 在 整 点 上 。 \\ 假 设 B 坐 标 (a, b) ， D 坐 标 (c, d) \\ s_{1} = 以 a, b 为 边 长 的 直 角 三 角 形 中 1 \times 1 方 格 的 数 量 \\ s_{2} = 以 c, d 为 边 长 的 直 角 三 角 形 中 1 \times 1 方 格 的 数 量 \\ 则 a n s = (s_{1} + s_{2}) \times 2 + (a - c) \times (d - b) \\ s_{1} = \sum_{i = 0}^{a - 1} ⌊ \frac{b \cdot x}{a} ⌋ 可 以 方 便 的 用 类 欧 几 里 得 算 法 求 解 。 \end{aligned}

code:

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <iostream>
#define int long long

using namespace std;

const int mo = 998244353;
const int d[12] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};

struct gauss {
    __int128 a, b;
    gauss() {}
    gauss(int o, int p) {
        a = o;
        b = p;
    }
    bool operator==(const gauss& o) const { return (a == o.a) && (b == o.b); }
    bool operator<(const gauss& o) const {
        return (a < o.a) || ((a == o.a) && (b < o.b));
    }
    gauss operator-(const gauss& o) const { return gauss(a - o.a, b - o.b); }
    gauss operator*(const gauss& o) const {
        return gauss(a * o.a - b * o.b, a * o.b + b * o.a);
    }
    gauss operator%(const gauss& o) const {
        int t1 = floor(((long double)a / o.b + (long double)b / o.a) /
                           ((long double)o.a / o.b + (long double)o.b / o.a) +
                       0.5);
        int t2 = floor(((long double)b / o.b - (long double)a / o.a) /
                           ((long double)o.a / o.b + (long double)o.b / o.a) +
                       0.5);
        return gauss(a, b) - o * gauss(t1, t2);
    }
};

int n, m, bo[1000005], prime[200005], s0 = 0, cnt = 0, div1[1005][2],
                                      div3[1005][3], s1 = 0, s3 = 0, s2 = 0;
gauss divid[1005], possible[2000005], st[1005][1005];

__int128 abss(__int128 o) { return (o > 0) ? o : (-o); }

int gcd(int o, int p) { return (!p) ? o : gcd(p, o % p); }

int mi(int o, int p, int mo) {
    int yu = 1;
    while (p) {
        if (p & 1) yu = (__int128)yu * o % mo;
        o = (__int128)o * o % mo;
        p >>= 1;
    }
    return yu;
}

bool test(int o, int p) {
    if (mi(o, p - 1, p) != 1) return 0;
    int yu = p - 1;
    while (!(yu & 1)) {
        yu >>= 1;
        if (mi(o, yu, p) == (p - 1)) return 1;
    }
    return mi(o, yu, p) == 1;
}

bool Miller_Rabin(int o) {
    if (o <= 1) return 1;
    for (int i = 0; i < 12; i++)
        if (o == d[i]) return 1;
    for (int i = 0; i < 12; i++)
        if (!test(d[i], o)) return 0;
    return 1;
}

int Pollard_Rho(int o) {
    int x1 = 1ll * rand() * rand() * rand() * rand() % o + 1, c = rand() + 1,
        y = x1;
    for (int lim = 1;; lim = min(lim, lim << 1)) {
        int cnt = 1;
        for (int i = 1; i <= lim; i++) {
            x1 = ((__int128)x1 * x1 + c) % o;
            y = ((__int128)y * y + c) % o;
            y = ((__int128)y * y + c) % o;
            cnt = (__int128)cnt * abs(x1 - y) % o;
        }
        int yu = gcd(cnt, o);
        if (yu > 1) return yu;
    }
    return o;
}

gauss gauss_mi(gauss o, int p) {
    gauss yu = gauss(1, 0);
    while (p) {
        if (p & 1) yu = yu * o;
        o = o * o;
        p >>= 1;
    }
    return yu;
}

gauss gauss_gcd(gauss o, gauss p) {
    if (p == gauss(0, 0)) return o;
    return gauss_gcd(p, o % p);
}

gauss split(int o) {
    int yu = 1ll * rand() * rand() * rand() * rand() % o + 1;
    while (mi(yu, (o - 1) >> 1, o) != (o - 1)) {
        yu = 1ll * rand() * rand() * rand() * rand() % o + 1;
    }
    yu = mi(yu, (o - 1) >> 2, o);
    gauss t = gauss_gcd(gauss(yu, -1), gauss(o, 0));
    int a1 = abss(t.a), a2 = abss(t.b);
    if (a1 > a2) swap(a1, a2);
    return gauss(a1, a2);
}

void insert(gauss o) { possible[++s0] = gauss(abss(o.a), abss(o.b)); }

void dfs(int o, gauss p) {
    if (o > s1) {
        gauss yu = p;
        insert(yu);
        insert(yu * gauss(0, 1));
        return;
    }
    gauss yu = gauss(1, 0);
    st[o][0] = gauss(1, 0);
    for (int i = 1; i <= div1[o][1]; i++)
        st[o][i] = st[o][i - 1] * gauss(divid[o].a, -divid[o].b);
    for (int i = 0; i <= div1[o][1]; i++) {
        dfs(o + 1, p * st[o][div1[o][1] - i] * yu);
        yu = yu * divid[o];
    }
}

int Mo(int o) { return (o >= mo) ? (o - mo) : o; }

int calc(__int128 a, __int128 b, __int128 c, __int128 n) {
    if (a == 0) return ((b / c) % mo) * ((n + 1) % mo) % mo;
    if ((a >= c) || (b >= c)) {
        int s1 = ((n * (n + 1) / 2) % mo * ((a / c) % mo)) % mo;
        int s2 = ((n + 1) % mo) * ((b / c) % mo) % mo;
        return Mo(Mo(s1 + s2) + calc(a % c, b % c, c, n));
    }
    int s1 = ((n % mo) * ((a * n + b) / c) % mo -
              calc(c, c - b - 1, a, (a * n + b) / c - 1)) %
             mo;
    return Mo(s1 + mo);
}

signed main() {
    srand((unsigned)time(NULL));
    for (int i = 2; i <= 100000; i++) {
        if (!bo[i]) prime[++cnt] = i;
        for (int j = 1; (j <= cnt) && (i * prime[j] <= 100000); j++) {
            bo[i * prime[j]] = 1;
            if (i % prime[j] == 0) break;
        }
    }
    int T;
    cin >> T;
    while (T--) {
        scanf("%lld%lld", &n, &m);
        int gg = gcd(n, m);
        s1 = s2 = s3 = s0 = 0;
        for (int i = 1; i <= cnt; i++)
            if (gg % prime[i] == 0) {
                if (prime[i] % 4 == 1) {
                    s1++;
                    div1[s1][0] = prime[i];
                    div1[s1][1] = 0;
                    while (gg % prime[i] == 0) div1[s1][1]++, gg /= prime[i];
                } else if (prime[i] % 4 == 3) {
                    s3++;
                    div3[s3][0] = prime[i];
                    div3[s3][1] = 0;
                    div3[s3][2] = 1;
                    while (gg % prime[i] == 0) {
                        div3[s3][1]++;
                        gg /= prime[i];
                        div3[s3][2] *= prime[i];
                    }
                } else
                    while (gg % 2 == 0) gg >>= 1, s2++;
            }
        while (!Miller_Rabin(gg)) {
            int yu = Pollard_Rho(gg);
            gg /= yu;
            if (yu > gg) swap(yu, gg);
            if (yu > 1) {
                if (yu % 4 == 1) {
                    s1++;
                    div1[s1][0] = yu;
                    div1[s1][1] = 1;
                    while (gg % yu == 0) div1[s1][1]++, gg /= yu;
                } else {
                    s3++;
                    div3[s3][0] = yu;
                    div3[s3][1] = div3[s3][2] = 1;
                    while (gg % yu == 0) {
                        div3[s3][1]++;
                        gg /= yu;
                        div3[s3][2] *= yu;
                    }
                }
            }
        }
        if (gg > 1) {
            if (gg % 4 == 1) {
                s1++;
                div1[s1][0] = gg;
                div1[s1][1] = 1;
            } else {
                s3++;
                div3[s3][0] = gg;
                div3[s3][1] = 1;
                div3[s3][2] = gg;
            }
        }
        s2 <<= 1;
        for (int i = 1; i <= s1; i++) div1[i][1] <<= 1;
        for (int i = 1; i <= s3; i++) div3[i][1] <<= 1;
        for (int i = 1; i <= s1; i++) divid[i] = split(div1[i][0]);
        gauss yu = gauss_mi(gauss(1, -1), s2);
        for (int i = 1; i <= s3; i++) yu = yu * gauss(div3[i][2], 0);
        dfs(1, yu);
        for (int i = 1; i <= s0; i++) {
            possible[i].a = abss(possible[i].a);
            possible[i].b = abss(possible[i].b);
        }
        for (int i = 1; i <= s0; i++)
            if (possible[i].a > possible[i].b)
                swap(possible[i].a, possible[i].b);
        sort(possible + 1, possible + s0 + 1);
        possible[0] = gauss(0, 0);
        int ans = 0;
        gg = gcd(n, m);
        for (int i = 1; i <= s0; i++) {
            if (possible[i] == possible[i - 1]) continue;
            if (!possible[i].a) continue;
            if (!possible[i].b) continue;
            int a = possible[i].a * (n / gg), b = possible[i].b * (n / gg);
            int c = possible[i].b * (m / gg), d = possible[i].a * (m / gg);
            int yu = calc(b, 0, a, a - 1) * 2 % mo;
            yu = (yu + calc(c, 0, d, d - 1) * 2) % mo;
            yu = (yu + (__int128)(c - a) * (b - d) % mo) % mo;
            yu = (yu + mo) % mo;
            if (possible[i].a != possible[i].b) yu = yu * 2 % mo;
            ans = (ans + yu) % mo;
        }
        ans = (ans + (__int128)n * m % mo) % mo;
        if (n != m) ans = ans * 2 % mo;
        printf("%lld\n", ans);
    }
    return 0;
}

posted @ 2023-08-05 00:13 clapp 阅读(279) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 数论基本算法学习笔记

· 莫比乌斯反演学习笔记

· [useless]高斯整数学习笔记

· 社论 22.10.20 高斯整数环

· 莫比乌斯反演

阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· Manus爆火，是硬核还是营销？
· 一文读懂知识蒸馏
· 终于写完轮子一部分：tcp代理了，记录一下

公告

昵称： clapp
园龄： 1年11个月
粉丝： 3
关注： 4

+加关注

2025年3月

日

一

二

三

四

五

六

clapp

高斯整数学习笔记

高斯整数及其应用

高斯整数

最大公约数和唯一分解

高斯整数与平方和

一些例子

公告

搜索

常用链接

随笔档案

阅读排行榜

推荐排行榜