Gavin Hexo https://gavin-blog.pages.dev/ All rights reserved 2026, Gavin Time waits for no one. Gavin's Blog 2026-05-08T11:13:00.000Z Gavin 采用的 NTT，模数和原根就在代码开头改。Solver 里挂了目前可以解决的所有洛谷板子题，把 PROB 宏改成题号可以直接跑。

理论上需要 >=17 的 C++ 标准，更老的标准可能需要改一下。没有使用编译器拓展。本质是直接继承的 vector<int>。

下面的链接是挂的 GitHub Gist 的 Embed，这个有点丑。

]]> https://gavin-blog.pages.dev/2026/poly-template/ 2026-05-08T11:13:00.000Z 采用的 NTT，模数和原根就在代码开头改。Solver 里挂了目前可以解决的所有洛谷板子题，把 PROB 宏改成题号可以直接跑。

理论上需要 >=17 的 C++ 标准，更老的标准可能需要改一下。没有使用编译器拓展。本质是直接继承的 vector<]]>

Poly Template 2026-05-08T11:13:00.000Z Gavin 什么是 BT

在遥远的 2001 年，程序员…

TBD.

]]> https://gavin-blog.pages.dev/2026/peer%E3%80%81dht%E4%B8%8E%E5%8F%8D%E5%90%B8%E8%A1%80/ 2026-05-05T03:14:00.000Z 什么是 BT

在遥远的 2001 年，程序员…

TBD.

]]> Peer、DHT与反吸血 2026-05-05T03:14:00.000Z Gavin 网站托管于海因里希·海涅杜塞尔多夫大学

假定您对 Lean 4 有基本的了解——至少知道它是做什么的。

教程世界

第1关：rfl 策略

介绍第一个策略（tactic）——rfl，它可以证明所有形如 X = X 的定理。

1
2
example (x q : Nat) : 37 * x + q = 37 * x + q := by
  rfl

关于 rfl：

  • rfl 是“相等关系的自反性”（reflexivity of equality）的缩写。
  • 出于教学目的，我们的 rfl 比标准 Lean 中的版本要弱一些。数学家不区分命题相等与定义相等——在他们看来，zero_add 和 add_zero 都只是“事实”，谁在乎加法是如何定义的呢。
  • 因此在标准 Lean 中，2 + 2 = 4 可以用 rfl 来证明，因为它是定义相等。但在 NNG4 中，2 + 2 = 4 无法仅用 rfl 证明。

第2关：rw 策略

证明方法很简单，就是将 h 代入目标表达式，这可以通过 rw [h] 实现。重写之后，目标变为 2 * (x + 7) = 2 * (x + 7)。

1
2
3
example (x y : Nat) (h : y = x + 7) : 2 * y = 2 * (x + 7) := by
  rw [h]
  rfl

关于 rw：

  • 如果 h 是一个形如 X = Y 的相等关系的证明，那么 rw [h] 会将目标中所有的 X 替换成 Y。这就是“代入”的方法。

第3关：数字

Lean 中的自然数由两条规则定义。

  • 0 是一个自然数。
  • 如果 n 是一个自然数，那么 n 的后继（successor）succ n 也是一个自然数。

n 的后继指紧跟在 n 之后的自然数。

1
2
3
4
example : 2 = succ (succ 0) := by
  rw [two_eq_succ_one]
  rw [one_eq_succ_zero]
  rfl
]]> https://gavin-blog.pages.dev/2026/nng4-solutions-%E7%AE%80%E4%B8%AD%E7%89%88/ 2026-04-28T08:14:00.000Z 网站托管于海因里希·海涅杜塞尔多夫大学 Website Hosted By Heinrich Heine University Düsseldorf

Assuming you have a basic understanding of Lean 4 — at least knowing what it is used for.

Tutorial World

Level 1. The rfl tactic

Introduce the first tactic called rfl, which proves all the theorems of the form X = X.

1
2
example (x q : Nat) : 37 * x + q = 37 * x + q := by
  rfl

About rfl:

  • rfl is short for “reflexivity of equality”.
  • For pedagogical purposes, our rfl is weaker than the standard version in Lean. Mathematicians don’t distinguish between propositional equality and definitional equality — to them, zero_add and add_zero are just “facts”, and who cares about how addition is defined.
  • So in standard Lean, 2 + 2 = 4 can be provide by rfl because it’s a definitional equality. But in NNG4, 2 + 2 = 4 cannot be proved by rfl alone.

Level 2. the rw tactic

The proof is simply to substitute h into the goal, which can be done by rw [h]. After rewriting, the goal becomes 2 * (x + 7) = 2 * (x + 7).

1
2
3
example (x y : Nat) (h : y = x + 7) : 2 * y = 2 * (x + 7) := by
  rw [h]
  rfl

About rw:

  • If h is a proof of an equality X = Y, then rw [h] will change all Xs in the goal to Ys. It’s the way to “substitute in”.
]]> https://gavin-blog.pages.dev/2026/nng4-solutions/ 2026-04-28T02:59:00.000Z Website Hosted By Heinrich Heine University Düsseldorf NNG4 Solutions 2026-04-28T04:05:00.000Z Gavin 支持随机访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include <iostream>
#include <vector>
#include <stdexcept>

template <typename T>
class Stack {
private:
    std::vector<T> container;

public:
    void push(const T& value) {
        container.push_back(value);
    }

    void push(T&& value) {
        container.push_back(std::move(value));
    }

    template <typename... Args>
    void emplace(Args&&... args) {
        container.emplace_back(std::forward<Args>(args)...);
    }

    void pop() {
        if (empty()) {
            throw std::out_of_range("Cannot pop from an empty stack");
        }
        container.pop_back();
    }

    T& top() {
        if (empty()) {
            throw std::out_of_range("Stack is empty");
        }
        return container.back();
    }

    const T& top() const {
        if (empty()) {
            throw std::out_of_range("Stack is empty");
        }
        return container.back();
    }

    bool empty() const {
        return container.empty();
    }

    size_t size() const {
        return container.size();
    }

    void clear() {
        container.clear();
    }

    T& operator[](size_t index) {
        return container[index];
    }

    const T& operator[](size_t index) const {
        return container[index];
    }

    T& at(size_t index) {
        return container.at(index);
    }

    const T& at(size_t index) const {
        return container.at(index);
    }

    T& peek_down(size_t depth) {
        if (depth >= container.size()) {
            throw std::out_of_range("Peek depth out of range");
        }
        return container[container.size() - 1 - depth];
    }

    const T& peek_down(size_t depth) const {
        if (depth >= container.size()) {
            throw std::out_of_range("Peek depth out of range");
        }
        return container[container.size() - 1 - depth];
    }

    using iterator = typename std::vector<T>::iterator;
    using const_iterator = typename std::vector<T>::const_iterator;

    iterator begin() { return container.begin(); }
    iterator end() { return container.end(); }
    const_iterator begin() const { return container.begin(); }
    const_iterator end() const { return container.end(); }

    using reverse_iterator = typename std::vector<T>::reverse_iterator;
    using const_reverse_iterator = typename std::vector<T>::const_reverse_iterator;

    reverse_iterator rbegin() { return container.rbegin(); }
    reverse_iterator rend() { return container.rend(); }
    const_reverse_iterator rbegin() const { return container.rbegin(); }
    const_reverse_iterator rend() const { return container.rend(); }
};
]]> https://gavin-blog.pages.dev/2026/%E6%A0%88%E6%A8%A1%E6%9D%BF/ 2026-04-16T00:53:00.000Z 支持随机访问。


    
    栈模板
    2026-04-16T00:53:00.000Z
  
  
    
      Gavin
    
    
    
      CF573D Bear and Cavalry
总之我只会 O(nq)O(nq)。将 ww 和 hh 分别排序，存一下每个战士对应的马，每次修改直接交换。每次询问从前到后统计答案，只需要这一个对应，然后左右两个交叉对应，然后三个对应，这几种情况取最大就行。
CF838D Airplane Arrangements
方案数也可以转成概率乘总方案数。 我们将问题转换为每个人随机指定一个位置并开始走，求最后合法的概率。那这样仍然是求解困难的，我们可以将其想象成在一个长度为 nn 的环上顺时针或逆时针走，那就可以在 11 与 nn 之间加入一个虚点表示无解。
则问题转为统计给一个 n+1n+1 的环分配 mm 个人任意走最后使得 n+1n+1 没有被占据的概率，一个位置被占据的概率为 mn+1\frac{m}{n+1}，可以得到答案发生的概率为 n+1−mn+1\frac{n+1-m}{n+1}，乘以方案数 (2×(n+1))m(2 \times (n+1))^m 即可。
CF1814D Balancing Weapons
有一说一，富文本编辑器写得真爽
首先，此问题一定有解，且答案的上界显然为 nn。答案要更优，一定有一把枪的 pip_i 是不变的。去枚举这个不变的，则其他 pjp_j 都要向这个 pip_i 调整。此时对于其它的每把枪，pjp_j 只会调整为以下值：
  • 不变。
  • 变为不超过 pip_i 且为 fjf_j 倍数的最大值。
  • 变为超过 pip_i 且为 fjf_j 倍数的最小值。
因此，可能的取值数量为 O(n)O(n)。将取值排序，使用双指针维护极差不超过 kk 的极大区间，检查包含的枪械种类数是否为 nn 即可。
以后可以分讨出所有情况，方案总数有时候是很好弄的。
CF938F Erasing Substrings
字典序最优化问题可以考虑逐位贪心。
我们假设 dpi,jdp_{i,j} 表示现在枚举到了答案第 ii 个字符，然后我们已经用掉了二进制 jj 的段。
我们发现这个题最有趣的一点是，你状压之后每个 dp 的位置可以恰好对应一个状态。我们只需要做 ii 轮，每一轮对 dpi,jdp_{i,j} 的 0/10/1 去求值就好了。
我们发现，dpi,jdp_{i,j} 为 11 当且仅当存在一个 dpi−1,?dp_{i-1,?}  可以转移且 ai+ja_{i+j} 为可以转移到的位置的字典序最小值。
然后我们考虑去用 SOSdp 对 dpi−1,0∼2k−1dp_{i-1,0 \sim 2^k-1} 去拉可能，然后挨个判断即可。
CF135E Weak Subsequence
性质是，最长的弱串是一个前缀或后缀，反证法可证明。[1,i][1,i] 是最长弱串的一个必要性质是，sis_i 在 (i,n](i,n] 中出现且 (i,n](i,n] 中无重复字符。分讨，要么减掉算重算多的部分，要么将必要性转为充要性。
由最长弱串的必要性可以想到，枚举 ss 前后缀无重复字符的长度为 ii，钦定这样的前后缀一定有一个紧挨着最长弱串。讨论即可。
CF1055F Tree and XOR
树上路径异或要差分，这样的话路径异或就转成了两点异或，这个问题就转换到了序列上。
异或还要想到 0/1Trie。 将所有数插入 0/1Trie，考虑贪心地从高位到低位考虑答案，因为只要高位较大，低位就不用考虑了。接下来对于每个位，决策往 00 走还是往 11 走就解决了。
CF1879F Last Man Standing
TBD.
CF1943D2 Counting Is Fun (Hard Version)
如果没有 l<rl<r 的限制一定有解，于是我们考虑这个条件到底带来了什么性质。
显然，如果存在 ii 满足 ai>ai−1+ai+1a_i > a_{i-1} + a_{i+1}，则必定无解。
计数 ai≥ai−1−ai−2a_i \geq a_{i-1} - a_{i-2}，一个做法是设 fi,x,yf_{i,x,y} 表示前 ii 个位置中位置 ii 是 xx 且 i−1i-1 是 yy 的方案数，过不了。继续找性质，发现一个重要性质：不合法的位置不会相邻。所以我们可以直接从 i−2i-2 转移而不用考虑 i−3i-3，设 fi,jf_{i,j} 表示考虑到第 ii 个数，末尾是 jj。
fi,j←∑fi−1−∑x=0fi−2,x×(k−j−x)f_{i,j} \gets \sum f_{i-1} - \sum_{x=0} f_{i-2,x} \times (k-j-x)
CF1942G Bessie and Cards
首先，“抽 11 张”卡是无用的，我们可以忽略掉。其次打法也不重要，抽到就可以打。特殊卡可以看成“抽 00 卡”。
00 张和 22 张可以分别看成 +1+1 和 −1-1，容易想到括号序列，然后初始有 55 次。括号序列可以转化为格路计数。
记 f(x,y)f(x,y) 表示抽了 xx 张 00，yy 张 22 的方案数，转化为每次向上或向右走一格，也就是从 (0,4)(0,4) 走到 (x,y+4)(x,y+4) 且不跨越 y=xy=x，不合法的方案等价于走到 (y+5,x−1)(y+5,x-1)，得到 f(x,y)=(x+yy)−(x+yy+5)f(x,y) = \binom{x+y}{y} - \binom{x+y}{y+5}。
对于正好选了 x+5x+5 张 00 和 xx 张 22 的情况，因为最后一次一定是 00，直接去除最后一次的贡献，等价于从 (0,4)(0,4) 走到 (x+4,x+4)(x+4,x+4)，对答案的贡献为 f(x+4,x)×(x+5x)×(a+c−2×xa−x)f(x+4,x) \times \binom{x+5}{x} \times \binom{a+c-2 \times x}{a-x}。
类似地，对于全抽完的情况，贡献是 f(a+5,c)×(a+55)f(a+5,c) \times \binom{a+5}{5}。
最后全部加起来，除以总方案数 (a+c+5a,c,5)\binom{a+c+5}{a,c,5}。
CF1852C Ina of the Mountain
TBD.
CF1990E2 Catch the Mole(Hard Version)
TBD.
CF1917F Construct Tree
做法大概是找几条性质，有点复杂。
首先给 ll 从小到大排序。
  • 性质 1：如果序列最大的两个值的和大于 dd（即 ln+ln−1>dl_n + l_{n - 1} > d），则一定无解。
    证明：一定存在一条跨过这两条边的路径，使得这条路径的和大于 dd。
  • 性质 2：如果存在 ll 的一个子集 SS，使得 SS 的和为 dd，并且 ll 的最大值在 SS 集合内（即存在 S⊆l,∑i∈Sli=d,n∈SS \subseteq l,\sum\limits_{i \in S} l_i = d,n \in S），则一定有解。
    证明：可以构造一条长为 ∣S∣|S| 的链，然后把 (1,2)(1,2) 的边权设为 lnl_n，其他没有用到的边都一定有 li≤1nl_i \leq 1_n，直接把这些边连在结点 22 上即可，这些边无论怎么与已放的边组合都不会使得直径变得更大。
  • 性质 3：如果存在 ll 的两个互不相交的子集 s1,d2s1,d2 使得这两个子集的和都不小于 lnl_n，并且 s1,s2s1,s2 的和恰好为 dd（即存在 s1⊆l,s2⊆l,s1∩s2=∅,(∑i∈s1li)≥ln,(∑i∈s2li)≥ln,(∑i∈s1li)+(∑i∈s2li)=ds1 \subseteq l,s2 \subseteq l,s1 \cap s2 = \varnothing,(\sum\limits_{i \in s1} l_i) \geq l_n,(\sum\limits_{i \in s2} l_i) \geq l_n,(\sum\limits_{i \in s1} l_i)+(\sum\limits_{i \in s2} l_i) = d），则一定有解。
    证明：可以同上构造一条链，然后找到一个点 uu，使得左端点到 uu 的边权和为 ∑i∈s1li\sum\limits_{i \in s1} l_i，把剩下的边挂在 uu 上即可。
对于性质 2，直接 O(nd)O(nd) 跑一个背包即可。
对于性质 3，设 dp(i,j)dp(i,j) 表示第一个集合和为 ii，第二个集合和为 jj 是否可以得到，也可以直接跑背包，这样做是 nd2nd ^ 2 的，由于状态是 0101，可以直接用 bitsetbitset 优化，这样时间复杂度是 O(nd2w)O(\frac{nd ^ 2}{w}) 的，可以通过。
CF1363F Rotating Substrings
TBD.
CF1626F A Random Code Problem
TBD.
CF1767E Algebra Flash
TBD.
CF1858E2 Rollbacks (Hard Version)
TBD.
CF1393E2 Twilight and Ancient Scroll (harder version)
Unaccepted.
CF1809G Prediction
TBD.
CF1949J Amanda the Amoeba
TBD.
CF794E Choosing Carrot
TBD.
CF1107F Vasya and Endless Credits
TBD.
CF1863G Swaps
TBD.
CF1906B Button Pressing
TBD.
CF1893D Colorful Constructive
TBD.
CF1392G Omkar and Pies
Unaccepted.
CF1731F Function Sum
TBD.
CF1834F Typewriter
我们先考虑单次答案求的到底是什么。根据题意，往右移动是无代价的，而往左移则需要 11 的代价。
那单次答案就是需要往左移动的元素个数。
Ans=∑i=1n[pi<i]Ans = \sum_{i=1}^{n} [p_{i} < i]
接下来我们引入移动与翻转操作。有个很妙的点是，加上这两种操作，排列也只有 2×n2 \times n 种情况，我们完全可以预处理出来，后面维护一个偏移量和一个翻转标志，最后只需 O(1)O(1) 查询答案。下述偏移量均为向右移动时的偏移量。
先来看没翻转的情况。显然，我们只需要算出一个元素对答案的哪些区间有所贡献。
设 vv 表示当前元素 pip_{i}，我们希望它对答案有贡献，即要求它的值小于它的新位置。
v<new_pos  ⟹  new_pos∈[v+1,n]v < new\_pos \implies new\_pos \in [v + 1, n]
这样的有效位置有 n−(v+1)+1n-(v+1)+1 也就是 n−vn-v 个。
贡献开始的偏移量就是 vv 这个元素移到 v+1v+1 这个位置需要的步数，注意考虑循环。
S=(v+1−i+n)(modn)S = (v + 1 - i + n) \pmod n
这一块不用写树状数组什么的，维护答案数组的差分数组，每次直接在端点加减即可，最后做前缀和。注意判一下，如果贡献区间的右端点 r≥nr \ge n 了，那需要把溢出的一部分放到左边去。
翻转过来也是一样的。
对于移动操作，算新的偏移量就可以。注意第三个操作，更新翻转标志以后，偏移量也是随之变化了的，具体的式子写在下面了。
offset=(n−offset)(modn)offset = (n - offset) \pmod n
复杂度线性。
CF1788F XOR, Tree, and Queries
TBD.
CF1827D Two Centroids
TBD.
CF1422E Minlexes
TBD.
CF1949D Funny or Scary?
TBD.
CF1842F Tenzing and Tree
TBD.
CF989E A Trance of Nightfall
Unaccepted.
CF1421E Swedish Heroes
TBD.
CF1799G Count Voting
TBD.
CF1808E3 Minibuses on Venus (hard version)
Unaccepted.
CF1956E2 Nene vs. Monsters (Hard Version)
TBD.
CF1814F Communication Towers
TBD.
CF627D Preorder Test
TBD.
CF1906C Cursed Game
肯定不能瞎构造，最好的方法就是直接找到哪些地方有孔。这个其实很好找，输出一个仅在 (3,3)(3,3) 为 11 的矩阵就行了。
知道哪些地方有孔以后就好针对性构造了。我们可以直接对每个 (i,j)(i,j) 算一下目前答案，如果不合法，我们去修正坐标字典序最大的一个孔，这样由于后面的格子在前面的窗口对应更靠后的孔坐标（超越了最大孔），就绝对不会破坏已经修好的前面窗口的奇偶性。
所以单次会有两个询问，绰绰有余。
这个做法在 n=3n = 3 的时候不太行，特判掉随机化一下，容易证明期望询问次数也是 22。
CF1835B Lottery
TBD.
CF1762F Good Pairs
TBD.
CF1487F Ones
TBD.
CF1775F Laboratory on Pluto
TBD.
CF1884E Hard Design
Unaccepted.
CF1758F Decent Division
Unaccepted.
CF1019D Large Triangle
TBD.
CF888F Connecting Vertices
TBD.
CF1763F Edge Queries
TBD.
CF1764H Doremy’s Paint 2
Unaccepted.
CF1028F Make Symmetrical
TBD.
CF1178F2 Long Colorful Strip
TBD.
CF1753D The Beach
TBD.
CF2181G Greta’s Game
TBD.
CF2030F Orangutan Approved Subarrays
TBD.
CF2107F2 Cycling (Hard Version)
超出我的知识范围了。
CF2181E Elevator Against Humanity
Unaccepted.
CF1837F Editorial for Two
TBD.
CF1661F Teleporters
Unaccepted.
CF1374E2 Reading Books (hard version)
Unaccepted.
CF2176E Remove at the lowest cost
Unaccepted.
CF1771F Hossam and Range Minimum Query
奇偶性往两个方向想，一个是 bitset，一个是异或哈希。
板子题，将每个数赋一个随机 hash 值，主席树上二分。
CF1870F Lazy Numbers
Unaccepted.
CF1082F Speed Dial
Unaccepted.
CF1874C Jellyfish and EVA
设 fuf_u 为最优情况下 uu 走到 nn 的概率。
显然从 nn 开始倒推，再设 pu→vp_{u \to v} 表示 uu 到 vv 的概率，我们显然有如下式子。
fu=∑(u,v)∈Efv×pu→vf_u = \sum_{(u,v) \in E} f_v \times p_{u \to v}
pu→vp_{u \to v} 还能再拆。贪心地，对于一个节点的所有出边，优先选概率大的。设 gi,jg_{i,j} 表示在一个出度为 ii 的点走第 jj 优点的概率。
gg 显然是可以预处理的，于是就做完了。具体地，初始条件为 gi,1=1ig_{i,1} = \frac{1}{i}，其他情况下我肯定选最优边，根据对方选的边，得到转移 gi,j=gi−2,j−1×i−ji+gi−2,j−2×j−2ig_{i,j} = g_{i-2,j-1} \times \frac{i-j}{i} + g_{i-2,j-2} \times \frac{j-2}{i}。
]]>
    
    https://gavin-blog.pages.dev/2026/%E6%88%91%E4%B9%9F%E4%B8%8D%E7%9F%A5%E9%81%93%E6%88%91%E5%9C%A8%E6%80%BB%E9%9B%86%E4%BB%80%E4%B9%88%E4%BD%86%E6%80%BB%E4%B9%8B-2026-%E9%A2%98%E7%9B%AE%E6%80%BB%E9%9B%86/
    
    2026-04-01T00:26:00.000Z
    
      CF573D Bear and Cavalry

总之我只会 
    
    
    
    
    
      
本文假定您有基础的 Web 知识，不会对某些概念进行说明。
JWT 是什么？
JWT，全称是 JSON Web Token，可是说是当下最流行的一种跨域的认证方案。
1
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJHYXZpbiIsImlhdCI6MTc3NDk3MDgyMywiZXhwIjoxNzc0OTc0NDIzfQ.M1tneo2EbPuE5QLdDkGNJk0V9QQ2-ZOXYyRqqID5HH3mUqec4DHQsinG5F_ovDdKlsNeyg1vDnN5vDMf_tEocHIHiBCsfX14YuCWb6lRZ9prJkbfJHXwqGu94yPskGo5dfX7_D_lmNznAOloFK_0GEvhpNmIBrwe9bw0drRRTH8BPKmR_xscCSKT-mQxfbgXGSfKohxPnjhl9PZVnXe5q_2D5cVu3PIr6yeOmbAI-Ju8C1U9cC0DqM4P8m53WktbjyxW2k8uSIOvVOnaNIP7y5CMTmC-pG4JYMzHCxn5uMIZqw5Fw3FHR25i2MQfk5j9bs2n28qRl-gur-RCM3lwUg
上面就是一个符合规范的 JWT，其分为三个部分，用 . 隔开，依次是 Header，Payload 与 Signature。
Header 部分是一个 JSON 对象，存储了 JWT 的 Metadata，如下面所示。
1
2
3
4
{
  "alg": "RS256",
  "typ": "JWT"
}
其中的 alg 是用来签名的算法，其中默认算法是 HS256，也就是 HMAC SHA256，这里的 RS256 则是 RSA SHA256。有关签名算法会在后文探讨。
typ 则表示 Token 的类型，JWT 都统一写成 JWT。
值得注意的是，我们最终拿到的 JWT 中这部分实际上是通过了 Base64URL 转换的。
Payload 部分解码如下。
1
2
3
4
5
{
  "sub": "Gavin",
  "iat": 1774970823,
  "exp": 1774974423
}
这里则是存放实际的数据，RFC 7519 实际上定义了七个官方字段，但我们也可以定义任何私有字段。
七个官方字段：
  • iss (issuer)：签发人
  • exp (expiration time)：过期时间
  • sub (subject)：主题
  • aud (audience)：受众
  • nbf (Not Before)：生效时间
  • iat (Issued At)：签发时间
  • jti (JWT ID)：编号
同样的，最终呈现在 JWT 中的信息经过了 Base64URL 转换。
Signature 的部分是对 Header 和 Payload 的签名。首先，指定一个（如果使用的是不对称加密算法，这里的两次应该是对）密钥，然后使用 Header 指定的加密算法将 Header.Payload 产生签名。
至此，我们就了解了一个 JWT 的组成。
注意，JWT 的 Payload 部分本身是不加密的，请勿在里面存放敏感信息。
Base64URL
前文频繁提到的 Base64URL 是 Base64 编码标准的一个变体，它的设计目的是使编码结果可以作为文件名或 URL 地址使用。在标准 Base64 字母表中包含了一些对于 URL 和文件名来说无效的字符，因此 Base64URL 进行了适当的修改以避免这些问题。
Base64URL 采用与标准 Base64 相同的算法，但在以下方面有所不同：
  • 将 + 替换为 -；
  • 将 / 替换为 _；
  • 不需要填充字符 =；
  • 禁止使用行分隔符。
如何使用 JWT？
服务端签发 JWT 后，客户端与服务端通信只要带上 JWT 即可，一种普遍的做法是将 JWT 存放于请求头的 Authorization 里。
1
Authorization: Bearer <token>
服务端收到 Token 后，只需要拿密钥验证签名即可。
结束了？
遇到跨域处理，对称性加密就没那么好用了。这个时候，我们就需要用到非对称性加密。比如上文提到的 RS256 就是一种非对称性加密，即每次生成一对公私钥，使用私钥加密，公钥验证。
身份提供服务将公钥暴露出去，其他服务端接收到来自此服务的 Token 只需要找到公钥验证即可。
暴露公钥也有相关的规范，也就是 JWK，全称 JSON Web Key。
JWK 是用于表示加密密钥的基于 JSON 的格式，其格式也有 RFC 7517 规约。
其常见参数总结如下：
  • kty：密钥类型，标识使用的签名算法，必须存在；
  • use：公钥的预期用途，例如 sig 用于签名，enc 用于加密；
  • key_ops：密钥允许的操作列表，为一个数组，可能的取值有 sign，verify 等；
  • alg：密钥对应的算法；
  • kid：密钥 ID，用于在 JWK Set 中匹配具体密钥；
视密钥签名算法而定可能有其他参数。
例如在文章一开头给出的示例中，我们的 RS256 公钥如下。
1
2
3
4
5
6
7
8
9
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArQOjkox78MYLBZEAhuOP
L2bTDulSpjl6G6qARp2/njwh+zvtHKGU63QwAhCtJS37k9rZio5tDbBmtlJwlrgw
f+UWgc7GtV9EC1Jgdwd6yGpsI8ZWs7UWH/eJDwi6NP2qbwBha7UtQyzf1cOfJk5y
lT6FyCsHGy1ssYiEK42keXd7RtuoS6C/QhfgWyf28Mwjj63TBmuOY6fZ8UPhvQCe
dmHkfW9tgWHOsz3qI5vKrY9MifDnh1wU6k6/A9MtXAKHd95aBEjHzF+y1rAly+rE
ZnefLvt/gvIqaoa0Yy2VpKqTSu17u+AoyDskUDolIN55w/2Z7OQR/8poHKTOSpwF
9wIDAQAB
-----END PUBLIC KEY-----
其对应的 JWK 则为下面所示。
1
2
3
4
5
6
7
8
9
{
    "kty": "RSA",
    "key_ops": ["verify"],
    "n": "vumBc5W0z-bDNVf-z_qR2qoey9EXp3YhsWCGBjbxxjfJvDUT9ptqENCxAOh4uZlAjWOkkUa0Ako104cY5A4myvrJbuxbLai7oknq6d5pBZxYJHlA5XroQ2vfDe3mcHUePcMIsSMo-hZQ5bcTvKxGW2idKuPWUxAUtnkxZgjF9uzh3IqpFHyZ5swN4zCZ89JLGUb7Vzb5bthziqm71cXpDQPx-RvJZ47DAQfioMplogRAh_VdnVPRknHxABbn9eTR_OhcxdhGTPSb4Bz-1iagZydyID4CPYOYRY9Y_7-q4c_zx1b-M8HHWmFpI3quN21N42LvAJK6nL7hGCQrm9m9lQ",
    "e": "AQAB",
    "kid": "key-H-_edi7gYRGFhkfiFHpUpw",
    "alg": "RS256",
    "use": "sig"
}
这里的 kid 是通过提取公钥的 DER 字节流，计算 SHA-256 哈希，然后转成 URL 安全的 Base64 字符串作为唯一的 kid。笔者查询了一下，并没有发现通用的 kid 生成规则，暂且这么办吧。
当需要将多个 JWK 组合在一起时，它们会被组织成一个 JSON Web 密钥 Set (JWKS)，仅包含上述 JWK 的 JWKS 如下面所示。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
  "keys": [
    {
      "kty": "RSA",
      "key_ops": [
        "verify"
      ],
      "n": "vumBc5W0z-bDNVf-z_qR2qoey9EXp3YhsWCGBjbxxjfJvDUT9ptqENCxAOh4uZlAjWOkkUa0Ako104cY5A4myvrJbuxbLai7oknq6d5pBZxYJHlA5XroQ2vfDe3mcHUePcMIsSMo-hZQ5bcTvKxGW2idKuPWUxAUtnkxZgjF9uzh3IqpFHyZ5swN4zCZ89JLGUb7Vzb5bthziqm71cXpDQPx-RvJZ47DAQfioMplogRAh_VdnVPRknHxABbn9eTR_OhcxdhGTPSb4Bz-1iagZydyID4CPYOYRY9Y_7-q4c_zx1b-M8HHWmFpI3quN21N42LvAJK6nL7hGCQrm9m9lQ",
      "e": "AQAB",
      "kid": "key-H-_edi7gYRGFhkfiFHpUpw",
      "alg": "RS256",
      "use": "sig"
    }
  ]
}
一般，我们使用 /.well-known/jwks.json 暴露 JWKS。
一些小技巧
阮一峰老师的博客写了几条 JWT 相关的特点，可以看看。
对于强制过期以前的 Token，我的选择是在服务端存一个 token_version，每次强制下线时只需把这个版本改掉，接收的 JWT 直接与这个比对就行。但这样不好跨站？需要研究下。
完结撒花 o(￣▽￣)ブ
]]>
    
    https://gavin-blog.pages.dev/2026/%E6%B5%85%E8%B0%88-jwt-json-web-tokens/
    
    2026-03-31T16:40:00.000Z
    
      

本文假定您有基础的 Web 知识，不会对某些概念进行说明。



JWT 是什么？


JWT，全称是 JSON Web Token，可是说是当下最流行的一种跨域的认证方案。



    

    浅谈 JWT (JSON Web Tokens)
    2026-03-31T16:40:00.000Z
  
  
    
      Gavin
    
    
    
    
      Round 1
结合题目名的 Link，观察题目链接 132-submit_haunt。
提交 haunt 即可。
I Know That One
都是一些英文的 Riddle 也就是字谜，先把题面凑出来（直接去搜）。
括号内逗号前面表示答案的单词数量，比如 a chicken 对应的就是 1 7，逗号后的数字是字谜答案中取第几个字母，不算空格。
把所有字母拼起来还是个字谜，答案是 towel。
Wordles
把题面给的 Wordle 依次打出来，拿到了五段 Hint。
1
2
3
4
5
First fifth: AEEFSW
Second fifth: INOV
Third fifth: AERRTS
Fourth fifth: DHNRS
Fifth fifth: EILST
下面那个看似是一个 Wordle 盘面，实际上是一个 dropquote。
把每个词竖着放到相应的列里，跳过黑色格子，然后按照 dropquote 的规则，将每列重排序。
最后的结果如下。
1
2
3
4
5
6
ANS/I
S/THE
FIRST
EVER/
WORDL
E/ANS
去找第一个 Wordle，答案为 cigar。
Scrabbling for an Answer
模拟题，用 https://www.thewordfinder.com/board-solver/scrabble/ 来就行。
最后依次读取中心格左侧的字母、中心格左侧第三格的字母、棋盘最南端的字母、棋盘最北端的字母以及棋盘最东端的字母，即可得到 dunes。
I Lost
ILOST 五个字母都有对应的方块样式。
具体可以看这张。
然后对于每个部分，其上方的字母标记了目标块，下方的 topmost 等具体到了目标块的哪个格子。
然后直接从上方的字母开始按字母表往下填，填完了从 A 循环，拼起来得到 magic。
[Meta] Tapping in
通过标题容易想到 Tap Code，但这是后文了。
把前五个谜题按字典序排序，将给出的 DE 解读为 (4,5)，以此类推。
将每个坐标的字母拼起来，得到 chant。
Interlude Puzzle I
下方的密文中，数字部分提取出来去掉循环节为 13 15 18 19 05，也就是 morse。
这提示我们需要使用摩尔斯电码解码去掉数字的密文。
解码结果为 N U M B E R S A R T I C L E S E N D M A R K S E N D M A R，分一下词即为 numbers articles endmarks endmarks。
因此，分别对文章内的数字、冠词以及终止符进行计数并转为英文，答案为 doll。
Round 2
Nutrimatic Can’t Save You
根据题目名，先把前三行丢进 Nutrimatic，得到 the answer is。
下面几行用 nutrimatic 就行不通了，注意到 TRANSMISSION BROKEN 行的其他字符是摩尔斯电码，进行解码，第一个结果为 BUTQATMIGHT，这指示我们可以使用 Qat 解码。
同理，后面几个解密工具依次是 quipqiup，Wordle Solver，最后返回 Nutrimatic。
最后完整的话为 the answer is a word where the percentage of vowels in the word is the same as its synonym in this puzzles title，翻成简中是“答案是一个单词，其中元音字母的百分比与本谜题标题中同义单词的元音字母百分比相同”。
至于最后两行，结合之前的解密经验，感性理解一下，大致意思是 a word that starts [with] a consonant letter，也就是“一个辅音字母开头的单词”。
最终答案为标题中 save 对应的 rescue。
]]>
    
    https://gavin-blog.pages.dev/2026/flatdurian-hunt-%E4%B8%AA%E4%BA%BA%E9%A2%98%E8%A7%A3/
    
    2026-03-24T03:52:00.000Z
    
      Round 1


结合题目名的 Link，观察题目链接 132-submit_haunt。


提交 haunt 即可。

<]]>
    
    FlatDurian Hunt 个人题解
    2026-03-24T16:07:00.000Z
  
  
    
      Gavin
    
    
    
    
      exgcd 求解逆元
1
2
3
// ax%b==1
exgcd(a,b,x,y);
ans = (x+b)%b;
Miller-Rabin 素性测试 & Pollard-Rho
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include <random>

const int TEST_TIME=16;
random_device rd;
mt19937_64 gen(rd());

ll bmul(ll a,ll b,ll m){
  ull c=(ull)a*(ull)b-(ull)((ld)a/m*b+0.5L)*(ull)m;
  if(c<(ull)m){
      return c;
  }
  return c+m;
}

ll qpow(ll a,ll b,ll P){
    ll res=1;
    while(b>0){
        if(b&1){
            res = bmul(res,a,P);
        }
        a = bmul(a,a,P);
        b >>= 1;
    }
    return res;
}

bool MillerRabin(ll n){
    if(n<2){
        return false;
    }
    if(n==2||n==3){
        return true;
    }

    ll u=n-1,t=0;
    while(u%2==0){
        u /= 2;
        t++;
    }

    uniform_int_distribution<ll> dist(0,n-4);

    for(int i=1;i<=TEST_TIME;i++){
        ll a=dist(gen)+2,v=qpow(a,u,n),s=0;
        if(v==1){
            continue;
        }
        for(s=0;s<t;s++){
            if(v==n-1){
                break;
            }
            v = bmul(v,v,n);
        }
        if(s==t){
            return false;
        }
    }

    return true;
}

ll gcd(ll a,ll b){
    return b==0?a:gcd(b,a%b);
}

ll PollardRho(ll x){
    ll s=0,t=0,c=uniform_int_distribution<>(0,x-2)(gen)+1,val=1;

    for(int gl=1;;gl*=2,s=t,val=1){
        for(int stp=1;stp<=gl;stp++){
            t = (bmul(t,t,x)+c)%x;
            val = bmul(val,abs(t-s),x);
            if((stp%127)==0){
                ll d=gcd(val,x);
                if(d>1){
                    return d;
                }
            }
        }
        ll d=gcd(val,x);
        if(d>1){
            return d;
        }
    }
}

ll mxfac;
void maxFac(ll x,bool fst=true){
    if(fst){
        mxfac = 0;
    }

    if(x<=mxfac||x<2){
        return;
    }

    if(MillerRabin(x)){
        mxfac = max(mxfac,x);
        return;
    }

    ll p=x;
    while(p>=x){
        p = PollardRho(x);
    }
    while((x%p)==0){
        x /= p;
    }

    maxFac(x,false);
    maxFac(p,false);
}

#include <vector>

vector<ll> facs;
void getFacs(ll x,bool fst=true){
    if(fst){
        facs.clear();
    }

    if(x==1){
        return;
    }

    if(MillerRabin(x)){
        facs.push_back(x);
        return;
    }

    ll p=x;
    while(p==x){
        p = PollardRho(x);
    }

    getFacs(p,false);
    getFacs(x/p,false);
}
CRT & exCRT
CRT
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void exgcd(ll a,ll b,ll &x,ll &y){
    if(b==0){
        x = 1;
        y = 0;
    }
    else{
        exgcd(b,a%b,y,x);
        y -= a/b*x;
    }
}

ll crt(int k,ll* a,ll* r){
    ll n=1,ans=0;
    for(int i=1;i<=k;i++){
        n = n*a[i];
    }
    for(int i=1;i<=k;i++){
        ll m=n/a[i],b,y;
        exgcd(m,a[i],b,y);
        ans = (ans+r[i]*m*b%n)%n;
    }
    return (ans%n+n)%n;
}
exCRT
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/******************************
 - @GavinCQTD / 2026-03-13 15:12:07
 - "P4777 【模板】扩展中国剩余定理（EXCRT）" From Luogu
 - # https://www.luogu.com.cn/problem/P4777
 - 1000 ms / 500 MB
******************************/

#include <iostream>
#include <cassert>
using namespace std;
using ll = __int128_t;
using ull = unsigned long long;
using ld = long double;

ll n,a[100005],b[100005],A=1,B;

ll exgcd(ll a,ll b,ll &x,ll &y){
    if(b==0){
        x = 1;
        y = 0;
        return a;
    }
    else{
        ll res=exgcd(b,a%b,y,x);
        y -= a/b*x;
        return res;
    }
}

// FastIO...

int main(){
    read(n);
    for(int i=1;i<=n;i++){
        read(a[i],b[i]);
        b[i] %= a[i];

        ll x,y,gres=exgcd(A,a[i],x,y);
        // (B-r[i])%gres!=0: No solution
        x = (B-b[i])/gres*x;
        B = B-A*x;
        A = a[i]/gres*A;
        B = (B%A+A)%A;
    }

    put((B%A+A)%A);

    return 0;
}
Lagrange Interpolation
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <vector>

ll qpow(ll a,ll b,ll P){
    ll res=1;
    while(b>0){
        if(b&1){
            res = res*a%P;
        }
        a = a*a%P;
        b >>= 1;
    }
    return res;
}

ll inv(ll a,ll P){
    return qpow(a,P-2,P);
}

vector<int> lagrangeInterpolation(const vector<int> &x,
                                  const vector<int> &y,
                                  ull P){
    int n=x.size();
    vector<int> M(n+1),px(n,1),f(n);
    M[0] = 1;

    for(int i=0;i<n;i++){
        for(int j=i;j>=0;j--){
            M[j+1] = (M[j]+M[j+1])%P;
            M[j] = (ll)M[j]*(P-x[i])%P;
        }
    }

    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(i!=j){
                px[i] = (ll)px[i]*(x[i]-x[j]+P)%P;
            }
        }
    }

    for(int i=0;i<n;i++){
        ll t=(ll)y[i]*inv(px[i],P)%P,k=M[n];
        for(int j=n-1;j>=0;j--){
            f[j] = (f[j]+k*t)%P;
            k = (M[j]+k*x[i])%P;
        }
    }

    return f;
}
Lucas & exLucas
Lucas实现1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
ll qpow(ll a,ll b,ll P){
    ll res=1;
    while(b>0){
        if(b&1){
            res = res*a%P;
        }
        a = a*a%P;
        b >>= 1;
    }
    return res;
}

ll inv(ll a,ll P){
    return qpow(a,P-2,P);
}

ll fac[100005],ifac[100005];

void init(int P){
    fac[0] = 1;
    for(int i=1;i<P;i++){
        fac[i] = fac[i-1]*i%P;
    }
    ifac[P-1] = inv(fac[P-1],P);
    for(int i=P-1;i>=1;i--){
        ifac[i-1] = ifac[i]*i%P;
    }
}

ll C(int n,int m,int P){
    if(n<m){
        return 0;
    }
    if(n<P&&m<P){
        return fac[n]*ifac[n-m]%P*ifac[m]%P;
    }
    return C(n/P,m/P,P)*C(n%P,m%P,P)%P;
}
Lucas实现2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class BinomModPrime{
    int p;
    vector<int> fac,ifac;

    int calc(int n,int k){
        if(n<k){
            return 0;
        }
        ll res=fac[n];
        res = (res*ifac[k])%p;
        res = (res*ifac[n-k])%p;
        return res;
    }

public:
    BinomModPrime(int p):p(p),fac(p),ifac(p){
        fac[0] = 1;
        for(int i=1;i<p;i++){
            fac[i] = (ll)fac[i-1]*i%p;
        }
        ifac[p-1] = p-1;
        for(int i=p-1;i>=1;i--){
            ifac[i-1] = (ll)ifac[i]*i%p;
        }
    }

    int binomial(ll n,ll k){
        ll res=1;
        while(n>0||k>0){
            res = (res*calc(n%p,k%p))%p;
            n /= p;
            k /= p;
        }
        return res;
    }

    int operator()(const ll &n,const ll &k){
        return binomial(n,k);
    }
};
exLucas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <vector>

void exgcd(int a,int b,int &x,int &y){
    if(b==0){
        x = 1;
        y = 0;
    }
    else{
        exgcd(b,a%b,y,x);
        y -= a/b*x;
    }
}

int inv(int a,int P){
    int x,y;
    exgcd(a,P,x,y);
    return (x%P+P)%P;
}

int crtCoeff(int mi,int m){
    ll mm=m/mi;
    mm *= inv(mm,mi);
    return mm%m;
}

class BinomModPrimePower{
    int p,a,pa;
    vector<int> f;

    ll nu(ll n){
        ll cnt=0;
        do{
            n /= p;
            cnt += n;
        }while(n>0);
        return cnt;
    }

    ll factMod(ll n){
        bool neg=(p!=2)||(pa<=4);
        ll res=1;
        while(n>1){
            if((n/pa)&neg){
                res = pa-res;
            }
            res = res*f[n%pa]%pa;
            n /= p;
        }
        return res;
    }

public:
    BinomModPrimePower(int p,int a,int pa):p(p),a(a),pa(pa),f(pa){
        f[0] = 1;
        for(int i=1;i<pa;i++){
            f[i] = i%p!=0?(ll)f[i-1]*i%pa:f[i-1];
        }
    }

    int binomial(ll n,ll k){
        ll v=nu(n)-nu(n-k)-nu(k);
        if(v>=a){
            return 0;
        }
        auto res=factMod(n-k)*factMod(k)%pa;
        res = factMod(n)*inv(res,pa)%pa;
        for(;v!=0;v--){
            res *= p;
        }
        return res%pa;
    }
};

class BinomMod{
    int m;
    vector<BinomModPrimePower> bp;
    vector<ll> crtM;

public:
    BinomMod(int n):m(n){
        for(int p=2;p*p<=n;p++){
            if(n%p==0){
                int a=0,pa=1;
                for(;n%p==0;n/=p,a++,pa*=p);
                bp.emplace_back(p,a,pa);
                crtM.emplace_back(crtCoeff(pa,m));
            }
        }
        if(n>1){
            bp.emplace_back(n,1,n);
            crtM.emplace_back(crtCoeff(n,m));
        }
    }

    int binomial(ll n,ll k){
        ll res=0;
        for(size_t i=0;i!=bp.size();i++){
            res = (bp[i].binomial(n,k)*crtM[i]+res)%m;
        }
        return res;
    }

    int operator()(const ll &n,const ll &k){
        return binomial(n,k);
    }
};
原根
求解原根
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
/******************************
 - @GavinCQTD / 2026-03-23 09:25:56
 - "P6091 【模板】原根" From Luogu
 - # https://www.luogu.com.cn/problem/P6091
 - 3000 ms / 250 MB
******************************/

#include <iostream>
#include <cassert>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

#include <bitset>
#include <vector>
#include <random>

random_device rd;
mt19937_64 gen(rd());

ll randint(ll l,ll r){
    return uniform_int_distribution<ll>(l,r)(gen);
}

vector<ll> prms;

ll qpow(ll a,ll b,ll P){
    ll res=1;
    while(b>0){
        if(b&1){
            res = res*a%P;
        }
        a = a*a%P;
        b >>= 1;
    }
    return res;
}

void pri(ll x){
    prms.clear();
    for(ll i=2;i*i<=x;i++){
        if(x%i==0){
            prms.push_back(i);
            while(x%i==0){
                x /= i;
            }
        }
    }
    if(x>1){
        prms.push_back(x);
    }
}

ll phi(ll x){
    pri(x);
    for(ll i:prms){
        x = x/i*(i-1);
    }
    return x;
}

bitset<1000005> u,v;

int T,n,d;

void solve(){
    u.set();
    v.reset();

    cin >> n >> d;

    int m=phi(n),g=0;
    pri(m);

    for(int i=1,r;i<=200;i++){
        r = randint(1,n-1);
        if(qpow(r,m,n)==1){
            bool flg=true;
            for(ll j:prms){
                if(qpow(r,m/j,n)==1){
                    flg = false;
                    break;
                }
            }
            if(flg){
                g = r;
                break;
            }
        }
    }

    if(g==0){
        cout << "0\n\n";
        return;
    }

    for(ll i:prms){
        for(ll j=1;j<i&&i*j<=n;j++){
            u[i*j] = false;
        }
    }

    for(ll i=1;i<=n;i++){
        for(ll j:prms){
            if(j>i||i*j>n){
                break;
            }
            u[i*j] = false;
            if(i%j==0){
                break;
            }
        }
    }

    for(ll i=1,p=g;i<=n;i++,p=p*g%n){
        if(u[i]){
            v[p] = 1;
        }
    }

    vector<int> ans;
    for(ll i=1;i<=n;i++){
        if(v[i]){
            ans.push_back(i);
        }
    }

    cout << ans.size() << "\n";
    for(ll i=1;i<=(int)ans.size()/d;i++){
        cout << ans[i*d-1] << " ";
    }
    cout << "\n";
}

int main(){
    cin >> T;

    for(int i=1;i<=T;i++){
        solve();
    }

    return 0;
}
原根判定
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/******************************
 - @GavinCQTD / 2026-03-23 11:20:46
 - "Primitive Root" From SPOJ - Classical
 - # https://www.spoj.com/problems/PROOT/en/
 - 1000 ms / 1536 MB
******************************/

#include <iostream>
#include <cassert>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

#include <bitset>
#include <vector>

bitset<100005> ntp;
vector<int> prms;

void init(){
    for(int i=2;i<=1e5;i++){
        if(!ntp[i]){
            prms.push_back(i);
        }
        for(int pj:prms){
            if(i*pj>1e5){
                break;
            }
            ntp[i*pj] = true;
            if(i%pj==0){
                break;
            }
        }
    }
}

ll qpow(ll a,ll b,ll P){
    ll res=1;
    while(b>0){
        if(b&1){
            res = res*a%P;
        }
        a = a*a%P;
        b >>= 1;
    }
    return res;
}

vector<int> facs;
void getf(int x){
    facs.clear();
    for(int prm:prms){
        if(x%prm==0){
            facs.push_back(prm);
        }
        while(x%prm==0){
            x /= prm;
        }
    }
}

bool check(int p,int x){
    for(int fac:facs){
        int u=(p-1)/fac,tmp=qpow(x,u,p);
        if(tmp==1){
            return false;
        }
    }
    return true;
}

int p,n;

int main(){
    init();

    while(cin>>p>>n){
        if(p==0&&n==0){
            break;
        }

        getf(p-1);
        for(int i=1;i<=n;i++){
            int x;
            cin >> x;
            cout << (check(p,x)?"YES\n":"NO\n");
        }
    }

    return 0;
}
BSGS & exBSGS
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include <unordered_map>
#include <cmath>

unordered_map<ll,ll> mp;

ll qpow(ll a,ll b,ll P){
    ll res=1;
    while(b>0){
        if(b&1){
            res = res*a%P;
        }
        a = a*a%P;
        b >>= 1;
    }
    return res;
}

ll exgcd(ll a,ll b,ll &x,ll &y){
    if(b==0){
        x = 1;
        y = 0;
        return a;
    }

    ll res=exgcd(b,a%b,y,x);
    y -= a/b*x;
    return res;
}

ll inv(ll a,ll P){
    ll x,y;
    exgcd(a,P,x,y);
    return (x%P+P)%P;
}

ll BSGS(ll a,ll b,ll P){
    if(a%P==b%P){
        return 1;
    }
    if(a%P==0&&b!=0){
        return -1;
    }

    mp.clear();

    ll uni=(ll)ceil(sqrt(P)),tmp=qpow(a,uni,P);
    mp.reserve(4*uni);

    for(int i=0;i<=uni;i++){
        mp[b] = i;
        b = b*a%P;
    }

    b = 1;

    for(int i=1;i<=uni;i++){
        b = b*tmp%P;
        if(mp.count(b)){
            return i*uni-mp[b];
        }
    }

    return -1;
}

ll exBSGS(ll a,ll b,ll P){
    a %= P;
    b %= P;

    if(b==1||P==1){
        return 0;
    }

    ll x,y,g=exgcd(a,P,x,y),k=0,tmp=1;

    while(g!=1){
        if(b%g!=0){
            return -1;
        }
        k++;
        b /= g;
        P /= g;
        tmp = tmp*(a/g)%P;
        if(tmp==b){
            return k;
        }
        g = exgcd(a,P,x,y);
    }

    ll ans=BSGS(a,b*inv(tmp,P)%P,P);
    if(ans==-1){
        return -1;
    }
    return ans+k;
}
康托展开&逆展开
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
/***************
 - @GavinCQTD
***************/

#include <iostream>
#include <cassert>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

class Fenwick{
private:
    int n;
    vector<int> tree;

    int lowbit(int x){
        return x&(-x);
    }

public:
    int query(int x){
        int ans=0;
        while(x!=0){
            ans += tree[x];
            x -= lowbit(x);
        }
        return ans;
    }

    void update(int x,int k){
        while(x<=n){
            tree[x] += k;
            x += lowbit(x);
        }
    }

    void fill(){
        for(int i=1;i<=n;i++){
            tree[i] += lowbit(i);
        }
    }

    int kth(int k){
        int ps=0,x=0;
        for(int i=(int)log2(n);i>=0;i--){
            int nxtx=x+(1<<i);
            if(nxtx<=n&&ps+tree[nxtx]<k){
                x = nxtx;
                ps += tree[x];
            }
        }
        return x+1;
    }

    Fenwick(int n_):n(n_),tree(n_+1,0){}
};

const int MOD=998244353;

ll cantor(int n,const vector<int>& a){
    Fenwick fen(n+1);
    ll fac=1,res=0;
    for(int i=n-1;i>=0;i--){
        res = (res+(ll)fen.query(a[i]-1)*fac)%MOD;
        fen.update(a[i],1);
        fac = (fac*(n-i))%MOD;
    }

    return (res+1)%MOD;
}

vector<int> revCantor(int n,ll k){
    k--;
    vector<int> lem(n);
    for(int i=1;i<=n;i++){
        lem[n-i] = k % i;
        k /= i;
    }
    Fenwick fen(n+1);
    fen.fill();
    vector<int> res(n);
    for(int i=0;i<n;i++){
        res[i] = fen.kth(lem[i]+1);
        fen.update(res[i],-1);
    }
    return res;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    if(!(cin >> T)) return 0;

    for(int i=1;i<=T;i++){
        int op, n;
        cin >> op;

        if(op==0){
            cin >> n;
            vector<int> a(n);
            for(int j=0;j<n;j++){
                cin >> a[j];
            }
            cout << solve1(n,a) << "\n";
        }

        else{
            ll rk;
            cin >> n >> rk;
            auto res=solve2(n,rk);
            for(int j=0;j<n;j++){
                cout << res[j] << " ";
            }
            cout << "\n";
        }
    }

    return 0;
}
还有一个“可重元素集的康托展开”，例题是 [HAOI2010] 计数。
高次剩余
二次剩余判别
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
ll qpow(ll a,ll b,ll P){
    ll res=1;
    while(b>0){
        if(b&1){
            res = res*a%P;
        }
        a = a*a%P;
        b >>= 1;
    }
    return res;
}

bool check(ll x,ll P){
    ll a=((x%P)+P)%P;
    if(a==0){
        return true;
    }
    return qpow(a,(P-1)/2,P)==1;
}
二次剩余
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
/******************************
 - @GavinCQTD / 2026-04-14 11:52:45
 - "P5491 【模板】二次剩余" From Luogu
 - # https://www.luogu.com.cn/problem/P5491
 - 1000 ms / 125 MB
******************************/

#include <iostream>
#include <cassert>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

#include <utility>
#include <random>

ll p,v;

struct Poly{
    ll a,b;
    Poly(ll a=0,ll b=0):a(a),b(b){}

    friend Poly operator*(const Poly &x,const Poly &y){
        return Poly((x.a*y.a+v*(x.b*y.b%p))%p,(x.a*y.b+x.b*y.a)%p);
    }
};

Poly qpow(Poly a,ll b){
    Poly res(1,0);
    while(b>0){
        if(b&1){
            res = res*a;
        }
        a = a*a;
        b >>= 1;
    }
    return res;
}

ll qpow(ll a,ll b){
    a %= p;
    ll res=1;
    while(b>0){
        if(b&1){
            res = res*a%p;
        }
        a = a*a%p;
        b >>= 1;
    }
    return res;
}

mt19937_64 gen(random_device{}());

ll cipolla(ll a,ll _p){
    p = _p;
    if(a==0){
        return 0;
    }
    else if(qpow(a,(p-1)/2)==p-1){
        return -1;
    }
    else{
        ll r;
        for(r=gen()%p;;r=gen()%p){
            if(qpow(((r*r%p-a)%p+p)%p,(p-1)/2)==p-1){
                break;
            }
        }
        v = ((r*r%p-a)%p+p)%p;
        return qpow(Poly(r,1),(p+1)/2).a;
    }
}

pair<ll,ll> getAns(ll a,ll _p){
    ll cans=cipolla(a,_p);
    if(cans<=0){
        return {cans,-1};
    }
    else{
        ll ans2=(_p-cans)%_p;
        if(ans2<cans){
            swap(cans,ans2);
        }
        return {cans,ans2};
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    int T;
    cin >> T;

    while(T--){
        int n,p;
        cin >> n >> p;

        auto [ans1,ans2]=getAns(n,p);
        if(ans1==-1){
            cout << "Hola!\n";
        }
        else if(ans1==0){
            cout << "0\n";
        }
        else{
            cout << ans1 << " " << ans2 << "\n";
        }
    }

    return 0;
}
任意模数二次剩余
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
/***************
 - @GavinCQTD
***************/

#include <iostream>
#include <cassert>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

#include <algorithm>
#include <bitset>
#include <vector>
#include <random>

using i128 = __int128_t;
const int LINEAR_LIMIT = 300000;

bitset<LINEAR_LIMIT+5> ntp;
vector<int> prms;

void init(){
    for(int i=2;i<=LINEAR_LIMIT;i++){
        if(!ntp[i]){
            prms.push_back(i);
        }
        for(int pj:prms){
            if(i*pj>LINEAR_LIMIT){
                break;
            }
            ntp[i*pj] = true;
            if(i%pj==0){
                break;
            }
        }
    }
}

ll bmul(ll a,ll b,ll P){
    ull c=(ull)a*(ull)b-(ull)((ld)a/P*b+0.5L)*(ull)P;
    if(c<(ull)P){
        return c;
    }
    return c+P;
}

ll qpow(ll a,ll b,ll P){
    a %= P;
    ll res=1;
    while(b>0){
        if(b&1){
            res = bmul(res,a,P);
        }
        a = bmul(a,a,P);
        b >>= 1;
    }
    return res;
}

ll exgcd(ll a,ll b,ll &x,ll &y){
    if(b==0){
        x = 1;
        y = 0;
        return a;
    }
    ll res=exgcd(b,a%b,y,x);
    y -= a/b*x;
    return res;
}

ll inv(ll a,ll P){
    ll x,y;
    exgcd(a,P,x,y);
    return (x%P+P)%P;
}

ll v,MOD;

struct Poly{
    ll a,b;
    Poly(ll a=0,ll b=0):a(a),b(b){}

    friend Poly operator*(const Poly &x,const Poly &y){
        return Poly((bmul(x.a,y.a,MOD)+bmul(v,bmul(x.b,y.b,MOD),MOD))%MOD
                    ,(bmul(x.a,y.b,MOD)+bmul(x.b,y.a,MOD))%MOD);
    }
};

Poly qpow(Poly a,ll b){
    Poly res(1,0);
    while(b>0){
        if(b&1){
            res = res*a;
        }
        a = a*a;
        b >>= 1;
    }
    return res;
}

const int TEST_TIME=16;
mt19937_64 gen(random_device{}());

bool MillerRabin(ll n){
    if(n<2){
        return false;
    }
    if(n==2||n==3){
        return true;
    }

    ll u=n-1,t=0;
    while(u%2==0){
        u /= 2;
        t++;
    }

    uniform_int_distribution<ll> dist(0,n-4);

    for(int i=1;i<=TEST_TIME;i++){
        ll a=dist(gen)+2,v=qpow(a,u,n),s=0;
        if(v==1){
            continue;
        }
        for(s=0;s<t;s++){
            if(v==n-1){
                break;
            }
            v = bmul(v,v,n);
        }
        if(s==t){
            return false;
        }
    }

    return true;
}

ll PollardRho(ll x){
    ll s=0,t=0,c=uniform_int_distribution<>(0,x-2)(gen)+1,val=1;

    for(int gl=1;;gl*=2,s=t,val=1){
        for(int stp=1;stp<=gl;stp++){
            t = (bmul(t,t,x)+c)%x;
            val = bmul(val,abs(t-s),x);
            if((stp%127)==0){
                ll d=gcd(val,x);
                if(d>1){
                    return d;
                }
            }
        }
        ll d=gcd(val,x);
        if(d>1){
            return d;
        }
    }
}

vector<ll> facs;
void getFacs(ll x,bool fst=true){
    if(fst){
        facs.clear();
    }

    if(x==1){
        return;
    }

    if(MillerRabin(x)){
        facs.push_back(x);
        return;
    }

    ll p=x;
    while(p==x){
        p = PollardRho(x);
    }

    getFacs(p,false);
    getFacs(x/p,false);
}

ll solve2k(ll a,ll k){
    if(a%(1ll<<k)==0){
        return 0;
    }
    a %= (1ll<<k);

    ll t=0,res=1;
    while(a%2==0){
        a /= 2;
        t++;
    }

    if((a&7)^1){
        return -1;
    }
    if(t&1){
        return -1;
    }
    k -= t;
    for(int i=4;i<=k;i++){
        res = (res+(a%(1ll<<i)-res*res)/2)%(1ll<<k);
    }
    res %= (1ll<<k);
    if(res<0){
        res += (1ll<<k);
    }
    return res<<(t>>1);
}

ll solveP(ll a,ll P){
    a %= P;
    if(qpow(a,(P-1)/2,P)==P-1){
        return -1;
    }
    ll b;
    MOD = P;
    uniform_int_distribution<ll> dist(0,P-1);
    while(true){
        b = dist(gen);
        v = (bmul(b,b,P)-a+P)%P;
        if(qpow(v,(P-1)/2,P)==P-1){
            break;
        }
    }
    ll ans=qpow(Poly(b,1),(P+1)/2).a;
    return min(ans,P-ans);
}

ll solvePK(ll a,ll k,ll p,ll mod){
    if(a%mod==0){
        return 0;
    }
    ll t=0,hmod=1;
    while(a%p==0){
        a /= p;
        t++;
        hmod *= (t&1)?p:1;
    }
    if(t&1){
        return -1;
    }
    k -= t;
    mod /= hmod*hmod;
    ll res=solveP(a,p);
    if(res==-1){
        return -1;
    }
    Poly tmp(res,1);
    v = a;
    MOD = mod;
    tmp = qpow(tmp,k);
    res = bmul(tmp.a,inv(tmp.b,MOD),MOD);
    return res*hmod;
}

ll rm[105],md[105];
ll crt(ll P){
    ll ans=0;
    for(int i=1;i<=(int)facs.size();i++){
        ans = (ans+bmul(bmul(P/md[i],inv(P/md[i],md[i]),P),rm[i],P))%P;
    }
    return ans;
}

ll solve(ll a,ll pmod){
    a %= pmod;
    ll crtp=pmod;
    getFacs(pmod);
    sort(facs.begin(),facs.end());
    facs.erase(unique(facs.begin(),facs.end()),facs.end());
    for(int i=1;i<=(int)facs.size();i++){
        ll nw=0,rmod=1;
        while(pmod%facs[i-1]==0){
            pmod /= facs[i-1];
            nw++;
            rmod *= facs[i-1];
        }
        md[i] = rmod;
        if(facs[i-1]==2){
            rm[i] = solve2k(a,nw);
        }
        else{
            rm[i] = solvePK(a,nw,facs[i-1],rmod);
        }
        if(rm[i]==-1){
            return -1;
        }
    }
    return crt(crtp);
}

int main(){
    init();

    int T;
    cin >> T;

    while(T--){
        ll a,p;
        cin >> a >> p;
        cout << solve(a,p) << "\n";
    }

    return 0;
}
N次剩余
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
/******************************
 - @GavinCQTD / 2026-04-15 10:18:45
 - "P5668 【模板】N 次剩余" From Luogu
 - # https://www.luogu.com.cn/problem/P5668
 - 2000 ms / 128 MB
******************************/

#include <algorithm>
#include <iostream>
#include <cassert>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

#include <unordered_map>
#include <numeric>
#include <random>
#include <vector>
#include <cmath>

struct PrimePower{
    int p,e,pe;
    PrimePower(int p,int e,int pe):p(p),e(e),pe(pe){}
};

auto factorize(int n){
    vector<PrimePower> res;
    for(int x=2;x*x<=n;x++){
        int e=0,pe=1;
        for(;n%x==0;n/=x,e++,pe*=x);
        if(e!=0){
            res.emplace_back(x,e,pe);
        }
    }
    if(n>1){
        res.emplace_back(n,1,n);
    }
    return res;
}

int qpow(int a,int b,int P=0){
    int res=1;
    while(b>0){
        if(b&1){
            res = (P==0?res*a:(ll)res*a%P);
        }
        a = (P==0?a*a:(ll)a*a%P);
        b >>= 1;
    }
    return res;
}

int primitiveRoot(PrimePower pp){
    vector<int> exp;
    int phi=pp.pe/pp.p*(pp.p-1);
    for(auto fac:factorize(pp.p-1)){
        exp.push_back(phi/fac.p);
    }
    if(pp.e!=1){
        exp.push_back(phi/pp.p);
    }
    int ans=0;
    bool ok=false;
    while(!ok){
        ans++;
        ok = true;
        for(int b:exp){
            if(qpow(ans,b,pp.pe)==1){
                ok = false;
                break;
            }
        }
    }
    return ans;
}

int exgcd(int a,int b,int &x,int &y){
    if(b==0){
        x = 1;
        y = 0;
        return a;
    }
    int res=exgcd(b,a%b,y,x);
    y -= a/b*x;
    return res;
}

int inv(int a,int P){
    int x,y;
    exgcd(a,P,x,y);
    return (x%P+P)%P;
}

mt19937_64 gen(random_device{}());

int nonResidue(int p,int m,int phi){
    uniform_int_distribution<> dist(1,m-1);
    while(true){
        int c=dist(gen);
        if(gcd(c,m)==1&&qpow(c,phi/p,m)!=1){
            return c;
        }
    }
    return -1;
}

int pethRootModM(int p,int e,int a,int m,int phi){
    if(m==2){
        return 1;
    }
    int s=0,r=phi,pe=qpow(p,e);
    for(;r%p==0;r/=p,s++);
    int q=pe-inv(r,pe),ans=qpow(a,((ll)q*r+1)/pe%phi,m)
        ,eta=nonResidue(p,m,phi);
    unordered_map<int,int> mp;
    int zeta=qpow(eta,r,m),xi=qpow(eta,phi/p,m),B=sqrt((s-e)*p+0.25l)+1
        ,pB=pe/B+1,po0=qpow(xi,pB,m);
    for(int j=1,po1=1;j<=B;j++){
        po1 = (ll)po1*po0%m;
        mp[po1] = j;
    }
    for(int j=0;j<s-e;j++){
        int err=(ll)qpow(ans,pe,m)*inv(a,m)%m,xihj=qpow(err,qpow(p,s-e-j-1),m);
        ll hj=0;
        for(int i=1;i<=pB;i++){
            xihj = (ll)xihj*xi%m;
            if(mp.count(xihj)!=0){
                hj = mp[xihj]*pB-i;
                break;
            }
        }
        ans = (ll)ans*qpow(zeta,phi-hj*qpow(p,j)%phi,m)%m;
    }
    return ans;
}

int kthRootModPe(int k,int a,int pe,int phi){
    a %= pe;
    if(k==0){
        return a==1?0:-1;
    }
    if(a==0){
        return 0;
    }
    int d=gcd(k,phi);
    if(qpow(a,phi/d,pe)!=1){
        return -1;
    }
    a = qpow(a,inv(k/d,phi/d),pe);
    for(int dp=2;dp*dp<=d&&dp*dp*dp*dp<pe;dp++){
        if(d%dp==0){
            int de=0;
            for(;d%dp==0;d/=dp,de++);
            a = pethRootModM(dp,de,a,pe,phi);
        }
    }
    if(d!=1){
        int dp=gcd(d,phi/d),de=0;
        if(dp!=1){
            for(;d%dp==0;d/=dp,de++);
            a = pethRootModM(dp,de,a,pe,phi);
        }
        if(d!=1){
            a = pethRootModM(d,1,a,pe,phi);
        }
    }
    return a;
}

auto calc(int g,int k,int a,int p,int pe){
    int mm=(p==2?pe/4:pe/p*(p-1)),ans=kthRootModPe(k,a,pe,mm);
    if(ans==-1){
        return vector<int>();
    }
    int d=mm/gcd(k,mm),po=qpow(g,d,pe);
    vector<int> res(mm/d);
    for(auto &x:res){
        x = ans;
        ans = (ll)ans*po%pe;
    }
    return res;
}

auto kthRootsModPe(int k,int a,PrimePower pp){
    int p=pp.p,e=pp.e,pe=pp.pe;
    a %= pe;
    if(a==0){
        int d=qpow(p,(e-1)/k+1);
        vector<int> res(pe/d);
        for(int i=0;i<pe/d;i++){
            res[i] = i*d;
        }
        return res;
    }

    int s=0;
    for(;a%p==0;a/=p,s++);
    if(s%k){
        return vector<int>();
    }
    int psk=qpow(p,s/k),pss=qpow(p,s-s/k),pes=qpow(p,e-s);
    vector<int> res;
    if(p!=2){
        int g=primitiveRoot(PrimePower(p,e-s,pes));
        res = calc(g,k,a,p,pes);
    }
    else if(pes==2){
        res.push_back(a);
    }
    else if(k&1){
        bool jd=(a%4==3);
        a = (jd?pes-a:a);
        res = calc(5,k,a,p,pes);
        if(jd){
            for(auto &x:res){
                x = pes-x;
            }
        }
    }
    else{
        if(a%4==3){
            return vector<int>();
        }
        res = calc(5,k,a,p,pes);
        int m=res.size();
        res.reserve(m*2);
        for(int i=0;i<m;i++){
            res.push_back(pes-res[i]);
        }
    }
    int m=res.size();
    res.reserve(m*pss);
    for(int j=1;j<pss;j++){
        for(int i=0;i<m;i++){
            res.push_back(res.end()[-m]+pes);
        }
    }
    for(auto &x:res){
        x *= psk;
    }
    return res;
}

auto kthRootsModM(int k,int a,int m){
    auto facs=factorize(m);
    int m0=0;
    vector<vector<int>> sols;
    for(auto pp:facs){
        sols.push_back(kthRootsModPe(k,a,pp));
        if(sols.back().empty()){
            return vector<int>();
        }
    }
    vector<int> ans;
    for(int i=0;i<(int)facs.size();i++){
        auto pp=facs[i];
        if(i==0){
            m0 = pp.pe;
            ans = sols[i];
        }
        else{
            ll m1=pp.pe*inv(pp.pe,m0),m2=m0*inv(m0,pp.pe);
            m0 *= pp.pe;
            vector<int> _ans;
            _ans.reserve(ans.size()*sols[i].size());
            for(auto x:ans){
                for(auto y:sols[i]){
                    _ans.push_back((m1*x+m2*y)%m0);
                }
            }
            ans.swap(_ans);
        }
    }
    return ans;
}

int main(){
    int T;
    cin >> T;

    while(T--){
        int n,m,k;
        cin >> n >> m >> k;
        auto ans=kthRootsModM(n,k,m);
        cout << ans.size() << "\n";
        if(ans.empty()){
            continue;
        }
        sort(ans.begin(),ans.end());
        for(auto itm:ans){
            cout << itm << " ";
        }
        cout << "\n";
    }

    return 0;
}
基于值域预处理的快速离散对数
跑得很慢，没做什么优化，就是卡着过了
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
/******************************
 - @GavinCQTD / 2026-04-15 10:35:45
 - "P11175 【模板】基于值域预处理的快速离散对数" From Luogu
 - # https://www.luogu.com.cn/problem/P11175
 - 1500 ms / 512 MB
******************************/

#include <iostream>
#include <cassert>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

#include <unordered_map>
#include <cmath>

int qpow(int a,int b,int P){
    int res=1;
    while(b>0){
        if(b&1){
            res = (ll)res*a%P;
        }
        a = (ll)a*a%P;
        b >>= 1;
    }
    return res;
}

namespace BSGS{
    unordered_map<int,int> M;
    int B,U,P,g;

    void init(int g,int P0,int B0){
        M.clear();
        B = B0;
        P = P0;
        U = qpow(qpow(g,B,P),P-2,P);
        int w=1;
        for(int i=0;i<B;i++){
            M[w] = i;
            w = (ll)w*g%P;
        }
    }

    int solve(int y){
        int w=y;
        for(int i=0;i<=P/B;i++){
            auto it=M.find(w);
            if(it!=M.end()){
                return i*B+it->second;
            }
            w = (ll)w*U%P;
        }
        return -1;
    }
}

const int MAXN = 1e7+5;

int H[MAXN],P[MAXN],H0,p,h,g,mod;
bool V[MAXN];

int solve(int x){
    if(x<=h){
        return H[x];
    }
    int v=mod/x,r=mod%x;
    if(r<x-r){
        return ((H0+solve(r))%(mod-1)-H[v]+mod-1)%(mod-1);
    }
    else{
        return (solve(x-r)-H[v+1]+mod-1)%(mod-1);
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    cin >> mod >> g;
    h = sqrt(mod)+1;

    BSGS::init(g,mod,sqrt((ll)mod*sqrt(mod)/log(mod)));
    H0 = BSGS::solve(mod-1)%(mod-1);

    H[1] = 0;
    for(int i=2;i<=h;i++){
        if(!V[i]){
            P[++p] = i;
            H[i] = BSGS::solve(i);
        }
        for(int j=1;j<=p&&P[j]<=h/i;j++){
            int p=P[j];
            H[i*p] = (H[i]+H[p])%(mod-1);
            V[i*p] = true;
            if(i%p==0){
                break;
            }
        }
    }

    int T;
    cin >> T;
    for(int i=1;i<=T;i++){
        int x;
        cin >> x;
        cout << solve(x) << "\n";
    }

    return 0;
}
基于值域预处理的快速 GCD
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <bitset>
#include <utility>

constexpr int M = 1e6;
constexpr int T = 1e3; // T = sqrt(M)

int pre[T+5][T+5],fac[M+5][3],pri[M+5],tot;
bitset<M+5> isp;

void init(){
    fac[1][0] = fac[1][1] = fac[1][2] = 1;
    for(int i=2;i<=M;i++){
        if(!isp[i]){
            fac[i][0] = fac[i][1] = 1;
            fac[i][2] = i;
            pri[++tot] = i;
        }
        for(int j=1;pri[j]*i<=M;j++){
            int tmp=pri[j]*i;
            isp[tmp] = true;
            fac[tmp][0] = fac[i][0]*pri[j];
            fac[tmp][1] = fac[i][1];
            fac[tmp][2] = fac[i][2];
            if(fac[tmp][0]>fac[tmp][1]){
                swap(fac[tmp][0],fac[tmp][1]);
            }
            if(fac[tmp][1]>fac[tmp][2]){
                swap(fac[tmp][1],fac[tmp][2]);
            }
            if(i%pri[j]==0){
                break;
            }
        }
    }

    for(int i=0;i<=T;i++){
        pre[0][i] = pre[i][0] = i;
    }
    for(int i=1;i<=T;i++){
        for(int j=1;j<=i;j++){
            pre[i][j] = pre[j][i] = pre[j][i%j];
        }
    }
}

int qgcd(int a,int b){
    int ans=1;
    for(int i=0;i<3;i++){
        int tmp=(fac[a][i]>T?(b%fac[a][i]>0?1:fac[a][i]):pre[fac[a][i]][b%fac[a][i]]);
        b /= tmp;
        ans *= tmp;
    }
    return ans;
}
]]>
    
    https://gavin-blog.pages.dev/2026/%E6%95%B0%E8%AE%BA%E6%A8%A1%E6%9D%BF/
    
    2026-03-11T00:41:00.000Z
    
      exgcd 求解逆元


    
    
    
      把排列的变换打出来找找规律，会发现对于合法的 pp，置换后的 p−1p^{-1} 都很相似。
以下是截取的几个 n=10n = 10 时的合法情况。
1
2
3
4
5
[2,1,8,9,6,5,10,3,4,7] => [2,1,8,9,6,5,10,3,4,7]
[2,1,8,9,6,5,10,4,3,7] => [2,1,9,8,6,5,10,3,4,7]
[2,1,8,9,7,6,5,3,4,10] => [2,1,8,9,7,6,5,3,4,10]
[2,1,8,9,7,6,5,4,3,10] => [2,1,9,8,7,6,5,3,4,10]
[2,1,8,9,7,10,5,3,4,6] => [2,1,8,9,7,10,5,3,4,6]
于是我们把置换环画出来，会发现只有一元环、二元环和四元环，至于证明我是真不会。
先来看一、二元，就是这两种情况。
  1. pi=ip_i = i
  2. pi=j,pj=i(i<j)p_i = j, p_j = i (i < j)
这个东西是非常能预处理的。设 fif_i 代表排列有 ii 个元素时的方案数，则 fi=fi−1+fi−2×(i−1)f_i = f_{i-1} + f_{i-2} \times (i - 1)，注意 f0=f1=1f_0 = f_1 = 1。
然后来处理四元环，四元环形如这个样子。
i→j→i+1→j+1→ii \to j \to i+1 \to j+1 \to i
其中需要保证 ∣i−j∣>1|i - j| > 1。
我们考虑直接枚举四元环的个数 tt，则我们需要在 [1,n−1][1,n - 1] 之间选出 2t2t 个数，剩下的那个 11 是为了保证 +1+1 以后不会超过 nn 的，方案数为 (n−2t2t)\binom{n-2t}{2t}。
再把这些数两两组合成二元组，不妨直接任意排列，计相邻两项是二元组，方案数为 (2t)!t!\frac{(2t)!}{t!}。
最后再把一、二元环的答案加回来。
综上，做完了。
Ans=(n−2t2t)(2t)!t!fn−4tAns = \binom{n-2t}{2t} \frac{(2t)!}{t!} f_{n - 4t}
]]>
    
    https://gavin-blog.pages.dev/2026/codeforces-1726e-almost-perfect/
    
    2026-02-26T03:38:00.000Z
    
      把排列的变换打出来找找规律，会发现对于合法的 <]]>
    
    Codeforces 1726E - Almost Perfect
    2026-02-26T03:38:00.000Z
  
  
    
      Gavin
    
    
    
          
    
                
  
]]>
    
    https://gavin-blog.pages.dev/2026/%E5%9E%83%E5%9C%BE%E7%AE%B1/
    
    2026-02-24T16:01:00.000Z
    Here's something encrypted, password is required to continue reading.
    垃圾箱
    2026-02-24T16:31:00.000Z
  
  
    
      Gavin
    
    
    
    
      感谢大神 @Swirl 指点，大家都去关注喵。
不错的题。
看到这个首先想到拉插（拉格朗日插值法，大概就是可以给任意数列找通项公式），但我们没有除法。
我们尝试简化问题，将 nn 个圆看作 nn 个圆的圆心，那么就可以把 f(x)f(x) 和 g(x)g(x) 独立来看。
我们还是往拉插方面想，其本质大概是一堆函数相加，每个都是下面这种形式。
f(x)={b,x=a0,x≠af(x) =\begin{cases}b, & x = a \\0, & x \neq a\end{cases}
那把这个函数构造出来就没问题了。
这貌似是整题最难的部分，经过 Gemini 老师的指点，令 k=b2k = \frac{b}{2}，我们得到了下面这个简短的式子。
f(x)=k×( ∣ ∣x−a∣−1 ∣−∣x−a∣+1 )f(x) = k \times ( \ | \ |x - a| - 1 \ | - |x - a| + 1 \ )
问题来了，根据题意，kk 只能为整数，这显然会在 bb 为奇数时坠机。
但我们注意到 2≤r2 \le r，所以我们直接除以 22 向下取整，差出来的 11 是能接受的，那就没问题了。
因为加法外面要打括号，建议写成往两边递归，不然实在有点难写了。
按习惯来说，spj 题我一般会挂上个 spj 用来自查，但这个东西实在难实现了，就咕咕了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/******************************
 - @GavinCQTD
 - "C. Beautiful Function"
 - # https://codeforces.com/problemset/problem/593/C
 - 2000 ms
******************************/

#include <iostream>
#include <cassert>
#include <string>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

int n,x[55],y[55];

string solve(int a[],int l,int r){
    if(l==r){
        // (k*(abs((abs((t−a))−1))−(abs((t−a))−1)))
        return "("+to_string(a[l]/2)+"*(abs((abs((t-"+to_string(l)
            +"))-1))-(abs((t-"+to_string(l)+"))-1)))";
    }
    int mid=(l+r)/2;
    return "("+solve(a,l,mid)+"+"+solve(a,mid+1,r)+")";
}

int main(){
    cin >> n;
    for(int i=1;i<=n;i++){
        int r;
        cin >> x[i] >> y[i] >> r;
    }

    cout << solve(x,1,n) << "\n" << solve(y,1,n) << "\n";

    return 0;
}
upd:
还是丢个 Python 写的 spj 在这，要用的自取，直接运行就好。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
import sys


def readData():
    print("Input data:")
    n = int(sys.stdin.readline().strip())

    circles = []
    for _ in range(n):
        parts = list(map(int, sys.stdin.readline().split()))
        if len(parts) == 3:
            xi, yi, ri = parts
            circles.append((xi, yi, ri))

    print("\nInput f(t):")
    f = sys.stdin.readline().strip()

    if len(f) > 100*n:
        print("f(t) is too long.")
        sys.exit(1)

    if f.count("*") > 50:
        print("f(t) contains too many multiplications.")
        sys.exit(1)

    print("\nInput g(t):")
    g = sys.stdin.readline().strip()

    if len(g) > 100*n:
        print("g(t) is too long.")
        sys.exit(1)

    if g.count("*") > 50:
        print("g(t) contains too many multiplications.")
        sys.exit(1)

    return circles, f, g


def generatePoints(f, g):
    points = []

    for t in range(51):
        x = eval(f, {"t": t})
        y = eval(g, {"t": t})
        points.append((x, y))

    return points


def main():
    circles, f, g = readData()

    points = generatePoints(f, g)

    print("\nGenerated points:")
    for t, (x, y) in enumerate(points):
        print(f"t={t}: ({x}, {y})")

    for t, (x, y) in enumerate(points):
        if not (-10**9 <= x <= 10**9 and -10**9 <= y <= 10**9):
            print(f"Point at t={t} ({x}, {y}) is out of bounds.")
            sys.exit(1)

    valid_circles = [False] * len(circles)

    print("\nCircles containing points:")
    for i, (xi, yi, ri) in enumerate(circles):
        for t, (x, y) in enumerate(points):
            if (x - xi) ** 2 + (y - yi) ** 2 <= ri**2:
                valid_circles[i] = True
                print(
                    f"Circle {i} contains point at t={t} ({points[t][0]}, {points[t][1]}), dis: {((x - xi) ** 2 + (y - yi) ** 2) ** 0.5:.2f}"
                )

    print("\nResult:")
    for i, valid in enumerate(valid_circles):
        if not valid:
            print(f"Circle {i} does not contain any points.")

    if all(valid_circles):
        print("All circles contain at least one point.")


if __name__ == "__main__":
    main()
]]>
    
    https://gavin-blog.pages.dev/2026/%E9%A2%98%E8%A7%A3%EF%BC%9Acf593c-beautiful-function/
    
    2026-02-23T16:19:00.000Z
    
      感谢大神 @Swirl
    
    
    
      好题。
因为只需要三条线段，直接分讨一下情况，实际上只有五种（CF 题解图片炸了，补一张自己画的）。
考虑所有限制，只有第二种和第五种是合法的，但是这两者都需要定一求二计算，很难算啊。
考虑正难则反，用总方案数 (n3)\binom{n}{3} 减去第一、三、四种分别的方案数。
第一种很好算，断环为链以后就是二维数点，至于第三、四种分开算仍然难处理，需要合在一起算。
做完了。
在具体实现中，因为一根线把圆分成了左右两部分，我们只需要分别处理两边与其不相交的线段个数就可以了。
然后就是三、四两种情况会算重，取一半就行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/******************************
 - @GavinCQTD
 - "E. Mystic Carvings"
 - # https://codeforces.com/problemset/problem/297/E
 - 3000 ms
******************************/

#include <algorithm>
#include <iostream>
#include <cassert>
#include <cstring>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

class Fenwick{
private:
    int tree[200005],n;

    int lowbit(int x){
        return x&(-x);
    }

public:
    int query(int x){
        int ans=0;
        while(x!=0){
            ans += tree[x];
            x -= lowbit(x);
        }
        return ans;
    }

    void update(int x,int k){
        while(x<=n){
            tree[x] += k;
            x += lowbit(x);
        }
    }

    void reset(){
        memset(tree,0,sizeof(tree));
    }

    Fenwick(){}
    Fenwick(int n):n(n){}
};

struct Element{
    int a,b,l,r;
};

int n;
ull ans=0;
Element el[100005];
Fenwick fen;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n;
    for(int i=1;i<=n;i++){
        cin >> el[i].a >> el[i].b;
        if(el[i].a>el[i].b){
            swap(el[i].a,el[i].b);
        }
    }

    fen = Fenwick(2*n);

    stable_sort(el+1,el+n+1,[](Element x,Element y){
        return x.a<y.a;
    });

    for(int i=n;i>=1;i--){
        el[i].l = fen.query(el[i].b);
        fen.update(el[i].b,1);
    }

    for(int i=1;i<=n;i++){
        el[i].r += fen.query(el[i].a);
    }

    fen.reset();

    for(int i=1;i<=n;i++){
        el[i].r += fen.query(2*n)-fen.query(el[i].b);
        fen.update(el[i].b,1);
    }

    fen.reset();

    for(int i=1;i<=n;i++){
        fen.update(el[i].a,1);
    }
    for(int i=1;i<=n;i++){
        el[i].r += fen.query(2*n)-fen.query(el[i].b);
    }

    // #1 (|||)
    ull ans1=0;
    for(int i=1;i<=n;i++){
        ans1 += (ull)el[i].l*(ull)el[i].r;
    }

    // #3 / #4 (XI / H)
    ull ans2=0;
    for(int i=1;i<=n;i++){
        ans2 += (ull)(el[i].l+el[i].r)*(ull)(n-el[i].l-el[i].r-1);
    }

    cout << (ull)n*(ull)(n-1)*(ull)(n-2)/6-ans1-ans2/2 << "\n";

    return 0;
}
]]>
    
    https://gavin-blog.pages.dev/2026/codeforces-297e-mystic-carvings/
    
    2026-01-29T16:32:00.000Z
    
      好题。


因为只需要三条线段，直接分讨一下情况，实际上只有五种（CF 题解图片炸了，补一张自己画的）。



    
    
    
      序理论，简要来说，就是利用二元关系来将「次序」这一概念严格化的数学分支[1]。
二元关系
二元关系是定序这一行为的基础。集合 XX 与集合 YY 上的一个二元关系 RR 定义为元组 (X,Y,G(R))(X,Y,G(R))，其中的 XX 被称为定义域，YY 被称为值域[2]，G(R)G(R) 则被称为 RR 的图，且满足 G(R)⊆X×YG(R) \subseteq X \times Y[3]。xRyxRy 成立当且仅当 (x,y)∈G(R)(x,y) \in G(R)。
若 X=YX = Y，则我们将二元关系 RR 称为齐次二元关系或内关系。下文将集中讨论齐次二元关系。
首先，有一些特殊的二元关系。对于一个集合 AA，则
  1. 空集 ∅\varnothing 称作 AA 上的空关系。
  2. EA=A×AE_A = A \times A 称作 AA 上的全域关系。
  3. IA={(x,x)∣x∈A}I_A = \{(x,x) | x \in A\} 称作 AA 上的恒等关系。
二元关系具有一些特别的性质，对于集合 AA 上的二元关系 RR，有如下特殊性质：
  1. 自反性：∀x∈A,(˜x,x)∈R\forall x \in A, \~(x,x) \in R
  2. 反自反性：∀x∈A,(˜x,x)∉R\forall x \in A, \~(x,x) \notin R
  3. 对称性：∀x,y∈A,(˜x,y)∈R  ⟹  (y,x)∈R\forall x,y \in A, \~(x,y) \in R \implies (y,x) \in R
  4. 反对称性：∀x,y∈A,(˜(x,y)∈R∧(y,x)∈R)  ⟹  x=y\forall x,y \in A, \~((x,y) \in R \wedge (y,x) \in R) \implies x=y
  5. 非对称性：∀x,y∈A,(˜x,y)∈R  ⟹  (y,x)∉R\forall x,y \in A, \~(x,y) \in R \implies (y,x) \notin R
  6. 传递性：∀x,y,z∈A,(˜(x,y)∈R∧(y,z)∈R)  ⟹  (x,z)∈R\forall x,y,z \in A, \~((x,y) \in R \wedge (y,z) \in R) \implies (x,z) \in R
在此基础上，我们便可以定义出几种较为特殊的二元关系。
  1. 序理论 - OI Wiki ↩︎
  2. OI Wiki 将其翻译成了"陪域"，这里采用了维基百科的译法 ↩︎
  3. X×YX \times Y 表示集合 XX 与集合 YY 的笛卡尔积，X×Y={(x,y):x∈X,y∈Y}X \times Y = \{(x,y): x \in X, y \in Y\} ↩︎
]]>
    
    https://gavin-blog.pages.dev/2026/%E8%BF%99%E6%98%AF%E4%BB%80%E4%B9%88%EF%BC%9F%E5%BA%8F%E7%90%86%E8%AE%BA%E3%80%82/
    
    2026-01-19T06:10:00.000Z
    
      序理论，简要来说，就是利用二元关系来将「次序」这一概念严格化的数学分支[1]。


二元关系


二元关系是定序这一行为的基]]>
    

    这是什么？序理论。
    2026-01-19T11:18:00.000Z
  
  
    
      Gavin
    
    
      Problem #1 Multiples of 3 or 5
Problem Description
If we list all the natural numbers below $10$ that are multiples of $3$ or $5$, we get $3, 5, 6$ and $9$. The sum of these multiples is $23$.
Find the sum of all the multiples of $3$ or $5$ below $1000$.
Chinese / 3 或 5 的倍数
如果我们列出所有小于 $10$ 的 $3$ 或 $5$ 的倍数，我们会得到 $3、5、6$ 和 $9$。这些倍数的和是 $23$。
求所有小于 $1000$ 的 $3$ 或 $5$ 的倍数之和。
Solution
枚举每个数即可，答案为 233168233168。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

int main(){
    ll ans=0;

    for(int i=1;i<1000;i++){
        if(i%3==0||i%5==0){
            ans += i;
        }
    }

    cout << ans << "\n";

    return 0;
}

Python
1
2
3
4
5
6
7
8
ans = 0

for i in range(1000):
    if i % 3 == 0 or i % 5 == 0:
        ans += i

print(ans)

Wolfram Language
1
2
3
4
5
6
7
8
9
10
answer = 0

For[i = 0, i < 1000, i++,
  If[Mod[i, 3] == 0 || Mod[i, 5] == 0,
    answer += i
  ]
]

Print[answer]

Problem #2 Even Fibonacci Numbers
Problem Description
Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with $1$ and $2$, the first $10$ terms will be:$$1, 2, 3, 5, 8, 13, 21, 34, 55, 89, \dots$$
By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.
Chinese / 偶斐波那契数
斐波那契数列中的每个新项都是通过将前两项相加而生成的。从 $1$ 和 $2$ 开始，前 $10$ 项分别是：$$1, 2, 3, 5, 8, 13, 21, 34, 55, 89, \dots$$
考虑斐波那契数列中值不超过四百万的项，求其中为偶数的项之和。
Solution
也是直接模拟斐波那契数列即可，答案为 46137324613732。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

constexpr int LIMIT=4000000;

vector<int> fib;

int main(){
    ll ans=0;

    fib.push_back(1);
    fib.push_back(1);

    while(true){
        int nw=fib[fib.size()-1]+fib[fib.size()-2];
        if(nw>LIMIT){
            break;
        }
        if(nw%2==0){
            ans += nw;
        }
        fib.push_back(nw);
    }

    cout << ans << "\n";

    return 0;
}

Problem #3 Largest Prime Factor
Problem Description
The prime factors of $13195$ are $5, 7, 13$ and $29$.
What is the largest prime factor of the number $600851475143$?
Chinese / 最大质因子
$13195$ 的质因子是 $5、7、13$ 和 $29$。
数字 $600851475143$ 的最大质因子是多少?
Solution
枚举给定数的所有质因子即可，这里使用了 Miller–Rabin 素性测试。答案为 68576857。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include <iostream>
#include <random>
#include <vector>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

constexpr ll NUM=600851475143;

random_device rd;
mt19937_64 gen(rd());

ll randll(ll l,ll r){
    return uniform_int_distribution<ll>(l,r)(gen);
}

ll qpow(ll a,ll b,ll P){
    ll res=1;
    while(b!=0){
        if(b&1){
            res *= a;
            res %= P;
        }
        a *= a;
        a %= P;
        b >>= 1;
    }
    return res;
}

bool millerRabin(ll n){
    constexpr ll TEST_TIME=10;

    if(n<3||n%2==0){
        return n==2;
    }

    if(n%3==0){
        return n==3;
    }

    ll u=n-1,t=0;
    while(u%2==0){
        u /= 2;
        t++;
    }

    for(ll i=1;i<=TEST_TIME;i++){
        ll a=randll(0,n-4)+2,v=qpow(a,u,n);
        if(v==1){
            continue;
        }
        ll s;
        for(s=0;s<t;s++){
            if(v==n-1){
                break;
            }
            v = (ll)v*v%n;
        }
        if(s==t){
            return false;
        }
    }

    return true;
}

vector<int> fac;

signed main(){
    // 775146
    int sqrtn=sqrt(NUM);

    for(int i=1;i<=sqrtn;i++){
        if(NUM%i==0){
            if(millerRabin(NUM/i)){
                cout << NUM/i << "\n";
                return 0;
            }
            if(millerRabin(i)){
                fac.push_back(i);
            }
        }
    }

    cout << fac.back() << "\n";

    return 0;
}

Problem #4 Largest Palindrome Product
Problem Description
A palindromic number reads the same both ways. The largest palindrome made from the product of two $2$-digit numbers is $9009 = 91 \times 99$.
Find the largest palindrome made from the product of two $3$-digit numbers.
Chinese / 最大回文乘积
回文数从两个方向读都是相同的。由两个 $2$ 位数的乘积构成的最大回文数是 $9009 = 91 \times 99$。
求由两个 $3$ 位数的乘积构成的最大回文数。
Solution
枚举便可，答案为 906609906609。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

bool judge(int num){
    string snum=to_string(num);
    int i=0,j=snum.size()-1;
    while(i<=j){
        if(snum[i]!=snum[j]){
            return false;
        }
        i++;
        j--;
    }
    return true;
}

int main(){
    int ans=0;

    for(int i=999;i>=100;i--){
        for(int j=999;j>=100;j--){
            if(judge(i*j)){
                ans = max(ans,i*j);
            }
        }
    }

    cout << ans << "\n";

    return 0;
}

Problem #5 Smallest Multiple
Problem Description
$2520$ is the smallest number that can be divided by each of the numbers from $1$ to $10$ without any remainder.
What is the smallest positive number that is evenly divisibledivisible with no remainder by all of the numbers from $1$ to $20$?
Chinese / 最小公倍数
$2520$ 是能被从 $1$ 到 $10$ 的每个数整除的最小数。
能被从 $1$ 到 $20$ 的所有数整除的最小正数是多少?
Solution
题意转化为求 11 到 2020 的最小公倍数。我们用 gcd⁡(a,b)\gcd(a,b) 表示 aa 与 bb 的最大公因数，lcm(a,b)\mathrm{lcm}(a,b) 代表最小公倍数。
lcm(a,b)=abgcd⁡(a,b)\mathrm{lcm}(a,b) = \frac{ab}{\gcd(a,b)}
答案为 232792560232792560。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <algorithm>
#include <iostream>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

ll lcm(ll a,ll b){
    return a*b/__gcd(a,b);
}

constexpr int N=20;

int main(){
    ll ans=1;

    for(int i=2;i<=N;i++){
        ans = lcm(ans,i);
    }

    cout << ans << "\n";

    return 0;
}

Problem #6 Sum Square Difference
Problem Description
The sum of the squares of the first ten natural numbers is,
$$1^2 + 2^2 + ... + 10^2 = 385.$$
The square of the sum of the first ten natural numbers is,
$$(1 + 2 + ... + 10)^2 = 55^2 = 3025.$$
Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is $3025 - 385 = 2640$.
Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.
Chinese / 平方和与和平方之差
前十个自然数的平方和是
$$1^2 + 2^2 + ... + 10^2 = 385.$$
前十个自然数的和的平方是
$$(1 + 2 + ... + 10)^2 = 55^2 = 3025.$$
因此，前十个自然数的平方和与和的平方之间的差是 $3025 - 385 = 2640$。
求前一百个自然数的平方和与和的平方之间的差。
Solution
我们有如下两个公式。
∑i=1ni2=n(n+1)(2n+1)6\sum_{i=1}^{n} i^2 = \frac{n(n+1)(2n+1)}{6}
∑i=1ni=(1+n)∗n2\sum_{i=1}^{n} i = \frac{(1+n)*n}{2}
答案为 2516415025164150。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

constexpr int N=100;

int main(){
    cout << abs(N*(N+1)*(2*N+1)/6-((1+N)*N/2)*((1+N)*N/2)) << "\n";

    return 0;
}

Problem #7 10 001st Prime
Problem Description
By listing the first six prime numbers: $2, 3, 5, 7, 11$, and $13$, we can see that the $6$th prime is $13$.
What is the $10\,001$st prime number?
Chinese / 第 10001 个质数
列出前六个质数：$2、3、5、7、11$ 和 $13$，我们可以看到第 $6$ 个质数是 $13$。
第 $10001$ 个质数是多少?
Solution
使用线性筛解决，答案为 104743104743。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <bitset>
#include <vector>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

constexpr int N=10001;

vector<int> prms;
bitset<100000005> notp;

int main(){
    for(int i=2;;i++){
        if(!notp[i]){
            prms.push_back(i);
            if(prms.size()>=N){
                break;
            }
        }
        for(int prm:prms){
            if(prm*i>100000000){
                break;
            }
            notp[prm*i] = true;
            if(i%prm==0){
                break;
            }
        }
    }

    cout << prms.back() << "\n";

    return 0;
}

Problem #8 Largest Product in a Series
Problem Description
The four adjacent digits in the $1000$-digit number that have the greatest product are $9 \times 9 \times 8 \times 9 = 5832$.
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
Find the thirteen adjacent digits in the $1000$-digit number that have the greatest product. What is the value of this product?
Chinese / 连续数字最大乘积
在这个 $1000$ 位数字中,乘积最大的四个相邻数字是 $9 \times 9 \times 8 \times 9 = 5832$。
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
在这个 $1000$ 位数字中找出乘积最大的十三个相邻数字。这个乘积的值是多少?
Solution
暴力枚举即可，答案为 2351462400023514624000。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

constexpr int N=1000,M=13;

string num="7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";

int main(){
    num = ' '+num;

    ll ans=1;

    for(int i=1;i<=N-M+1;i++){
        ll cur=1;
        for(int j=i;j<=i+M-1;j++){
            cur *= num[j]-'0';
        }
        ans = max(ans,cur);
    }

    cout << ans << "\n";

    return 0;
}

Problem #9 Special Pythagorean Triplet
Problem Description
A Pythagorean triplet is a set of three natural numbers, $a \lt b \lt c$, for which,$$a^2 + b^2 = c^2.$$
For example, $3^2 + 4^2 = 9 + 16 = 25 = 5^2$.
There exists exactly one Pythagorean triplet for which $a + b + c = 1000$.
Find the product $abc$.
Chinese / 特殊毕达哥拉斯三元组
勾股数是一组三个自然数，$a \lt b \lt c$，满足$$a^2 + b^2 = c^2.$$
例如，$3^2 + 4^2 = 9 + 16 = 25 = 5^2$。
存在唯一一组勾股数满足 $a + b + c = 1000$。
求这组勾股数的乘积 $abc$。
Solution
直接枚举 aa 和 bb，计算 cc 并判断合法性。答案为 3187500031875000。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

int main(){
    for(int a=1;a<=1000;a++){
        for(int b=a+1;b<1000-a-b;b++){
            int c=1000-a-b;
            if(a*a+b*b==c*c){
                cout << a*b*c << "\n";
                return 0;
            }
        }
    }

    return 0;
}

Problem #10 Summation of Primes
Problem Description
The sum of the primes below $10$ is $2 + 3 + 5 + 7 = 17$.
Find the sum of all the primes below two million.
Chinese / 质数求和
小于 $10$ 的质数之和是 $2 + 3 + 5 + 7 = 17$。
求小于两百万的所有质数之和。
Solution
使用线性筛筛一遍就可，答案为 142913828922142913828922。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <bitset>
#include <vector>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

constexpr int N=2000000;

vector<int> prms;
bitset<N+5> notp;

int main(){
    ull ans=0;

    for(int i=2;i<=N;i++){
        if(!notp[i]){
            prms.push_back(i);
            ans += i;
        }
        for(int prm:prms){
            if(i*prm>N){
                break;
            }
            notp[i*prm] = true;
            if(i%prm==0){
                break;
            }
        }
    }

    cout << ans << "\n";

    return 0;
}

Problem #11 Largest Product in a Grid
Problem Description
In the $20 \times 20$ grid below, four numbers along a diagonal line have been marked in red.
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
The product of these numbers is $26 \times 63 \times 78 \times 14 = 1788696$.
What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the $20 \times 20$ grid?
Chinese / 方阵中的最大乘积
在下面的 $20 \times 20$ 的方阵中，有四个呈对角线排列的数被标记为红色。
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
这些数字的乘积是 $26 \times 63 \times 78 \times 14 = 1788696$。
在 $20 \times 20$ 的方阵中，四个呈一直线（竖直、水平或对角线）的相邻的数的最大乘积是多少？
Solution
枚举所有可能的情况即可，答案为 7060067470600674。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include <iostream>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

constexpr int NUM[20][20]={
    {8,2,22,97,38,15,0,40,0,75,4,5,7,78,52,12,50,77,91,8},
    {49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,4,56,62,0},
    {81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,3,49,13,36,65},
    {52,70,95,23,4,60,11,42,69,24,68,56,1,32,56,71,37,2,36,91},
    {22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80},
    {24,47,32,60,99,3,45,2,44,75,33,53,78,36,84,20,35,17,12,50},
    {32,98,81,28,64,23,67,10,26,38,40,67,59,54,70,66,18,38,64,70},
    {67,26,20,68,2,62,12,20,95,63,94,39,63,8,40,91,66,49,94,21},
    {24,55,58,5,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72},
    {21,36,23,9,75,0,76,44,20,45,35,14,0,61,33,97,34,31,33,95},
    {78,17,53,28,22,75,31,67,15,94,3,80,4,62,16,14,9,53,56,92},
    {16,39,5,42,96,35,31,47,55,58,88,24,0,17,54,24,36,29,85,57},
    {86,56,0,48,35,71,89,7,5,44,44,37,44,60,21,58,51,54,17,58},
    {19,80,81,68,5,94,47,69,28,73,92,13,86,52,17,77,4,89,55,40},
    {4,52,8,83,97,35,99,16,7,97,57,32,16,26,26,79,33,27,98,66},
    {88,36,68,87,57,62,20,72,3,46,33,67,46,55,12,32,63,93,53,69},
    {4,42,16,73,38,25,39,11,24,94,72,18,8,46,29,32,40,62,76,36},
    {20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,4,36,16},
    {20,73,35,29,78,31,90,1,74,31,49,71,48,86,81,16,23,57,5,54},
    {1,70,54,71,83,51,54,69,16,92,33,48,61,43,52,1,89,19,67,48}
};

int main(){
    ull ans=0;

    for(int i=0;i<20;i++){
        for(int j=0;j<17;j++){
            ull cans=1;
            for(int k=j;k<j+4;k++){
                cans *= NUM[i][k];
            }
            ans = max(ans,cans);
        }
    }

    for(int i=0;i<17;i++){
        for(int j=0;j<20;j++){
            ull cans=1;
            for(int k=i;k<i+4;k++){
                cans *= NUM[k][j];
            }
            ans = max(ans,cans);
        }
    }

    for(int i=0;i<17;i++){
        for(int j=0;j<17;j++){
            ull cans=1;
            for(int k=i,l=j;k<i+4&&l<j+4;k++,l++){
                cans *= NUM[k][l];
            }
            ans = max(ans,cans);
            cans = 1;
            for(int k=i+3,l=j;k>=i&&l<j+4;k--,l++){
                cans *= NUM[k][l];
            }
            ans = max(ans,cans);
        }
    }

    cout << ans << "\n";

    return 0;
}

Problem #12 Highly Divisible Triangular Number
Problem Description
The sequence of triangle numbers is generated by adding the natural numbers. So the $7$th triangle number would be $1 + 2 + 3 + 4 + 5 + 6 + 7 = 28$. The first ten terms would be:$$1, 3, 6, 10, 15, 21, 28, 36, 45, 55, \dots$$
Let us list the factors of the first seven triangle numbers:
$$\begin{align}\mathbf 1 &\colon 1\\\mathbf 3 &\colon 1,3\\\mathbf 6 &\colon 1,2,3,6\\\mathbf{10} &\colon 1,2,5,10\\\mathbf{15} &\colon 1,3,5,15\\\mathbf{21} &\colon 1,3,7,21\\\mathbf{28} &\colon 1,2,4,7,14,28\end{align}$$
We can see that $28$ is the first triangle number to have over five divisors.
What is the value of the first triangle number to have over five hundred divisors?
Chinese / 有很多因数的三角形数
三角形数是通过连续累加自然数得到的。例如第 $7$ 个三角形数是 $1 + 2 + 3 + 4 + 5 + 6 + 7 = 28$。前十个三角形数是：$$1, 3, 6, 10, 15, 21, 28, 36, 45, 55, \dots$$
让我们列出前七个三角形数的所有因数：
$$\begin{align}\mathbf 1 &\colon 1\\\mathbf 3 &\colon 1,3\\\mathbf 6 &\colon 1,2,3,6\\\mathbf{10} &\colon 1,2,5,10\\\mathbf{15} &\colon 1,3,5,15\\\mathbf{21} &\colon 1,3,7,21\\\mathbf{28} &\colon 1,2,4,7,14,28\end{align}$$
我们可以看到 $28$ 是第一个拥有超过五个因数的三角形数。
第一个拥有超过五百个因数的三角形数的值是多少？
Solution
枚举数并判断其因数个数即可，答案为 7657650076576500。
Code
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;

int fac(ll u){
    int res=0;
    for(int i=1;i<=sqrt(u);i++){
        if(u%i==0){
            if(i==sqrt(u)){
                res++;
            }
            else{
                res += 2;
            }
        }
    }
    return res;
}

int main(){
    ll cur=0;

    for(int i=1;;i++){
        cur += i;
        if(fac(cur)>500){
            cout << cur << "\n";
            break;
        }
    }

    return 0;
}

]]>
    
    https://gavin-blog.pages.dev/2025/%E6%AC%A7%E6%8B%89%E8%AE%A1%E5%88%92%E5%A4%A7%E5%90%88%E9%9B%86/
    
    2025-12-07T07:33:00.000Z
    
      Problem #1 Multiples of 3 or 5

Problem Description


If we li]]>
    

    欧拉计划大合集
    2025-12-09T06:06:00.000Z
  
  
    
      Gavin
    
    
    
    
      洛谷导航：https://www.luogu.com.cn/article/t3wj25h5
考前 ??? 天
在校内 NOIP 模拟赛中获得了均分 100 的极品好成绩，你也来试试吧。
被教练带着复习了一遍组合数学，包括但不限于上、下指标前缀和，吸收恒等式，范德蒙德卷积等。
尝试证明李善兰恒等式，失败了。
考前两天的晚自习，教练分享往届学长消除考前压力方法。有一人竟与生物竞赛女同学在操场走了 10 圈。
当晚放学后试图寻找生物竞赛女同学，失败了。
哦对那天晚上机房还有开封菜吃，但因为与 @BoodHouse 在楼下开 impart 差点没有吃到。
一群人没洗手便上手抓，颇有拉肚子风险。
当晚在家与肠胃斗争，失败了，一泻千里。
考前 1 天
上午在机房与同学进行思维（？碰撞，因同学出的题在洛谷上数据点分值配错满分为 800 而嘲笑他，两分钟后发现自己的题也配错了，满分是 8 分。
平常开窗口透明打游戏的演都不演直接最大化开打。
下午要去试机，因为我的家长无法到来，将由教练带着前往 CQBZ 试机。
试机在下午，中午机房没开，遂与 @YYH2030 随机游走至学校附近的公园后打了一中午舟。
发现几个月没上舟的我操作与人机无异。
下午试机，T3 出行创造了从点击开始打车按钮到上车仅需 5 秒的神话。
路过小学，感叹我们小学盛产原批。
到达 CQBZ，打了一个 dij 板子，发现在 n, m = 1e5 时需要跑 0.3 秒。
听未知同学说 CQBZ 去年提供双系统结果所有 Linux 切回 Windows 的人 cena 都消失了，故今年仅提供虚拟机。不知真假。
围观未知中学的同学打云原神。
下午与学长 @Annihilation_y 一路回家。走到小学附近时意识到可以去探望亲爱的老师。
然后被校长认出来了（？
遇见了小学班主任（语文老师），并向她展示了在初中学会的油嘴滑舌（？
购买了 10 根士力架与 2L 脉动。
教练在考前几周约有 10%-15% 的时间生病了，严肃怀疑是林黛玉。
考试当天
被教练要求我校所有年级进考场前在科技楼门口合影留念。
大于等于初二的同学们摆出了一副死气沉沉的姿态（？而初一在拍照时大喊神秘口号，逗乐全场。
看到楼梯堵死，与机智的 @X_m_X 一同乘坐电梯，并对走楼梯姗姗来迟的同学们发起随机嘲讽（？
开始考试，在 T1 猜了一个结论（除了 x+y 最小的要取多个，其他最多取一个），发现是对的，在 30min 内通过了。
顺便发现了使用 Lemon 测试大样例是极方便的，建议标配给所有环境。
吃了一根士力架，真好吃啊。
然后大战了 3h 的极品 T2 并觉得自己能做出来，失败了。
然后吃了一根士力架，真好吃啊。
观看 T3 意识到 mex 过于抽象，果断跳过。
然后吃了一根士力架，真好吃啊。
剩下 1h 开始大战 T4，觉得可能是个数据结构神秘题（实则也是，但并没有想到维护斜线信息，至少 LCA 的题解是这样维护的），并相信自己能做出来。
剩余 30min 时，自己仍处于 100+0+0+0 的极品分数，由于昨天晚上导多了（大概？），此时？意袭来，在 10min 内上了 3 次厕所。
然后吃了一根士力架，真好吃啊。
剩余 20min 时，得出了 T1 < T4 < T2 < T3 的极品结论，并意识到自己的 100+eps 分数可能处于一个非常极品的排名。但被 T2 与 T4 轮番草飞没有任何心情打暴力，离场了。
出考场，得知同学们基本处于 100+eps 的极品分数后冷静了下来，并膜拜 wyb 大蛇切出 T2。
比较难受，于是一口气吃完所有剩下的士力架。
后记
回家查看洛谷难度，得知是极品黄黑黑黑，破防了。
与神秘女同学聊天，心情迅速恢复。
晚上得知大战了 3h 未能成功的 T2 降紫了，更破防了。
第二天观看 LCA 的题解，发现 T2 可以直接写柿子然后运用范德蒙德卷积优化，突然意识到这个什么什么卷积貌似在哪听过（警示大家：上课请听讲，虽然我听了也没做出来）。
后后记
小问答：文章中出现了多少个 极品？
]]>
    
    https://gavin-blog.pages.dev/2025/noi-plus-2025-%E9%82%AE%E5%AF%84/
    
    2025-12-01T13:53:00.000Z
    
      洛谷导航：https://www.luogu.com.cn/article/t3wj25h5
    
    
    
      2025/11/28:
先挂在这，谁知道呢。
练习赛 / 2025.12.13
在下午三点半开始速通练习赛。
十分钟严肃速通前三题，而后笔者被 T4 创飞。
一件趣事：我校四个队伍的排名连在了一起。
（因最上面的队名涉及对同学的开盒，已经打码。）
初赛 / 2025.12.14
你说得对但是强烈谴责今年比去年多了 300+ team 导致 DOMJudge 505。
可爱 yyh 为 J 贡献了 -12 的超高成绩。
可爱 xmx 为 G 贡献了 -6 的超高成绩。
哦对这个唐必在交 M 的时候没选 Problem 交了两发 A。
我在干什么？
我口胡了 D 并成功没有写出 flow。
最后以 J+G+M 的 3 题超高成绩领跑【】中学。
]]>
    
    https://gavin-blog.pages.dev/2025/thupc-2026-%E6%8E%92%E8%A1%8C%E6%A6%9C%E8%A7%82%E5%AF%9F%E8%AE%B0/
    
    2025-11-27T23:59:00.000Z
    
      2025/11/28:


先挂在这，谁知道呢。


队友：@X_m_X
    
    
      如果一个本地 git 仓库的 remote 是 ssh，与 remote 的通信不会走 ~/.gitconfig 指定的代理
显然要配置 ssh 走代理
这个需求可以用 nc(Netcat) 做到，这里使用了较新的 ncat
编辑 ~/.ssh/config 文件
1
2
Host *
ProxyCommand ncat --proxy-type socks5 --proxy 127.0.0.1:7891 %h %p
第一行的 * 代表我想让所有 host 走代理，改其他的比如 github.com 也没问题
第二行指定了代理用的命令，proxy-type 可以更改，如 socks4 等，proxy 后面的 IP 改成自己代理的 IP。
以上
]]>
    
    https://gavin-blog.pages.dev/2025/%E5%A6%82%E4%BD%95%E7%BB%99-ssh-%E4%B8%8A%E4%BB%A3%E7%90%86/
    
    2025-11-16T16:40:00.000Z
    
      如果一个本地 git 仓库的 remote 是 ssh，与 remote 的通信不会走 ~/.gitconfig 指定的代理


显然要配置 ssh 走代理


这个需求可以用 nc(Netcat) 做到，这里使用了较新的 ncat


编辑]]>
    

    如何给 ssh 上代理
    2025-11-17T06:25:00.000Z
  
  
    
      Gavin
    
    
    
    
    
      
同 AT_joisc2014_c 歴史の研究 | 更差的阅读体验
阅读之前请确保你知道基本的莫队相关知识。
可以离线的区间查询问题，我们考虑莫队。
记录区间内事件数量。当区间伸长时，直接更新即可。
但是，我们无法快速处理区间缩短时的情况。
这时，需要用到回滚莫队。
将序列进行分块。
若一个询问的 ll 与 rr 在同一个块内，暴力扫描；如果这次询问 ll 所属的块与上次 ll 所属的块不一样，那将莫队当前的 ll 重置到现在 ll 所属块的右端点，rr 重置到右端点减一；若以上两种情况都不满足，直接伸长区间回答询问，回答完后回滚莫队区间左端点到询问 ll 所属块的右端点。
设块长为 bb，暴力扫描复杂度是 O(b)\mathcal{O}(b)。
对于其他情况，右端点移动是 O(n)\mathcal{O}(n) 的，左端点移动则是 O(b)\mathcal{O}(b) 的。
在 b=n(m)b = \frac{n}{\sqrt(m)} 时复杂度最优，为 O(nm)\mathcal{O}(n\sqrt{m})
]]>
    
    https://gavin-blog.pages.dev/2025/%E6%B4%9B%E8%B0%B7-p14420-joisc-2014-%E5%8E%86%E5%8F%B2%E7%9A%84%E7%A0%94%E7%A9%B6-historical-research-%E9%A2%98%E8%A7%A3/
    
    2025-11-05T08:04:00.000Z
    
      

同 AT_j]]>
    

    洛谷 P14420 [JOISC 2014] 历史的研究 / Historical Research 题解
    2025-11-05T08:04:00.000Z
  
  
    
      Gavin
    
    
    
      August
过去的已经过去，再也回不来了。
在七夕节尝试给全班写情书，失败了。
September
Week 1
我的多彩初中生活之开学怎么比暑假轻松。
老师说我们班级形象♂大赛的节目过于优秀，要在神秘活动中再演一遍。操。
Week 2
Monday / Tuesday
得知要去劳改基地花钱劳动两天。
第一天非常牛，上午做了蛋糕，虽然我也不知道为什么做成了蛋糕味的饼干，操。
班级大牛在蛋糕制作时大改工序，做出了新疆的馍，比蛋糕好吃。
中午吃饭发现男生桌没给我留位置，于是加入了仅有三个女生的闺蜜桌。人家（请大家去洛谷搜索 Swirl 谢谢喵）都有感情史了而我在干什么，操。吃屎真爽啊。
下午做酸梅汤，做出来了你问我我也不知道是什么的东西，在 20° 的空调下吹了十分钟温度丝毫没有下降。
第二天请假在家打原神了。
Week 3
Saturday
神秘活动初赛，共供奉 200 元整。真恐怖啊某学会。
初赛结束后为完成语文作业与同学一起采访了我校教练。
负责念采访稿的同学念一句笑一句，不知道在笑什么，尤其是说“每天备课到凌晨”时笑得最开心？
辛苦教练了。
Week 4
Thursday
教练叫我们竞赛生集体在社团招新中报名“阳光编程社”。
在社团摊位中找了 n 圈没找到。
打电话给教练询问，教练也不知道。
最后发现在给教练打电话时，“模拟飞行社”的展板上被用白板笔写上了“阳光编程社”。
操。
Saturday
不返校。
但被班主任拉到学校礼堂参加神秘活动（详见下文）彩排，内容为在台上举牌子带动班级喊口号。
但是，在礼堂排了两个小时？？？
Sunday
构式调休。
神秘活动（Callback September Week 1）来临。
。
]]>
    
    https://gavin-blog.pages.dev/2025/%E7%9F%B3%E6%A5%A0%E8%8A%B1%E5%A4%95%E6%8B%BE/
    
    2025-09-13T07:27:00.000Z
    
      August

过去的已经过去，再也回不来了。


在七夕节尝试给全班写情书，失败了。


September


Week 1


    
    石楠花夕拾
    2025-09-29T05:40:00.000Z
  


队友：@X_m_X / @YYH2030