<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Sanzenin 凪</title><description>Sanzenin 凪的个人博客，记录技术、阅读与日常。</description><link>https://sanzenin.top/</link><language>zh_CN</language><item><title>FFT 与 NTT 算法笔记</title><link>https://sanzenin.top/posts/obsidian/fft%E4%B8%8Entt%E7%AE%97%E6%B3%95%E7%AC%94%E8%AE%B0/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/fft%E4%B8%8Entt%E7%AE%97%E6%B3%95%E7%AC%94%E8%AE%B0/</guid><description>设两个多项式分别有 、 个系数： 将乘积展开并按次数合并，得到 这就是线性卷积。直接枚举每一对系数需要 时间。 若改为记录多项式在若干点上的取值，则在每个点 上都有 乘积点值可以通过逐项相乘得到。用点值计算多项式乘法，需要快速完成系数表示与点值表示之间的转换。MIT 6.046J FFT 讲义 次数小于 的多项式由 个</description><pubDate>Mon, 16 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;FFT 与 NTT 算法笔记&lt;/h1&gt;
&lt;h2&gt;多项式乘法与点值表示&lt;/h2&gt;
&lt;p&gt;设两个多项式分别有 $n$、$m$ 个系数：&lt;/p&gt;
&lt;p&gt;$$
A(x)=\sum_{i=0}^{n-1}a_ix^i,\qquad
B(x)=\sum_{j=0}^{m-1}b_jx^j.
$$&lt;/p&gt;
&lt;p&gt;将乘积展开并按次数合并，得到&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
C(x)&amp;amp;=A(x)B(x)
=\sum_{i=0}^{n-1}\sum_{j=0}^{m-1}a_ib_jx^{i+j},\
c_k&amp;amp;=\sum_{\substack{i+j=k\0\le i&amp;lt;n,\ 0\le j&amp;lt;m}}a_ib_j,
\qquad 0\le k&amp;lt;n+m-1.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;这就是线性卷积。直接枚举每一对系数需要 $O(nm)$ 时间。&lt;/p&gt;
&lt;p&gt;若改为记录多项式在若干点上的取值，则在每个点 $x_k$ 上都有&lt;/p&gt;
&lt;p&gt;$$
C(x_k)=A(x_k)B(x_k).
$$&lt;/p&gt;
&lt;p&gt;乘积点值可以通过逐项相乘得到。用点值计算多项式乘法，需要快速完成系数表示与点值表示之间的转换。&lt;a href=&quot;https://ocw.mit.edu/courses/6-046j-design-and-analysis-of-algorithms-spring-2012/dcfa155d0ae636c210bebd70e3b87ba1_MIT6_046JS12_lec05.pdf&quot;&gt;MIT 6.046J FFT 讲义&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;次数小于 $N$ 的多项式由 $N$ 个互不相同的点值唯一确定。证明：若 $P$、$Q$ 在这些点取值相同，则 $P-Q$ 有至少 $N$ 个根；非零多项式的根数不超过次数，而 $\deg(P-Q)&amp;lt;N$，所以 $P-Q=0$。因此，只要选取 $N\ge n+m-1$ 个不同的点，就能从乘积点值恢复完整系数。&lt;/p&gt;
&lt;h2&gt;FFT 的推导&lt;/h2&gt;
&lt;h3&gt;复数与单位根&lt;/h3&gt;
&lt;p&gt;复数写作 $z=u+iv$，其中 $i^2=-1$。乘法为&lt;/p&gt;
&lt;p&gt;$$
(u+iv)(s+it)=(us-vt)+i(ut+vs).
$$&lt;/p&gt;
&lt;p&gt;单位圆上的点可以表示为 $e^{i\theta}=\cos\theta+i\sin\theta$。由三角函数的和角公式，&lt;/p&gt;
&lt;p&gt;$$
e^{i\alpha}e^{i\beta}
=\cos(\alpha+\beta)+i\sin(\alpha+\beta)
=e^{i(\alpha+\beta)}.
$$&lt;/p&gt;
&lt;p&gt;因而乘法对应角度相加，乘方对应角度成倍增加。&lt;/p&gt;
&lt;p&gt;求方程 $z^N=1$ 的根。将 $z$ 写为 $re^{i\theta}$，由 $r^N=1$ 得 $r=1$，由 $N\theta$ 是 $2\pi$ 的整数倍得&lt;/p&gt;
&lt;p&gt;$$
z=e^{2\pi ik/N},\qquad 0\le k&amp;lt;N.
$$&lt;/p&gt;
&lt;p&gt;定义&lt;/p&gt;
&lt;p&gt;$$
\omega_N=e^{2\pi i/N}
=\cos\frac{2\pi}{N}+i\sin\frac{2\pi}{N}.
$$&lt;/p&gt;
&lt;p&gt;全部 $N$ 次单位根为 $1,\omega_N,\ldots,\omega_N^{N-1}$。若 $\omega_N^u=\omega_N^v$，则 $e^{2\pi i(u-v)/N}=1$，等价于 $N\mid(u-v)$；所以这些根两两不同，且 $\omega_N$ 的阶恰为 $N$。&lt;/p&gt;
&lt;p&gt;以下采用 $N=2^s$ 的变换长度。对偶数 $N$，单位根有三条性质。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;周期性：&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;$$
\omega_N^{k+N}
=e^{2\pi ik/N}e^{2\pi i}
=\omega_N^k.
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;相隔半圈取相反数：&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;$$
\omega_N^{k+N/2}
=e^{2\pi ik/N}e^{\pi i}
=-\omega_N^k.
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;平方后成为下一层单位根：&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;$$
(\omega_N^k)^2
=e^{4\pi ik/N}
=e^{2\pi ik/(N/2)}
=\omega_{N/2}^k.
$$&lt;/p&gt;
&lt;p&gt;特别地，$\omega_N^k$ 与 $\omega_N^{k+N/2}$ 的平方相同。全部 $N$ 个单位根平方后，恰好得到 $N/2$ 个单位根，每个出现两次；这使规模为 $N$ 的求值问题能够递归到规模为 $N/2$ 的求值问题。&lt;/p&gt;
&lt;h3&gt;离散傅里叶变换的定义&lt;/h3&gt;
&lt;p&gt;把系数数组补零到 $N$ 项，令&lt;/p&gt;
&lt;p&gt;$$
A(x)=\sum_{j=0}^{N-1}a_jx^j.
$$&lt;/p&gt;
&lt;p&gt;在全部 $N$ 次单位根上求值，得到离散傅里叶变换（DFT）：&lt;/p&gt;
&lt;p&gt;$$
\widehat a_k
=A(\omega_N^k)
=\sum_{j=0}^{N-1}a_j\omega_N^{jk},
\qquad 0\le k&amp;lt;N.
$$&lt;/p&gt;
&lt;p&gt;本文约定正变换使用正指数。每个点值直接计算需要 $O(N)$ 时间，全部点值需要 $O(N^2)$ 时间。FFT 利用单位根之间的关系，以 $O(N\log N)$ 时间计算同一组点值。&lt;/p&gt;
&lt;h3&gt;奇偶拆分&lt;/h3&gt;
&lt;p&gt;将偶数下标和奇数下标分别组成两个多项式：&lt;/p&gt;
&lt;p&gt;$$
A_0(x)=\sum_{j=0}^{N/2-1}a_{2j}x^j,\qquad
A_1(x)=\sum_{j=0}^{N/2-1}a_{2j+1}x^j.
$$&lt;/p&gt;
&lt;p&gt;由指数 $2j$ 与 $2j+1$ 的区别，&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
A(x)
&amp;amp;=\sum_{j=0}^{N/2-1}a_{2j}x^{2j}
+\sum_{j=0}^{N/2-1}a_{2j+1}x^{2j+1}\
&amp;amp;=A_0(x^2)+xA_1(x^2).
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;求 $A$ 在 $\omega_N^k$ 上的值，只需知道 $A_0$、$A_1$ 在 $(\omega_N^k)^2=\omega_{N/2}^k$ 上的值。两个子多项式的系数个数与所需点值个数都减半，因而可继续采用同一拆分。到 $N=1$ 时，多项式为常数，唯一点值就是 $a_0$。&lt;/p&gt;
&lt;p&gt;长度为 $8$ 时，递归中各组包含的原数组元素如下。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/FFT_NTT_coefficient_split_tree.png&quot; alt=&quot;长度为八的系数数组按奇偶下标递归拆分&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;蝶形合并的推导&lt;/h3&gt;
&lt;p&gt;设已经完成两个长度为 $N/2$ 的子变换：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
E_k&amp;amp;=A_0(\omega_{N/2}^k)
=\sum_{j=0}^{N/2-1}a_{2j}\omega_{N/2}^{jk},\
O_k&amp;amp;=A_1(\omega_{N/2}^k)
=\sum_{j=0}^{N/2-1}a_{2j+1}\omega_{N/2}^{jk},
\qquad 0\le k&amp;lt;N/2.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;将 $x=\omega_N^k$ 代入奇偶拆分式，由 $(\omega_N^k)^2=\omega_{N/2}^k$ 得&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\widehat a_k
&amp;amp;=A_0((\omega_N^k)^2)
+\omega_N^kA_1((\omega_N^k)^2)\
&amp;amp;=E_k+\omega_N^kO_k.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;还需计算另一个点 $\omega_N^{k+N/2}$。它与 $\omega_N^k$ 互为相反数，而&lt;/p&gt;
&lt;p&gt;$$
(\omega_N^{k+N/2})^2
=\omega_N^{2k+N}
=\omega_N^{2k}
=\omega_{N/2}^k.
$$&lt;/p&gt;
&lt;p&gt;所以两个子多项式仍取相同的点值，奇数部分的外部因子变号：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\widehat a_{k+N/2}
&amp;amp;=A_0((\omega_N^{k+N/2})^2)
+\omega_N^{k+N/2}A_1((\omega_N^{k+N/2})^2)\
&amp;amp;=E_k-\omega_N^kO_k.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;合并公式为&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\widehat a_k&amp;amp;=E_k+\omega_N^kO_k,\
\widehat a_{k+N/2}&amp;amp;=E_k-\omega_N^kO_k,
\qquad 0\le k&amp;lt;N/2.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;每对输入 $(E_k,O_k)$ 计算一次 $\omega_N^kO_k$，再通过一加一减得到两个点值；$N/2$ 对输入恰好给出全部 $N$ 个结果。&lt;/p&gt;
&lt;h3&gt;位逆序与按层合并&lt;/h3&gt;
&lt;p&gt;递归时先取偶数下标，再取奇数下标。设原下标的二进制表示为&lt;/p&gt;
&lt;p&gt;$$
j=\sum_{t=0}^{s-1}b_t2^t,\qquad b_t\in{0,1}.
$$&lt;/p&gt;
&lt;p&gt;第一层按 $b_0$ 分组，第二层按 $b_1$ 分组，依次直到 $b_{s-1}$。叶子从左到右排列时，第一次分组决定叶子位置的最高位，第二次分组决定次高位，因此原下标 $j$ 的叶子位置为&lt;/p&gt;
&lt;p&gt;$$
\operatorname{rev}&lt;em&gt;s(j)
=\sum&lt;/em&gt;{t=0}^{s-1}b_t2^{s-1-t}.
$$&lt;/p&gt;
&lt;p&gt;例如 $N=8$ 时，下标 $1=(001)_2$ 位逆序后为 $(100)_2=4$，所以 $a_1$ 位于叶子序列的第 $4$ 个位置（从 $0$ 开始）。完整叶子顺序为&lt;/p&gt;
&lt;p&gt;$$
a_0,a_4,a_2,a_6,a_1,a_5,a_3,a_7.
$$&lt;/p&gt;
&lt;p&gt;先按位逆序重排，递归树中的每个子问题就占据连续区间。从底层向上依次合并长度为 $2,4,8,\ldots,N$ 的区间，得到迭代变换。每层使用该层长度对应的单位根 $\omega_2,\omega_4,\ldots,\omega_N$；长度为 $M$ 的子变换，其定义中本来就使用 $M$ 次单位根。&lt;/p&gt;
&lt;p&gt;每层各子问题的长度总和为 $N$，合并工作量为 $O(N)$。共有 $\log_2N$ 层，因此&lt;/p&gt;
&lt;p&gt;$$
T(N)=2T(N/2)+O(N)=O(N\log N).
$$&lt;/p&gt;
&lt;p&gt;采用原地迭代时，系数与点值复用同一数组，所需存储空间为 $O(N)$。&lt;/p&gt;
&lt;h3&gt;单位根求和与逆变换&lt;/h3&gt;
&lt;p&gt;对任意整数 $d$，考虑&lt;/p&gt;
&lt;p&gt;$$
S_d=\sum_{k=0}^{N-1}\omega_N^{dk}.
$$&lt;/p&gt;
&lt;p&gt;若 $N\mid d$，每一项都为 $1$，于是 $S_d=N$。若 $N\nmid d$，令 $r=\omega_N^d$，则 $r\ne1$ 且 $r^N=1$，由等比数列求和，&lt;/p&gt;
&lt;p&gt;$$
S_d=\sum_{k=0}^{N-1}r^k
=\frac{1-r^N}{1-r}
=0.
$$&lt;/p&gt;
&lt;p&gt;因此&lt;/p&gt;
&lt;h1&gt;$$
\sum_{k=0}^{N-1}\omega_N^{dk}&lt;/h1&gt;
&lt;p&gt;\begin{cases}
N,&amp;amp;N\mid d,\
0,&amp;amp;N\nmid d.
\end{cases}
$$&lt;/p&gt;
&lt;p&gt;这个求和关系可以把正变换中的各个系数分离。固定待恢复的下标 $j$，把正变换代入负指数求和：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\frac{1}{N}\sum_{k=0}^{N-1}\widehat a_k\omega_N^{-jk}
&amp;amp;=\frac{1}{N}\sum_{k=0}^{N-1}
\left(\sum_{t=0}^{N-1}a_t\omega_N^{tk}\right)\omega_N^{-jk}\
&amp;amp;=\frac{1}{N}\sum_{t=0}^{N-1}a_t
\sum_{k=0}^{N-1}\omega_N^{(t-j)k}\
&amp;amp;=a_j.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;由于 $0\le t,j&amp;lt;N$，条件 $N\mid(t-j)$ 仅在 $t=j$ 时成立。求和后只有 $Na_j$ 保留，因此除以 $N$ 即可恢复 $a_j$。&lt;/p&gt;
&lt;p&gt;逆变换公式为&lt;/p&gt;
&lt;p&gt;$$
a_j=\frac{1}{N}\sum_{k=0}^{N-1}\widehat a_k\omega_N^{-jk}.
$$&lt;/p&gt;
&lt;p&gt;$\omega_N^{-1}=e^{-2\pi i/N}$ 仍是阶为 $N$ 的单位根，具有同样的周期性、半圈变号与平方折半性质。因此，对点值数组使用负角度的单位根执行同样的分治，最后将每项除以 $N$，就得到原系数。逆变换的时间复杂度同样为 $O(N\log N)$。&lt;/p&gt;
&lt;h2&gt;NTT 的推导&lt;/h2&gt;
&lt;h3&gt;素数模数下的运算&lt;/h3&gt;
&lt;p&gt;NTT 在有限域 $\mathbb{F}_q$ 中进行，本文取素数 $q$，以 $0,1,\ldots,q-1$ 表示域元素。加法、减法和乘法都对 $q$ 取模。下文 NTT 公式中的等号均表示 $\mathbb{F}_q$ 内的相等，即对应整数模 $q$ 同余。&lt;/p&gt;
&lt;p&gt;每个非零元素都有乘法逆元。对 $u\ne0$，因为 $q$ 为素数，$\gcd(u,q)=1$，所以乘以 $u$ 会把全部非零余数重新排列。比较这些余数的乘积，有&lt;/p&gt;
&lt;p&gt;$$
u^{q-1}\prod_{v=1}^{q-1}v
=\prod_{v=1}^{q-1}v.
$$&lt;/p&gt;
&lt;p&gt;乘积非零，可以约去，得到费马小定理及逆元公式：&lt;/p&gt;
&lt;p&gt;$$
u^{q-1}=1,\qquad u^{-1}=u^{q-2}.
$$&lt;/p&gt;
&lt;p&gt;这使等比数列求和中的除法，以及逆变换末尾的归一化，都能在模意义下完成。&lt;/p&gt;
&lt;h3&gt;原根与变换长度&lt;/h3&gt;
&lt;p&gt;一个非零元素的阶，是使其幂等于 $1$ 的最小正整数。模素数 $q$ 的原根 $g$ 的阶为 $q-1$，因而&lt;/p&gt;
&lt;p&gt;$$
1,g,g^2,\ldots,g^{q-2}
$$&lt;/p&gt;
&lt;p&gt;恰好遍历全部非零余数。&lt;/p&gt;
&lt;p&gt;原根存在可以由有限域中多项式的根数说明。设全部非零元素的阶的最小公倍数为 $d$。对 $d$ 的素因数分解中的每个素数幂 $r^e$，选取一个阶中含有 $r^e$ 的元素；若其阶为 $r^eu$ 且 $\gcd(r,u)=1$，取它的 $u$ 次幂就得到阶为 $r^e$ 的元素。将不同素数对应的元素相乘，得到阶为 $d$ 的元素：这些元素的阶两两互质，乘积的阶等于各阶之积，因为相应子群的交集只有单位元。&lt;/p&gt;
&lt;p&gt;另一方面，每个非零元素都是 $x^d-1$ 的根，故 $q-1\le d$；由费马小定理，每个元素的阶均整除 $q-1$，故 $d\le q-1$。于是 $d=q-1$，上述乘积就是一个原根。&lt;/p&gt;
&lt;p&gt;要进行长度为 $N$ 的变换，需要一个阶恰为 $N$ 的元素。它的阶必须整除 $q-1$，所以要求&lt;/p&gt;
&lt;p&gt;$$
N\mid(q-1).
$$&lt;/p&gt;
&lt;p&gt;满足该条件时，定义&lt;/p&gt;
&lt;p&gt;$$
\zeta_N=g^{(q-1)/N}.
$$&lt;/p&gt;
&lt;p&gt;验证其阶：一方面&lt;/p&gt;
&lt;p&gt;$$
\zeta_N^N=g^{q-1}=1;
$$&lt;/p&gt;
&lt;p&gt;另一方面，若 $\zeta_N^t=1$，由 $g$ 的阶为 $q-1$ 得&lt;/p&gt;
&lt;p&gt;$$
q-1\mid\frac{q-1}{N}t,
$$&lt;/p&gt;
&lt;p&gt;等价于 $N\mid t$。因此 $\zeta_N$ 的阶恰为 $N$，且 $1,\zeta_N,\ldots,\zeta_N^{N-1}$ 两两不同。&lt;/p&gt;
&lt;p&gt;取 $N=2^s$ 时，模数通常写作 $q=c,2^h+1$，其中 $c$ 为奇数。支持的二次幂长度满足 $s\le h$。例如&lt;/p&gt;
&lt;p&gt;$$
998244353-1=119\cdot2^{23}
$$&lt;/p&gt;
&lt;p&gt;且 $g=3$ 是该模数的原根，因此支持的最大二次幂长度为 $2^{23}$。&lt;a href=&quot;https://github.com/atcoder/ac-library/blob/master/atcoder/internal_math.hpp&quot;&gt;ACL 的原根实现&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;检查非零候选 $g$ 是否为原根时，只需对 $q-1$ 的每个不同素因子 $r$ 验证&lt;/p&gt;
&lt;p&gt;$$
g^{(q-1)/r}\ne1.
$$&lt;/p&gt;
&lt;p&gt;若 $g$ 的阶为真因子 $d&amp;lt;q-1$，则整数 $(q-1)/d&amp;gt;1$ 含有某个素因子 $r$，从而 $d\mid(q-1)/r$，对应幂会等于 $1$；反之，任一这样的幂等于 $1$，都说明阶小于 $q-1$。&lt;/p&gt;
&lt;h3&gt;模意义下的单位根性质&lt;/h3&gt;
&lt;p&gt;对于偶数长度 $N\mid(q-1)$，必有奇素数模数 $q$。周期性直接来自 $\zeta_N^N=1$：&lt;/p&gt;
&lt;p&gt;$$
\zeta_N^{k+N}=\zeta_N^k.
$$&lt;/p&gt;
&lt;p&gt;令 $v=\zeta_N^{N/2}$，则 $v^2=1$，即&lt;/p&gt;
&lt;p&gt;$$
(v-1)(v+1)=0.
$$&lt;/p&gt;
&lt;p&gt;域中没有零因子，所以 $v=1$ 或 $v=-1$。由于 $\zeta_N$ 的阶为 $N$，不能有 $\zeta_N^{N/2}=1$，故&lt;/p&gt;
&lt;p&gt;$$
\zeta_N^{N/2}=-1,\qquad
\zeta_N^{k+N/2}=-\zeta_N^k.
$$&lt;/p&gt;
&lt;p&gt;对下一层长度，用同一个原根定义 $\zeta_{N/2}=g^{(q-1)/(N/2)}$，于是&lt;/p&gt;
&lt;p&gt;$$
\zeta_N^2
=g^{2(q-1)/N}
=g^{(q-1)/(N/2)}
=\zeta_{N/2},
$$&lt;/p&gt;
&lt;p&gt;从而&lt;/p&gt;
&lt;p&gt;$$
\zeta_N^{2k}=\zeta_{N/2}^k.
$$&lt;/p&gt;
&lt;p&gt;这里的 $-1$ 表示余数 $q-1$，半圈变号由域中方程 $v^2=1$ 的两个解导出。&lt;/p&gt;
&lt;h3&gt;NTT 正变换与蝶形合并&lt;/h3&gt;
&lt;p&gt;把系数视为 $\mathbb{F}_q$ 中的元素，定义正变换&lt;/p&gt;
&lt;p&gt;$$
\widehat a_k
=\sum_{j=0}^{N-1}a_j\zeta_N^{jk},
\qquad 0\le k&amp;lt;N.
$$&lt;/p&gt;
&lt;p&gt;同样按下标奇偶性定义&lt;/p&gt;
&lt;p&gt;$$
A_0(x)=\sum_{j=0}^{N/2-1}a_{2j}x^j,\qquad
A_1(x)=\sum_{j=0}^{N/2-1}a_{2j+1}x^j.
$$&lt;/p&gt;
&lt;p&gt;$A(x)=A_0(x^2)+xA_1(x^2)$ 是多项式恒等式，在有限域中仍成立。记两个子变换为&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
E_k&amp;amp;=\sum_{j=0}^{N/2-1}a_{2j}\zeta_{N/2}^{jk},\
O_k&amp;amp;=\sum_{j=0}^{N/2-1}a_{2j+1}\zeta_{N/2}^{jk}.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;对 $0\le k&amp;lt;N/2$，展开完整变换并使用折半性质：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\widehat a_k
&amp;amp;=\sum_{j=0}^{N/2-1}a_{2j}\zeta_N^{2jk}
+\sum_{j=0}^{N/2-1}a_{2j+1}\zeta_N^{(2j+1)k}\
&amp;amp;=\sum_{j=0}^{N/2-1}a_{2j}\zeta_{N/2}^{jk}
+\zeta_N^k\sum_{j=0}^{N/2-1}a_{2j+1}\zeta_{N/2}^{jk}\
&amp;amp;=E_k+\zeta_N^kO_k.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;把 $k$ 替换为 $k+N/2$。子变换中的取值点不变，因为&lt;/p&gt;
&lt;p&gt;$$
\zeta_{N/2}^{k+N/2}=\zeta_{N/2}^k;
$$&lt;/p&gt;
&lt;p&gt;奇数部分的因子变号，因为 $\zeta_N^{k+N/2}=-\zeta_N^k$。于是&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\widehat a_{k+N/2}
&amp;amp;=E_k-\zeta_N^kO_k,\
(\widehat a_k,\widehat a_{k+N/2})
&amp;amp;=(E_k+\zeta_N^kO_k,\ E_k-\zeta_N^kO_k).
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;递归终点仍是 $N=1$ 时的常数多项式。每层 $O(N)$ 次模运算，共 $\log_2N$ 层，故正变换需要 $O(N\log N)$ 时间。位逆序由系数的奇偶拆分决定，与使用复数还是有限域无关，因此仍可按同一叶子顺序进行原地迭代。&lt;/p&gt;
&lt;h3&gt;NTT 逆变换的推导&lt;/h3&gt;
&lt;p&gt;有限域中的单位根也满足求和关系。若 $N\mid d$，&lt;/p&gt;
&lt;p&gt;$$
\sum_{k=0}^{N-1}\zeta_N^{dk}=N.
$$&lt;/p&gt;
&lt;p&gt;若 $N\nmid d$，令 $r=\zeta_N^d$，则 $r\ne1$，所以 $1-r$ 非零且可逆，得到&lt;/p&gt;
&lt;p&gt;$$
\sum_{k=0}^{N-1}r^k
=(1-r^N)(1-r)^{-1}
=0.
$$&lt;/p&gt;
&lt;p&gt;因此&lt;/p&gt;
&lt;h1&gt;$$
\sum_{k=0}^{N-1}\zeta_N^{dk}&lt;/h1&gt;
&lt;p&gt;\begin{cases}
N,&amp;amp;N\mid d,\
0,&amp;amp;N\nmid d.
\end{cases}
$$&lt;/p&gt;
&lt;p&gt;由于 $N\mid(q-1)$，有 $1\le N\le q-1$，所以 $N$ 在模 $q$ 下非零，逆元 $N^{-1}=N^{q-2}$ 存在。将正变换代入：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
N^{-1}\sum_{k=0}^{N-1}\widehat a_k\zeta_N^{-jk}
&amp;amp;=N^{-1}\sum_{t=0}^{N-1}a_t
\sum_{k=0}^{N-1}\zeta_N^{(t-j)k}\
&amp;amp;=N^{-1}\cdot N a_j\
&amp;amp;=a_j.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;故逆变换为&lt;/p&gt;
&lt;p&gt;$$
a_j=N^{-1}\sum_{k=0}^{N-1}\widehat a_k\zeta_N^{-jk}.
$$&lt;/p&gt;
&lt;p&gt;逆单位根可以从原根逆元构造：&lt;/p&gt;
&lt;p&gt;$$
\zeta_N^{-1}
=\left(g^{-1}\right)^{(q-1)/N},
\qquad g^{-1}=g^{q-2}.
$$&lt;/p&gt;
&lt;p&gt;对点值数组用 $g^{-1}$ 生成各层单位根，执行同样的蝶形合并，再把每一项乘以 $N^{-1}$，就得到原系数。&lt;/p&gt;
&lt;h3&gt;小模数例子&lt;/h3&gt;
&lt;p&gt;取 $q=17$、$g=3$。由于 $3^8\equiv-1\pmod{17}$，而 $3^{16}\equiv1\pmod{17}$，$3$ 的阶为 $16$，是原根。长度为 $4$ 的单位根为&lt;/p&gt;
&lt;p&gt;$$
\zeta_4=3^{16/4}\equiv13\pmod{17},
\qquad
(1,\zeta_4,\zeta_4^2,\zeta_4^3)=(1,13,16,4).
$$&lt;/p&gt;
&lt;p&gt;对系数 $(1,2,3,4)$，偶数与奇数下标数组分别是 $(1,3)$、$(2,4)$。由于 $\zeta_2=-1$，两个子变换为&lt;/p&gt;
&lt;p&gt;$$
(E_0,E_1)=(1+3,\ 1-3)=(4,15),
$$&lt;/p&gt;
&lt;p&gt;$$
(O_0,O_1)=(2+4,\ 2-4)=(6,15).
$$&lt;/p&gt;
&lt;p&gt;在模 $17$ 下合并：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\widehat a_0&amp;amp;=4+6=10,\
\widehat a_2&amp;amp;=4-6=15,\
\widehat a_1&amp;amp;=15+13\cdot15=6,\
\widehat a_3&amp;amp;=15-13\cdot15=7.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;所以完整点值数组为 $(10,6,15,7)$。这里按原下标顺序存放结果，而计算过程中按成对点值合并。&lt;/p&gt;
&lt;p&gt;逆单位根为 $\zeta_4^{-1}=4$，归一化因子为 $4^{-1}=13$。例如恢复下标 $j=1$ 的系数：&lt;/p&gt;
&lt;p&gt;$$
a_1
=13\left(10+6\cdot4+15\cdot16+7\cdot13\right)
=13\cdot8
=2.
$$&lt;/p&gt;
&lt;p&gt;此例中的全部等式均在 $\mathbb{F}_{17}$ 内成立。&lt;/p&gt;
&lt;h2&gt;由变换得到卷积&lt;/h2&gt;
&lt;h3&gt;点值相乘为什么得到卷积&lt;/h3&gt;
&lt;p&gt;对 FFT 取 $\xi=\omega_N$，对 NTT 取 $\xi=\zeta_N$。将两个数组补零到相同长度 $N$，并记其正变换为 $\widehat a$、$\widehat b$。逐点相乘后，&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\widehat c_k
&amp;amp;=\widehat a_k\widehat b_k\
&amp;amp;=\left(\sum_{i=0}^{N-1}a_i\xi^{ik}\right)
\left(\sum_{j=0}^{N-1}b_j\xi^{jk}\right)\
&amp;amp;=\sum_{i=0}^{N-1}\sum_{j=0}^{N-1}a_ib_j\xi^{(i+j)k}.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;对这些乘积点值做逆变换。复数域中的 $N^{-1}$ 表示 $1/N$；有限域中表示模逆元。恢复出的第 $t$ 项（$0\le t&amp;lt;N$）为&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\widetilde c_t
&amp;amp;=N^{-1}\sum_{k=0}^{N-1}\widehat c_k\xi^{-tk}\
&amp;amp;=\sum_{i=0}^{N-1}\sum_{j=0}^{N-1}a_ib_j
\left(N^{-1}\sum_{k=0}^{N-1}\xi^{(i+j-t)k}\right)\
&amp;amp;=\sum_{\substack{0\le i,j&amp;lt;N\i+j\equiv t\pmod N}}a_ib_j.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;最后一步来自单位根求和：只有 $N\mid(i+j-t)$ 的项保留。因此，长度为 $N$ 的变换直接给出长度为 $N$ 的循环卷积。&lt;/p&gt;
&lt;h3&gt;线性卷积为什么需要补零&lt;/h3&gt;
&lt;p&gt;原数组仅在 $0\le i&amp;lt;n$、$0\le j&amp;lt;m$ 时非零，所以所有有效次数满足&lt;/p&gt;
&lt;p&gt;$$
0\le i+j\le n+m-2.
$$&lt;/p&gt;
&lt;p&gt;若选取 $N\ge n+m-1$，这些次数均小于 $N$。此时对 $0\le t&amp;lt;N$，条件 $i+j\equiv t\pmod N$ 等价于 $i+j=t$，从而&lt;/p&gt;
&lt;p&gt;$$
\widetilde c_t=c_t.
$$&lt;/p&gt;
&lt;p&gt;若长度不足，则次数 $t$、$t+N$ 等位置的系数会累加到同一项。从多项式看，单位根满足 $\xi^N=1$，变换结果只能区分模 $x^N-1$ 后的多项式：&lt;/p&gt;
&lt;p&gt;$$
x^{t+N}\equiv x^t\pmod{x^N-1}.
$$&lt;/p&gt;
&lt;p&gt;因而需要完整线性卷积时，选取不小于 $n+m-1$ 的最小二次幂 $N$；需要循环卷积时，则利用这一折叠关系。例如模 $x^m-1$ 的卷积可先求普通乘积，再将次数按模 $m$ 合并。&lt;/p&gt;
&lt;p&gt;NTT 还必须满足 $N\mid(q-1)$。ACL 的模数卷积接口也要求素数模数及足够大的二次幂因子。&lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/convolution.html&quot;&gt;ACL 卷积文档&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;计算量与数值结果&lt;/h3&gt;
&lt;p&gt;完整卷积包含两次正变换、一次逐点相乘、一次逆变换，总时间为 $O(N\log N)$，采用原地迭代时空间为 $O(N)$。&lt;/p&gt;
&lt;p&gt;FFT 的上述等式在复数域内精确成立；浮点实现会产生舍入误差。若原系数为整数，只有当恢复值与真实整数之间的误差小于 $1/2$ 时，四舍五入才保证正确，系数范围和变换长度会影响这一误差。&lt;/p&gt;
&lt;p&gt;NTT 的运算给出精确的模 $q$ 卷积系数。单个模数只确定余数；需要其他模数下的结果或普通整数系数时，可以使用多个 NTT 模数与 CRT，并满足整数恢复的范围条件。下文三份源代码均执行 NTT，其中前两份将变换函数命名为 &lt;code&gt;fft&lt;/code&gt;。&lt;/p&gt;
&lt;h2&gt;Luogu P4245：任意模数多项式乘法&lt;/h2&gt;
&lt;h3&gt;题目重述&lt;/h3&gt;
&lt;p&gt;给出两个多项式及目标模数 $p$，输出它们相乘后各项系数对 $p$ 取模的结果。目标模数不一定支持所需长度的 NTT。&lt;/p&gt;
&lt;h3&gt;关键观察&lt;/h3&gt;
&lt;p&gt;代码分别在 $p_1=998244353$、$p_2=1004535809$、$p_3=469762049$ 下做 NTT。记三次卷积得到的第 $k$ 项余数为 $r_1,r_2,r_3$，令 $P=p_1p_2p_3$，$M_i=P/p_i$，并令 $t_i=M_i^{-1}\pmod {p_i}$，则 CRT 重建为&lt;/p&gt;
&lt;p&gt;$$
C_k=\left(\sum_{i=1}^{3} r_iM_it_i\right)\bmod P.
$$&lt;/p&gt;
&lt;h3&gt;解析&lt;/h3&gt;
&lt;p&gt;代码先把两个多项式补零至足够大的二次幂长度，再对三个 NTT 模数分别执行卷积。最后用 CRT 恢复普通整数系数，并对目标模数 $p$ 取模。所有中间合并使用 &lt;code&gt;__int128&lt;/code&gt;，避免乘积溢出。&lt;/p&gt;
&lt;p&gt;CRT 只能唯一恢复区间 $[0,P)$ 中的整数。若原系数均在 $[0,p)$，则单个卷积系数满足&lt;/p&gt;
&lt;p&gt;$$
C_k\le \min(\ell_A,\ell_B)(p-1)^2,
$$&lt;/p&gt;
&lt;p&gt;其中 $\ell_A,\ell_B$ 是两个输入的系数个数。恢复普通整数系数要求这一上界严格小于 $P$。三模数共同支持的二次幂长度受 $p_2$ 限制，最大为 $2^{21}$。&lt;/p&gt;
&lt;p&gt;总时间复杂度为 $O(N\log N)$，空间复杂度为 $O(N)$；三组模数只增加常数倍开销。&lt;/p&gt;
&lt;h3&gt;代码&lt;/h3&gt;
&lt;p&gt;源代码文件：&lt;code&gt;luogu/P4245.cpp&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define tii tuple&amp;lt;int, int, int&amp;gt;
#define tll tuple&amp;lt;ll, ll, ll&amp;gt;
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
#define inf 0x3f3f3f3f3f3f3f3f
#define N 100005
#define lc p &amp;lt;&amp;lt; 1
#define rc p &amp;lt;&amp;lt; 1 | 1
#define ll __int128
using namespace std;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    auto qp = [&amp;amp;](ll x, ll k, ll MOD) {
        ll res = 1;
        while (k) {
            if (k &amp;amp; 1)
                res = (res * x) % MOD;
            x = (x * x) % MOD;
            k &amp;gt;&amp;gt;= 1;
        }
        return res;
    };
    auto multi = [&amp;amp;](vector&amp;lt;ll&amp;gt; a, vector&amp;lt;ll&amp;gt; b, ll MOD) {
        auto n = a.size();
        const ll g = 3, gi = qp(3, MOD - 2, MOD);
        auto fft = [&amp;amp;](vector&amp;lt;ll&amp;gt; &amp;amp;a, ll g) {
            int n = a.size();
            vector&amp;lt;int&amp;gt; aim(n, 0);
            for (int i = 1; i &amp;lt; n; i++) {
                aim[i] = (aim[i &amp;gt;&amp;gt; 1] &amp;gt;&amp;gt; 1) + (i &amp;amp; 1) * (n &amp;gt;&amp;gt; 1);
            }
            for (int i = 0; i &amp;lt; n; i++) {
                if (i &amp;lt; aim[i])
                    swap(a[i], a[aim[i]]);
            }
            for (int len = 2; len &amp;lt;= n; len &amp;lt;&amp;lt;= 1) {
                for (int left = 0; left &amp;lt; n; left += len) {
                    ll gk = 1;
                    ll g1 = qp(g, (MOD - 1) / len, MOD);
                    for (int j = 0; j &amp;lt; len / 2; j++) {
                        ll x = a[left + j], y = a[left + j + len / 2] * gk % MOD;
                        a[left + j] = (x + y) % MOD, a[left + j + len / 2] = (x - y + MOD) % MOD;
                        gk = (gk * g1) % MOD;
                    }
                }
            }
        };
        fft(a, g);
        fft(b, g);
        vector&amp;lt;ll&amp;gt; res(n, 0);
        for (int i = 0; i &amp;lt; n; i++) {
            res[i] = a[i] * b[i] % MOD;
        }
        fft(res, gi);
        auto inv = qp(n, MOD - 2, MOD);
        for (int i = 0; i &amp;lt; n; i++) {
            res[i] = (res[i] * inv) % MOD;
        }
        return std::move(res);
    };
    auto solve = [&amp;amp;]() {
        long long n, m, p;
        cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m &amp;gt;&amp;gt; p;
        vector&amp;lt;ll&amp;gt; a(n + 1, 0);
        vector&amp;lt;ll&amp;gt; b(m + 1, 0);
        for (int i = 0; i &amp;lt;= n; i++) {
            long long x;
            cin &amp;gt;&amp;gt; x;
            a[i] = x;
        }
        for (int i = 0; i &amp;lt;= m; i++) {
            long long x;
            cin &amp;gt;&amp;gt; x;
            b[i] = x;
        }
        for (m = n + m, n = 1; n &amp;lt;= m; n &amp;lt;&amp;lt;= 1)
            ;
        a.resize(n, 0);
        b.resize(n, 0);
        const ll p1 = 998244353;
        const ll p2 = 1004535809;
        const ll p3 = 469762049;
        ll product = (ll)p1 * p2 * p3;
        ll M1 = product / p1;
        ll M2 = product / p2;
        ll M3 = product / p3;
        ll t1 = qp((ll)(M1 % p1), p1 - 2, p1);
        ll t2 = qp((ll)(M2 % p2), p2 - 2, p2);
        ll t3 = qp((ll)(M3 % p3), p3 - 2, p3);
        auto r1 = multi(a, b, p1);
        auto r2 = multi(a, b, p2);
        auto r3 = multi(a, b, p3);
        for (int k = 0; k &amp;lt;= m; k++) {
            ll C = ((ll)r1[k] * M1 * t1 + (ll)r2[k] * M2 * t2 + (ll)r3[k] * M3 * t3) % product;

            cout &amp;lt;&amp;lt; (long long)(C % p) &amp;lt;&amp;lt; &apos; &apos;;
        }
    };

    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;AtCoder practice2 F：固定模数卷积&lt;/h2&gt;
&lt;h3&gt;题目重述&lt;/h3&gt;
&lt;p&gt;给出两个系数数组，计算它们在模 $998244353$ 下的线性卷积，并按次数递增输出系数。&lt;/p&gt;
&lt;h3&gt;关键观察&lt;/h3&gt;
&lt;p&gt;$998244353=119\cdot2^{23}+1$，原根为 $3$，因而支持不超过 $2^{23}$ 的二次幂长度 NTT。代码中的 &lt;code&gt;fft&lt;/code&gt; 函数执行 NTT。&lt;/p&gt;
&lt;h3&gt;解析&lt;/h3&gt;
&lt;p&gt;程序读取两个数组后补零到不小于输出系数个数的最小二次幂，分别做正变换，再逐点相乘。逆变换使用 $3^{-1}\pmod{998244353}$，随后乘 $N^{-1}\pmod{998244353}$，输出前 $n+m-1$ 项。复杂度为 $O(N\log N)$，空间复杂度为 $O(N)$。&lt;/p&gt;
&lt;h3&gt;代码&lt;/h3&gt;
&lt;p&gt;源代码文件：&lt;code&gt;atcoder/practice2/f.cpp&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define tii tuple&amp;lt;int, int, int&amp;gt;
#define tll tuple&amp;lt;ll, ll, ll&amp;gt;
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
#define inf 0x3f3f3f3f3f3f3f3f
#define N 100005
#define M 1000005
#define lc p &amp;lt;&amp;lt; 1
#define rc p &amp;lt;&amp;lt; 1 | 1
using namespace std;
const ll MOD = 998244353;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    auto qp = [&amp;amp;](ll x, ll k) {
        ll res = 1;
        while (k) {
            if (k &amp;amp; 1)
                res = (res * x) % MOD;
            x = (x * x) % MOD;
            k &amp;gt;&amp;gt;= 1;
        }
        return res;
    };
    const ll g = 3, gi = qp(3, MOD - 2);
    auto fft = [&amp;amp;](vector&amp;lt;ll&amp;gt; &amp;amp;a, ll g) {
        int n = a.size();
        vector&amp;lt;int&amp;gt; aim(n, 0);
        for (int i = 1; i &amp;lt; n; i++) {
            aim[i] = (aim[i &amp;gt;&amp;gt; 1] &amp;gt;&amp;gt; 1) + (i &amp;amp; 1) * (n &amp;gt;&amp;gt; 1);
        }
        for (int i = 0; i &amp;lt; n; i++) {
            if (i &amp;lt; aim[i])
                swap(a[i], a[aim[i]]);
        }
        for (int len = 2; len &amp;lt;= n; len &amp;lt;&amp;lt;= 1) {
            for (int left = 0; left &amp;lt; n; left += len) {
                ll gk = 1;
                ll g1 = qp(g, (MOD - 1) / len);
                for (int j = 0; j &amp;lt; len / 2; j++) {
                    ll x = a[left + j], y = a[left + j + len / 2] * gk % MOD;
                    a[left + j] = (x + y) % MOD, a[left + j + len / 2] = (x - y + MOD) % MOD;
                    gk = (gk * g1) % MOD;
                }
            }
        }
    };
    auto solve = [&amp;amp;]() {
        ll n, m;
        cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
        n--, m--;
        vector&amp;lt;ll&amp;gt; a(n + 1, 0);
        vector&amp;lt;ll&amp;gt; b(m + 1, 0);
        for (int i = 0; i &amp;lt;= n; i++)
            cin &amp;gt;&amp;gt; a[i];
        for (int i = 0; i &amp;lt;= m; i++)
            cin &amp;gt;&amp;gt; b[i];
        for (m = n + m, n = 1; n &amp;lt;= m; n &amp;lt;&amp;lt;= 1)
            ;
        a.resize(n, 0);
        b.resize(n, 0);
        fft(a, g);
        fft(b, g);
        vector&amp;lt;ll&amp;gt; res(n, 0);
        for (int i = 0; i &amp;lt; n; i++) {
            res[i] = a[i] * b[i] % MOD;
        }
        fft(res, gi);
        auto inv = qp(n, MOD - 2);
        for (int i = 0; i &amp;lt;= m; i++) {
            cout &amp;lt;&amp;lt; (res[i] * inv) % MOD &amp;lt;&amp;lt; &apos; &apos;;
        }
    };

    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;2023 ICPC 西安区域赛 F：An Easy Counting Problem&lt;/h2&gt;
&lt;h3&gt;题目重述&lt;/h3&gt;
&lt;p&gt;给定整数 $k$、素数 $p$ 和非零剩余类 $x$，求满足&lt;/p&gt;
&lt;p&gt;$$
0\le b\le a&amp;lt;p^k,\qquad \binom ab\equiv x\pmod p
$$&lt;/p&gt;
&lt;p&gt;的整数对 $(a,b)$ 数量，答案对 $q=998244353$ 取模。约束为 $1\le k\le2^{1000}$、$2\le p\le5000$、$1\le x&amp;lt;p$；$k$ 以二进制字符串给出。&lt;a href=&quot;https://codeforces.com/gym/105471/problem/F?locale=en&quot;&gt;原题：2023 ICPC 西安区域赛 F&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;关键观察&lt;/h3&gt;
&lt;p&gt;将 $a,b$ 写成 $k$ 位的 $p$ 进制数，不足的位补零：&lt;/p&gt;
&lt;p&gt;$$
a=\sum_{t=0}^{k-1}a_tp^t,\qquad
b=\sum_{t=0}^{k-1}b_tp^t.
$$&lt;/p&gt;
&lt;p&gt;则&lt;/p&gt;
&lt;p&gt;$$
\binom ab\equiv\prod_{t=0}^{k-1}\binom{a_t}{b_t}\pmod p.
$$&lt;/p&gt;
&lt;p&gt;当 $p$ 为素数时，$\binom p r$ 在 $0&amp;lt;r&amp;lt;p$ 时均能被 $p$ 整除，故 $(1+z)^p\equiv1+z^p\pmod p$。于是&lt;/p&gt;
&lt;p&gt;$$
(1+z)^a\equiv\prod_{t=0}^{k-1}(1+z^{p^t})^{a_t}\pmod p.
$$&lt;/p&gt;
&lt;p&gt;比较 $z^b$ 的系数即得 Lucas 定理。各因子的局部次数小于 $p$，因此不产生数位进位。&lt;/p&gt;
&lt;p&gt;若某位 $b_t&amp;gt;a_t$，该位组合数为零，整个乘积为零，与 $x\ne0$ 矛盾。若各位均满足 $0\le b_t\le a_t&amp;lt;p$，则 $b\le a$；局部组合数的分子、分母都由小于 $p$ 的正整数相乘，所以其模 $p$ 余数非零。合法整数对因此与 $k$ 组满足局部条件的数位对一一对应，答案取决于这些组合数余数的乘积。&lt;/p&gt;
&lt;p&gt;取模 $p$ 的原根 $\rho$，令 $m=p-1$。单个数位产生余数 $r$ 的方案数为&lt;/p&gt;
&lt;p&gt;$$
f_r=#\left{(i,j):0\le j\le i&amp;lt;p,\ \binom ij\equiv r\pmod p\right},
\qquad 1\le r&amp;lt;p.
$$&lt;/p&gt;
&lt;p&gt;合并两段数位时，余数满足乘法关系，所以频数转移为&lt;/p&gt;
&lt;p&gt;$$
(f\star h)&lt;em&gt;r=\sum&lt;/em&gt;{uv\equiv r\pmod p}f_uh_v.
$$&lt;/p&gt;
&lt;p&gt;因为 $\rho^i\rho^j=\rho^{(i+j)\bmod m}$，按离散对数重新排列余数后，下标转移成为模 $m$ 的加法。定义&lt;/p&gt;
&lt;p&gt;$$
F(z)=\sum_{e=0}^{m-1}f_{\rho^e\bmod p}z^e,
$$&lt;/p&gt;
&lt;p&gt;则所求答案为&lt;/p&gt;
&lt;p&gt;$$
[z^{\log_\rho x}]\left(F(z)^k\bmod(z^m-1)\right).
$$&lt;/p&gt;
&lt;p&gt;组合数及余数乘法在模 $p$ 下计算；方案数及 NTT 运算在模 $q=998244353$ 下计算。代码中的 &lt;code&gt;root&lt;/code&gt; 是模 $p$ 的原根 $\rho$，&lt;code&gt;g = 3&lt;/code&gt; 是模 $q$ 的 NTT 原根。&lt;/p&gt;
&lt;h3&gt;解析&lt;/h3&gt;
&lt;p&gt;每个数位的余数分布都相同，因而需要计算 $F(z)$ 在模 $z^m-1$ 下的 $k$ 次幂。二进制快速幂需要 $O(L)$ 次循环卷积，其中 $L$ 为 $k$ 的二进制长度。&lt;/p&gt;
&lt;p&gt;程序先用 Pascal 递推计算 &lt;code&gt;c[i][j]&lt;/code&gt;，此处对 $p$ 取模。枚举 $0\le j\le i&amp;lt;p$，将每项计入 &lt;code&gt;base.s[rev[c[i][j]]]&lt;/code&gt;，其中 &lt;code&gt;rev[v]&lt;/code&gt; 存储 $\log_\rho v$。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;poly::operator*&lt;/code&gt; 使用模 $q$ 的 NTT 计算两个长度为 $m$ 的数组的线性卷积。设结果为 $c_e$，由于 $z^m=1$，循环卷积需要折叠为&lt;/p&gt;
&lt;p&gt;$$
h_e=c_e+c_{e+m}\pmod q,\qquad 0\le e&amp;lt;m.
$$&lt;/p&gt;
&lt;p&gt;两个输入的次数都小于 $m$，乘积次数至多 $2m-2$，因此每项最多折叠一次。代码先完成逆变换及乘 $N^{-1}$ 的归一化，再把第 $e+m$ 项加回第 $e$ 项，最后保留前 $m$ 项。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;qp_&lt;/code&gt; 从二进制字符串末尾向前读取，维护当前底数与累积结果。初始结果是常数多项式 $1$；当前位为一时乘入底数，每处理一位就将底数平方。全部数位处理完后，&lt;code&gt;res.s[rev[x]]&lt;/code&gt; 即为答案。&lt;/p&gt;
&lt;p&gt;设二进制串长度为 $L$，代码选取不小于 $2m$ 的最小二次幂 $N$。由 $p\le5000$ 可知 $N\le2^{14}$，且 $N\mid(q-1)$。Pascal 表与逐候选原根搜索的预处理耗时至多 $O(p^2)$；快速幂耗时 $O(LN\log N)$。总时间复杂度为 $O(p^2+LN\log N)$，空间复杂度为 $O(p^2+N)$；其中平方级空间来自代码保存的完整 Pascal 表。&lt;/p&gt;
&lt;h3&gt;代码&lt;/h3&gt;
&lt;p&gt;源代码文件：&lt;code&gt;reginonals/23xian/f.cpp&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/extc++.h&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define tii tuple&amp;lt;int, int, int&amp;gt;
#define tll tuple&amp;lt;ll, ll, ll&amp;gt;
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
#define inf 0x3f3f3f3f3f3f3f3f
#define N 100005
#define M 1000005
#define lc p &amp;lt;&amp;lt; 1
#define rc p &amp;lt;&amp;lt; 1 | 1
using namespace std;
using namespace __gnu_pbds;
ll p, x;
string k;
const ll MOD = 998244353;
auto qp = [](ll x, ll k) {
    ll res = 1;
    while (k) {
        if (k &amp;amp; 1)
            res = (res * x) % MOD;
        x = (x * x) % MOD;
        k &amp;gt;&amp;gt;= 1;
    }
    return res;
};
const ll g = 3, gi = qp(3, MOD - 2);
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);

    auto solve = [&amp;amp;]() {
        cin &amp;gt;&amp;gt; k &amp;gt;&amp;gt; p &amp;gt;&amp;gt; x;
        class poly {
          public:
            vector&amp;lt;ll&amp;gt; s;
            poly() {
                s.assign(p - 1, 0);
                s[0] = 1;
            }
            poly(vector&amp;lt;ll&amp;gt; &amp;amp;&amp;amp;a) noexcept : s(std::move(a)){};
            static void ntt(vector&amp;lt;ll&amp;gt; &amp;amp;a, ll g) {
                int n = a.size();
                vector&amp;lt;ll&amp;gt; aim(a.size(), 0);
                for (int i = 1; i &amp;lt; n; i++) {
                    aim[i] = (aim[i &amp;gt;&amp;gt; 1] &amp;gt;&amp;gt; 1) + (i &amp;amp; 1) * (n &amp;gt;&amp;gt; 1);
                }
                for (int i = 0; i &amp;lt; n; i++) {
                    if (i &amp;lt; aim[i])
                        swap(a[i], a[aim[i]]);
                }
                for (int len = 2; len &amp;lt;= n; len &amp;lt;&amp;lt;= 1) {
                    ll g1 = qp(g, (MOD - 1) / len);
                    for (int left = 0; left &amp;lt; n; left += len) {
                        ll gk = 1;
                        for (int j = 0; j &amp;lt; len / 2; j++) {
                            ll x = a[left + j], y = a[left + j + len / 2] * gk % MOD;
                            a[left + j] = (x + y) % MOD, a[left + j + len / 2] = (x - y + MOD) % MOD;
                            gk = gk * g1 % MOD;
                        }
                    }
                }
            }
            poly operator*(const poly &amp;amp;oth) const {
                vector&amp;lt;ll&amp;gt; a = s;
                vector&amp;lt;ll&amp;gt; b = oth.s;
                auto ori = a.size();
                auto n = a.size(), m = b.size();
                for (m = n + m, n = 1; n &amp;lt; m; n &amp;lt;&amp;lt;= 1)
                    ;
                a.resize(n, 0);
                b.resize(n, 0);
                ntt(a, g);
                ntt(b, g);
                for (int i = 0; i &amp;lt; n; i++) {
                    a[i] = a[i] * b[i] % MOD;
                }
                ntt(a, gi);
                auto inv = qp(n, MOD - 2);
                for (int i = 0; i &amp;lt; ori; i++) {
                    a[i] = a[i] * inv % MOD, a[i + ori] = a[i + ori] * inv % MOD;
                    a[i] = (a[i] + a[i + ori]) % MOD;
                }
                a.resize(ori);
                return {std::move(a)};
            };
        };
        auto find_root = [&amp;amp;](ll p) {
            if (p == 2)
                return 1;
            for (int i = 2; i &amp;lt; p; i++) {
                auto x = i;
                for (int j = 1, x = i; j &amp;lt; p - 1; j++, x = x * i % p) {
                    if (x == 1)
                        goto ca;
                }
                return i;
            ca:;
            }
        };
        auto root = find_root(p);
        vector&amp;lt;ll&amp;gt; rev(p + 10, 0);
        for (int i = 1, cnt = 0; cnt &amp;lt; p - 1; cnt++, i = i * root % p) {
            rev[i] = cnt;
        }
        vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt; c(p + 5, vector&amp;lt;ll&amp;gt;(p + 5, 0));
        auto init = [&amp;amp;]() {
            c[0][0] = 1;
            for (int i = 1; i &amp;lt; p; i++) {
                c[i][0] = 1, c[i][i] = 1;
                for (int j = 1; j &amp;lt; i; j++) {
                    c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % p;
                }
            }
        };
        init();
        poly base;
        base.s[0] = 0;
        for (int i = 0; i &amp;lt; p; i++) {
            for (int j = 0; j &amp;lt;= i; j++) {
                base.s[rev[c[i][j]]]++;
            }
        }
        auto qp_ = [&amp;amp;](poly x, string &amp;amp;k) {
            poly res;
            while (k.size()) {
                if (k.back() == &apos;1&apos;)
                    res = (res * x);
                x = (x * x);
                k.pop_back();
            }
            return res;
        };
        auto res = qp_(base, k);
        cout &amp;lt;&amp;lt; res.s[rev[x]];
    };

    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Josephus Problem II</title><link>https://sanzenin.top/posts/obsidian/josephus%E7%8E%AF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/josephus%E7%8E%AF/</guid><description>有 个孩子按编号 围成一圈。游戏不断进行：每次跳过 个仍在圈中的孩子，然后删除下一个孩子。要求输出所有孩子被删除的顺序。 约束为 ， 。由于 可能很大，不能逐个模拟跳过过程；由于删除次数为 ，也不能在普通数组中直接删除元素，否则总复杂度会达到 。 当前剩余孩子按编号升序排列，可视为一个动态序列。若上一轮删除的是当前序列</description><pubDate>Mon, 16 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Josephus Problem II&lt;/h1&gt;
&lt;h2&gt;题目重述&lt;/h2&gt;
&lt;p&gt;有 $n$ 个孩子按编号 $1,2,\ldots,n$ 围成一圈。游戏不断进行：每次跳过 $k$ 个仍在圈中的孩子，然后删除下一个孩子。要求输出所有孩子被删除的顺序。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/circle_step_1.png&quot; alt=&quot;样例第一轮删除&quot; /&gt;&lt;/p&gt;
&lt;p&gt;约束为 $1 \le n \le 2 \times 10^5$，$0 \le k \le 10^9$。由于 $k$ 可能很大，不能逐个模拟跳过过程；由于删除次数为 $n$，也不能在普通数组中直接删除元素，否则总复杂度会达到 $O(n^2)$。&lt;/p&gt;
&lt;h2&gt;关键观察&lt;/h2&gt;
&lt;p&gt;当前剩余孩子按编号升序排列，可视为一个动态序列。若上一轮删除的是当前序列中的下标 $id$，删除后其右侧元素会自动前移，因此下一轮的起点仍然是新的下标 $id$。于是下一次删除位置满足：&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/relative_index_compression.png&quot; alt=&quot;相对下标压缩&quot; /&gt;&lt;/p&gt;
&lt;p&gt;$$
id \leftarrow (id + k) \bmod \text{cur_size}.
$$&lt;/p&gt;
&lt;p&gt;这里的 $id$ 是当前存活序列中的 $0$ 基相对下标，不是孩子的真实编号。真实编号需要通过数据结构查询“当前第 $id+1$ 个存活孩子是谁”。&lt;/p&gt;
&lt;p&gt;树状数组维护每个编号是否仍然存活。令存活为 $1$，删除为 $0$，则当前第 $p$ 个存活孩子等价于寻找最小位置 $x$，使得：&lt;/p&gt;
&lt;p&gt;$$
\sum_{i=1}^{x} a_i \ge p.
$$&lt;/p&gt;
&lt;p&gt;树状数组的倍增查询可以在 $O(\log n)$ 时间内完成该查找。&lt;/p&gt;
&lt;h2&gt;解析&lt;/h2&gt;
&lt;p&gt;树状数组数组 &lt;code&gt;s&lt;/code&gt; 中，&lt;code&gt;s[x]&lt;/code&gt; 保存以 $x$ 为右端点、长度为 $\operatorname{lowbit}(x)$ 的区间和：&lt;/p&gt;
&lt;p&gt;$$
s[x] = \sum_{i=x-\operatorname{lowbit}(x)+1}^{x} a_i.
$$&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/fenwick_blocks.png&quot; alt=&quot;树状数组区间块&quot; /&gt;&lt;/p&gt;
&lt;p&gt;函数 &lt;code&gt;find_k(tol)&lt;/code&gt; 的目标是找到第 &lt;code&gt;tol&lt;/code&gt; 个存活孩子。它维护变量 &lt;code&gt;id&lt;/code&gt;，含义是：当前已经确认前 &lt;code&gt;id&lt;/code&gt; 个位置不足以包含目标，即：&lt;/p&gt;
&lt;p&gt;$$
\operatorname{prefix}(id) &amp;lt; \text{原始 } tol.
$$&lt;/p&gt;
&lt;p&gt;因此答案一定在 &lt;code&gt;id&lt;/code&gt; 的右侧。&lt;/p&gt;
&lt;p&gt;倍增时从不超过 $n$ 的最大二次幂开始，依次尝试 &lt;code&gt;step&lt;/code&gt;。令：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;next = id + step;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/find_kth_blocks_visual.png&quot; alt=&quot;倍增试探区间&quot; /&gt;&lt;/p&gt;
&lt;p&gt;若 &lt;code&gt;next &amp;lt;= n&lt;/code&gt; 且 &lt;code&gt;s[next] &amp;lt; tol&lt;/code&gt;，说明从 &lt;code&gt;id+1&lt;/code&gt; 到 &lt;code&gt;next&lt;/code&gt; 这一整块中的存活数量仍不足以包含目标，可以整块跳过，于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;tol -= s[next];
id = next;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;关键是为什么 &lt;code&gt;s[next]&lt;/code&gt; 正好表示右侧试探区间。倍增过程保持一个二进制对齐不变量：在当前 &lt;code&gt;step&lt;/code&gt; 轮开始时，&lt;code&gt;id&lt;/code&gt; 是 $2 \cdot step$ 的倍数。于是：&lt;/p&gt;
&lt;p&gt;$$
next = id + step
$$&lt;/p&gt;
&lt;p&gt;的最低位 $1$ 正好是 &lt;code&gt;step&lt;/code&gt;，即：&lt;/p&gt;
&lt;p&gt;$$
\operatorname{lowbit}(next) = step.
$$&lt;/p&gt;
&lt;p&gt;所以 &lt;code&gt;s[next]&lt;/code&gt; 覆盖的区间为：&lt;/p&gt;
&lt;p&gt;$$
[next-step+1,next] = [id+1,next].
$$&lt;/p&gt;
&lt;p&gt;这正是从当前边界向右试探的整块区间。&lt;/p&gt;
&lt;p&gt;若 &lt;code&gt;s[next] &amp;gt;= tol&lt;/code&gt;，说明目标已经落在该块内，不能跳过，只能缩小 &lt;code&gt;step&lt;/code&gt; 继续定位。循环结束时，&lt;code&gt;id&lt;/code&gt; 是最后一个满足前缀和仍小于目标的位置，因此答案是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;return id + 1;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每轮删除过程为：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;用 $id=(id+k)\bmod \text{cur_size}$ 得到当前存活序列中的删除下标；&lt;/li&gt;
&lt;li&gt;用 &lt;code&gt;find_k(id+1)&lt;/code&gt; 将相对下标转换为真实编号；&lt;/li&gt;
&lt;li&gt;输出该编号，并通过 &lt;code&gt;add(res, -1)&lt;/code&gt; 在树状数组中删除它。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;每个孩子被删除一次，每次执行一次树状数组倍增查找和一次单点更新，时间复杂度为：&lt;/p&gt;
&lt;p&gt;$$
O(n \log n).
$$&lt;/p&gt;
&lt;p&gt;树状数组占用 $O(n)$ 空间。&lt;/p&gt;
&lt;h2&gt;代码&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/extc++.h&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 200005
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define inf 100000000000
using namespace std;
ll n, m, k;
ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k;
#define lowbit(x) (x &amp;amp; -x)
    vector&amp;lt;int&amp;gt; s(n + 5, 0);
    auto add = [&amp;amp;](int x, int add) {
        for (int i = x; i &amp;lt;= n; i += lowbit(i)) {
            s[i] += add;
        }
    };
    for (int i = 1; i &amp;lt;= n; i++) {
        add(i, 1);
    }
    auto find_k = [&amp;amp;](ll tol) {
        ll step = 1LL &amp;lt;&amp;lt; (63 - __builtin_clzll(n));
        ll id = 0;
        for (; step &amp;gt;= 1; step &amp;gt;&amp;gt;= 1) {
            ll next = id + step;
            if (next &amp;lt;= n &amp;amp;&amp;amp; s[next] &amp;lt; tol) {
                tol -= s[next];
                id = next;
            }
        }
        return id + 1;
    };
    int id = 0;
    for (ll cur_size = n; cur_size &amp;gt;= 1; cur_size--) {
        id = (id + k) % cur_size;
        auto res = find_k(id + 1);
        cout &amp;lt;&amp;lt; res &amp;lt;&amp;lt; &apos;\n&apos;;
        add(res, -1);
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Problem: Sliding Window Maximum (LeetCode 239)</title><link>https://sanzenin.top/posts/obsidian/problem-sliding-window-maximum/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/problem-sliding-window-maximum/</guid><description>给定整数数组 与正整数 ，输出每个长度为 的滑动窗口中的最大值。 - 输入： ， - 输出： - 约束： 若窗口内存在下标 且 ，则只要 仍在窗口中， 就不可能成为最大值。因此可用单调递减双端队列维护可能成为最大值的元素下标：遇到更大元素时从尾部弹出较小元素，窗口左边界滑动时从头部弹出过期下标。队列值严格递减，队首即为</description><pubDate>Mon, 16 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Problem: Sliding Window Maximum (LeetCode 239)&lt;/h1&gt;
&lt;h2&gt;题目重述&lt;/h2&gt;
&lt;p&gt;给定整数数组 $\text{nums}$ 与正整数 $k$，输出每个长度为 $k$ 的滑动窗口中的最大值。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;输入：$\text{nums} = [1, 3, -1, -3, 5, 3, 6, 7]$，$k = 3$&lt;/li&gt;
&lt;li&gt;输出：$[3, 3, 5, 5, 6, 7]$&lt;/li&gt;
&lt;li&gt;约束：$1 \le k \le |\text{nums}| \le 10^5$&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;关键观察&lt;/h2&gt;
&lt;p&gt;若窗口内存在下标 $i &amp;lt; j$ 且 $\text{nums}[i] \le \text{nums}[j]$，则只要 $j$ 仍在窗口中，$\text{nums}[i]$ 就不可能成为最大值。因此可用单调递减双端队列维护可能成为最大值的元素下标：遇到更大元素时从尾部弹出较小元素，窗口左边界滑动时从头部弹出过期下标。队列值严格递减，队首即为当前窗口最大值。&lt;/p&gt;
&lt;h2&gt;解析&lt;/h2&gt;
&lt;p&gt;遍历下标 $i$，维护双端队列 $\text{dq}$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $\text{dq.front}() &amp;lt; i - k + 1$，则 $\text{pop_front}()$。&lt;/li&gt;
&lt;li&gt;当队列非空且 $\text{nums}[\text{dq.back}()] \le \text{nums}[i]$ 时，持续 $\text{pop_back}()$。&lt;/li&gt;
&lt;li&gt;将 $i$ 入队。&lt;/li&gt;
&lt;li&gt;若 $i \ge k - 1$，将 $\text{nums}[\text{dq.front}()]$ 加入答案。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;以 $\text{nums} = [1, 3, -1, -3, 5, 3, 6, 7]$、$k = 3$ 为例：&lt;/p&gt;
&lt;p&gt;首个窗口 $[1, 3, -1]$ 建立时，下标 $0$ 入队；下标 $1$ 的值 $3$ 大于 $1$，弹出 $0$ 后入队；下标 $2$ 的值 $-1$ 直接入队。此时队列为 $[1, 2]$，对应值 $[3, -1]$，窗口最大值为 $3$。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/step1.png&quot; alt=&quot;步骤 1：首个窗口建立，维护单调递减队列&quot; /&gt;&lt;/p&gt;
&lt;p&gt;当 $i = 4$、值为 $5$ 的元素进入时，$5$ 大于队列中所有元素，依次弹出 $2, 3$ 后只剩 $[4]$，窗口最大值更新为 $5$。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/step2.png&quot; alt=&quot;步骤 2：新元素 5 破坏单调性，弹出所有较小元素&quot; /&gt;&lt;/p&gt;
&lt;p&gt;最终窗口到达数组末尾，队首下标 $7$ 对应值 $7$，窗口最大值为 $7$。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/step3.png&quot; alt=&quot;步骤 3：最终窗口，队首始终为当前最大值&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;复杂度分析&lt;/strong&gt;：每个下标最多入队一次、出队一次，时间复杂度为 $O(n)$；队列最多保存 $k$ 个下标，空间复杂度为 $O(k)$。&lt;/p&gt;
&lt;h2&gt;代码&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;class Solution {
public:
    vector&amp;lt;int&amp;gt; maxSlidingWindow(vector&amp;lt;int&amp;gt;&amp;amp; nums, int k) {
        deque&amp;lt;int&amp;gt; dq;
        vector&amp;lt;int&amp;gt; res;
        for (int i = 0; i &amp;lt; nums.size(); ++i) {
            if (!dq.empty() &amp;amp;&amp;amp; dq.front() &amp;lt; i - k + 1) dq.pop_front();
            while (!dq.empty() &amp;amp;&amp;amp; nums[dq.back()] &amp;lt;= nums[i]) dq.pop_back();
            dq.push_back(i);
            if (i &amp;gt;= k - 1) res.push_back(nums[dq.front()]);
        }
        return res;
    }
};
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>算法竞赛个人模板库 (Competitive Programming Template Library)</title><link>https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A4%A7%E5%85%A8/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A4%A7%E5%85%A8/</guid><description>作者: Sanzenin 整理时间: 2026-10-25 使用入口: 第九章查 Trick，第十章查自包含模板，第十一章查数学套路，第十二章查抽象代数；个人易错点见文末附录。 - 第一章 竞赛框架与基础设施 - 1.1 C++ 快速 I/O 与竞赛宏模板 - 1.2 solve() 闭包骨架 - 1.3 离散化 (D</description><pubDate>Mon, 16 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛个人模板库 (Competitive Programming Template Library)&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;作者&lt;/strong&gt;: Sanzenin
&lt;strong&gt;整理时间&lt;/strong&gt;: 2026-10-25
&lt;strong&gt;使用入口&lt;/strong&gt;: 第九章查 Trick，第十章查自包含模板，第十一章查数学套路，第十二章查抽象代数；个人易错点见文末附录。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;目录 (Table of Contents)&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-1&quot;&gt;第一章 竞赛框架与基础设施&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-1-1&quot;&gt;1.1 C++ 快速 I/O 与竞赛宏模板&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-1-2&quot;&gt;1.2 solve() 闭包骨架&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-1-3&quot;&gt;1.3 离散化 (Discretization)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-1-4&quot;&gt;1.4 整数二分查找 (Binary Search)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-1-5&quot;&gt;1.5 整数三分查找 (Ternary Search)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-1-6&quot;&gt;1.6 双向分层搜索（梦魇专用实例）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-1-7&quot;&gt;1.7 八数码 A*（曼哈顿启发式）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-1-8&quot;&gt;1.8 编译器预处理、LOCAL 调试与 GCC pragma&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-2&quot;&gt;第二章 基础与进阶数据结构&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-1&quot;&gt;2.1 树状数组 (Fenwick Tree / 点修区间和)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-2&quot;&gt;2.2 树状数组 + 倍增求第 K 小 (约瑟夫环 II 实战)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-3&quot;&gt;2.3 线段树：单点修改与区间和查询&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-4&quot;&gt;2.4 线段树：区间修改与区间求和 (Lazy Tag)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-5&quot;&gt;2.5 线段树全功能完整实现 (Point &amp;amp; Range Updates)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-6&quot;&gt;2.6 线段树上二分 (Segment Tree Walk)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-7&quot;&gt;2.7 动态开点线段树 (Dynamic Segment Tree)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-8&quot;&gt;2.8 动态开点线段树 (完整题解版)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-9&quot;&gt;2.9 权值线段树 (Weight Segment Tree)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-10&quot;&gt;2.10 李超线段树（项目收益实例）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-11&quot;&gt;2.11 矩形面积并（0-based离散化，128位面积）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-12&quot;&gt;2.12 可持久化数组（历史版本单点修改/查询）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-13&quot;&gt;2.13 主席树：权值持久化实现&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-14&quot;&gt;2.14 ST 表：静态区间最值 (RMQ / Sparse Table)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-15&quot;&gt;2.15 单调队列：滑动窗口最值 (Monotone Queue)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-16&quot;&gt;2.16 单调栈 (Monotone Stack)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-17&quot;&gt;2.17 二叉堆（C++动态数组）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-18&quot;&gt;2.18 可并堆：左偏树 (Leftist Tree / Mergable Heap)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-19&quot;&gt;2.19 可持久化左偏树 (Persistent Leftist Tree)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-20&quot;&gt;2.20 笛卡尔树构造与特定 XOR 子树检查实例&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-21&quot;&gt;2.21 Treap 平衡树（FHQ 分裂合并版本）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-22&quot;&gt;2.22 Splay 伸展树 (Standard Splay)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-23&quot;&gt;2.23 Splay 伸展树 (第二实现版本)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-24&quot;&gt;2.24 隐式 FHQ Treap（区间翻转）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-25&quot;&gt;2.25 FHQ Treap 无旋平衡树 (按值分裂与合并 / 来自知乎专栏)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-26&quot;&gt;2.26 动态开点线段树合并 (Segment Tree Merge / 来自知乎专栏)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-27&quot;&gt;2.27 虚树 (Virtual Tree / CF613D &amp;amp; P2495 方案)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-2-28&quot;&gt;2.28 树状数组维护区间和（区间加、区间求和）&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-3&quot;&gt;第三章 PBDS (Policy-Based Data Structures)&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-3-1&quot;&gt;3.1 PBDS 红黑平衡树全家桶 (rb_tree_tag 全功能封装)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-3-2&quot;&gt;3.2 PBDS 有序集合 (Ordered Set)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-3-3&quot;&gt;3.3 PBDS 有序多重集合 (Ordered Multiset)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-3-4&quot;&gt;3.4 PBDS 哈希表 (gp_hash_table)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-3-5&quot;&gt;3.5 PBDS 可修改配对堆 (pairing_heap_tag priority_queue)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-3-6&quot;&gt;3.6 PBDS 字典树 (pat_trie_tag trie)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-4&quot;&gt;第四章 字符串算法&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-4-1&quot;&gt;4.1 KMP 字符串模式匹配算法&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-4-2&quot;&gt;4.2 字符串单哈希与前缀幂预处理&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-4-3&quot;&gt;4.3 单模哈希应用：对称分块&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-4-4&quot;&gt;4.4 Manacher 最长回文子串算法&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-4-5&quot;&gt;4.5 字典树 Trie（小写字母，动态节点）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-4-6&quot;&gt;4.6 01-Trie 最大异或对（uint32_t）&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-5&quot;&gt;第五章 图论与树论算法&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-1&quot;&gt;5.1 单源最短路 Dijkstra&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-2&quot;&gt;5.2 并查集 (Disjoint Set Union)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-3&quot;&gt;5.3 带权并查集 (Weighted DSU / 势能维护)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-4&quot;&gt;5.4 带权并查集 (完整题解版)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-5&quot;&gt;5.5 最小生成树 Kruskal&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-6&quot;&gt;5.6 Kruskal 重构树 (Kruskal Reconstruction Tree)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-7&quot;&gt;5.7 严格次小生成树 (Strict Second Minimum Spanning Tree)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-8&quot;&gt;5.8 最近公共祖先 LCA (倍增实现)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-9&quot;&gt;5.9 LCA 独立实现 (数组版)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-10&quot;&gt;5.10 两次 DFS 求树的直径&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-11&quot;&gt;5.11 树的直径完整实现 (带权与距离维护)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-12&quot;&gt;5.12 树上 DFS 与子树规模统计&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-13&quot;&gt;5.13 拓扑排序 (Kahn 算法)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-14&quot;&gt;5.14 Tarjan 算法：有向图强连通分量 (SCC 缩点)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-15&quot;&gt;5.15 Tarjan 有向图 SCC (独立实现版)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-16&quot;&gt;5.16 Tarjan 算法：无向图割点判定&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-17&quot;&gt;5.17 Tarjan 算法：无向图割边判定 (桥)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-18&quot;&gt;5.18 无向图割点与桥（重边/非连通）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-19&quot;&gt;5.19 2-SAT 问题求解 (Tarjan SCC)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-20&quot;&gt;5.20 二分图最大匹配 (匈牙利算法 / Kuhn 算法)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-21&quot;&gt;5.21 Hall 婚姻定理 (Hall&apos;s Marriage Theorem)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-22&quot;&gt;5.22 网络流：Dinic 最大流算法&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-23&quot;&gt;5.23 网络流：Dinic 独立实现版&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-24&quot;&gt;5.24 网络流：Edmonds-Karp (EK 增广路算法)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-25&quot;&gt;5.25 第 K 短路 A*（允许重复点边的 walk）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-26&quot;&gt;5.26 欧拉回路 (Eulerian Circuit / Path)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-27&quot;&gt;5.27 0-1 BFS（边权仅0或1）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-28&quot;&gt;5.28 树上启发式合并 (DSU on Tree / 来自知乎专栏)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-5-29&quot;&gt;5.29 基环树森林与倍增跳环 (CSES Planets Queries II)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-6&quot;&gt;第六章 数论与数学算法&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-1&quot;&gt;6.1 快速幂与模乘 (Binary Exponentiation)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-2&quot;&gt;6.2 质数判定与试除法分解&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-3&quot;&gt;6.3 埃氏筛与欧拉线性筛 (Euler Sieve)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-4&quot;&gt;6.4 扩展欧几里得算法 (EXGCD)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-5&quot;&gt;6.5 扩展欧几里得与一次同余方程 (独立例程)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-6&quot;&gt;6.6 裴蜀定理应用 (Bezout&apos;s Identity)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-7&quot;&gt;6.7 费马小定理与逆元 (Fermat&apos;s Little Theorem)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-8&quot;&gt;6.8 扩展欧拉降幂（十进制大指数）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-9&quot;&gt;6.9 组合数：阶乘与逆元预处理&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-10&quot;&gt;6.10 范德蒙德卷积公式与组合恒等式&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-11&quot;&gt;6.11 高斯普通消元法 (Gauss-Jordan Elimination)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-12&quot;&gt;6.12 高斯异或消元法 (XOR Gauss Elimination)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-13&quot;&gt;6.13 Miller-Rabin 素性测试 (大素数判定)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-14&quot;&gt;6.14 BSGS 离散对数算法 (Baby-step Giant-step)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-15&quot;&gt;6.15 中国剩余定理 CRT (Chinese Remainder Theorem)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-16&quot;&gt;6.16 扩展中国剩余定理 EXCRT (Extended CRT)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-17&quot;&gt;6.17 莫比乌斯反演与数论分块 (P3455 ZAP-Queries)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-18&quot;&gt;6.18 Dirichlet 卷积与莫比乌斯反演理论&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-19&quot;&gt;6.19 异或线性基 (Linear Basis)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-20&quot;&gt;6.20 K 个数的异或最大/特定统计&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-21&quot;&gt;6.21 逆序对统计 (树状数组 / 归并排序求法)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-22&quot;&gt;6.22 高精度乘法（幂的数位统计实例）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-23&quot;&gt;6.23 有界生成函数计数（滑动窗口DP）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-24&quot;&gt;6.24 卡特兰与括号前缀补全&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-25&quot;&gt;6.25 康托展开与逆康托展开 (Cantor Expansion / Obsidian / 知乎)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-26&quot;&gt;6.26 斯特林数 (Stirling Numbers / 递推与组合意义)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-6-27&quot;&gt;6.27 错排问题 (Derangement)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-7&quot;&gt;第七章 计算几何&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-1&quot;&gt;7.1 二维向量与点类基础结构 (Point &amp;amp; Vector)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-2&quot;&gt;7.2 整数点极角排序（128位叉积）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-3&quot;&gt;7.3 Andrew 二维凸包算法 (Convex Hull)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-4&quot;&gt;7.4 Andrew 凸包独立实现 (带周长与多边形面积计算)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-5&quot;&gt;7.5 二维凸包 (CSES g_andrew.cpp 实战版)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-6&quot;&gt;7.6 半平面交（有界多边形裁剪）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-7&quot;&gt;7.7 线段相交判定 (CSES Line Segment Intersection)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-8&quot;&gt;7.8 多边形面积计算 (CSES Polygon Area)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-9&quot;&gt;7.9 点在多边形内部判定 (CSES Point in Polygon)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-10&quot;&gt;7.10 二维最小圆覆盖（随机增量）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-11&quot;&gt;7.11 三维最小包围球概念&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-12&quot;&gt;7.12 两直线交点计算 (Line Intersection)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-13&quot;&gt;7.13 直线与圆的交点计算 (Line-Circle Intersection)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-14&quot;&gt;7.14 平面最近点对 (Closest Pair of Points / 分治法)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-15&quot;&gt;7.15 Pick 定理与多边形格点 (Pick&apos;s Theorem &amp;amp; Polygon Area)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-7-16&quot;&gt;7.16 光线投射算法 (Point in Polygon / 射线法判定点在多边形内部)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-8&quot;&gt;第八章 动态规划与博弈论&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-1&quot;&gt;8.1 矩阵快速幂 (Matrix Exponentiation)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-2&quot;&gt;8.2 广义矩阵乘法与恰好 K 步最短路 (CSES 1724)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-3&quot;&gt;8.3 区间博弈 DP (CSES Removal Game)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-4&quot;&gt;8.4 树状数组统计所有严格递增子序列&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-5&quot;&gt;8.5 状压 DP 求解哈密顿路径 (CSES Hamiltonian Flights)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-6&quot;&gt;8.6 二次代价 DP（离散李超树优化）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-7&quot;&gt;8.7 树形背包（恰选q条与根连通的边）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-8&quot;&gt;8.8 树形背包 DP (DFS 序展开优化版)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-9&quot;&gt;8.9 Nim 博弈 (经典异或和定理)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-10&quot;&gt;8.10 集合 Nim 博弈与 SG 函数 (Sprague-Grundy)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-11&quot;&gt;8.11 有向图棋子移动博弈 (Graph Chess Game)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-12&quot;&gt;8.12 剪纸博弈 (Cutting Game)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-8-13&quot;&gt;8.13 模拟退火：赛场可读模板与使用场景&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-9&quot;&gt;第九章 竞赛经典 Trick 与思维模型&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-9-1&quot;&gt;9.1 经典 Trick 全文（A–Z）&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-9-2&quot;&gt;9.2 贡献法应用&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-10&quot;&gt;第十章 常用可复用模板&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-10-1&quot;&gt;10.1 自包含模板、前提与完整示例&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-11&quot;&gt;第十一章 数学套路与赛时转化&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-11-1&quot;&gt;11.1 数学套路&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-12&quot;&gt;第十二章 抽象代数&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-1&quot;&gt;12.1 抽象代数的竞赛用法&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-2&quot;&gt;12.2 集合论与映射&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-3&quot;&gt;12.3 群与子群&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-4&quot;&gt;12.4 循环群与生成元&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-5&quot;&gt;12.5 陪集-Lagrange-正规子群&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-6&quot;&gt;12.6 商群与同态&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-7&quot;&gt;12.7 三大同构定理&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-8&quot;&gt;12.8 置换群-内自同构-Cayley&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#section-12-9&quot;&gt;12.9 易错点与证明套路&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;a href=&quot;#chapter-13&quot;&gt;附录 个人易错点&lt;/a&gt;&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#section-13-1&quot;&gt;13.1 个人易错点与三个月复盘&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第一章 竞赛框架与基础设施&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-1-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.1 C++ 快速 I/O 与竞赛宏模板&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：包含 &lt;code&gt;bits/stdc++.h&lt;/code&gt; 与 pbds 头文件、基础宏定义 (&lt;code&gt;ll&lt;/code&gt;, &lt;code&gt;pr&lt;/code&gt;, &lt;code&gt;inf&lt;/code&gt;, &lt;code&gt;lc&lt;/code&gt;, &lt;code&gt;rc&lt;/code&gt;)、解绑标准流 &lt;code&gt;ios::sync_with_stdio(0)&lt;/code&gt;，以及标准的 lambda &lt;code&gt;solve()&lt;/code&gt; 结构。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;bits/extc++.h&amp;gt;
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define tii tuple&amp;lt;int, int, int&amp;gt;
#define tll tuple&amp;lt;ll, ll, ll&amp;gt;
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
#define inf 0x3f3f3f3f3f3f3f3f
#define N 100005
#define M 1000005
#define lc p &amp;lt;&amp;lt; 1
#define rc p &amp;lt;&amp;lt; 1 | 1
using namespace std;
using namespace __gnu_pbds;

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

    auto solve = [&amp;amp;]()
    {
        // TODO: 读入题目数据、补充题目本身的逻辑
    };

    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-1-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.2 solve() 闭包骨架&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：多测或局部作用域闭包定义骨架。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto solve = [&amp;amp;]()
{
    // TODO: 题目逻辑
};

solve();
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-1-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.3 离散化 (Discretization)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：基于 &lt;code&gt;std::sort&lt;/code&gt; 与 &lt;code&gt;std::unique&lt;/code&gt; 的 1-indexed 离散化映射，返回 &lt;code&gt;lower_bound&lt;/code&gt; 后的离散编号。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;ll&amp;gt; nums;
// TODO: 先把所有会参与比较/查询的原值放入 nums。
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());

auto get_id = [&amp;amp;](ll x) -&amp;gt; int
{
    return lower_bound(nums.begin(), nums.end(), x) - nums.begin() + 1;
};

// TODO: get_id(x) 是 1-indexed 离散编号；输出原值用 nums[id - 1]。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-1-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.4 整数二分查找 (Binary Search)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：开区间单调性二分模板 (&lt;code&gt;l + 1 &amp;lt; r&lt;/code&gt;)，稳定防死循环，返回满足单调谓词的第一边界。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto check = [&amp;amp;](ll mid) -&amp;gt; bool
{
    // TODO: 判断 mid 是否可行，保持可行性单调。
    return true;
};

ll l = -1, r = 1e18;
while (l + 1 &amp;lt; r)
{
    ll mid = (l + r) &amp;gt;&amp;gt; 1;
    if (check(mid))
        r = mid;
    else
        l = mid;
}
// TODO: r 是第一个满足 check 的整数；边界按题目修改。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-1-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.5 整数三分查找 (Ternary Search)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：单峰 / 单谷函数的三分法极值搜索，三等分点迭代并在小区间内暴力比较极值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto cal = [&amp;amp;](ll x) -&amp;gt; ll
{
    // TODO: 单峰函数；按题意返回函数值。
    return x;
};

ll l = 0, r = 1e18;
while (r - l &amp;gt; 3)
{
    ll lm = (2 * l + r) / 3;
    ll rm = (l + 2 * r) / 3;
    if (cal(lm) &amp;lt; cal(rm))
        l = lm;
    else
        r = rm;
}
ll ans = cal(l);
for (ll i = l; i &amp;lt;= r; i++)
    ans = max(ans, cal(i));
// TODO: 求最小值时反转比较符号。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-1-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.6 双向分层搜索（梦魇专用实例）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：男生每轮3步、女生1步，鬼每轮扩散2格；不能当一般等代价双向BFS原封套用。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 805
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;

ll n,m,t,tim;
pr b,g;
vector&amp;lt;pr&amp;gt;gho;
char map1[N][N];
bool vis1[N][N];
bool vis2[N][N];
bool check(int x,int y)
{
    if(x&amp;lt;1 || y&amp;lt;1 ||x&amp;gt;n||y&amp;gt;m || map1[x][y]==&apos;X&apos;) return 0;
    for(auto gg:gho)
    {
        if(abs(x-gg.first)+abs(y-gg.second)&amp;lt;=tim*2) return false;
    }
    return 1;
}
pr mv[4]={{1,0},{-1,0},{0,1},{0,-1}};
void bfs()
{
    queue&amp;lt;pr&amp;gt;q1;
    queue&amp;lt;pr&amp;gt;q2;
    q1.push(b);
    q2.push(g);
    vis1[b.first][b.second]=1;
    vis2[g.first][g.second]=1;
    while(q1.size()|| q2.size())
    {
        tim++;
        for(int i=1;i&amp;lt;=3;i++)
        {
            ll siz=q1.size();
            for(int j=0;j&amp;lt;siz;j++)
            {
                auto now=q1.front();
                q1.pop();
                if(!check(now.first,now.second)) continue;
                for(int k=0;k&amp;lt;4;k++)
                {
                    ll x=now.first+mv[k].first;
                    ll y=now.second+mv[k].second;
                    if(!check(x,y)) continue;
                    if(vis2[x][y])
                    {
                        cout&amp;lt;&amp;lt;tim&amp;lt;&amp;lt;&apos;\n&apos;; //在当前步遇到
                        return;
                    }
                    if(vis1[x][y]) continue;
                    vis1[x][y]=1;
                    q1.push({x,y});
                }
            }
        }
        for(int i=1;i&amp;lt;=1;i++)
        {
            ll siz=q2.size();
            for(int j=0;j&amp;lt;siz;j++)
            {
                auto now=q2.front();
                q2.pop();
                if(!check(now.first,now.second)) continue;
                for(int k=0;k&amp;lt;4;k++)
                {
                    ll x=now.first+mv[k].first;
                    ll y=now.second+mv[k].second;
                    if(!check(x,y)) continue;
                    if(vis1[x][y])
                    {
                        cout&amp;lt;&amp;lt;tim&amp;lt;&amp;lt;&apos;\n&apos;;
                        return;
                    }
                    if(vis2[x][y]) continue;
                    vis2[x][y]=1;
                    q2.push({x,y});
                }
            }
        }

    }
    cout&amp;lt;&amp;lt;-1&amp;lt;&amp;lt;&apos;\n&apos;;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    cin&amp;gt;&amp;gt;t;
    while(t--)
    {
        tim=0;
        memset(vis1,0,sizeof vis1);
        memset(vis2,0,sizeof vis2);
        gho.clear();
        cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;
        for(int i=1;i&amp;lt;=n;i++)
        {
            for(int j=1;j&amp;lt;=m;j++)
            {
                cin&amp;gt;&amp;gt;map1[i][j];
                if(map1[i][j]==&apos;M&apos;) b={i,j};
                else if(map1[i][j]==&apos;G&apos;) g={i,j};
                else if(map1[i][j]==&apos;Z&apos;) gho.push_back({i,j});
            }
        }
        bfs();
    }

    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-1-7&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.7 八数码 A*（曼哈顿启发式）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：自定义目标，默认123804765；输入0..8排列，无解-1，最优步数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// A*+曼哈顿距离，忽略0空格；目标可自定义。输入须为0..8的排列。
int eight_puzzle(string start,string goal=&quot;123804765&quot;){
    auto valid=[](string s){sort(s.begin(),s.end());return s==&quot;012345678&quot;;};
    if(!valid(start)||!valid(goal))return -1;
    auto parity=[](const string&amp;amp;s){int c=0;for(int i=0;i&amp;lt;9;++i)if(s[i]!=&apos;0&apos;)for(int j=0;j&amp;lt;i;++j)if(s[j]!=&apos;0&apos;&amp;amp;&amp;amp;s[j]&amp;gt;s[i])++c;return c%2;};
    if(parity(start)!=parity(goal))return -1;
    array&amp;lt;int,9&amp;gt;pos{};for(int i=0;i&amp;lt;9;++i)pos[goal[i]-&apos;0&apos;]=i;
    auto h=[&amp;amp;](const string&amp;amp;s){int sum=0;for(int i=0;i&amp;lt;9;++i)if(s[i]!=&apos;0&apos;){int p=pos[s[i]-&apos;0&apos;];sum+=abs(i/3-p/3)+abs(i%3-p%3);}return sum;};
    using State=tuple&amp;lt;int,int,string&amp;gt;;priority_queue&amp;lt;State,vector&amp;lt;State&amp;gt;,greater&amp;lt;State&amp;gt;&amp;gt;q;
    unordered_map&amp;lt;string,int&amp;gt;d;d[start]=0;q.push({h(start),0,start});
    const int dx[]={1,-1,0,0},dy[]={0,0,1,-1};
    while(!q.empty()){
        auto[f,g,s]=q.top();q.pop();if(d[s]!=g)continue;if(s==goal)return g;
        int zero=s.find(&apos;0&apos;),x=zero/3,y=zero%3;
        for(int k=0;k&amp;lt;4;++k){int X=x+dx[k],Y=y+dy[k];if(X&amp;lt;0||X&amp;gt;=3||Y&amp;lt;0||Y&amp;gt;=3)continue;string t=s;swap(t[zero],t[X*3+Y]);auto it=d.find(t);if(it==d.end()||g+1&amp;lt;it-&amp;gt;second){d[t]=g+1;q.push({g+1+h(t),g+1,t});}}
    }
    return -1;
}
int main(){string s;if(cin&amp;gt;&amp;gt;s)cout&amp;lt;&amp;lt;eight_puzzle(s)&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-1-8&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;1.8 编译器预处理、LOCAL 调试与 GCC pragma&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：C++17 宏、条件编译、头文件保护、日志、断言与可选编译优化；包含完整单文件板子和编译命令。&lt;/p&gt;
&lt;h3&gt;算法竞赛编译器预处理&lt;/h3&gt;
&lt;p&gt;这里整理 C++17 的预处理指令和常见 GCC 编译选项。预处理解决“哪些源代码交给编译器、宏怎样替换”；优化选项控制编译器生成什么代码；筛法、阶乘等算法预计算属于算法章节。&lt;/p&gt;
&lt;h4&gt;1. 按用途选板子&lt;/h4&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;需要解决的问题&lt;/th&gt;
&lt;th&gt;使用什么&lt;/th&gt;
&lt;th&gt;应用边界&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;本地打印中间状态，提交时删除&lt;/td&gt;
&lt;td&gt;&lt;code&gt;LOCAL&lt;/code&gt; 条件编译与 &lt;code&gt;CP_DBG&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;关闭时参数完全不求值，必要操作不能写在日志参数里&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;常量、类型别名、更新最优值&lt;/td&gt;
&lt;td&gt;&lt;code&gt;constexpr&lt;/code&gt;、&lt;code&gt;using&lt;/code&gt;、函数模板&lt;/td&gt;
&lt;td&gt;交给类型系统，避免文字替换改变含义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同一头文件被重复包含&lt;/td&gt;
&lt;td&gt;include guard 或 &lt;code&gt;#pragma once&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;防同一翻译单元重复定义，不自动解决跨文件链接冲突&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;针对某个语言标准或编译器选代码&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#if&lt;/code&gt;、&lt;code&gt;defined&lt;/code&gt;、特性检测&lt;/td&gt;
&lt;td&gt;&lt;code&gt;constexpr&lt;/code&gt; 变量不能直接参与预处理表达式&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;给日志打印表达式、生成标识符&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#&lt;/code&gt;、&lt;code&gt;##&lt;/code&gt; 的二层宏&lt;/td&gt;
&lt;td&gt;宏专长是处理 token；别用它代替普通数值函数&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;编译后仍慢，想试优化&lt;/td&gt;
&lt;td&gt;先用命令行 &lt;code&gt;-O2&lt;/code&gt;，再实测局部 &lt;code&gt;O3&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;不改变算法复杂度，性能不保证单调提升&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;想启用 AVX2 等指令&lt;/td&gt;
&lt;td&gt;架构限定的函数版本及运行时分派&lt;/td&gt;
&lt;td&gt;目标 CPU 必须支持，基线入口不能先使用该指令集&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h4&gt;2. 默认竞赛框架：LOCAL 日志、类型与常量&lt;/h4&gt;
&lt;p&gt;下面是完整单文件板子，输入 &lt;code&gt;n&lt;/code&gt; 和 &lt;code&gt;n&lt;/code&gt; 个整数，输出总和。数值前提为 &lt;code&gt;n&amp;gt;=0&lt;/code&gt; 且所有前缀和能放进 &lt;code&gt;int64_t&lt;/code&gt;。日志只写 &lt;code&gt;stderr&lt;/code&gt;，正式答案只写 &lt;code&gt;stdout&lt;/code&gt;。&lt;code&gt;CP_DBG&lt;/code&gt; 支持已经定义 &lt;code&gt;operator&amp;lt;&amp;lt;&lt;/code&gt; 的类型；打印容器时自行提供输出函数，不假定 &lt;code&gt;vector&lt;/code&gt; 可以直接流输出。&lt;/p&gt;
&lt;p&gt;文件同源：&lt;code&gt;ready/preprocessor_example.cpp&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;cassert&amp;gt;
#include &amp;lt;cstdint&amp;gt;
#include &amp;lt;iostream&amp;gt;
#include &amp;lt;type_traits&amp;gt;

#if __cplusplus &amp;lt; 201703L
#error This template requires C++17 or later.
#endif

using i64 = std::int64_t;
[[maybe_unused]] constexpr i64 MOD = 1000000007;

#define CP_STRING_IMPL(x) #x
#define CP_STRING(x) CP_STRING_IMPL(x)
#define CP_JOIN_IMPL(a, b) a##b
#define CP_JOIN(a, b) CP_JOIN_IMPL(a, b)

#ifdef LOCAL
namespace cp_debug {
struct Line {
    const char* file;
    int line;
    const char* expressions;
    template&amp;lt;class... Ts&amp;gt;
    void operator()(const Ts&amp;amp;... values) const {
        std::cerr &amp;lt;&amp;lt; &apos;[&apos; &amp;lt;&amp;lt; file &amp;lt;&amp;lt; &apos;:&apos; &amp;lt;&amp;lt; line &amp;lt;&amp;lt; &quot;] &quot; &amp;lt;&amp;lt; expressions &amp;lt;&amp;lt; &quot; =&quot;;
        ((std::cerr &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt; values), ...);
        std::cerr &amp;lt;&amp;lt; &apos;\n&apos;;
    }
};
} // namespace cp_debug
#define CP_DBG(...) ::cp_debug::Line{__FILE__, __LINE__, #__VA_ARGS__}(__VA_ARGS__)
#else
#define CP_DBG(...) ((void)0)
#endif

template&amp;lt;class T&amp;gt;
bool chmin(T&amp;amp; current, const T&amp;amp; candidate) {
    if (candidate &amp;lt; current) {
        current = candidate;
        return true;
    }
    return false;
}

void solve() {
    int n;
    if (!(std::cin &amp;gt;&amp;gt; n)) return;
    assert(n &amp;gt;= 0);
    i64 sum = 0;
    for (int i = 0; i &amp;lt; n; ++i) {
        i64 x;
        std::cin &amp;gt;&amp;gt; x;
        sum += x;
    }
    CP_DBG(n, sum);
    std::cout &amp;lt;&amp;lt; sum &amp;lt;&amp;lt; &apos;\n&apos;;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如输入 &lt;code&gt;4 -3 2 7 9&lt;/code&gt;（空白分隔），标准输出为 &lt;code&gt;15&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;启用本地模式时 &lt;code&gt;CP_DBG(n, sum)&lt;/code&gt; 打印文件、行号、表达式文字和对应值；关闭后展开成 &lt;code&gt;((void)0)&lt;/code&gt;，没有参数求值。虽然这种隔离对日志方便，&lt;strong&gt;不要写 &lt;code&gt;CP_DBG(++cnt)&lt;/code&gt; 并依赖它推进算法&lt;/strong&gt;：本地和提交的行为会不同。多个参数的求值先后也不要依赖，例如不要在一条日志里同时修改并读取同一个变量。&lt;code&gt;__FILE__&lt;/code&gt;、&lt;code&gt;__LINE__&lt;/code&gt; 的语义见 &lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html&quot;&gt;GCC 标准预定义宏&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;chmin&lt;/code&gt; 用模板函数表达“比较并赋值”；类型别名使用 &lt;code&gt;using i64=...&lt;/code&gt;，常量使用 &lt;code&gt;constexpr&lt;/code&gt;。不把 &lt;code&gt;#define int long long&lt;/code&gt; 当默认配置，它会改写第三方声明、函数签名和本来需要 &lt;code&gt;int&lt;/code&gt; 的位置。&lt;/p&gt;
&lt;h4&gt;3. 宏是 token 替换，不是函数&lt;/h4&gt;
&lt;p&gt;下面这种宏即使加足括号，也会把参数复制两遍：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#define CP_BAD_SQUARE(x) ((x) * (x))
// CP_BAD_SQUARE(++i) 会展开为 ((++i) * (++i))，不能这样调用。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;若只写成 &lt;code&gt;#define CP_BAD_SQUARE(x) x*x&lt;/code&gt;，&lt;code&gt;CP_BAD_SQUARE(a+b)&lt;/code&gt; 还会产生运算优先级问题。算术函数用模板或 &lt;code&gt;inline&lt;/code&gt;；&lt;code&gt;inline&lt;/code&gt; 不是承诺“必须机器码内联”，是否内联由编译器决定。&lt;/p&gt;
&lt;p&gt;多个语句的宏若确有必要，用 &lt;code&gt;do { ... } while (0)&lt;/code&gt; 包成一个语句，调用者在最后写分号，才能正常接 &lt;code&gt;if (...) MACRO(...); else ...&lt;/code&gt;。括号解决结合方式，&lt;code&gt;do/while&lt;/code&gt; 解决语句边界；两者都不能自动消除重复求值。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Operator-Precedence-Problems.html&quot;&gt;GCC 宏优先级说明&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Duplication-of-Side-Effects.html&quot;&gt;重复副作用&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Swallowing-the-Semicolon.html&quot;&gt;宏与分号&lt;/a&gt;分别解释这三种问题。&lt;/p&gt;
&lt;h4&gt;4. 条件编译：存在性与数值判断分开&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;#ifdef LOCAL&lt;/code&gt;：只检查宏是否存在，&lt;code&gt;-DLOCAL=0&lt;/code&gt; 也会进入。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;#if defined(CP_DEBUG_LEVEL) &amp;amp;&amp;amp; CP_DEBUG_LEVEL &amp;gt;= 2&lt;/code&gt;：检查存在性和整数值。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;#if __cplusplus &amp;gt;= 201703L&lt;/code&gt;：选择 C++17 或以上分支。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;#error ...&lt;/code&gt;：不满足必要编译条件时直接给出诊断。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;code&gt;LOCAL&lt;/code&gt;、&lt;code&gt;DEBUG&lt;/code&gt;、&lt;code&gt;ONLINE_JUDGE&lt;/code&gt; 都是约定名称，不是 C++ 标准保证的环境开关。不要假定某个 OJ 一定定义 &lt;code&gt;ONLINE_JUDGE&lt;/code&gt;；自己掌控的本地开关用 &lt;code&gt;-DLOCAL&lt;/code&gt; 最直观。&lt;code&gt;-Dname&lt;/code&gt; 等价于预定义为 1，&lt;code&gt;-Uname&lt;/code&gt; 撤销定义。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Preprocessor-Options.html&quot;&gt;GCC 命令行预处理选项&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;预处理器不理解 C++ 的类型、&lt;code&gt;sizeof&lt;/code&gt;、&lt;code&gt;constexpr&lt;/code&gt; 变量。&lt;code&gt;#if LIMIT &amp;gt; 10&lt;/code&gt; 中，若 LIMIT 只是 C++ 变量而不是宏，预处理时它通常被当成 0；&lt;code&gt;-Wundef&lt;/code&gt; 能帮助发现未定义标识符。分支类型检查应使用 C++17 的 &lt;code&gt;if constexpr&lt;/code&gt;，但它不能无条件屏蔽任意非法代码：模板中不依赖模板参数的错误仍可能提前诊断，模板外的丢弃分支也不是随意放未声明名字的地方。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/If.html&quot;&gt;GCC #if 规则&lt;/a&gt;、&lt;a href=&quot;https://timsong-cpp.github.io/cppwp/n4659/stmt.if&quot;&gt;C++17 if constexpr 草案&lt;/a&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#ifndef CP_DEBUG_LEVEL
#define CP_DEBUG_LEVEL 0
#endif
#if CP_DEBUG_LEVEL &amp;gt;= 2
// 只有该配置会进入后续编译阶段。
#endif
constexpr int LIMIT = 20;
static_assert(LIMIT &amp;gt; 10, &quot;LIMIT must exceed 10&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;预处理条件是编译时选择，不随输入变化；题目分支仍用普通 &lt;code&gt;if&lt;/code&gt;。&lt;/p&gt;
&lt;h4&gt;5. assert 与 NDEBUG：检查不能承担算法工作&lt;/h4&gt;
&lt;p&gt;&lt;code&gt;assert(condition)&lt;/code&gt; 用于检查程序内部不变量；&lt;code&gt;-DNDEBUG&lt;/code&gt; 可以关闭它。不要写 &lt;code&gt;assert(read_input())&lt;/code&gt;、&lt;code&gt;assert(++ptr&amp;lt;n)&lt;/code&gt; 并指望其中的读取或自增仍会发生。先执行必要工作，再断言结果。&lt;code&gt;NDEBUG&lt;/code&gt; 必须在定义 &lt;code&gt;assert&lt;/code&gt; 的头文件被处理时生效，最简单是编译命令传 &lt;code&gt;-DNDEBUG&lt;/code&gt;。&lt;a href=&quot;https://timsong-cpp.github.io/cppwp/n4659/assertions&quot;&gt;C++17 断言章节&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;含模板逗号的表达式可用额外括号包住，例如 &lt;code&gt;assert((std::is_same_v&amp;lt;int, int&amp;gt;));&lt;/code&gt;，因为预处理器不会把尖括号当作宏参数的括号。静态条件使用 &lt;code&gt;static_assert&lt;/code&gt;；它不受 &lt;code&gt;NDEBUG&lt;/code&gt; 关闭。需要在正式程序处理的“无解”“输入允许的越界状态”等分支，写正常判断并返回错误结果，不仅依赖断言。&lt;/p&gt;
&lt;h4&gt;6. 字符串化、token 拼接与可变参数&lt;/h4&gt;
&lt;p&gt;默认框架里保留四个小宏：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#define CP_STRING_IMPL(x) #x
#define CP_STRING(x) CP_STRING_IMPL(x)
#define CP_JOIN_IMPL(a, b) a##b
#define CP_JOIN(a, b) CP_JOIN_IMPL(a, b)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如先 &lt;code&gt;#define CP_LIMIT 24&lt;/code&gt;：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;写法&lt;/th&gt;
&lt;th&gt;展开结果&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CP_STRING_IMPL(CP_LIMIT)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;字符串 &lt;code&gt;&quot;CP_LIMIT&quot;&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CP_STRING(CP_LIMIT)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;字符串 &lt;code&gt;&quot;24&quot;&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CP_JOIN_IMPL(value_, CP_LIMIT)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;标识符 &lt;code&gt;value_CP_LIMIT&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CP_JOIN(value_, CP_LIMIT)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;标识符 &lt;code&gt;value_24&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;直接遇到 &lt;code&gt;#&lt;/code&gt; 或 &lt;code&gt;##&lt;/code&gt; 的宏参数不会先按普通规则展开，所以外层用于先展开、内层用于字符串化或拼接。拼接后必须是合法 token，不能用它拼出任意语法。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Stringizing.html&quot;&gt;GCC 字符串化&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Concatenation.html&quot;&gt;GCC token 拼接&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;__VA_ARGS__&lt;/code&gt; 用于可变参数宏。C++17 不以 &lt;code&gt;__VA_OPT__&lt;/code&gt; 为标准特性；GNU 的 &lt;code&gt;, ##__VA_ARGS__&lt;/code&gt; 是扩展，别把它当跨编译器的标准 C++17 逗号处理方案。默认框架采用“构造日志对象后再调用”的写法，&lt;code&gt;CP_DBG()&lt;/code&gt; 也会形成合法的空参数函数调用，不会遗留逗号。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html&quot;&gt;GCC 可变参数宏说明&lt;/a&gt;&lt;/p&gt;
&lt;h4&gt;7. 头文件与特性检测&lt;/h4&gt;
&lt;p&gt;自写头文件可以使用唯一的 include guard：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#ifndef SANZENIN_CP_EXTRA_HPP_INCLUDED
#define SANZENIN_CP_EXTRA_HPP_INCLUDED
// 在这里放声明、inline 函数或模板。
#endif
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也可以在文件开头写 &lt;code&gt;#pragma once&lt;/code&gt;；它受 GCC、Clang 等支持，但不是 ISO C++ 的标准指令。二选一通常足够。宏名包含项目与文件信息，避免两个头文件误用同一个 guard。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Once-Only-Headers.html&quot;&gt;GCC 头文件保护&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Alternatives-to-Wrapper-_0023ifndef.html&quot;&gt;pragma once&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;检测头文件时先判是否支持检测操作：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#if defined(__has_include)
#  if __has_include(&amp;lt;bits/stdc++.h&amp;gt;)
#    include &amp;lt;bits/stdc++.h&amp;gt;
#  else
#    include &amp;lt;algorithm&amp;gt;
#    include &amp;lt;iostream&amp;gt;
#    include &amp;lt;vector&amp;gt;
#  endif
#else
#  include &amp;lt;algorithm&amp;gt;
#  include &amp;lt;iostream&amp;gt;
#  include &amp;lt;vector&amp;gt;
#endif
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个示例的回退只包含列出的三个标准头；真实代码用了什么就补什么。&lt;code&gt;__has_include&lt;/code&gt; 在 C++17 中已有标准依据，但头文件存在不等于其全部接口可在当前模式使用。&lt;code&gt;bits/stdc++.h&lt;/code&gt; 是实现提供的汇总头，不是标准头。&lt;a href=&quot;https://timsong-cpp.github.io/cppwp/n4659/cpp.cond&quot;&gt;C++17 条件包含草案&lt;/a&gt;、&lt;a href=&quot;https://clang.llvm.org/docs/LanguageExtensions.html#include-file-checking-macros&quot;&gt;Clang 头文件检测&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;区分编译器时，先检查 Clang，再检查 GCC 兼容宏：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#if defined(__clang__)
// Clang 路径
#elif defined(__GNUC__)
// GCC 或其他声明兼容 GNU 的编译器路径
#else
// 其他编译器路径
#endif
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;仅有 &lt;code&gt;__GNUC__&lt;/code&gt; 不能证明“这就是 GCC”。要探测某个内建函数，可先判 &lt;code&gt;defined(__has_builtin)&lt;/code&gt; 再调用 &lt;code&gt;__has_builtin(函数名)&lt;/code&gt;；不要因为版本号看起来够大就假定扩展存在。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html&quot;&gt;GCC 兼容宏定义&lt;/a&gt;、&lt;a href=&quot;https://clang.llvm.org/docs/LanguageExtensions.html#feature-checking-macros&quot;&gt;Clang 特性检测&lt;/a&gt;&lt;/p&gt;
&lt;h4&gt;8. GCC 优化与 target：按需求启用&lt;/h4&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;写法&lt;/th&gt;
&lt;th&gt;实际控制什么&lt;/th&gt;
&lt;th&gt;何时使用&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;命令行 &lt;code&gt;-O2&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;常见优化等级&lt;/td&gt;
&lt;td&gt;竞赛提交的常用起点，最终以 OJ 命令为准&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;命令行 &lt;code&gt;-O3&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;更多优化尝试&lt;/td&gt;
&lt;td&gt;对热点实测，代码膨胀等因素可能让它更慢&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;#pragma GCC optimize(&quot;O3&quot;)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;后续定义函数的优化选项&lt;/td&gt;
&lt;td&gt;需要局部试验时，使用 push/pop 限定范围&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;#pragma GCC target(&quot;avx2&quot;)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;后续函数可使用的指令集&lt;/td&gt;
&lt;td&gt;限定架构，并确保运行 CPU 支持&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;-Ofast&lt;/code&gt; / &lt;code&gt;fast-math&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;放宽浮点及其他语义限制&lt;/td&gt;
&lt;td&gt;只有明确允许这些变化的计算才考虑&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;&lt;code&gt;Ofast&lt;/code&gt; 包含 &lt;code&gt;fast-math&lt;/code&gt;，后者允许重关联等变换，并可假定没有 NaN/无穷。几何精度判定、模拟退火能量的 &lt;code&gt;isfinite&lt;/code&gt; 检查、依赖浮点特殊值的代码不应套一个全局“极限优化”开头；优化不能修复越界、有符号溢出或错误算法。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html&quot;&gt;GCC 优化选项&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;target(&quot;avx2&quot;)&lt;/code&gt; 不是“检测并开启 AVX2”，而是允许生成对应指令。&lt;code&gt;-march=native&lt;/code&gt; 也是针对当前编译机器，不保证换到评测机器还能运行。需要通用可执行文件时保留基线版本，用函数级 target 加运行时检测分派；包含检测逻辑的入口也要按基线指令集编译。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html&quot;&gt;GCC x86 选项&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/x86-Built-in-Functions.html&quot;&gt;CPU 检测内建函数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;下面完整程序演示局部 O3、可选 AVX2 版本和回退。默认不编译 AVX2 特化；使用 GCC 且传 &lt;code&gt;-DCP_ENABLE_AVX2&lt;/code&gt; 时才产生该版本，运行时仍检查是否支持。Clang 路径保留普通函数。数据本身只有四个元素，不用于宣称 AVX2 更快；实际热点应另行测量。&lt;code&gt;push_options/pop_options&lt;/code&gt; 保存与恢复当前函数选项，避免设置影响后续函数及头文件。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Function-Specific-Option-Pragmas.html&quot;&gt;GCC 函数选项 pragma&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;文件同源：&lt;code&gt;ready/preprocessor_pragmas.cpp&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;cstddef&amp;gt;
#include &amp;lt;cstdint&amp;gt;
#include &amp;lt;iostream&amp;gt;
#include &amp;lt;vector&amp;gt;

// GCC-only function options; Clang uses the baseline implementation below.
#if defined(__GNUC__) &amp;amp;&amp;amp; !defined(__clang__)
#pragma GCC push_options
#pragma GCC optimize(&quot;O3&quot;)
#endif
std::uint64_t sum_words(const std::vector&amp;lt;std::uint32_t&amp;gt;&amp;amp; a) {
    std::uint64_t answer = 0;
    for (std::uint32_t x : a) answer += x;
    return answer;
}
#if defined(__GNUC__) &amp;amp;&amp;amp; !defined(__clang__)
#pragma GCC pop_options
#endif

// Optional x86 specialization: opt in at compile time, then dispatch at runtime.
#if defined(CP_ENABLE_AVX2) &amp;amp;&amp;amp; defined(__GNUC__) &amp;amp;&amp;amp; !defined(__clang__) &amp;amp;&amp;amp; \
    (defined(__x86_64__) || defined(__i386__))
#define CP_HAS_AVX2_VARIANT 1
#pragma GCC push_options
#pragma GCC optimize(&quot;O3&quot;)
#pragma GCC target(&quot;avx2&quot;)
std::uint64_t sum_words_avx2(const std::vector&amp;lt;std::uint32_t&amp;gt;&amp;amp; a) {
    std::uint64_t answer = 0;
    for (std::uint32_t x : a) answer += x;
    return answer;
}
#pragma GCC pop_options
#else
#define CP_HAS_AVX2_VARIANT 0
#endif

int main() {
    const std::vector&amp;lt;std::uint32_t&amp;gt; a{1, 2, 3, 4};
    std::uint64_t answer;
#if CP_HAS_AVX2_VARIANT
    // main and the fallback must themselves be compiled for the baseline CPU.
    if (__builtin_cpu_supports(&quot;avx2&quot;)) answer = sum_words_avx2(a);
    else answer = sum_words(a);
#else
    answer = sum_words(a);
#endif
    std::cout &amp;lt;&amp;lt; answer &amp;lt;&amp;lt; &apos;\n&apos;;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;程序输出 &lt;code&gt;10&lt;/code&gt;。启用参数：&lt;code&gt;g++ -std=c++17 -O2 -DCP_ENABLE_AVX2 ready/preprocessor_pragmas.cpp -o /tmp/cp-pragmas&lt;/code&gt;。不要同时全局加 &lt;code&gt;-march=native&lt;/code&gt; 再把运行时检测当成跨 CPU 兼容保证。&lt;/p&gt;
&lt;h4&gt;9. 本地调试与提交命令&lt;/h4&gt;
&lt;p&gt;在模板目录运行，源文件换成你的提交文件即可：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 本地定位越界、悬空访问和一部分未定义行为；LOCAL 日志写 stderr。
g++ -std=c++17 -O1 -g -Wall -Wextra -Wshadow -Wundef \
  -DLOCAL -fsanitize=address,undefined -fno-omit-frame-pointer \
  ready/preprocessor_example.cpp -o /tmp/cp-debug
/tmp/cp-debug &amp;lt; input.txt &amp;gt; output.txt 2&amp;gt; debug.txt

# 贴近通常的优化提交环境；断言默认保留，不额外定义 LOCAL。
g++ -std=c++17 -O2 -Wall -Wextra \
  ready/preprocessor_example.cpp -o /tmp/cp-submit
/tmp/cp-submit &amp;lt; input.txt &amp;gt; output.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;-O2&lt;/code&gt; 本身不会自动定义 &lt;code&gt;NDEBUG&lt;/code&gt;。只有明确决定关闭断言时再加 &lt;code&gt;-DNDEBUG&lt;/code&gt;。Sanitizer 用于查错，会改变时间和内存开销，不能拿它测比赛极限性能；相关检测范围见 &lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html&quot;&gt;GCC 插桩选项&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;要查 STL 迭代器和部分容器前提，可另外用 &lt;code&gt;-D_GLIBCXX_DEBUG&lt;/code&gt; 编译本地单文件。它属于 libstdc++ 模式，不是标准 C++，会改变部分容器类型的大小与行为；跨编译单元传容器时需保持配置一致。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/libstdc++/manual/debug_mode_using.html&quot;&gt;libstdc++ Debug Mode&lt;/a&gt;&lt;/p&gt;
&lt;h4&gt;10. 看预处理结果：宏出问题时直接展开&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;# 展开 include 和宏，查看实际交给编译器的 C++。
g++ -std=c++17 -E -P ready/preprocessor_example.cpp -o /tmp/cp-expanded.cpp

# 查看当前编译器/标准模式预定义了哪些宏。
g++ -std=c++17 -dM -E -x c++ /dev/null &amp;gt; /tmp/cp-macros.txt
rg &apos;__cplusplus|__GNUC__|__clang__|ONLINE_JUDGE|LOCAL&apos; /tmp/cp-macros.txt

# 查看包含了哪些头文件，缩进反映包含深度。
g++ -std=c++17 -H -fsyntax-only ready/preprocessor_example.cpp 2&amp;gt; /tmp/cp-includes.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;-E&lt;/code&gt; 只做预处理，&lt;code&gt;-P&lt;/code&gt; 去掉输出中的行标记；&lt;code&gt;-dM -E&lt;/code&gt; 列出宏定义，&lt;code&gt;-H&lt;/code&gt; 输出包含层次。它们帮助判断 LOCAL 分支是否出现、某个名字是否被宏污染、头文件搜索是否符合预期。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Preprocessor-Options.html&quot;&gt;GCC 预处理命令文档&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E6%A8%A1%E6%8B%9F%E9%80%80%E7%81%AB%E7%9A%84%E9%80%82%E7%94%A8%E6%83%85%E5%BD%A2%E4%B8%8E%E5%88%86%E7%B1%BB%E6%A8%A1%E6%9D%BF/&quot;&gt;模拟退火的适用情形与分类模板&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第二章 基础与进阶数据结构&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.1 树状数组 (Fenwick Tree / 点修区间和)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：单点修改、前缀求和与区间求和，采用 &lt;code&gt;lowbit&lt;/code&gt; 运算；区间加、区间求和的双树状数组见2.28。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;ll&amp;gt; tree(n + 5);
auto add = [&amp;amp;](int x, ll v)
{
    for (; x &amp;lt;= n; x += x &amp;amp; -x)
        tree[x] += v;
};
auto sum = [&amp;amp;](int x) -&amp;gt; ll
{
    ll res = 0;
    for (; x; x -= x &amp;amp; -x)
        res += tree[x];
    return res;
};
auto query = [&amp;amp;](int l, int r) -&amp;gt; ll
{
    return sum(r) - sum(l - 1);
};

// TODO: 点修用 add(pos, delta)，区间和用 query(l, r)。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.2 树状数组 + 倍增求第 K 小 (约瑟夫环 II 实战)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：基于树状数组前缀权值和，通过二进制倍增 (&lt;code&gt;find_k&lt;/code&gt;) 在 $O(\log N)$ 内完成单次第 $K$ 小元素查询与动态删除。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;bits/extc++.h&amp;gt;
#define N 200005
#define ll long long
#define pr pair&amp;lt;ll,ll&amp;gt;
#define inf 100000000000
using namespace std;
ll n,m,k;
ll mod=1e9+7;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;k;
    #define lowbit(x) (x&amp;amp;-x)
    vector&amp;lt;int&amp;gt;s(n+5,0);
    auto add=[&amp;amp;](int x,int add)
    {
        for(int i=x;i&amp;lt;=n;i+=lowbit(i))
        {
            s[i]+=add;
        }
    };
    for(int i=1;i&amp;lt;=n;i++)
    {
        add(i,1);
    }
    auto find_k=[&amp;amp;](ll tol)
    {
        ll step=1LL&amp;lt;&amp;lt;(63-__builtin_clzll(n));
        ll id=0;
        for(;step&amp;gt;=1;step&amp;gt;&amp;gt;=1)
        {
            ll next=id+step;
            if(next&amp;lt;=n&amp;amp;&amp;amp;s[next]&amp;lt;tol)
            {
                tol-=s[next];
                id=next;
            }
        }
        return id+1;
    };
    int id=0;
    for(ll cur_size=n;cur_size&amp;gt;=1;cur_size--)
    {
        id=(id+k)%cur_size;
        auto res=find_k(id+1);
        cout&amp;lt;&amp;lt;res&amp;lt;&amp;lt;&apos;\n&apos;;
        add(res,-1);
    }
    return 0;

}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.3 线段树：单点修改与区间和查询&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：四倍空间标准递归线段树，支持快速建树、单点增加与区间求和。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;ll&amp;gt; s(n + 5), tree(4 * n + 5);
auto up = [&amp;amp;](int p)
{
    tree[p] = tree[lc] + tree[rc];
};
auto build = [&amp;amp;](auto &amp;amp;&amp;amp;self, int p, int l, int r) -&amp;gt; void
{
    if (l == r)
    {
        tree[p] = s[l];
        return;
    }
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    self(self, lc, l, mid);
    self(self, rc, mid + 1, r);
    up(p);
};
auto change = [&amp;amp;](auto &amp;amp;&amp;amp;self, int p, int l, int r, int x, ll v) -&amp;gt; void
{
    if (l == r)
    {
        tree[p] += v;
        return;
    }
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    if (x &amp;lt;= mid)
        self(self, lc, l, mid, x, v);
    else
        self(self, rc, mid + 1, r, x, v);
    up(p);
};
auto query = [&amp;amp;](auto &amp;amp;&amp;amp;self, int p, int l, int r, int x, int y) -&amp;gt; ll
{
    if (x &amp;lt;= l &amp;amp;&amp;amp; r &amp;lt;= y)
        return tree[p];
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    ll ans = 0;
    if (x &amp;lt;= mid)
        ans += self(self, lc, l, mid, x, y);
    if (mid &amp;lt; y)
        ans += self(self, rc, mid + 1, r, x, y);
    return ans;
};

// TODO: build(build, 1, 1, n); 点修改用 change，区间查询用 query。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.4 线段树：区间修改与区间求和 (Lazy Tag)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：带延迟下传标记 (&lt;code&gt;down/lazy&lt;/code&gt;) 的区间修改线段树，维护区间和。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct SegNode
{
    ll sum = 0, add = 0;
};
vector&amp;lt;SegNode&amp;gt; tree(4 * n + 5);
auto up = [&amp;amp;](int p)
{
    tree[p].sum = tree[lc].sum + tree[rc].sum;
};
auto down = [&amp;amp;](int p, int l, int r)
{
    if (!tree[p].add || l == r)
        return;
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    ll v = tree[p].add;
    tree[lc].sum += (mid - l + 1) * v;
    tree[rc].sum += (r - mid) * v;
    tree[lc].add += v;
    tree[rc].add += v;
    tree[p].add = 0;
};
auto change = [&amp;amp;](auto &amp;amp;&amp;amp;self, int p, int l, int r, int x, int y, ll v) -&amp;gt; void
{
    if (x &amp;lt;= l &amp;amp;&amp;amp; r &amp;lt;= y)
    {
        tree[p].sum += (r - l + 1) * v;
        tree[p].add += v;
        return;
    }
    down(p, l, r);
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    if (x &amp;lt;= mid)
        self(self, lc, l, mid, x, y, v);
    if (mid &amp;lt; y)
        self(self, rc, mid + 1, r, x, y, v);
    up(p);
};
auto query = [&amp;amp;](auto &amp;amp;&amp;amp;self, int p, int l, int r, int x, int y) -&amp;gt; ll
{
    if (x &amp;lt;= l &amp;amp;&amp;amp; r &amp;lt;= y)
        return tree[p].sum;
    down(p, l, r);
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    ll ans = 0;
    if (x &amp;lt;= mid)
        ans += self(self, lc, l, mid, x, y);
    if (mid &amp;lt; y)
        ans += self(self, rc, mid + 1, r, x, y);
    return ans;
};

// TODO: 如果需要区间赋值，另加 set 标记；按题目补 build。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.5 线段树全功能完整实现 (Point &amp;amp; Range Updates)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：完整工程版线段树实现，包含完整 build、change_point、change_range、pushdown 逻辑。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define N 1000050
#define lc p&amp;lt;&amp;lt;1
#define rc p&amp;lt;&amp;lt;1|1
#define ll long long
#pragma GCC optimize(2)
using namespace std;
struct s_tree{
    int l,r;
    ll sum,add; //lazy标记是针对子节点而言的
}tree[4*N];
int s[N];
void up(int p)
{
    tree[p].sum=tree[lc].sum+tree[rc].sum;


    return;
}
void down(int p)
{
    if(tree[p].add)
    {
        tree[lc].sum+=(tree[lc].r-tree[lc].l+1)*tree[p].add;
        tree[rc].sum+=(tree[rc].r-tree[rc].l+1)*tree[p].add;
        tree[lc].add+=tree[p].add;
        tree[rc].add+=tree[p].add;
        tree[p].add=0;

    }
    up(p);
    return;
}
void build(int p,int l,int r)
{
    tree[p]={l,r,0,0};
    if(l==r)
    {
        tree[p].sum=s[l];
        return;
    }


    int mid=(l+r)&amp;gt;&amp;gt;1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    up(p);
    return;

}
ll ask(int p,int l,int r)
{

    if(tree[p].l&amp;gt;=l&amp;amp;&amp;amp;tree[p].r&amp;lt;=r)
        return  tree[p].sum;
    down(p);
    ll sum=0;
    int mid=(tree[p].l+tree[p].r)&amp;gt;&amp;gt;1;
    if(mid&amp;gt;=l) sum+=ask(lc,l,r);
    if(mid&amp;lt;r) sum+=ask(rc,l,r);

    return sum;
}
void change(int p,int l,int r,ll k)
{


    if(tree[p].l&amp;gt;=l&amp;amp;&amp;amp;tree[p].r&amp;lt;=r)
    {
        tree[p].sum+=(tree[p].r-tree[p].l+1)*k;
        tree[p].add+=k;
        return;
    }
    down(p);
    int mid=(tree[p].l+tree[p].r)&amp;gt;&amp;gt;1;
    if(mid&amp;gt;=l) change(lc,l,r,k);
    if(mid&amp;lt;r)  change(rc,l,r,k);
    up(p);
    return;

}
int main(){
    int n,q;
    char flag;
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;q;;
    for(int i=1;i&amp;lt;=n;i++)
    {
        cin&amp;gt;&amp;gt;s[i];
    }
    build(1,1,n);
    int a,b;
    ll c;
    for(int i=1;i&amp;lt;=q;i++)
    {

        cin&amp;gt;&amp;gt;flag;
        if(flag==&apos;C&apos;)
        {
            cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;c;
            change(1,a,b,c);
        }
        else
        {
            cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;
            printf(&quot;%lld\n&quot;,ask(1,a,b));
        }
        // getchar();
    }

    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.6 线段树上二分 (Segment Tree Walk)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：在权值线段树或计数线段树上直接二分跳转，单次 $O(\log N)$ 确定第 $k$ 大/小位置。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// 依赖：点修线段树的 tree、lc、rc。
auto kth = [&amp;amp;](auto &amp;amp;&amp;amp;self, int p, int l, int r, ll k) -&amp;gt; int
{
    if (l == r)
        return l;
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    if (tree[lc] &amp;gt;= k)
        return self(self, lc, l, mid, k);
    return self(self, rc, mid + 1, r, k - tree[lc]);
};

// TODO: tree 维护计数时，kth(kth, 1, 1, n, k) 返回第 k 个存在的位置。
// 区间内二分需要额外传入查询范围并判断左右子树贡献。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-7&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.7 动态开点线段树 (Dynamic Segment Tree)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：动态开点区间加与区间和。long long闭区间；范围长度和区间和必须可表示。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;

// 0-based闭区间；值域端点必须可相减，所有区间和可放long long。
// 返回节点编号，不能跨vector扩容保留对子节点的引用。
struct DynamicRangeAddSum {
    using ll = long long;
    struct Node { int left = 0, right = 0; ll sum = 0, lazy = 0; };
    vector&amp;lt;Node&amp;gt; tr{Node{}};
    int root = 0;
    ll lo, hi;
    DynamicRangeAddSum(ll l, ll r) : lo(l), hi(r) { assert(l &amp;lt;= r); }
    int add(int p, ll l, ll r, ll L, ll R, ll value) {
        if (R &amp;lt; l || r &amp;lt; L) return p;
        if (!p) { p = int(tr.size()); tr.push_back({}); }
        if (L &amp;lt;= l &amp;amp;&amp;amp; r &amp;lt;= R) {
            tr[p].sum += (r - l + 1) * value;
            tr[p].lazy += value;
            return p;
        }
        ll mid = l + (r - l) / 2;
        int left = add(tr[p].left, l, mid, L, R, value);
        tr[p].left = left;
        int right = add(tr[p].right, mid + 1, r, L, R, value);
        tr[p].right = right;
        tr[p].sum = tr[left].sum + tr[right].sum + tr[p].lazy * (r - l + 1);
        return p;
    }
    ll sum(int p, ll l, ll r, ll L, ll R, ll carry = 0) const {
        ll overlap = max(0LL, min(r, R) - max(l, L) + 1);
        if (!overlap) return 0;
        if (!p) return carry * overlap;
        if (L &amp;lt;= l &amp;amp;&amp;amp; r &amp;lt;= R) return tr[p].sum + carry * (r - l + 1);
        ll mid = l + (r - l) / 2;
        carry += tr[p].lazy;
        return sum(tr[p].left, l, mid, L, R, carry)
             + sum(tr[p].right, mid + 1, r, L, R, carry);
    }
    void add(ll l, ll r, ll value) { assert(lo &amp;lt;= l &amp;amp;&amp;amp; l &amp;lt;= r &amp;amp;&amp;amp; r &amp;lt;= hi); root = add(root, lo, hi, l, r, value); }
    ll sum(ll l, ll r) const { assert(lo &amp;lt;= l &amp;amp;&amp;amp; l &amp;lt;= r &amp;amp;&amp;amp; r &amp;lt;= hi); return sum(root, lo, hi, l, r); }
};
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-8&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.8 动态开点线段树 (完整题解版)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：带完整动态分配与值域覆盖的独立实现。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;algorithm&amp;gt;
#define ll long long
#define N 300003*49
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n,q;

class dynamic_t
{
    public:
    int root;
    int n,cnt;
    int lc[N]={};
    int rc[N]={};
    int lazy[N];
    dynamic_t()
    {
        memset(lazy,-1,sizeof lazy);
    }
    struct node
    {
        int sum;
    }tree[N];
    void up(int x)
    {
        tree[x].sum=tree[lc[x]].sum+tree[rc[x]].sum;
    }
    void down(int x,int l,int r)
    {
        if(lazy[x]==-1) return;
        if(!lc[x]) lc[x]=++cnt;
        if(!rc[x]) rc[x]=++cnt;
        lazy[lc[x]]=lazy[x];
        lazy[rc[x]]=lazy[x];
        int mid=(l+r)&amp;gt;&amp;gt;1;
        tree[lc[x]].sum=(mid-l+1)*lazy[x];
        tree[rc[x]].sum=(r-mid)*lazy[x];
        lazy[x]=-1;
    }
    void change(int &amp;amp;u,int l,int r,int x,int y,int k)
    {
        if(!u) u=++cnt;
        if(l&amp;gt;=x &amp;amp;&amp;amp; r&amp;lt;=y)
        {
            tree[u].sum=k*(r-l+1);
            lazy[u]=k;
            return;
        }
        down(u,l,r);
        int mid=l+r&amp;gt;&amp;gt;1;
        if(x&amp;lt;=mid) change(lc[u],l,mid,x,y,k);
        if(y&amp;gt;mid) change(rc[u],mid+1,r,x,y,k);
        up(u);
    }
    int query(int &amp;amp;u,int l,int r,int x,int y)
    {
        if(l&amp;gt;=x &amp;amp;&amp;amp; r&amp;lt;=y)
        {
            return tree[u].sum;
        }
        down(u,l,r);
        int mid=l+r&amp;gt;&amp;gt;1;
        int ans=0;
        if(x&amp;lt;=mid) ans+=query(lc[u],l,mid,x,y);
        if(y&amp;gt;mid) ans+=query(rc[u],mid+1,r,x,y);
        return ans;
    }
}t;

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

    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;q;
    int l,r,k;
    for(int i=1;i&amp;lt;=q;i++)
    {
        cin&amp;gt;&amp;gt;l&amp;gt;&amp;gt;r&amp;gt;&amp;gt;k;
        k--;
        k=!k;
        t.change(t.root,1,n,l,r,k);
        // cout&amp;lt;&amp;lt;t.query(t.root,1,n,1,n)&amp;lt;&amp;lt;&apos;\n&apos;;
        cout&amp;lt;&amp;lt;n-t.tree[1].sum&amp;lt;&amp;lt;&apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-9&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.9 权值线段树 (Weight Segment Tree)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：维护元素出现频次、支持前驱/后继与第 $k$ 大查询的权值线段树。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;algorithm&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n;

class wei_segment_t
{
    #define lc x&amp;lt;&amp;lt;1
    #define rc x&amp;lt;&amp;lt;1|1
    public:
    struct weisegment_t
    {
        int l,r,sum;
    }tree[N*4];
    void up(int x)
    {
        tree[x].sum=tree[lc].sum+tree[rc].sum;
    }
    void build(int x,int l,int r)
    {
        tree[x]={l,r,0};
        if(l==r) return ;
        int mid=(l+r)&amp;gt;&amp;gt;1;
        build(lc,l,mid);
        build(rc,mid+1,r);
    }
    void change(int x,int u,int k)
    {
        if(tree[x].l==tree[x].r)
        {
            tree[x].sum+=k;
            return;
        }
        int mid=(tree[x].l+tree[x].r)&amp;gt;&amp;gt;1;
        if(u&amp;lt;=mid) change(lc,u,k);
        if(u&amp;gt;mid) change(rc,u,k);
        up(x);
    }
    int get_rank(int x,int l,int r)
    {
        if(l&amp;gt;r || r&amp;lt;tree[x].l || tree[x].r&amp;lt;l) return 0;
        if(tree[x].l&amp;gt;=l &amp;amp;&amp;amp;tree[x].r&amp;lt;=r) //注意这里不要把大小顺序搞反了
        {
            return tree[x].sum;
        }
        int ans=0;
        int mid=(tree[x].l+tree[x].r)&amp;gt;&amp;gt;1;
        if(l&amp;lt;=mid) ans+=get_rank(lc,l,r);
        if(r&amp;gt;mid) ans+=get_rank(rc,l,r);
        return ans;
    }
    int get_val(int x,int v)
    {
        if(tree[x].l==tree[x].r)
        {
            return tree[x].l;
        }
        if(v&amp;lt;=tree[lc].sum) return get_val(lc,v);
        else return get_val(rc,v-tree[lc].sum);
    }
}t;
int op[N],v[N];
int b[N];
int m;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);

    scanf(&quot;%d&quot;,&amp;amp;n);
    for(int i=1;i&amp;lt;=n;i++)
    {
        scanf(&quot;%d%d&quot;,&amp;amp;op[i],&amp;amp;v[i]);
        if(!(op[i]==4)) b[++m]=v[i];
    }
    t.build(1, 1, m);
    sort(b+1,b+m+1);
    int x,ans,id;
    for(int i=1;i&amp;lt;=n;i++)
    {
        id=lower_bound(b+1, b+m+1, v[i])-b;
        if(op[i]==1)
        {
            t.change(1,id,1);
        }
        else if(op[i]==2)
        {
            t.change(1,id,-1);
        }
        else if(op[i]==3)
        {
            ans=t.get_rank(1,1,id-1)+1; //实际上是查询权值的前缀和
            printf(&quot;%d\n&quot;,ans);
        }
        else if(op[i]==4)
        {
            ans=t.get_val(1,v[i]);
            printf(&quot;%d\n&quot;,b[ans]);
        }
        else if(op[i]==5)
        {
            ans=t.get_rank(1,1,id-1);
            ans=b[t.get_val(1,ans)];
            printf(&quot;%d\n&quot;,ans);
        }
        else if(op[i]==6)
        {
            ans=t.get_rank(1,1,id)+1;
            ans=b[t.get_val(1,ans)];
            printf(&quot;%d\n&quot;,ans);
        }
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-10&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.10 李超线段树（项目收益实例）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：固定x值域1..50000，默认收益0；只插入整条线的Project/Query实例，负线会被0截断。一般负值DP使用8.6的离散Li Chao。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;iostream&amp;gt;
#include&amp;lt;vector&amp;gt;
#define N 100005
using namespace std;
class lc_t
{
    public:
    struct line
    {
        double k,b;
    }lin[N];
    int tree[N*2];
    int cnt;
    #define lc x&amp;lt;&amp;lt;1
    #define rc x&amp;lt;&amp;lt;1|1
    void add(double a,double bb)
    {
        lin[++cnt]={a,bb};
    }
    double cal(int id,int x)
    {
        return lin[id].k*x+lin[id].b;
    }
    void modify(int x,int l,int r,int ll,int rr,int id)
    {
        int mid=l+r&amp;gt;&amp;gt;1;
        if(l&amp;gt;=ll &amp;amp;&amp;amp;r&amp;lt;=rr)
        {
            if(cal(tree[x],mid)&amp;lt;cal(id,mid)) swap(id,tree[x]);
            if(cal(tree[x],l)&amp;lt;cal(id,l)) modify(lc,l,mid,ll,rr,id);
            if(cal(tree[x],r)&amp;lt;cal(id,r)) modify(rc,mid+1,r,ll,rr,id);
            return ;
        }
        if(ll&amp;lt;=mid) modify(lc,l,mid,ll,rr,id);
        if(mid&amp;lt;rr) modify(rc,mid+1,r,ll,rr,id);

    }
    double query(int x,int l,int r,int pos)
    {
        double ans=cal(tree[x],pos);
        int mid=l+r&amp;gt;&amp;gt;1;
        if(l==r) return ans;
        if(pos&amp;lt;=mid) return max(ans,query(lc,l,mid,pos));
        else return max(ans,query(rc,mid+1,r,pos));
    }
}t;
int main(){
    int q;
    int n=50000;
    cin&amp;gt;&amp;gt;q;
    while(q--)
    {
        string s;
        cin&amp;gt;&amp;gt;s;
        if(s==&quot;Project&quot;)
        {
            double a,b;
            cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;
            t.add(b,a-b);
            t.modify(1,1,n,1,n,t.cnt);
        }else {
            int day;
            cin&amp;gt;&amp;gt;day;
            long long ans=t.query(1,1,n,day)/100;
            cout&amp;lt;&amp;lt;ans&amp;lt;&amp;lt;&apos;\n&apos;;
        }
    }
	return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-11&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.11 矩形面积并（0-based离散化，128位面积）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：线段树维护区间被覆盖次数与有效被覆盖总长度，结合离散化计算矩形并集面积。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;using i128=__int128_t;
// 整数矩形并面积；忽略零面积矩形，坐标与总面积在128位内。
i128 rectangle_union(vector&amp;lt;array&amp;lt;ll,4&amp;gt;&amp;gt; rect){
    struct Event{ll x,y1,y2;int d;bool operator&amp;lt;(const Event&amp;amp;o)const{return x&amp;lt;o.x;}};
    vector&amp;lt;Event&amp;gt;ev;vector&amp;lt;ll&amp;gt;ys;
    for(auto [x1,y1,x2,y2]:rect){
        if(x1&amp;gt;x2)swap(x1,x2);if(y1&amp;gt;y2)swap(y1,y2);
        if(x1==x2||y1==y2)continue;
        ev.push_back({x1,y1,y2,1});ev.push_back({x2,y1,y2,-1});ys.push_back(y1);ys.push_back(y2);
    }
    if(ev.empty())return 0;
    sort(ev.begin(),ev.end());sort(ys.begin(),ys.end());ys.erase(unique(ys.begin(),ys.end()),ys.end());
    int n=int(ys.size())-1;vector&amp;lt;int&amp;gt;cover(4*n+4);vector&amp;lt;i128&amp;gt;len(4*n+4);
    auto add=[&amp;amp;](auto&amp;amp;&amp;amp;self,int p,int l,int r,int L,int R,int d)-&amp;gt;void{
        if(R&amp;lt;l||r&amp;lt;L)return;
        if(L&amp;lt;=l&amp;amp;&amp;amp;r&amp;lt;=R)cover[p]+=d;
        else{int mid=(l+r)/2;self(self,p*2,l,mid,L,R,d);self(self,p*2+1,mid+1,r,L,R,d);}
        if(cover[p]&amp;gt;0)len[p]=i128(ys[r+1])-ys[l];
        else len[p]=l==r?0:len[p*2]+len[p*2+1];
    };
    i128 area=0;ll last=ev[0].x;
    for(size_t i=0;i&amp;lt;ev.size();){
        ll x=ev[i].x;area+=len[1]*(i128(x)-last);
        while(i&amp;lt;ev.size()&amp;amp;&amp;amp;ev[i].x==x){auto e=ev[i++];int l=lower_bound(ys.begin(),ys.end(),e.y1)-ys.begin(),r=lower_bound(ys.begin(),ys.end(),e.y2)-ys.begin()-1;add(add,1,0,n-1,l,r,e.d);}
        last=x;
    }
    return area;
}
int main(){
    int n;if(!(cin&amp;gt;&amp;gt;n))return 0;vector&amp;lt;array&amp;lt;ll,4&amp;gt;&amp;gt;r(n);for(auto&amp;amp;a:r)for(auto&amp;amp;x:a)cin&amp;gt;&amp;gt;x;
    i128 ans=rectangle_union(r);string s;do{s+=char(&apos;0&apos;+ans%10);ans/=10;}while(ans);reverse(s.begin(),s.end());cout&amp;lt;&amp;lt;s&amp;lt;&amp;lt;&apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-12&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.12 可持久化数组（历史版本单点修改/查询）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：可持久化数组，支持历史版本单点查询和单点修改；区间第K小见2.13。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 1000003
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n,m;
class his_tree
{
    public:
    int n=0,cnt=0;
    int tr[N*25];
    int lc[N*25];
    int rc[N*25];
    int root[N];
    his_tree(int l){n=l;};

    void build(int &amp;amp;u,int l,int r,int s[])
    {
        u=++cnt;
        if(l==r)
        {
            tr[u]=s[l];
            return;
        }
        int m=l+r&amp;gt;&amp;gt;1;
        build(lc[u],l,m,s);
        build(rc[u],m+1,r,s);
    }
    void change(int &amp;amp;u,int v,int l,int r,int x,int num)
    {
        u=++cnt;
        tr[u]=tr[v];
        lc[u]=lc[v],rc[u]=rc[v];
        if(l==r)
        {
            tr[u]=num;
            return;
        }
        int m=l+r&amp;gt;&amp;gt;1;
        if(x&amp;lt;=m) change(lc[u],lc[v],l,m,x,num);
        else change(rc[u],rc[v],m+1,r,x,num);
    }
    int query(int &amp;amp;u,int l,int r,int x)
    {
        if(l==r) return tr[u];
        int m=l+r&amp;gt;&amp;gt;1;
        if(x&amp;lt;=m)  return query(lc[u],l,m,x);
        else return query(rc[u],m+1,r,x);
    }

}t(n);
int s[N],op,v,p,c;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;

    for(int i=1;i&amp;lt;=n;i++)
    {

        cin&amp;gt;&amp;gt;s[i];
    }
    t.build(t.root[0],1,n,s);

    for(int i=1;i&amp;lt;=m;i++)
    {
        cin&amp;gt;&amp;gt;v&amp;gt;&amp;gt;op;

        if(--op)
        {

            t.root[i]=t.root[v];
            cin&amp;gt;&amp;gt;p;
            cout&amp;lt;&amp;lt;t.query(t.root[v], 1,n,p)&amp;lt;&amp;lt;&apos;\n&apos;;
        }
        else
        {
            cin&amp;gt;&amp;gt;p&amp;gt;&amp;gt;c;
            t.change(t.root[i],t.root[v],1,n,p,c);
        }
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-13&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.13 主席树：权值持久化实现&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：主席树维护权值与历史版本更新的变体实现。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 1000003
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n,m;
int s[N];
vector &amp;lt;int&amp;gt;nums;
int op,v,p,c;
class trr
{
    public:
        int s[N*20];
        int cnt=0;
        int lc[N*20],rc[N*20],root[N*20];
    void insert(int &amp;amp;u,int v,int l,int r,int k)
    {
        u=++cnt;
        s[u]=s[v]+1;
        lc[u]=lc[v];
        rc[u]=rc[v];
        if(l==r) return;
        int m=l+r&amp;gt;&amp;gt;1;
        if(k&amp;lt;=m) insert(lc[u],lc[v],l,m,k);
        else insert(rc[u],rc[v],m+1,r,k);
    }
    int query(int u,int v,int l,int r,int k)
    {
        if(l==r) return l;
        int num=s[lc[v]]-s[lc[u]];
        int m=l+r&amp;gt;&amp;gt;1;
        if(k&amp;lt;=num) return query(lc[u],lc[v],l,m,k);
        else return query(rc[u],rc[v],m+1,r,k-num);
    }
}t;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;
    for(int i=1;i&amp;lt;=n;i++)
    {
        cin&amp;gt;&amp;gt;s[i];
        nums.push_back(s[i]);
    }
    // auto cmp=[](auto a,auto b){return a.num&amp;lt;=b.num;};
    // sort(s+1,s+n+1,cmp);
    sort(nums.begin(),nums.end());
    nums.erase(unique(nums.begin(),nums.end()),nums.end());
    int len=nums.size();
    for(int i=1;i&amp;lt;=n;i++)
    {
        int id=lower_bound(nums.begin(),nums.end(),s[i])-nums.begin()+1;
        t.insert(t.root[i],t.root[i-1], 1,len,id);
    }
    int l,r,k,id;
    while(m--)
    {
        cin&amp;gt;&amp;gt;l&amp;gt;&amp;gt;r&amp;gt;&amp;gt;k;
        id=t.query(t.root[l-1],t.root[r],1,len,k);
        cout&amp;lt;&amp;lt;nums[id-1]&amp;lt;&amp;lt;&apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-14&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.14 ST 表：静态区间最值 (RMQ / Sparse Table)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：$O(N \log N)$ 预处理、$O(1)$ 在线回答静态区间最大/最小值的倍增数据结构。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int LOG = __lg(n) + 1;
vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt; st(LOG, vector&amp;lt;ll&amp;gt;(n + 1));
for (int i = 1; i &amp;lt;= n; i++)
    st[0][i] = a[i];
for (int j = 1; j &amp;lt; LOG; j++)
    for (int i = 1; i + (1 &amp;lt;&amp;lt; j) - 1 &amp;lt;= n; i++)
        st[j][i] = max(st[j - 1][i], st[j - 1][i + (1 &amp;lt;&amp;lt; (j - 1))]);

auto query = [&amp;amp;](int l, int r) -&amp;gt; ll
{
    int k = __lg(r - l + 1);
    return max(st[k][l], st[k][r - (1 &amp;lt;&amp;lt; k) + 1]);
};

// TODO: 求区间最小值时把 max 改为 min；ST 表只适合静态数据。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-15&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.15 单调队列：滑动窗口最值 (Monotone Queue)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：双端队列维护区间单调性，在线性 $O(N)$ 时间内滑动处理定长窗口最值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;deque&amp;lt;int&amp;gt; que;
for (int i = 1; i &amp;lt;= n; i++)
{
    while (que.size() &amp;amp;&amp;amp; que.front() &amp;lt;= i - k)
        que.pop_front();
    while (que.size() &amp;amp;&amp;amp; a[que.back()] &amp;gt;= a[i])
        que.pop_back();
    que.push_back(i);
    if (i &amp;gt;= k)
        cout &amp;lt;&amp;lt; a[que.front()] &amp;lt;&amp;lt; &apos; &apos;;
}
// TODO: 求最大值时将 &amp;gt;= 改为 &amp;lt;=；窗口边界按题意调整。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-16&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.16 单调栈 (Monotone Stack)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：$O(N)$ 时间求解序列中每个元素左侧/右侧第一个更大或更小的元素位置。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;int&amp;gt; sta;
for (int i = 1; i &amp;lt;= n; i++)
{
    while (sta.size() &amp;amp;&amp;amp; a[sta.back()] &amp;gt;= a[i])
    {
        int x = sta.back();
        sta.pop_back();
        // TODO: i 是 x 右侧第一个不大于它的位置，利用 x 补答案。
    }
    if (sta.size())
    {
        // TODO: sta.back() 是 i 左侧最近的更小位置。
    }
    sta.push_back(i);
}
// TODO: 求更大/允许相等时调整比较符号。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-17&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.17 二叉堆（C++动态数组）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：自包含C++二叉堆，Compare控制大小根，push/pop为O(log n)，空堆先检查。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// Compare=less&amp;lt;T&amp;gt;是最大堆，greater&amp;lt;T&amp;gt;是最小堆；top/pop前检查empty。
template&amp;lt;class T,class Compare=less&amp;lt;T&amp;gt;&amp;gt;struct BinaryHeap{
    vector&amp;lt;T&amp;gt;a;Compare less_priority;
    bool empty()const{return a.empty();}
    size_t size()const{return a.size();}
    const T&amp;amp;top()const{assert(!empty());return a[0];}
    void push(T x){
        a.push_back(x);size_t i=a.size()-1;
        while(i){size_t p=(i-1)/2;if(!less_priority(a[p],a[i]))break;swap(a[p],a[i]);i=p;}
    }
    void pop(){
        assert(!empty());a[0]=a.back();a.pop_back();if(empty())return;
        size_t i=0;
        while(i*2+1&amp;lt;a.size()){
            size_t child=i*2+1;if(child+1&amp;lt;a.size()&amp;amp;&amp;amp;less_priority(a[child],a[child+1]))++child;
            if(!less_priority(a[i],a[child]))break;swap(a[i],a[child]);i=child;
        }
    }
};
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-18&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.18 可并堆：左偏树 (Leftist Tree / Mergable Heap)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：支持 $O(\log N)$ 距离调整与两堆无损合并的可并优先队列，结合并查集维护连通分支。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
ll k,n,m;
class dsu
{
    public:
    int fa[N];
    void init()
    {
        for(int i=1;i&amp;lt;N;i++) fa[i]=i;
    }
    int find(int x){return fa[x]=(fa[x]==x?x:find(fa[x]));}
    bool merge(int x,int y)
    {
        int rx,ry;
        rx=find(x);
        ry=find(y);
        if(rx==ry) return 0;
        fa[rx]=ry;
        return 1;
    }
}ds;
class mergeable_heap
{
    public:

    int val[N],rc[N],lc[N],dis[N],id=0;

    int new_(int x)
    {
        val[++id]=x;
        dis[id]=1;
        return id;
    }
    int merge(int x,int y)
    {
        if(!x||!y) return x+y;
        if(make_pair(val[x],x)&amp;gt;make_pair(val[y], y)) swap(x,y);
        rc[x]=merge(rc[x],y);
        if(dis[rc[x]]&amp;gt;dis[lc[x]]) swap(lc[x],rc[x]);
        dis[x]=dis[rc[x]]+1;
        return x;
    }
}mh;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;
    ds.init();
    for(int i=1;i&amp;lt;=n;i++)
    {
        ll x;
        cin&amp;gt;&amp;gt;x;
        mh.new_(x);
    }
    mh.val[0]=-1;
    while(m--)
    {
        ll opt,x,y;
        cin&amp;gt;&amp;gt;opt;
        if(opt==1)
        {
            cin&amp;gt;&amp;gt;x&amp;gt;&amp;gt;y;
            if(mh.val[x]==-1 || mh.val[y]==-1 ) continue;
            x=ds.find(x),y=ds.find(y);
            if(x!=y) ds.fa[x]=ds.fa[y]=mh.merge(ds.find(x),ds.find(y));
        }else {
            cin&amp;gt;&amp;gt;x;
            if(mh.val[x]==-1) cout&amp;lt;&amp;lt;-1&amp;lt;&amp;lt;&apos;\n&apos;;
            else
            {
                x=ds.find(x);
                cout&amp;lt;&amp;lt;mh.val[x]&amp;lt;&amp;lt;&apos;\n&apos;;
                mh.val[x]=-1;
                ds.fa[x]=ds.fa[mh.lc[x]]=ds.fa[mh.rc[x]]=mh.merge(mh.lc[x],mh.rc[x]);
            }
        }
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-19&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.19 可持久化左偏树 (Persistent Leftist Tree)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：仅收可持久化堆接口，0为空，push/pop/merge返回新版本根；不再混入资金购买路径的整题代码。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;

// 函数式左偏最小堆；所有版本只读共享，操作返回新根。0为空堆。
// 每次merge复制右路径，O(log(n+m))新节点；禁止同一版本与自身合并。
struct PersistentLeftistHeap {
    using ll = long long;
    struct Node { ll value = 0; int left = 0, right = 0, dist = 0; };
    vector&amp;lt;Node&amp;gt; tr{Node{}};
    int singleton(ll value) {
        tr.push_back({value, 0, 0, 1});
        return int(tr.size()) - 1;
    }
    int merge(int x, int y) {
        if (!x || !y) return x ? x : y;
        if (tr[x].value &amp;gt; tr[y].value) swap(x, y);
        Node node = tr[x]; // 不保留vector元素引用
        node.right = merge(node.right, y);
        if (tr[node.left].dist &amp;lt; tr[node.right].dist) swap(node.left, node.right);
        node.dist = tr[node.right].dist + 1;
        tr.push_back(node);
        return int(tr.size()) - 1;
    }
    int push(int root, ll value) { return merge(root, singleton(value)); }
    ll top(int root) const { assert(root); return tr[root].value; }
    int pop(int root) { assert(root); return merge(tr[root].left, tr[root].right); }
};
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-20&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.20 笛卡尔树构造与特定 XOR 子树检查实例&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：包含笛卡尔树和题目特定DSU on Tree判定；不是只需输入数组即返回通用笛卡尔树接口。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/extc++.h&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define tii tuple&amp;lt;int, int, int&amp;gt;
#define tll tuple&amp;lt;ll, ll, ll&amp;gt;
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
#define inf 0x3f3f3f3f3f3f3f3f
#define N 100005
using namespace std;
using namespace __gnu_pbds;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);

    vector&amp;lt;ll&amp;gt; cnt(1 &amp;lt;&amp;lt; 21, 0);
    auto solve = [&amp;amp;]() {
        ll n, root;
        cin &amp;gt;&amp;gt; n;
        vector&amp;lt;array&amp;lt;int, 2&amp;gt;&amp;gt; tr(n + 5, {0, 0});
        stack&amp;lt;int&amp;gt; sta;
        vector&amp;lt;int&amp;gt; s(n + 5, 0);
        vector&amp;lt;int&amp;gt; pre(n + 5, 0);
        for (int i = 1; i &amp;lt;= n; i++) {
            cin &amp;gt;&amp;gt; s[i];
            int pre = -1;
            while (sta.size() &amp;amp;&amp;amp; s[sta.top()] &amp;lt; s[i])
                pre = sta.top(), sta.pop();
            if (sta.size())
                tr[sta.top()][1] = i;
            else
                root = i;
            if (pre != -1)
                tr[i][0] = pre;
            sta.push(i);
        }
        ll ans = 0;
        auto check = [&amp;amp;](int M) -&amp;gt; bool {
            for (int i = 1; i &amp;lt;= n; i++) {
                pre[i] = pre[i - 1] ^ (s[i] &amp;amp; M);
            }
            bool found = false;
            auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int l, int r, bool keep) -&amp;gt; void {
                if (l == r) {
                    if (keep)
                        cnt[pre[l]]++;
                    return;
                }
                int lc = tr[x][0], rc = tr[x][1];
                bool leftSmall = x - 1 - l &amp;lt;= r - x;
                int sl = leftSmall ? l : x, sr = leftSmall ? x - 1 : r;
                if (leftSmall)
                    self(self, lc, l, x - 1, false), self(self, rc, x, r, true);
                else
                    self(self, rc, x, r, false), self(self, lc, l, x - 1, true);
                if ((s[x] &amp;amp; M) == M) {
                    bool bad = (pre[x - 1] ^ pre[x]) == M;
                    int badid = leftSmall ? x - 1 : x;
                    for (int i = sl; i &amp;lt;= sr; i++) {
                        if (cnt[pre[i] ^ M] - (bad &amp;amp;&amp;amp; badid == i) &amp;gt; 0)
                            found = true;
                    }
                }
                for (int i = sl; i &amp;lt;= sr; i++)
                    cnt[pre[i]]++;
                if (!keep)
                    for (int i = l; i &amp;lt;= r; i++)
                        cnt[pre[i]]--;
            };
            dfs(dfs, root, 0, n, false);
            return found;
        };
        for (int i = 20; i &amp;gt;= 0; i--) {
            if (check(ans | (1 &amp;lt;&amp;lt; i)))
                ans |= (1 &amp;lt;&amp;lt; i);
        }
        cout &amp;lt;&amp;lt; ans &amp;lt;&amp;lt; &apos;\n&apos;;
    };
    ll t;
    cin &amp;gt;&amp;gt; t;
    while (t--)
        solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-21&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.21 Treap 平衡树（FHQ 分裂合并版本）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：本节实际为FHQ Treap，不是旋转Treap；与2.25同型。值域不含INT_MIN，前驱/后继保证存在时调用。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n;
class treap
{
    #define lc tr[p].l
    #define rc tr[p].r
    public:
    int n=0,root=0,idx=0;
    struct node
    {
        int l,r;
        int v;
        int key;
        int size;
    }tr[N];
    int newnode(int v)
    {
        tr[++idx].v=v;
        tr[idx].key=rand();
        tr[idx].size=1;
        return idx;
    }
    void push_up(int p)
    {
        tr[p].size=tr[lc].size+tr[rc].size+1;
    }
    void split(int p,int v,int &amp;amp;x,int &amp;amp;y) //x 和 y分别是分裂出来的根及子树需要填补的右左节点
    {
        if(!p) {x=0,y=0;return;}
        if(tr[p].v&amp;lt;=v)
        {
            x=p; //是上一个需要填补的子树根的右孩子
            split(rc,v,rc,y);//因为x以及整个左子树均符合要求,就去右子树上找去填补x的右孩子
        }else {
            y=p;
            split(lc,v,x,lc);
        }
        push_up(p);
    }
    int merge(int x,int y)//根据堆的性质合并左右子树
    {
        if(!x || !y) return x+y;
        //这里采用小根堆
        if(tr[x].key&amp;lt;tr[y].key)//x是根
        {
            tr[x].r=merge(tr[x].r,y); //1.递归过程中x始终是小于v的子树,y及其子树值都大于x上值,为满足搜索树性质应填补右子树 2.根据堆的性质,应挑选自己的右孩子和y中key最大的节点作为右子节点
            push_up(x);
            return x;
        }else {
            tr[y].l=merge(x,tr[y].l);
            push_up(y);
            return y;
        }
    }
    void insert(int v)
    {
        int x,y,z;
        split(root,v,x,y);
        z=newnode(v);
        root=merge(merge(x,z),y); //这里就很好理解了 把小于等于v的树和v合并再和大于v的合并
    }
    void del(int v)
    {
         int x,y,z;
        split(root,v,x,y);
        split(x,v-1,x,z); //此时x y z 分别为 小于v的子树 大于v的子树 和只有v的子树
        z=merge(tr[z].l,tr[z].r);//把z的根丢掉 即删除了一个v
        root=merge(merge(x,z),y);//复原树
    }
    int get_k(int p,int k)//返回第k个节点
    {
        if(!p) return 0;
        if(k&amp;lt;=tr[lc].size) return get_k(lc, k);//左子树节点数量多于排名 说明要找的节点就在左链上
        else if(k==tr[lc].size+1) return p;
        else return get_k(rc, k-1-tr[lc].size); //单独去右子树找,则需要将整个左子树中以及小于排名的数量减去(排除了)
    }
    int get_pre(int v)
    {
        int x,y,ans;
        split(root,v-1,x,y);
        ans=get_k(x,tr[x].size);//x中最大的节点
        root=merge(x,y);
        return tr[ans].v;
    }
    int get_suc(int v)
    {
        int x,y,ans;
        split(root,v,x,y);
        ans=get_k(y,1);
        root=merge(x,y);
        return tr[ans].v;
    }
    int get_val(int k)
    {
        return tr[get_k(root,k)].v;
    }
    int get_rank(int v)
    {
        int x,y,ans;
        split(root,v-1,x,y);
        ans=tr[x].size+1;
        root=merge(x,y);
        return ans;
    }

}t;

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

    scanf(&quot;%d&quot;,&amp;amp;n);
    int op,x,ans;
    for(int i=1;i&amp;lt;=n;i++)
    {
        scanf(&quot;%d%d&quot;,&amp;amp;op,&amp;amp;x);
        if(op==1)
        {
            t.insert(x);
        }
        else if(op==2)
        {
            t.del(x);
        }
        else if(op==3)
        {
            ans=t.get_rank(x);
            printf(&quot;%d\n&quot;,ans);
            // cout&amp;lt;&amp;lt;ans&amp;lt;&amp;lt;&apos;\n&apos;;
        }
        else if(op==4)
        {
            ans=t.get_val(x);
            printf(&quot;%d\n&quot;,ans);

        }
        else if(op==5)
        {
            ans=t.get_pre(x);
            printf(&quot;%d\n&quot;,ans);

        }
        else if(op==6)
        {
            ans=t.get_suc(x);
            printf(&quot;%d\n&quot;,ans);

        }

    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-22&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.22 Splay 伸展树 (Standard Splay)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：单旋/双旋双向更新的通用自平衡二叉树，具备极强的区间拆分与合并能力。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n;
//能不看模板手写这种东西的也是神人了
class splay_
{
    #define lx tree[x].s[0]
    #define rx tree[x].s[1]
    public:
    int root=0;
    int idx=0;
    struct node
    {
        int s[2];
        int fa;
        int v;
        int cnt;
        int size;
        void init(int fa1,int v1)
        {
            fa=fa1,v=v1;
            cnt=size=1;
        }
    }tree[N];
    void pushup(int x)
    {
        tree[x].size=tree[tree[x].s[0]].size+tree[tree[x].s[1]].size+tree[x].cnt;
    }
    void rotate(int x)
    {
        int y=tree[x].fa,z=tree[y].fa,k=tree[y].s[1]==x;//爹 爷爷 是不是右儿子
        tree[y].s[k]=tree[x].s[k^1]; //吧自己的儿子给爹
        tree[tree[x].s[k^1]].fa=y;//儿子变孙子了
        tree[x].s[k^1]=y;
        tree[y].fa=x;
        tree[z].s[tree[z].s[1]==y]=x;
        tree[x].fa=z;
        pushup(y);//有先后顺序
        pushup(x);
    }
    void splay(int x,int k)
    {
        while(tree[x].fa!=k)
        {
            int y=tree[x].fa,z=tree[y].fa;
            if(z!=k) (tree[y].s[0]==x)^(tree[z].s[0]==y)?rotate(x):rotate(y);
            rotate(x);//最后已经把x转到根节点儿子了,再转就是根了
        }
        if(!k) root=x;
    }
    void find(int v)
    {
        int x=root;
        while(tree[x].s[v&amp;gt;tree[x].v] &amp;amp;&amp;amp;tree[x].v!=v) //子节点不空且没走到
        {
            x=tree[x].s[v&amp;gt;tree[x].v];
        }
        splay(x,0);//节点不存在可以最后会走到比他更大的点或是更小的点
    }
    void insert(int v)
    {
        int x=root,fa=0;
        while(x &amp;amp;&amp;amp; tree[x].v!=v) fa=x,x=tree[x].s[v&amp;gt;tree[x].v];
        if(x &amp;amp;&amp;amp; tree[x].v==v) tree[x].cnt++;
        else
        {
            x=++idx;
            tree[x].init(fa, v);
            tree[fa].s[v&amp;gt;tree[fa].v]=x;
        }
        pushup(x);
        splay(x,0);
    }
    int get_pre(int v)
    {
        find(v);
        int x=root;
        if(tree[x].v&amp;lt;v) return x;
        x=lx;
        while(rx) x=rx;//根左节点的右子树的末端是最接近的前驱
        splay(x,0);
        return x;
    }
    int gp(int v)
    {
        return tree[get_pre(v)].v;
    }
    int get_suc(int v)
    {
        find(v);
        int x=root;
        if(tree[x].v&amp;gt;v) return x;
        x=rx;
        while(lx) x=lx;
        splay(x,0);
        return x;
    }
    int gs(int v)
    {
        return tree[get_suc(v)].v;
    }
    void del(int v)
    {
        int pre=get_pre(v);
        int suc=get_suc(v);
        splay(pre,0);
        splay(suc,pre);//让suc变成pre的右子节点 保证要删除节点一定是suc的左节点
        int del=tree[suc].s[0];
        if(tree[del].cnt&amp;gt;1)
        {
            tree[del].cnt--;
            splay(del,0);//间接更新数据
        }else {
            tree[suc].s[0]=0;//为什么可以直接删除?此时比pre小的数都在pre左子树,比suc大的都在suc的右子树,那del一定没有孩子
            splay(suc,0);
        }
    }
    int get_rank(int v)
    {
        insert(v);
        int x=root;
        int ans=tree[lx].size;
        del(v);
        return ans;
    }
    int get_val(int k)
    {
        int x=root;
        while(1)
        {
            int y=lx;
            if(k&amp;lt;=tree[lx].size) x=lx;
            else if(k&amp;lt;=tree[lx].size+tree[x].cnt) break; //主要这里的逻辑顺序
            else k-=tree[y].size+tree[x].cnt,x=rx;
        }
        splay(x,0);
        return tree[x].v;
    }
}t;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    t.insert(1e9);
    t.insert(-1e9);
    scanf(&quot;%d&quot;,&amp;amp;n);
    int op,x,ans;
    for(int i=1;i&amp;lt;=n;i++)
    {
        scanf(&quot;%d%d&quot;,&amp;amp;op,&amp;amp;x);
        if(op==1)
        {
            t.insert(x);
        }
        else if(op==2)
        {
            t.del(x);
        }
        else if(op==3)
        {
            ans=t.get_rank(x);
            printf(&quot;%d\n&quot;,ans);
            // cout&amp;lt;&amp;lt;ans&amp;lt;&amp;lt;&apos;\n&apos;;
        }
        else if(op==4)
        {
            ans=t.get_val(x+1);
            printf(&quot;%d\n&quot;,ans);

        }
        else if(op==5)
        {
            ans=t.gp(x);
            printf(&quot;%d\n&quot;,ans);

        }
        else if(op==6)
        {
            ans=t.gs(x);
            printf(&quot;%d\n&quot;,ans);

        }

    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-23&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.23 Splay 伸展树 (第二实现版本)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：Splay 平衡树的备选编码风格与指针/节点封装。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n;
//能不看模板手写这种东西的也是神人了

    #define lx tree[x].s[0]
    #define rx tree[x].s[1]

    int root=0;
    int idx=0;
    struct node
    {
        int s[2];
        int fa;
        int v;
        int cnt;
        int size;
        void init(int fa1,int v1)
        {
            fa=fa1,v=v1;
            cnt=size=1;
        }
    }tree[N];
    void pushup(int x)
    {
        tree[x].size=tree[tree[x].s[0]].size+tree[tree[x].s[1]].size+tree[x].cnt;
    }
    void rotate(int x)
    {
        int y=tree[x].fa,z=tree[y].fa,k=tree[y].s[1]==x;//爹 爷爷 是不是右儿子
        tree[y].s[k]=tree[x].s[k^1]; //吧自己的儿子给爹
        tree[tree[x].s[k^1]].fa=y;//儿子变孙子了
        tree[x].s[k^1]=y;
        tree[y].fa=x;
        tree[z].s[tree[z].s[1]==y]=x;
        tree[x].fa=z;
        pushup(y);//有先后顺序
        pushup(x);
    }
    void splay(int x,int k)
    {
        while(tree[x].fa!=k)
        {
            int y=tree[x].fa,z=tree[y].fa;
            if(z!=k) (tree[y].s[0]==x)^(tree[z].s[0]==y)?rotate(x):rotate(y);
            rotate(x);//最后已经把x转到根节点儿子了,再转就是根了
        }
        if(!k) root=x;
    }
    void find(int v)
    {
        int x=root;
        while(tree[x].s[v&amp;gt;tree[x].v] &amp;amp;&amp;amp;tree[x].v!=v) //子节点不空且没走到
        {
            x=tree[x].s[v&amp;gt;tree[x].v];
        }
        splay(x,0);//节点不存在可以最后会走到比他更大的点或是更小的点
    }
    void insert(int v)
    {
        int x=root,fa=0;
        while(x &amp;amp;&amp;amp; tree[x].v!=v) fa=x,x=tree[x].s[v&amp;gt;tree[x].v];
        if(x &amp;amp;&amp;amp; tree[x].v==v) tree[x].cnt++;
        else
        {
            x=++idx;
            tree[x].init(fa, v);
            tree[fa].s[v&amp;gt;tree[fa].v]=x;
        }
        pushup(x);
        splay(x,0);
    }
    int get_pre(int v)
    {
        find(v);
        int x=root;
        if(tree[x].v&amp;lt;v) return x;
        x=lx;
        while(rx) x=rx;//根左节点的右子树的末端是最接近的前驱
        splay(x,0);
        return x;
    }
    int gp(int v)
    {
        return tree[get_pre(v)].v;
    }
    int get_suc(int v)
    {
        find(v);
        int x=root;
        if(tree[x].v&amp;gt;v) return x;
        x=rx;
        while(lx) x=lx;
        splay(x,0);
        return x;
    }
    int gs(int v)
    {
        return tree[get_suc(v)].v;
    }
    void del(int v)
    {
        int pre=get_pre(v);
        int suc=get_suc(v);
        splay(pre,0);
        splay(suc,pre);//让suc变成pre的右子节点 保证要删除节点一定是suc的左节点
        int del=tree[suc].s[0];
        if(tree[del].cnt&amp;gt;1)
        {
            tree[del].cnt--;
            splay(del,0);//间接更新数据
        }else {
            tree[suc].s[0]=0;//为什么可以直接删除?此时比pre小的数都在pre左子树,比suc大的都在suc的右子树,那del一定没有孩子
            splay(suc,0);
        }
    }
    int get_rank(int v)
    {
        insert(v);
        int x=root;
        int ans=tree[lx].size;
        del(v);
        return ans;
    }
    int get_val(int k)
    {
        int x=root;
        while(1)
        {
            int y=lx;
            if(tree[x].cnt+tree[y].size&amp;lt;k)
            {
                k-=tree[y].size+tree[x].cnt;//因为要在右子树上进行查找
                x=rx;
            }else {
                if(tree[y].size&amp;gt;=k) x=lx;
                else break;
            }

        }
        splay(x,0);
        return tree[x].v;
    }

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    insert(1e9);
    insert(-1e9);
    scanf(&quot;%d&quot;,&amp;amp;n);
    int op,x,ans;
    for(int i=1;i&amp;lt;=n;i++)
    {
        scanf(&quot;%d%d&quot;,&amp;amp;op,&amp;amp;x);
        if(op==1)
        {
            insert(x);
        }
        else if(op==2)
        {
            del(x);
        }
        else if(op==3)
        {
            ans=get_rank(x);
            printf(&quot;%d\n&quot;,ans);
            // cout&amp;lt;&amp;lt;ans&amp;lt;&amp;lt;&apos;\n&apos;;
        }
        else if(op==4)
        {
            ans=get_val(x+1);
            printf(&quot;%d\n&quot;,ans);

        }
        else if(op==5)
        {
            ans=gp(x);
            printf(&quot;%d\n&quot;,ans);

        }
        else if(op==6)
        {
            ans=gs(x);
            printf(&quot;%d\n&quot;,ans);

        }

    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-24&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.24 隐式 FHQ Treap（区间翻转）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：原题名误写Splay；代码按位置split，随机优先级merge，维护翻转懒标记。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n,m;
class wy_t
{
    #define lc tr[p].l
    #define rc tr[p].r
    public:
    int cnt=0,root=0;
    struct node
    {
        int key;
        int num;
        int l,r;
        bool lazy;//这里的lazy_tag和线段树中的一样,都是标记子节点需要操作
        int size;
    }tr[N];
    int newnoede(int p)
    {
        tr[++cnt].key=rand();
        tr[cnt].num=p;
        tr[cnt].size=1;
        return cnt;
    }
    void up(int p)
    {
        tr[p].size=tr[lc].size+tr[rc].size+1;
    }
    void down(int p)
    {
        if(!tr[p].lazy) return;
        swap(lc,rc);
        tr[lc].lazy^=1;//如果本身子节点需要交换 再交换一次就抵消为0
        tr[rc].lazy^=1;
        tr[p].lazy^=1;
    }
    void split(int p,int k,int &amp;amp;x,int &amp;amp;y)
    {
        if(!p)
        {
            x=y=0;
            return;
        }
        down(p);
        if(tr[lc].size&amp;lt;k)
        {
            x=p;
            k-=tr[lc].size+1;
            split(tr[p].r,k,tr[p].r,y);
        }
        else {
            y=p;
            split(tr[p].l,k,x,tr[p].l);
        }
        up(p);
    }
    int merge(int x,int y)
    {
        if(!x||!y) return x+y;
        if(tr[x].key&amp;lt;tr[y].key)
        {
            down(x);
            tr[x].r=merge(tr[x].r,y);
            up(x);
            return x;
        }
        else {
            down(y);
            tr[y].l=merge(x,tr[y].l);
            up(y);
            return y;
        }
    }
    void out(int p)
    {
        if(!p) return;
        down(p);
        out(lc);
        cout&amp;lt;&amp;lt;tr[p].num&amp;lt;&amp;lt;&apos; &apos;;
        out(rc);
    }
}t;

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;
    for(int i=1;i&amp;lt;=n;i++) t.root=t.merge(t.root,t.newnoede(i));
    while(m--)
    {
        int l,r;
        cin&amp;gt;&amp;gt;l&amp;gt;&amp;gt;r;
        int x,y,z;
        t.split(t.root,r,y,z);
        t.split(y,l-1,x,y);
        t.tr[y].lazy^=1;
        t.root=t.merge(t.merge(x,y),z);
    }
    t.out(t.root);
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-25&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.25 FHQ Treap 无旋平衡树 (按值分裂与合并 / 来自知乎专栏)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：基于 split 和 merge 操作的非旋转 Treap，代码短且支持可持久化，覆盖 rank、kth、前驱、后继。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n;
class treap
{
    #define lc tr[p].l
    #define rc tr[p].r
    public:
    int n=0,root=0,idx=0;
    struct node
    {
        int l,r;
        int v;
        int key;
        int size;
    }tr[N];
    int newnode(int v)
    {
        tr[++idx].v=v;
        tr[idx].key=rand();
        tr[idx].size=1;
        return idx;
    }
    void push_up(int p)
    {
        tr[p].size=tr[lc].size+tr[rc].size+1;
    }
    void split(int p,int v,int &amp;amp;x,int &amp;amp;y) //x 和 y分别是分裂出来的根及子树需要填补的右左节点
    {
        if(!p) {x=0,y=0;return;}
        if(tr[p].v&amp;lt;=v)
        {
            x=p; //是上一个需要填补的子树根的右孩子
            split(rc,v,rc,y);//因为x以及整个左子树均符合要求,就去右子树上找去填补x的右孩子
        }else {
            y=p;
            split(lc,v,x,lc);
        }
        push_up(p);
    }
    int merge(int x,int y)//根据堆的性质合并左右子树
    {
        if(!x || !y) return x+y;
        //这里采用小根堆
        if(tr[x].key&amp;lt;tr[y].key)//x是根
        {
            tr[x].r=merge(tr[x].r,y); //1.递归过程中x始终是小于v的子树,y及其子树值都大于x上值,为满足搜索树性质应填补右子树 2.根据堆的性质,应挑选自己的右孩子和y中key最大的节点作为右子节点
            push_up(x);
            return x;
        }else {
            tr[y].l=merge(x,tr[y].l);
            push_up(y);
            return y;
        }
    }
    void insert(int v)
    {
        int x,y,z;
        split(root,v,x,y);
        z=newnode(v);
        root=merge(merge(x,z),y); //这里就很好理解了 把小于等于v的树和v合并再和大于v的合并
    }
    void del(int v)
    {
         int x,y,z;
        split(root,v,x,y);
        split(x,v-1,x,z); //此时x y z 分别为 小于v的子树 大于v的子树 和只有v的子树
        z=merge(tr[z].l,tr[z].r);//把z的根丢掉 即删除了一个v
        root=merge(merge(x,z),y);//复原树
    }
    int get_k(int p,int k)//返回第k个节点
    {
        if(!p) return 0;
        if(k&amp;lt;=tr[lc].size) return get_k(lc, k);//左子树节点数量多于排名 说明要找的节点就在左链上
        else if(k==tr[lc].size+1) return p;
        else return get_k(rc, k-1-tr[lc].size); //单独去右子树找,则需要将整个左子树中以及小于排名的数量减去(排除了)
    }
    int get_pre(int v)
    {
        int x,y,ans;
        split(root,v-1,x,y);
        ans=get_k(x,tr[x].size);//x中最大的节点
        root=merge(x,y);
        return tr[ans].v;
    }
    int get_suc(int v)
    {
        int x,y,ans;
        split(root,v,x,y);
        ans=get_k(y,1);
        root=merge(x,y);
        return tr[ans].v;
    }
    int get_val(int k)
    {
        return tr[get_k(root,k)].v;
    }
    int get_rank(int v)
    {
        int x,y,ans;
        split(root,v-1,x,y);
        ans=tr[x].size+1;
        root=merge(x,y);
        return ans;
    }

}t;

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

    scanf(&quot;%d&quot;,&amp;amp;n);
    int op,x,ans;
    for(int i=1;i&amp;lt;=n;i++)
    {
        scanf(&quot;%d%d&quot;,&amp;amp;op,&amp;amp;x);
        if(op==1)
        {
            t.insert(x);
        }
        else if(op==2)
        {
            t.del(x);
        }
        else if(op==3)
        {
            ans=t.get_rank(x);
            printf(&quot;%d\n&quot;,ans);
            // cout&amp;lt;&amp;lt;ans&amp;lt;&amp;lt;&apos;\n&apos;;
        }
        else if(op==4)
        {
            ans=t.get_val(x);
            printf(&quot;%d\n&quot;,ans);

        }
        else if(op==5)
        {
            ans=t.get_pre(x);
            printf(&quot;%d\n&quot;,ans);

        }
        else if(op==6)
        {
            ans=t.get_suc(x);
            printf(&quot;%d\n&quot;,ans);

        }

    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-26&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.26 动态开点线段树合并 (Segment Tree Merge / 来自知乎专栏)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：解决树上统计与子树权值合并的经典工具，单次合并耗时正比于重叠节点数，均摊复杂度 $O(N \log N)$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
ll n,m,cnt,vv;
int root[N];
ll ans[N];
class segment
{
    public:
    int cnt;
    int mx_sum[N*50],lc[N*50],rc[N*50],typ[N*50];
    #define mid ((l+r)&amp;gt;&amp;gt;1)
    void up(int x)
    {
        if(mx_sum[lc[x]]&amp;gt;=mx_sum[rc[x]]) typ[x]=typ[lc[x]];
        else typ[x]=typ[rc[x]];
        mx_sum[x]=max(mx_sum[lc[x]],mx_sum[rc[x]]);
    }
    void update(int &amp;amp;x,int l,int r,int pos,int add)
    {
        if(!x) x=++cnt;
        if(l==r)
        {
            mx_sum[x]+=add,typ[x]=pos;
            return;
        }
        if(pos&amp;lt;=mid) update(lc[x],l,mid,pos,add);
        else update(rc[x],mid+1,r,pos,add);
        up(x);
    }
    int merge(int x,int y,int l,int r)
    {
        if(!x || ! y) return x+y;
        if(l==r)
        {
            mx_sum[x]+=mx_sum[y];
            return x;
        }
        lc[x]=merge(lc[x],lc[y],l,mid);
        rc[x]=merge(rc[x],rc[y],mid+1,r);
        up(x);
        return x;
    }
}t;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;map1;
int fa[N][25];
int dep[N];
void dfs(int x,int f)
{
    for(int i=1;i&amp;lt;=22;i++)
    {
        fa[x][i]=fa[fa[x][i-1]][i-1];
    }
    dep[x]=dep[f]+1;
    for(auto v:map1[x])
    {
        if(v==f ) continue;
        fa[v][0]=x;
        dfs(v,x);
    }
}
int lca(int x,int y)
{
    if(dep[x]&amp;lt;dep[y]) swap(x,y);
    for(int i=22;i&amp;gt;=0;i--)
    {
        if(dep[fa[x][i]]&amp;gt;=dep[y]) x=fa[x][i];
    }
    if(x==y) return x;
    for(int i=22;i&amp;gt;=0;i--)
    {
        if(fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
    }
    return fa[x][0];
}
void cal(int x,int f)
{
    for(auto v:map1[x])
    {
        if(v==f) continue;
        cal(v,x);
        root[x]=t.merge(root[x],root[v],1,N-1);//注意这里要记录合并后的点
    }
    ans[x]=t.mx_sum[root[x]]?t.typ[root[x]]:0;//如果这个点没有东西就需要输出0
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;
    map1.resize(n+5,{});
    for(int i=1;i&amp;lt;n;i++)
    {
        int a,b;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;
        map1[a].push_back(b);
        map1[b].push_back(a);
    }
    dfs(1,0);
    for(int i=1;i&amp;lt;=m;i++)
    {
        int x,y,z;
        cin&amp;gt;&amp;gt;x&amp;gt;&amp;gt;y&amp;gt;&amp;gt;z;
        int lc=lca(x,y);
        t.update(root[x],1,N-1,z,1);
        t.update(root[y],1,N-1,z,1);
        t.update(root[lc],1,N-1,z,-1);
        t.update(root[fa[lc][0]],1,N-1,z,-1);
    }
    cal(1,0);
    for(int i=1;i&amp;lt;=n;i++) cout&amp;lt;&amp;lt;ans[i]&amp;lt;&amp;lt;&apos;\n&apos;;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-27&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.27 虚树 (Virtual Tree / CF613D &amp;amp; P2495 方案)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：针对树上关键点集合的多组询问，单调栈构建 $O(K)$ 关键分叉子树，大幅压缩树形 DP 规模。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
ll n, ans, m, cnt, tol, q;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
    for (int i = 1; i &amp;lt; n; i++) {
        ll a, b;
        cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    vector&amp;lt;int&amp;gt; dep(n + 5, 0);
    vector&amp;lt;int&amp;gt; dfn(n + 5, 0);
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; fa(n + 5, vector&amp;lt;int&amp;gt;(25, 0));
    auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int f, auto &amp;amp;&amp;amp;tim) -&amp;gt; void {
        dfn[x] = ++tim;
        fa[x][0] = f;
        dep[x] = dep[f] + 1;
        for (int i = 1; i &amp;lt;= 20; i++) {
            fa[x][i] = fa[fa[x][i - 1]][i - 1];
        }
        for (auto v : adj[x]) {
            if (v == f)
                continue;
            self(self, v, x, tim);
        }
    };
    dfs(dfs, 1, 0, 0);
    auto lca = [&amp;amp;](ll x, ll y) -&amp;gt; ll {
        if (dep[x] &amp;lt; dep[y])
            swap(x, y);
        for (int i = 20; i &amp;gt;= 0; i--) {
            if (dep[fa[x][i]] &amp;gt;= dep[y])
                x = fa[x][i];
        }
        if (x == y)
            return x;
        for (int i = 20; i &amp;gt;= 0; i--) {
            if (fa[x][i] != fa[y][i])
                x = fa[x][i], y = fa[y][i];
        }
        return fa[x][0];
    };
    vector&amp;lt;ll&amp;gt; h(n + 5, -1);
    vector&amp;lt;ll&amp;gt; cnt(n + 5, 0);
    vector&amp;lt;bool&amp;gt; iscri(n + 5, 0);
    vector&amp;lt;pr&amp;gt; edges;
#define next first
#define to second
    cin &amp;gt;&amp;gt; q;
    while (q--) {
        ll k;
        cin &amp;gt;&amp;gt; k;
        vector&amp;lt;int&amp;gt; cri(k + 5, 0);
        for (int i = 1; i &amp;lt;= k; i++) {
            cin &amp;gt;&amp;gt; cri[i];
            iscri[cri[i]] = 1;
            cnt[cri[i]] = 1;
        }
        sort(cri.begin() + 1, cri.begin() + k + 1, [&amp;amp;](ll a, ll b) { return dfn[a] &amp;lt; dfn[b]; });
        auto build = [&amp;amp;]() {
            auto add = [&amp;amp;](ll a, ll b) {
                auto tmp = h[a];
                h[a] = edges.size();
                edges.push_back({tmp, b});
            };
            edges.clear();
            vector&amp;lt;int&amp;gt; sta;
            sta.push_back(1);
            if (cri[1] != 1)
                sta.push_back(cri[1]);
            for (int i = 2; i &amp;lt;= k; i++) {
                auto l = lca(sta.back(), cri[i]);
                // 递归处理lca下方的链
                while (sta.size() &amp;gt; 1 &amp;amp;&amp;amp; dep[sta[sta.size() - 2]] &amp;gt;= dep[l]) {
                    add(sta[sta.size() - 2], sta.back());
                    sta.pop_back();
                }
                // 如果lca不在栈中
                if (l != sta.back()) {
                    add(l, sta.back());
                    sta.pop_back();
                    sta.push_back(l);
                }
                sta.push_back(cri[i]);
            }
            while (sta.size() &amp;gt; 1) {
                add(sta[sta.size() - 2], sta.back());
                sta.pop_back();
            }
        };
        build();
        int flag = 0;
        for (int i = 1; i &amp;lt;= k; i++) {
            if (iscri[fa[cri[i]][0]]) {
                flag = 1;
                break;
            }
        }
        ll ans = 0;
        auto done = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void {
            for (int i = h[x]; ~i; i = edges[i].next) {
                auto v = edges[i].to;
                self(self, v);
            }
            iscri[x] = 0;
            h[x] = -1;
            cnt[x] = 0;
        };
        if (flag) {
            cout &amp;lt;&amp;lt; -1 &amp;lt;&amp;lt; &apos;\n&apos;;
            done(done, 1);
            continue;
        }
        auto dp = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void {
            if (iscri[x]) {
                for (int i = h[x]; ~i; i = edges[i].next) {
                    auto v = edges[i].to;
                    self(self, v);
                    if (cnt[v]) {
                        ans++;
                        cnt[v] = 0;
                    }
                }
            } else {
                for (int i = h[x]; ~i; i = edges[i].next) {
                    auto v = edges[i].to;
                    self(self, v);
                    cnt[x] += cnt[v];
                    cnt[v] = 0;
                }
                if (cnt[x] &amp;gt; 1)
                    ans++, cnt[x] = 0;
            }
        };
        dp(dp, 1);
        done(done, 1);
        cout &amp;lt;&amp;lt; ans &amp;lt;&amp;lt; &apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-2-28&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;2.28 树状数组维护区间和（区间加、区间求和）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：两棵树状数组维护差分与加权差分，支持区间加、区间求和；保留原笔记配图、公式推导和按行离线矩形计数的完整代码。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84%E7%BB%B4%E6%8A%A4%E5%8C%BA%E9%97%B4%E5%92%8C-1791116082410.webp&quot; alt=&quot;树状数组维护区间和-1791116082410&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;AtCoder Beginner Contest 477 F：Count Cells in a Window&lt;/h3&gt;
&lt;h4&gt;题目重述&lt;/h4&gt;
&lt;p&gt;给定一个 $N$ 行 $M$ 列的网格。第 $i$ 行中，第 $L_i$ 列到第 $R_i$ 列的格子为黑色，其余格子为白色。&lt;/p&gt;
&lt;p&gt;每次查询给出 $A,B,C,D$，求矩形区域&lt;/p&gt;
&lt;p&gt;$$
[A,B]\times[C,D]
$$&lt;/p&gt;
&lt;p&gt;内黑色格子的数量。&lt;/p&gt;
&lt;p&gt;约束为 $1\le N,M,Q\le 2\times 10^5$，且 $1\le L_i\le R_i\le M$。&lt;/p&gt;
&lt;h4&gt;关键观察&lt;/h4&gt;
&lt;p&gt;固定扫描到前 $i$ 行，令 &lt;code&gt;cover[x]&lt;/code&gt; 表示第 $x$ 列在这些行中出现的黑格数量，则查询前缀行区间 $[1,i]$ 对列区间 $[C,D]$ 的答案就是&lt;/p&gt;
&lt;p&gt;$$
\sum_{x=C}^{D}\text{cover}[x].
$$&lt;/p&gt;
&lt;p&gt;加入第 $i$ 行时，需要对整个区间 $[L_i,R_i]$ 加 $1$；查询时需要求列区间和。因此问题转化为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;区间加：对 $[L_i,R_i]$ 中每个位置加 $1$；&lt;/li&gt;
&lt;li&gt;区间求和：求 $[C,D]$ 的元素和。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;单棵树状数组适合“单点修改、前缀和查询”，不能直接同时完成区间加和区间求和。使用两棵树状数组维护差分数组即可支持这两种操作。&lt;/p&gt;
&lt;h4&gt;解析&lt;/h4&gt;
&lt;h5&gt;两棵树状数组维护区间加、区间和&lt;/h5&gt;
&lt;p&gt;设对差分数组在位置 $l$ 加上 $k$、在位置 $r+1$ 加上 $-k$。令第一棵树状数组维护这些差分值，第二棵树状数组维护差分值乘以位置偏移后的结果：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\text{tr}_1[l]&amp;amp;\mathrel{+}=k, &amp;amp;\text{tr}_1[r+1]&amp;amp;\mathrel{-}=k,\
\text{tr}_2[l]&amp;amp;\mathrel{+}=k(l-1), &amp;amp;\text{tr}_2[r+1]&amp;amp;\mathrel{-}=kr.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;记两棵树状数组在位置 $x$ 的前缀和分别为 $S_1(x)$、$S_2(x)$，则原数组的前缀和为&lt;/p&gt;
&lt;p&gt;$$
\operatorname{prefix}(x)=xS_1(x)-S_2(x).
$$&lt;/p&gt;
&lt;p&gt;所以区间和可以写成&lt;/p&gt;
&lt;p&gt;$$
\operatorname{sum}(l,r)=\operatorname{prefix}(r)-\operatorname{prefix}(l-1).
$$&lt;/p&gt;
&lt;p&gt;代码中的 &lt;code&gt;modify(l, r, k)&lt;/code&gt; 实现区间加，&lt;code&gt;query_interval(l, r)&lt;/code&gt; 实现区间求和。&lt;/p&gt;
&lt;h5&gt;按行编号离线处理查询&lt;/h5&gt;
&lt;p&gt;设一个查询为 $(A,B,C,D)$。扫描行编号 $i$ 时：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在处理第 $A$ 行之前，树状数组维护的是第 $1$ 到第 $A-1$ 行，因此记录一次负贡献；&lt;/li&gt;
&lt;li&gt;加入第 $A$ 行到第 $B$ 行后，树状数组维护的是第 $1$ 到第 $B$ 行，因此记录一次正贡献。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;两次前缀状态之差恰好只保留第 $A$ 到第 $B$ 行的贡献。代码使用 &lt;code&gt;enter[A]&lt;/code&gt; 保存负贡献事件，使用 &lt;code&gt;settle[B]&lt;/code&gt; 保存正贡献事件：&lt;/p&gt;
&lt;p&gt;$$
\text{answer}(A,B,C,D)
=F(B,C,D)-F(A-1,C,D),
$$&lt;/p&gt;
&lt;p&gt;其中 $F(i,C,D)$ 表示前 $i$ 行在列区间 $[C,D]$ 中的黑格数。&lt;/p&gt;
&lt;h5&gt;正确性说明&lt;/h5&gt;
&lt;p&gt;在扫描到第 $i$ 行后，树状数组中每一列的值等于前 $i$ 行该列黑格的数量，因为每行只在自己的黑色区间 $[L_i,R_i]$ 上加 $1$。因此 &lt;code&gt;query_interval(C, D)&lt;/code&gt; 等于前 $i$ 行在列区间 $[C,D]$ 内的黑格总数。&lt;/p&gt;
&lt;p&gt;对于查询 $(A,B,C,D)$，负事件发生在加入第 $A$ 行前，得到 $F(A-1,C,D)$；正事件发生在加入第 $B$ 行后，得到 $F(B,C,D)$。两者相减后，编号不在 $[A,B]$ 内的行贡献完全抵消，剩余值正是目标矩形中的黑格数量。&lt;/p&gt;
&lt;p&gt;每次区间修改或区间查询需要 $O(\log M)$ 时间，所有行和查询的总复杂度为&lt;/p&gt;
&lt;p&gt;$$
O((N+Q)\log M),
$$&lt;/p&gt;
&lt;p&gt;空间复杂度为 $O(N+Q+M)$。&lt;/p&gt;
&lt;h4&gt;代码&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define tii tuple&amp;lt;int, int, int&amp;gt;
#define tll tuple&amp;lt;ll, ll, ll&amp;gt;
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
#define inf 0x3f3f3f3f3f3f3f3f
#define N 100005
#define M 1000005
#define lc p &amp;lt;&amp;lt; 1
#define rc p &amp;lt;&amp;lt; 1 | 1
#define lowbit(x) (x &amp;amp; -x)
using namespace std;

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

    auto solve = [&amp;amp;]() {
        ll n, m, q;
        cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m &amp;gt;&amp;gt; q;
        vector&amp;lt;ll&amp;gt; tr1(m + 5, 0);
        vector&amp;lt;ll&amp;gt; tr2(m + 5, 0);
        vector&amp;lt;pr&amp;gt; block(n + 5);
        for (int i = 1; i &amp;lt;= n; i++) {
            cin &amp;gt;&amp;gt; block[i].first &amp;gt;&amp;gt; block[i].second;
        }
        vector&amp;lt;vector&amp;lt;tuple&amp;lt;ll, ll, ll&amp;gt;&amp;gt;&amp;gt; enter(n + 5); //
        vector&amp;lt;vector&amp;lt;tuple&amp;lt;ll, ll, ll&amp;gt;&amp;gt;&amp;gt; settle(n + 5);
        for (int i = 1; i &amp;lt;= q; i++) {
            ll a, b, c, d;
            cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b &amp;gt;&amp;gt; c &amp;gt;&amp;gt; d;
            enter[a].push_back({i, c, d});
            settle[b].push_back({i, c, d});
        }
        auto add = [&amp;amp;](vector&amp;lt;ll&amp;gt; &amp;amp;tr, ll x, ll add) {
            for (; x &amp;lt;= m; x += lowbit(x))
                tr[x] += add;
        };
        auto query = [&amp;amp;](vector&amp;lt;ll&amp;gt; &amp;amp;tr, ll x) {
            ll res = 0;
            for (; x; x -= lowbit(x))
                res += tr[x];
            return res;
        };
        auto modify = [&amp;amp;](ll l, ll r, ll k) {
            add(tr1, l, k);
            add(tr1, r + 1, -k);
            add(tr2, l, k * (l - 1));
            add(tr2, r + 1, -k * r);
        };
        auto query_interval = [&amp;amp;](ll l, ll r) {
            return (query(tr1, r) * r - query(tr2, r) - (query(tr1, l - 1) * (l - 1) - query(tr2, l - 1)));
        };
        vector&amp;lt;ll&amp;gt; ans(q + 5, 0);
        for (int i = 1; i &amp;lt;= n; i++) {
            for (auto [id, l, r] : enter[i]) {
                ans[id] -= query_interval(l, r);
            }
            modify(block[i].first, block[i].second, 1);
            for (auto [id, l, r] : settle[i]) {
                ans[id] += query_interval(l, r);
            }
        }
        for (int i = 1; i &amp;lt;= q; i++)
            cout &amp;lt;&amp;lt; ans[i] &amp;lt;&amp;lt; &apos;\n&apos;;
    };

    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第三章 PBDS (Policy-Based Data Structures)&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-3-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;3.1 PBDS 红黑平衡树全家桶 (rb_tree_tag 全功能封装)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：通过带 uid 的 &lt;code&gt;pair&amp;lt;ll, int&amp;gt;&lt;/code&gt; 实现可重平衡树，涵盖 rank (第 $k$ 小)、order_of_key (排名)、前驱后继、split (分裂)、join (合并)。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;using key = pair&amp;lt;ll, int&amp;gt;;
using pbds_tree = tree&amp;lt;
    key,
    null_type,
    less&amp;lt;key&amp;gt;,
    rb_tree_tag,
    tree_order_statistics_node_update&amp;gt;;

pbds_tree tr;
int uid = 0;

// 插入：第二维 uid 让重复值也能共存。
auto insert = [&amp;amp;](ll x)
{
    tr.insert({x, ++uid});
};

// 查找、边界、精确删除。
auto find = [&amp;amp;](ll x, int id)
{
    return tr.find({x, id});
};
auto lower = [&amp;amp;](ll x)
{
    return tr.lower_bound({x, numeric_limits&amp;lt;int&amp;gt;::min()});
};
auto upper = [&amp;amp;](ll x)
{
    return tr.upper_bound({x, numeric_limits&amp;lt;int&amp;gt;::max()});
};
auto erase_exact = [&amp;amp;](ll x, int id)
{
    tr.erase({x, id});
};

// 按值删除一个、删除所有；删除一个时不需要知道 uid。
auto erase_one = [&amp;amp;](ll x)
{
    auto it = lower(x);
    if (it != tr.end() &amp;amp;&amp;amp; it-&amp;gt;first == x)
        tr.erase(it);
};
auto erase_all = [&amp;amp;](ll x)
{
    auto l = lower(x), r = upper(x);
    while (l != r)
    {
        auto now = l++;
        tr.erase(now);
    }
};

// 排名与第 k 小：这里统一使用 1-indexed 对外接口。
auto rank = [&amp;amp;](ll x) -&amp;gt; ll
{
    return tr.order_of_key({x, numeric_limits&amp;lt;int&amp;gt;::min()}) + 1;
};
auto kth = [&amp;amp;](ll k) -&amp;gt; key
{
    auto it = tr.find_by_order(k - 1);
    // TODO: k 越界时 it == tr.end()，按题意处理。
    return *it;
};

// 前驱与后继。
auto predecessor = [&amp;amp;](ll x) -&amp;gt; key
{
    auto it = lower(x);
    if (it == tr.begin())
        return {-(ll)4e18, -1};
    --it;
    return *it;
};
auto successor = [&amp;amp;](ll x) -&amp;gt; key
{
    auto it = upper(x);
    if (it == tr.end())
        return {(ll)4e18, -1};
    return *it;
};

// 迭代器遍历、容量和清空。
for (auto [x, id] : tr)
{
    // TODO: 使用 x、id。
}
int sz = tr.size();
bool empty = tr.empty();
// tr.clear(); // 清空整棵树

// split：左树保留 &amp;lt;= key 的元素，右树得到 &amp;gt; key 的元素。
pbds_tree right;
// tr.split({3, numeric_limits&amp;lt;int&amp;gt;::max()}, right);

// join：要求当前 tr 的所有 key 严格小于 right 的所有 key，且类型相同。
// tr.join(right);
// join 成功后 right 为空；不满足顺序条件时不要 join。

// 常用写法：
//   rank(x)                 第一个 &amp;gt;= x 的排名
//   kth(k)                  第 k 小的 {值, uid}
//   lower(x), upper(x)      边界迭代器
//   tr.order_of_key(key)    严格小于 key 的数量
//   tr.find_by_order(k)     0-indexed 第 k 小
//   tr.split(key, other)    按 key 拆树
//   tr.join(other)          合并两棵有序且不相交的树

// TODO: 如果只需要不重复集合，把 key 改成 ll，并删除 uid 相关逻辑。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-3-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;3.2 PBDS 有序集合 (Ordered Set)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：单值 &lt;code&gt;ordered_set&lt;/code&gt;，支持 $O(\log N)$ 的 &lt;code&gt;order_of_key&lt;/code&gt; 与 &lt;code&gt;find_by_order&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;using ordered_set = tree&amp;lt;
    ll,
    null_type,
    less&amp;lt;ll&amp;gt;,
    rb_tree_tag,
    tree_order_statistics_node_update&amp;gt;;

ordered_set os;
os.insert(x);
os.erase(x);

ll less_count = os.order_of_key(x); // 严格小于 x 的元素个数
auto it = os.find_by_order(k);       // 0-indexed 第 k 小元素
if (it != os.end())
    cout &amp;lt;&amp;lt; *it &amp;lt;&amp;lt; &apos;\n&apos;;

// TODO: order_of_key 是排名查询；find_by_order 越界时返回 end()。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-3-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;3.3 PBDS 有序多重集合 (Ordered Multiset)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：多重可重有序集合，支持重复元素及其排名范围统计。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;using ordered_multiset = tree&amp;lt;
    pair&amp;lt;ll, int&amp;gt;,
    null_type,
    less&amp;lt;pair&amp;lt;ll, int&amp;gt;&amp;gt;,
    rb_tree_tag,
    tree_order_statistics_node_update&amp;gt;;

ordered_multiset oms;
int uid = 0;
oms.insert({x, ++uid});

ll less_count = oms.order_of_key({x, -1});
ll less_equal_count = oms.order_of_key({x, INT_MAX});
auto it = oms.find_by_order(k);
if (it != oms.end())
    cout &amp;lt;&amp;lt; it-&amp;gt;first &amp;lt;&amp;lt; &apos;\n&apos;;

// TODO: 删除时保存插入用的 uid；用 pair 的第二维区分重复值。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-3-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;3.4 PBDS 哈希表 (gp_hash_table)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：探测法哈希表，相比 STL &lt;code&gt;unordered_map&lt;/code&gt; 常数更小且防 Codeforces 针对性 Anti-hash。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;gp_hash_table&amp;lt;ll, ll&amp;gt; h;

h[x]++;
h[x] = value;
if (h.find(x) != h.end())
    cout &amp;lt;&amp;lt; h[x] &amp;lt;&amp;lt; &apos;\n&apos;;
h.erase(x);

// TODO: gp_hash_table 接口接近 unordered_map；需要自定义 hash 时补第三个模板参数。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-3-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;3.5 PBDS 可修改配对堆 (pairing_heap_tag priority_queue)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：支持持迭代器并在 $O(1)$ 均摊复杂度修改已有节点键值 (&lt;code&gt;modify&lt;/code&gt;) 的配对堆。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__gnu_pbds::priority_queue&amp;lt;
    pr,
    greater&amp;lt;pr&amp;gt;,
    pairing_heap_tag&amp;gt; pq;

auto it = pq.push({dis, vertex});
pq.modify(it, {new_dis, vertex});
auto [d, x] = pq.top();
pq.pop();

// TODO: push 返回迭代器，只有 pairing_heap 等支持 modify；普通优先队列不能修改旧元素。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-3-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;3.6 PBDS 字典树 (pat_trie_tag trie)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：内置前缀查询与区间迭代器范围 (&lt;code&gt;prefix_range&lt;/code&gt;) 的高效 PAT 字典树。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;using string_trie = trie&amp;lt;
    string,
    null_type,
    trie_string_access_traits&amp;lt;&amp;gt;,
    pat_trie_tag,
    trie_prefix_search_node_update&amp;gt;;

string_trie tr;
tr.insert(s);
tr.erase(s);
auto [first, last] = tr.prefix_range(prefix);
for (auto it = first; it != last; it++)
    cout &amp;lt;&amp;lt; *it &amp;lt;&amp;lt; &apos;\n&apos;;

// TODO: prefix_range(prefix) 返回所有以 prefix 为前缀的字符串。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第四章 字符串算法&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-4-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;4.1 KMP 字符串模式匹配算法&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：求解前缀函数 &lt;code&gt;next / pi&lt;/code&gt; 数组，在 $O(N+M)$ 时间内完成单模式串完全匹配与周期计算。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 1000005
#define sp &amp;lt;&amp;lt; &quot; &quot;&amp;lt;&amp;lt;
#define mp make_pair
#define pr pair&amp;lt;ll,ll&amp;gt;
#define MOD 998244353
using namespace std;

ll n,m,b,sum,a,c,max_,cnt;

ll ne[N];

int main()
{
    string s,t,ss;

    s=&apos;\0&apos;;
    cin&amp;gt;&amp;gt;ss;
    s+=ss;
    n=s.size()-1;
    t=&apos;\0&apos;;
    cin&amp;gt;&amp;gt;ss;
    t+=ss;
    m=t.size()-1;
    for(int i=2,j=0;i&amp;lt;=m;i++)
    {
        while(j&amp;amp;&amp;amp;t[i]!=t[j+1]) j=ne[j];
        if(t[i]==t[j+1]) j++;
        ne[i]=j;
    }
    for(int i=1,j=0;i&amp;lt;=n;i++)
    {
        while(j&amp;amp;&amp;amp;s[i]!=t[j+1]) j=ne[j];
        if(s[i]==t[j+1]) j++;
        if(j==m) cout&amp;lt;&amp;lt;i-m+1&amp;lt;&amp;lt;endl;
    }

    for(int i=1;i&amp;lt;=m;i++) cout&amp;lt;&amp;lt;ne[i]&amp;lt;&amp;lt;&apos; &apos;;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-4-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;4.2 字符串单哈希与前缀幂预处理&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：1-indexed 基础多项式哈希，单模数预处理子串快速 $O(1)$ 哈希值截取。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const ll HASH_BASE = 337;
const ll HASH_MOD = 1000000007;
string s;
cin &amp;gt;&amp;gt; s;
int len = s.size();
s = &quot; &quot; + s;
vector&amp;lt;ll&amp;gt; pre(len + 1), power(len + 1);
power[0] = 1;
for (int i = 1; i &amp;lt;= len; i++)
{
    pre[i] = (pre[i - 1] * HASH_BASE + s[i]) % HASH_MOD;
    power[i] = power[i - 1] * HASH_BASE % HASH_MOD;
}

auto get_hash = [&amp;amp;](int l, int r) -&amp;gt; ll
{
    return (pre[r] - pre[l - 1] * power[r - l + 1] % HASH_MOD + HASH_MOD) % HASH_MOD;
};

// TODO: 需要更低碰撞概率时再加第二模数；区间下标从 1 开始。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-4-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;4.3 单模哈希应用：对称分块&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：单模字符串哈希；存在碰撞概率，必要时加第二模数或校验。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 200005
using namespace std;
ll ans;
ll n, m, k;
ll t;
#define pr pair&amp;lt;ll, ll&amp;gt;
const ll B = 337;
const ll M = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; t;
    while (t--) {
        auto solve = [&amp;amp;]() {
            string s;
            cin &amp;gt;&amp;gt; s;
            n = s.length();
            vector&amp;lt;ll&amp;gt; pre(n + 5, 0);
            vector&amp;lt;ll&amp;gt; p(n + 5, 0);
            auto init = [&amp;amp;]() {
                p[0] = 1;
                for (int i = 1; i &amp;lt;= n; i++) {
                    pre[i] = (pre[i - 1] * B + s[i]) % M;
                    p[i] = p[i - 1] * B % M;
                }
            };
            s = &apos;0&apos; + s;
            init();
            int mid = n / 2;
            ll len = 0;
            ll cnt = 0;
            auto cal = [&amp;amp;](int l, int r) {
                return (pre[r] - pre[l - 1] * p[r - l + 1] % M + M) % M;
            };
            for (int l = 1, r = n; l &amp;lt;= mid; l++, r--) {
                len++;
                if (cal(l - len + 1, l) == cal(r, r + len - 1)) {
                    len = 0;
                    cnt += 2;
                }
            }
            if (len || (n % 2))
                cnt++;
            cout &amp;lt;&amp;lt; cnt &amp;lt;&amp;lt; &apos;\n&apos;;
        };
        solve();
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-4-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;4.4 Manacher 最长回文子串算法&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：利用回文中心对称性，线性 $O(N)$ 时间求解所有位置的回文半径与全局最长回文子串。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;

int longest_palindrome(const string&amp;amp; s) {
    int n = s.size(), ans = 0;
    vector&amp;lt;int&amp;gt; odd(n), even(n);
    for (int i = 0, l = 0, r = -1; i &amp;lt; n; ++i) {
        int k = i &amp;gt; r ? 1 : min(odd[l + r - i], r - i + 1);
        while (i - k &amp;gt;= 0 &amp;amp;&amp;amp; i + k &amp;lt; n &amp;amp;&amp;amp; s[i-k] == s[i+k]) ++k;
        odd[i] = k; ans = max(ans, 2*k-1);
        if (i+k-1 &amp;gt; r) l = i-k+1, r = i+k-1;
    }
    for (int i = 0, l = 0, r = -1; i &amp;lt; n; ++i) {
        int k = i &amp;gt; r ? 0 : min(even[l + r - i + 1], r - i + 1);
        while (i-k-1 &amp;gt;= 0 &amp;amp;&amp;amp; i+k &amp;lt; n &amp;amp;&amp;amp; s[i-k-1] == s[i+k]) ++k;
        even[i] = k; ans = max(ans, 2*k);
        if (i+k-1 &amp;gt; r) l = i-k, r = i+k-1;
    }
    return ans;
}
int main() { string s; cin &amp;gt;&amp;gt; s; cout &amp;lt;&amp;lt; longest_palindrome(s) &amp;lt;&amp;lt; &apos;\n&apos;; }
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-4-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;4.5 字典树 Trie（小写字母，动态节点）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：经典 26 叉字典树，支持字符串集合插入与前缀计数统计。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;

// 小写英文字母；按实际节点数分配；重复插入累加结束计数。
struct LowercaseTrie {
    vector&amp;lt;array&amp;lt;int,26&amp;gt;&amp;gt; child{array&amp;lt;int,26&amp;gt;{}};
    vector&amp;lt;int&amp;gt; terminal{0};
    void insert(const string&amp;amp; s) {
        int p = 0;
        for (char c : s) {
            int k = c - &apos;a&apos;; assert(0 &amp;lt;= k &amp;amp;&amp;amp; k &amp;lt; 26);
            if (!child[p][k]) {
                int id = child.size();
                child.push_back({}); terminal.push_back(0);
                child[p][k] = id;
            }
            p = child[p][k];
        }
        ++terminal[p];
    }
    int node(const string&amp;amp; s) const {
        int p = 0;
        for (char c : s) {
            int k = c - &apos;a&apos;; assert(0 &amp;lt;= k &amp;amp;&amp;amp; k &amp;lt; 26);
            if (!child[p][k]) return -1;
            p = child[p][k];
        }
        return p;
    }
    int count(const string&amp;amp; s) const { int p = node(s); return p &amp;lt; 0 ? 0 : terminal[p]; }
    bool starts_with(const string&amp;amp; s) const { return node(s) &amp;gt;= 0; }
};
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-4-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;4.6 01-Trie 最大异或对（uint32_t）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：按高位到低位建树，支持贪心走反向位快速检索最大异或值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// 完整uint32_t值域，避免1&amp;lt;&amp;lt;31的有符号错误；至少插入一个值后才能查询。
struct XorTrie32{
    vector&amp;lt;array&amp;lt;int,2&amp;gt;&amp;gt;tr{array&amp;lt;int,2&amp;gt;{}};int count=0;
    void insert(uint32_t x){int p=0;for(int b=31;b&amp;gt;=0;--b){int k=x&amp;gt;&amp;gt;b&amp;amp;1U;if(!tr[p][k]){int id=tr.size();tr.push_back({});tr[p][k]=id;}p=tr[p][k];}++count;}
    uint32_t max_xor(uint32_t x)const{assert(count);int p=0;uint32_t ans=0;for(int b=31;b&amp;gt;=0;--b){int k=x&amp;gt;&amp;gt;b&amp;amp;1U;if(tr[p][k^1])ans|=uint32_t(1)&amp;lt;&amp;lt;b,p=tr[p][k^1];else p=tr[p][k];}return ans;}
};
int main(){int n;if(!(cin&amp;gt;&amp;gt;n))return 0;XorTrie32 t;vector&amp;lt;uint32_t&amp;gt;a(n);for(auto&amp;amp;x:a)cin&amp;gt;&amp;gt;x,t.insert(x);uint32_t ans=0;for(auto x:a)ans=max(ans,t.max_xor(x));cout&amp;lt;&amp;lt;ans&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第五章 图论与树论算法&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.1 单源最短路 Dijkstra&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：堆优化的非负权最短路算法，时间复杂度 $O((N+M) \log M)$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;pr&amp;gt;&amp;gt; adj(n + 5);
for (int i = 1; i &amp;lt;= m; i++)
{
    int u, v;
    ll w;
    cin &amp;gt;&amp;gt; u &amp;gt;&amp;gt; v &amp;gt;&amp;gt; w;
    adj[u].push_back({v, w});
    // TODO: 无向图时补上 adj[v].push_back({u, w});
}

const ll INF = 4e18;
vector&amp;lt;ll&amp;gt; dis(n + 5, INF);
std::priority_queue&amp;lt;pr, vector&amp;lt;pr&amp;gt;, greater&amp;lt;pr&amp;gt;&amp;gt; que;

auto dijkstra = [&amp;amp;](int st)
{
    fill(dis.begin(), dis.end(), INF);
    dis[st] = 0;
    que.push({0, st});
    while (que.size())
    {
        auto [d, x] = que.top();
        que.pop();
        if (d != dis[x])
            continue;
        for (auto [v, w] : adj[x])
        {
            if (dis[v] &amp;gt; dis[x] + w)
            {
                dis[v] = dis[x] + w;
                que.push({dis[v], v});
            }
        }
    }
};

// TODO: dijkstra(st); 根据题意处理 dis。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.2 并查集 (Disjoint Set Union)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：路径压缩并查集，极简 lambda 递归实现。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;int&amp;gt; fa(n + 5);
iota(fa.begin(), fa.end(), 0);

auto find = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; int
{
    return fa[x] == x ? x : fa[x] = self(self, fa[x]);
};

auto merge = [&amp;amp;](int x, int y)
{
    x = find(find, x);
    y = find(find, y);
    if (x != y)
        fa[x] = y;
};

// TODO: merge(x, y); 用 find(find, x) 判断连通性。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.3 带权并查集 (Weighted DSU / 势能维护)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：维护点到根相对权值（势能差）的并查集，解决差分约束与相对关系判定。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;int&amp;gt; fa(n + 5);
vector&amp;lt;ll&amp;gt; val(n + 5, 0);
iota(fa.begin(), fa.end(), 0);

// find 后 val[x] 表示 pot[x] - pot[根]。
auto find = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; int
{
    if (fa[x] == x)
        return x;
    int f = fa[x];
    fa[x] = self(self, fa[x]);
    val[x] += val[f];
    return fa[x];
};

// 约定 pot[y] - pot[x] = w。
auto merge = [&amp;amp;](int x, int y, ll w)
{
    int rx = find(find, x);
    int ry = find(find, y);
    if (rx == ry)
        return;
    fa[rx] = ry;
    val[rx] = val[y] - val[x] - w;
};

auto query = [&amp;amp;](int x, int y) -&amp;gt; ll
{
    if (find(find, x) != find(find, y))
        return (ll)4e18;
    return val[y] - val[x];
};

// TODO: 按题意决定权值方向，先统一写清楚 pot 的含义。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.4 带权并查集 (完整题解版)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：银河英雄传说式队列合并实例，M x y把x队接到y队；不是通用差分约束并查集。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 30005
using namespace std;

ll n,p,t;
ll fa[N];
ll vec[N];
ll siz[N];
ll find_(int x)
{
    ll tem=fa[x];
    if(fa[x]==x) return x;
    else
    {
        fa[x]=find_(fa[x]);
    }

    vec[x]=vec[x]+vec[tem];

    return fa[x];
}
//接在后面
void union_(int x,int y,int w)
{
    int rtx=find_(x);
    int rty=find_(y);

    if(rtx==rty) return;
    vec[rty]=siz[rtx]+w;
    siz[rtx]+=siz[rty]+w;
    fa[rty]=rtx;
}
ll query(int x,int y)
{
    int rtx=find_(x);
    int rty=find_(y);

    if(rtx!=rty) return -1;
    else return max(0LL,abs(vec[x]-vec[y])-1);

}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    cin&amp;gt;&amp;gt;t;
    memset(fa,0,sizeof fa);
        memset(vec,0,sizeof vec);
        for(int i=1;i&amp;lt;=30000;i++) fa[i]=i;
    while(t--)
    {
        char flag;
        ll l,r;

        cin&amp;gt;&amp;gt;flag&amp;gt;&amp;gt;l&amp;gt;&amp;gt;r;
        if(flag==&apos;M&apos;)
        {
            union_(r,l,1);
        }
        else {
            cout&amp;lt;&amp;lt;query(l,r)&amp;lt;&amp;lt;&apos;\n&apos;;
        }
    }

    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.5 最小生成树 Kruskal&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：贪心边排序加并查集合并，构建无向图最小生成树。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;tll&amp;gt; edges;
for (int i = 1; i &amp;lt;= m; i++)
{
    int u, v;
    ll w;
    cin &amp;gt;&amp;gt; u &amp;gt;&amp;gt; v &amp;gt;&amp;gt; w;
    edges.push_back({w, u, v});
}
sort(edges.begin(), edges.end());

vector&amp;lt;int&amp;gt; fa(n + 5);
iota(fa.begin(), fa.end(), 0);
auto find = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; int
{
    return fa[x] == x ? x : fa[x] = self(self, fa[x]);
};

ll ans = 0;
int cnt = 0;
for (auto [w, u, v] : edges)
{
    int ru = find(find, u);
    int rv = find(find, v);
    if (ru == rv)
        continue;
    fa[ru] = rv;
    ans += w;
    cnt++;
    // TODO: 需要重构树、记录边或提前停止时在这里补逻辑。
}
// TODO: cnt &amp;lt; n - 1 时按题意处理不连通情况。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.6 Kruskal 重构树 (Kruskal Reconstruction Tree)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：生成树化为具有堆性质的有根二叉树，把路径最大边权/瓶颈边权转化为两点 LCA 的点权。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#include &amp;lt;set&amp;gt;
#define ll long long
#define N 1000005
#define M 1000005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
ll n,a,b,cnt,m,q;
void work()
{
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;
    vector&amp;lt;tuple&amp;lt;ll,ll,ll&amp;gt;&amp;gt;edges;
    for(int i=1;i&amp;lt;=m;i++)
    {
        ll a,b,c;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;c;
        edges.push_back({-c,a,b});
    }
    int id=n;
    vector&amp;lt;int&amp;gt;pa(2*n+10,0);
    vector&amp;lt;int&amp;gt;val(2*n+10,0);
    vector&amp;lt;int&amp;gt;dep(2*n+10,0);
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;adj(2*n+10);
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;fa(2*n+10,vector&amp;lt;int&amp;gt;(30,0));
    for(int i=1;i&amp;lt;=2*n;i++) pa[i]=i;
    auto find=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x)-&amp;gt;int
    {
        return pa[x]=(pa[x]==x?x:self(self,pa[x]));
    };
    auto kruscal=[&amp;amp;]()
    {
        sort(edges.begin(),edges.end());
        for(auto [w,a,b]:edges)
        {
            auto ra=find(find,a);
            auto rb=find(find,b);
            if(ra!=rb)
            {
                id++;
                val[id]=-w;
                pa[ra]=id;
                pa[rb]=id;
                adj[id].push_back(ra),adj[id].push_back(rb);
            }
            if(id==2*n-1) break;
        }
    };
    kruscal();
    auto dfs=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x,int f)-&amp;gt;void
    {
        dep[x]=dep[f]+1;
        fa[x][0]=f;
        for(int i=1;i&amp;lt;=20;i++) fa[x][i]=fa[fa[x][i-1]][i-1];
        for(auto v:adj[x])
        {
            self(self,v,x);
        }
    };
    for(int i=1;i&amp;lt;=id;i++)
        if(pa[i]==i)
            dfs(dfs,i,0);
    auto lca=[&amp;amp;](int x,int y)
    {
        if(dep[x]&amp;lt;dep[y]) swap(x,y);
        for(int i=20;i&amp;gt;=0;i--)
        {
            if(dep[fa[x][i]]&amp;gt;=dep[y]) x=fa[x][i];
        }
        if(x==y) return x;
        for(int i=20;i&amp;gt;=0;i--)
        {
            if(fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
        }
        return fa[x][0];
    };
    cin&amp;gt;&amp;gt;q;
    while(q--)
    {
        ll a,b;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;
        if(find(find,a)!=find(find,b))
        {
            cout&amp;lt;&amp;lt;-1&amp;lt;&amp;lt;&apos;\n&apos;;
            continue;
        }
        cout&amp;lt;&amp;lt;val[lca(a,b)]&amp;lt;&amp;lt;&apos;\n&apos;;
    }
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    work();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-7&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.7 严格次小生成树 (Strict Second Minimum Spanning Tree)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：倍增维护树链上最大值与严格次大值，尝试替换非树边求解严格次小边权和。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;
// 返回严格次小生成树权值；不连通或不存在严格更大的生成树时nullopt。
// 顶点0-based；允许重边、自环、负边；|边权|&amp;lt;2^60，总权值可放long long。
optional&amp;lt;ll&amp;gt; strict_second_mst(int n,vector&amp;lt;tuple&amp;lt;int,int,ll&amp;gt;&amp;gt; edges) {
    assert(n&amp;gt;=1);
    vector&amp;lt;int&amp;gt; ids(edges.size()); iota(ids.begin(),ids.end(),0);
    sort(ids.begin(),ids.end(),[&amp;amp;](int a,int b){return get&amp;lt;2&amp;gt;(edges[a])&amp;lt;get&amp;lt;2&amp;gt;(edges[b]);});
    vector&amp;lt;int&amp;gt; parent(n),sz(n,1); iota(parent.begin(),parent.end(),0);
    auto find=[&amp;amp;](int x){while(parent[x]!=x)x=parent[x]=parent[parent[x]];return x;};
    vector&amp;lt;vector&amp;lt;pair&amp;lt;int,ll&amp;gt;&amp;gt;&amp;gt; adj(n);
    vector&amp;lt;bool&amp;gt; used(edges.size()); ll total=0; int chosen=0;
    for(int id:ids){
        auto [u,v,w]=edges[id]; int a=find(u),b=find(v);
        if(a==b)continue;
        if(sz[a]&amp;lt;sz[b])swap(a,b);parent[b]=a;sz[a]+=sz[b];
        used[id]=true;total+=w;++chosen;adj[u].push_back({v,w});adj[v].push_back({u,w});
    }
    if(chosen!=n-1)return nullopt;
    const ll NEG=-(1LL&amp;lt;&amp;lt;61);
    using Pair=pair&amp;lt;ll,ll&amp;gt;;
    auto combine=[&amp;amp;](Pair a,Pair b){
        Pair out{NEG,NEG};
        for(ll x:{a.first,a.second,b.first,b.second})
            if(x&amp;gt;out.first)out={x,out.first};else if(x&amp;lt;out.first &amp;amp;&amp;amp; x&amp;gt;out.second)out.second=x;
        return out;
    };
    int LOG=1;while((1LL&amp;lt;&amp;lt;LOG)&amp;lt;=n)++LOG;
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; up(LOG,vector&amp;lt;int&amp;gt;(n));
    vector&amp;lt;vector&amp;lt;Pair&amp;gt;&amp;gt; mx(LOG,vector&amp;lt;Pair&amp;gt;(n,{NEG,NEG}));
    vector&amp;lt;int&amp;gt; depth(n,-1),order{0};depth[0]=0;
    for(size_t i=0;i&amp;lt;order.size();++i){
        int u=order[i];
        for(auto [v,w]:adj[u])if(depth[v]==-1){depth[v]=depth[u]+1;up[0][v]=u;mx[0][v]={w,NEG};order.push_back(v);}
    }
    for(int k=1;k&amp;lt;LOG;++k)for(int v=0;v&amp;lt;n;++v){up[k][v]=up[k-1][up[k-1][v]];mx[k][v]=combine(mx[k-1][v],mx[k-1][up[k-1][v]]);}
    auto path_max=[&amp;amp;](int u,int v){
        Pair out{NEG,NEG};if(depth[u]&amp;lt;depth[v])swap(u,v);
        int delta=depth[u]-depth[v];
        for(int k=LOG-1;k&amp;gt;=0;--k)if(delta&amp;gt;&amp;gt;k&amp;amp;1){out=combine(out,mx[k][u]);u=up[k][u];}
        if(u==v)return out;
        for(int k=LOG-1;k&amp;gt;=0;--k)if(up[k][u]!=up[k][v]){out=combine(out,mx[k][u]);out=combine(out,mx[k][v]);u=up[k][u];v=up[k][v];}
        return combine(out,combine(mx[0][u],mx[0][v]));
    };
    optional&amp;lt;ll&amp;gt; best;
    for(int i=0;i&amp;lt;int(edges.size());++i)if(!used[i]){
        auto [u,v,w]=edges[i];if(u==v)continue;
        auto [first,second]=path_max(u,v);
        ll removed=w&amp;gt;first?first:second;
        if(removed==NEG)continue;
        ll candidate=total+w-removed;
        if(candidate&amp;gt;total &amp;amp;&amp;amp; (!best||candidate&amp;lt;*best))best=candidate;
    }
    return best;
}
int main(){
    ios::sync_with_stdio(false);cin.tie(nullptr);
    int n,m;if(!(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m))return 0;
    vector&amp;lt;tuple&amp;lt;int,int,ll&amp;gt;&amp;gt; edges;
    while(m--){int u,v;ll w;cin&amp;gt;&amp;gt;u&amp;gt;&amp;gt;v&amp;gt;&amp;gt;w;edges.push_back({u-1,v-1,w});}
    auto ans=strict_second_mst(n,edges);cout&amp;lt;&amp;lt;(ans?*ans:-1)&amp;lt;&amp;lt;&apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-8&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.8 最近公共祖先 LCA (倍增实现)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：树上二进制倍增跳转，预处理 $O(N \log N)$，单次查询 $O(\log N)$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const int LOG = 22;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;int&amp;gt; dep(n + 5);
vector&amp;lt;array&amp;lt;int, LOG&amp;gt;&amp;gt; fa(n + 5);

auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int f) -&amp;gt; void
{
    dep[x] = dep[f] + 1;
    fa[x][0] = f;
    for (int i = 1; i &amp;lt; LOG; i++)
        fa[x][i] = fa[fa[x][i - 1]][i - 1];
    for (auto v : adj[x])
    {
        if (v == f)
            continue;
        self(self, v, x);
    }
};

auto lca = [&amp;amp;](int x, int y) -&amp;gt; int
{
    if (dep[x] &amp;lt; dep[y])
        swap(x, y);
    for (int i = LOG - 1; i &amp;gt;= 0; i--)
        if (dep[fa[x][i]] &amp;gt;= dep[y])
            x = fa[x][i];
    if (x == y)
        return x;
    for (int i = LOG - 1; i &amp;gt;= 0; i--)
        if (fa[x][i] != fa[y][i])
            x = fa[x][i], y = fa[y][i];
    return fa[x][0];
};

// TODO: 建树后 dfs(dfs, root, 0); LOG 按 n 的范围调整。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-9&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.9 LCA 独立实现 (数组版)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：经典的数组形式倍增求 LCA 模板。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;iostream&amp;gt;
#include&amp;lt;vector&amp;gt;
#define mm 999999
#include&amp;lt;cstdio&amp;gt;
using namespace std;

vector &amp;lt;int&amp;gt;map1[mm];

int ans,n,m,f[mm][19],w[mm],deep[mm],w2[mm];
int lca(int a,int b){
	if(deep[a]&amp;lt;deep[b]) swap(a,b);

	for(int i=18;i&amp;gt;=0;i--){
		if(deep[f[a][i]]&amp;gt;=deep[b]) a=f[a][i];

	}
	if(b==a) return a;
	for(int i=18;i&amp;gt;=0;i--){
		if(f[a][i]!=f[b][i]) a=f[a][i],b=f[b][i];
	}
	return f[a][0];
}

void dfs1(int x,int fa){

	for(int i=0;i&amp;lt;map1[x].size();i++){
		int v=map1[x][i];
		if(v==fa) continue;
		deep[v]=deep[x]+1;
		f[v][0]=x;
		dfs1(v,x);

	}

}

void dfs2(int x,int fa){

	for(int i=0;i&amp;lt;map1[x].size();i++){
		int v=map1[x][i];

		if(v==fa) continue;

		dfs2(v,x);
		w2[x]+=w2[v];

	}

}


int main(){

	cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;
	int a,b;
	for(int i=1;i&amp;lt;=n-1;i++){
		scanf(&quot;%d%d&quot;,&amp;amp;a,&amp;amp;b);
		map1[a].push_back(b);
		map1[b].push_back(a);

	}
	deep[1]=1;
	dfs1(1,0);

	for(int i=1;i&amp;lt;=18;i++)
	for(int j=1;j&amp;lt;=n;j++){

		f[j][i]=f[f[j][i-1]][i-1];
	}

	for(int i=1;i&amp;lt;=m;i++){
		scanf(&quot;%d%d&quot;,&amp;amp;a,&amp;amp;b);
		w[a]++;
		w[b]++;
		w[lca(a,b)]-=2;
	}
	for(int i=1;i&amp;lt;=n;i++) w2[i]=w[i];
	dfs2(1,0);
	for(int i=2;i&amp;lt;=n;i++){
		if(w2[i]==0) ans+=m;
		else
		if(w2[i]==1) ans++;
	}
	cout&amp;lt;&amp;lt;ans;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-10&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.10 两次 DFS 求树的直径&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：适用于正权树，任意一点出发找最远点，再从该最远点出发找最远点，得到直径两端点。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;pr&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;ll&amp;gt; dis(n + 5, 0);

auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int fa) -&amp;gt; void
{
    for (auto [v, w] : adj[x])
    {
        if (v == fa)
            continue;
        dis[v] = dis[x] + w;
        self(self, v, x);
    }
};

auto farthest = [&amp;amp;](int st) -&amp;gt; int
{
    fill(dis.begin(), dis.end(), 0);
    dfs(dfs, st, 0);
    return max_element(dis.begin() + 1, dis.begin() + n + 1) - dis.begin();
};

int s = farthest(1);
int t = farthest(s);
ll diameter = dis[t];
// TODO: diameter 是直径长度；若需要路径，用 fa / pre 在 DFS 中记录。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-11&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.11 树的直径完整实现 (带权与距离维护)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：树的直径完整代码，包含最远点与距离跟踪。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 200005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
bitset&amp;lt;N&amp;gt;vis;
// vector &amp;lt;pr&amp;gt;map1[N];
vector&amp;lt;vector&amp;lt;pr&amp;gt;&amp;gt;map1;
vector&amp;lt;ll&amp;gt;dis;
vector&amp;lt;ll&amp;gt;pre;
ll n,m,mxd,max_;
pr dfs1(int x,int fa)
{
    pr ans={dis[x],x};
    for(auto [v,w]:map1[x])
    {
        if(v==fa) continue;
        dis[v]=dis[x]+w;
        pre[v]=x;
        auto tem=dfs1(v,x);
        if(tem&amp;gt;ans) ans=tem;
    }
    return ans;
}
ll dfs2(int x,int fa,ll dfa)
{
    ll d=dfa;
    for(auto [v,w]:map1[x])
    {
        if(v==fa|| vis[v]) continue;
        d=max(dfs2(v,x,dfa+w),d);
    }
    return d;
}
void solve()
{
    max_=0;
    cin&amp;gt;&amp;gt;n;
    vis.reset();
    map1.assign(n+5,{});
    pre.assign(n+5,0);
    for(int i=1;i&amp;lt;n;i++)
    {
        ll a,b,c;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;c;
        map1[a].push_back({b,c});
        map1[b].push_back({a,c});
    }
    max_=0;
    dis.assign(n+5,0);
    auto  r=dfs1(1,0).second;
    max_=0;
    dis.assign( n+5,0);
    pre.assign( n+5,0);
    auto  [mxd,l]=dfs1(r,0);
    cout&amp;lt;&amp;lt;mxd&amp;lt;&amp;lt;&apos;\n&apos;;
    for(int i=l;i;i=pre[i])
    {
        vis[i]=1;
    }
    ll pri_r=r;
    ll pri_l=l;
    for(int i=l;i;i=pre[i])
    {
        ll tem=dfs2(i,0,0);
        if(dis[i]+tem==mxd) l=i;
        else if(dis[i] == tem) {r=i;break;}
    }
    ll cnt=0;
    if(l==r) cnt=0;
    else for(int i=l;i!=r;i=pre[i]) cnt++;
    cout&amp;lt;&amp;lt;cnt&amp;lt;&amp;lt;&apos;\n&apos;;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-12&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.12 树上 DFS 与子树规模统计&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：树上深度与子树大小基础遍历框架。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;int&amp;gt; dep(n + 5), siz(n + 5);

auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int fa) -&amp;gt; void
{
    siz[x] = 1;
    for (auto v : adj[x])
    {
        if (v == fa)
            continue;
        dep[v] = dep[x] + 1;
        self(self, v, x);
        siz[x] += siz[v];
    }
};

// TODO: 建树后 dfs(dfs, root, 0); 按题意继续转移。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-13&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.13 拓扑排序 (Kahn 算法)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：基于入度统计与队列的 DAG 拓扑排序，检测有向图环结构。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;int&amp;gt; indeg(n + 5, 0);
// TODO: 建图时 adj[u].push_back(v), indeg[v]++。

queue&amp;lt;int&amp;gt; que;
for (int i = 1; i &amp;lt;= n; i++)
    if (!indeg[i])
        que.push(i);
vector&amp;lt;int&amp;gt; order;
while (que.size())
{
    int x = que.front();
    que.pop();
    order.push_back(x);
    for (auto v : adj[x])
        if (!--indeg[v])
            que.push(v);
}
// TODO: order.size() &amp;lt; n 时存在环；需要字典序时将 queue 换为 priority_queue。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-14&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.14 Tarjan 算法：有向图强连通分量 (SCC 缩点)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：基于 &lt;code&gt;dfn&lt;/code&gt; 与 &lt;code&gt;low&lt;/code&gt; 栈维护的有向图强连通分量划分，输出缩点映射。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;int&amp;gt; dfn(n + 5), low(n + 5), scc(n + 5);
vector&amp;lt;int&amp;gt; sta;
vector&amp;lt;bool&amp;gt; in_st(n + 5);
int tim = 0, block = 0;

auto tarjan = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void
{
    dfn[x] = low[x] = ++tim;
    sta.push_back(x);
    in_st[x] = true;
    for (auto v : adj[x])
    {
        if (!dfn[v])
        {
            self(self, v);
            low[x] = min(low[x], low[v]);
        }
        else if (in_st[v])
            low[x] = min(low[x], dfn[v]);
    }
    if (dfn[x] == low[x])
    {
        block++;
        while (true)
        {
            int v = sta.back();
            sta.pop_back();
            in_st[v] = false;
            scc[v] = block;
            if (v == x)
                break;
        }
    }
};

for (int i = 1; i &amp;lt;= n; i++)
    if (!dfn[i])
        tarjan(tarjan, i);
// TODO: 缩点、判环或按题意使用 scc。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-15&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.15 Tarjan 有向图 SCC (独立实现版)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：带图缩点重构与度数统计的完整代码。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 10005
using namespace std;
class graph
{
    public:
    struct edge
    {
        int next;
        int to;

    }edges[5*N];
    int head[N],cnt=0,n;
    graph()
    {
        memset(head,-1,sizeof head);
    }
    bitset&amp;lt;N&amp;gt;book;
    int stack[N],dfn[N]={},low[N]={},block=0,scc[N],din[N]={},dout[N]={};
    int top=0;
    void add(int from,int to)
    {
        cnt++;
        edges[cnt].next=head[from];
        edges[cnt].to=to;
        head[from]=cnt;
    }
    void tarjan(int x,int &amp;amp;time)
    {
        dfn[x]=low[x]=++time;
        stack[++top]=x;
        book[x]=1;
        for(int i=head[x];~i;i=edges[i].next)
        {
            int v=edges[i].to;
            if(!dfn[v])
            {
                tarjan(v,time);
                low[x]=min(low[x],low[v]);
            }else if(book[v]){ //如果还没出栈
                low[x]=min(low[x],dfn[v]);
            }
        }
        if(dfn[x]==low[x])
        {
            block++;
            while(1)
            {
                int v=stack[top--];
                book[v]=0;
                scc[v]=block;
                if(v==x) break;
            }
        }

    }
    void worK()
    {
        for(int i=1;i&amp;lt;=n;i++)
        {
            for(int j=head[i];~j;j=edges[j].next)
            {
                int v=edges[j].to;
                if(scc[i]!=scc[v])
                {
                    din[scc[v]]++;
                    dout[scc[i]]++;
                }
            }
        }
        int a=0,b=0;
        for(int i=1;i&amp;lt;=block;i++)
        {
            if(!din[i]) a++;
            if(!dout[i]) b++;
        }

        cout&amp;lt;&amp;lt;a&amp;lt;&amp;lt;&apos;\n&apos;;
        if(block==1) cout&amp;lt;&amp;lt;0&amp;lt;&amp;lt;&apos;\n&apos;;
            else
        cout&amp;lt;&amp;lt;max(a,b);
    }
}g;
int n;

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n;
    g.n=n;
    for(int i=1;i&amp;lt;=n;i++)
    {
        int a;
        while(cin&amp;gt;&amp;gt;a)
        {
            if(!a) break;
            g.add(i,a);
        }
    }
    int x=0;
    for(int i=1;i&amp;lt;=n;i++)
        if(!g.dfn[i]) g.tarjan(i, x);
    g.worK();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-16&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.16 Tarjan 算法：无向图割点判定&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：根据搜索树孩子节点 &lt;code&gt;low&lt;/code&gt; 与 &lt;code&gt;dfn&lt;/code&gt; 关系判定无向图关节点。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;int&amp;gt; dfn(n + 5), low(n + 5), cut(n + 5);
int tim = 0;

auto tarjan = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int fa, int root) -&amp;gt; void
{
    dfn[x] = low[x] = ++tim;
    int child = 0;
    for (auto v : adj[x])
    {
        if (!dfn[v])
        {
            child++;
            self(self, v, x, root);
            low[x] = min(low[x], low[v]);
            if (x != root &amp;amp;&amp;amp; low[v] &amp;gt;= dfn[x])
                cut[x] = 1;
        }
        else if (v != fa)
            low[x] = min(low[x], dfn[v]);
    }
    if (x == root &amp;amp;&amp;amp; child &amp;gt;= 2)
        cut[x] = 1;
};

for (int i = 1; i &amp;lt;= n; i++)
    if (!dfn[i])
        tarjan(tarjan, i, 0, i);
// TODO: cut[i] 是否为割点。重边图需要改成按边编号跳过父边。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-17&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.17 Tarjan 算法：无向图割边判定 (桥)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：无向图判定桥，处理重边时通过边 ID 避免反向走回反边。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct Edge
{
    int to, id;
};
vector&amp;lt;vector&amp;lt;Edge&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;int&amp;gt; dfn(n + 5), low(n + 5);
vector&amp;lt;pair&amp;lt;int, int&amp;gt;&amp;gt; bridge;
int tim = 0;

auto tarjan = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int in_edge) -&amp;gt; void
{
    dfn[x] = low[x] = ++tim;
    for (auto [v, id] : adj[x])
    {
        if (!dfn[v])
        {
            self(self, v, id);
            low[x] = min(low[x], low[v]);
            if (low[v] &amp;gt; dfn[x])
                bridge.push_back({x, v});
        }
        else if (id != in_edge)
            low[x] = min(low[x], dfn[v]);
    }
};

// 建边时：adj[u].push_back({v, i}); adj[v].push_back({u, i});
for (int i = 1; i &amp;lt;= n; i++)
    if (!dfn[i])
        tarjan(tarjan, i, 0);
// TODO: bridge 保存所有割边；有重边时 id 必须是真实边编号。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-18&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.18 无向图割点与桥（重边/非连通）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：按边编号处理父边，返回0-based割点和桥的输入编号；无向、非连通、重边均支持，深链须考虑递归栈。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// 无向图，可不连通，可含重边；边编号从0起，同一无向边两端用同一id。
pair&amp;lt;vector&amp;lt;int&amp;gt;,vector&amp;lt;int&amp;gt;&amp;gt; articulation_bridges(int n,const vector&amp;lt;pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;amp; edges){
    vector&amp;lt;vector&amp;lt;pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;gt;adj(n);
    for(int i=0;i&amp;lt;int(edges.size());++i){auto[u,v]=edges[i];adj[u].push_back({v,i});adj[v].push_back({u,i});}
    vector&amp;lt;int&amp;gt;dfn(n),low(n),cut(n),bridges;int time=0;
    auto dfs=[&amp;amp;](auto&amp;amp;&amp;amp; self,int u,int parent_edge)-&amp;gt;void{
        dfn[u]=low[u]=++time;int children=0;
        for(auto[v,id]:adj[u]){
            if(id==parent_edge)continue;
            if(!dfn[v]){
                ++children;self(self,v,id);low[u]=min(low[u],low[v]);
                if(parent_edge!=-1&amp;amp;&amp;amp;low[v]&amp;gt;=dfn[u])cut[u]=1;
                if(low[v]&amp;gt;dfn[u])bridges.push_back(id);
            }else low[u]=min(low[u],dfn[v]);
        }
        if(parent_edge==-1&amp;amp;&amp;amp;children&amp;gt;=2)cut[u]=1;
    };
    for(int i=0;i&amp;lt;n;++i)if(!dfn[i])dfs(dfs,i,-1);
    vector&amp;lt;int&amp;gt;points;for(int i=0;i&amp;lt;n;++i)if(cut[i])points.push_back(i);sort(bridges.begin(),bridges.end());
    return {points,bridges};
}
// 输入n,m和1-based边；输出割点数、割点列表、桥数、桥的1-based输入编号。
int main(){int n,m;if(!(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m))return 0;vector&amp;lt;pair&amp;lt;int,int&amp;gt;&amp;gt;e(m);for(auto&amp;amp;[u,v]:e)cin&amp;gt;&amp;gt;u&amp;gt;&amp;gt;v,--u,--v;auto[c,b]=articulation_bridges(n,e);cout&amp;lt;&amp;lt;c.size()&amp;lt;&amp;lt;&apos;\n&apos;;for(int x:c)cout&amp;lt;&amp;lt;x+1&amp;lt;&amp;lt;&apos; &apos;;cout&amp;lt;&amp;lt;&apos;\n&apos;&amp;lt;&amp;lt;b.size()&amp;lt;&amp;lt;&apos;\n&apos;;for(int x:b)cout&amp;lt;&amp;lt;x+1&amp;lt;&amp;lt;&apos; &apos;;cout&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-19&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.19 2-SAT 问题求解 (Tarjan SCC)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：构造布尔变量蕴含关系有向图，强连通缩点后判定无解并按拓扑逆序构造合法赋值。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(2 * n + 5);
vector&amp;lt;int&amp;gt; dfn(2 * n + 5), low(2 * n + 5), scc(2 * n + 5);
vector&amp;lt;int&amp;gt; sta;
vector&amp;lt;bool&amp;gt; in_st(2 * n + 5);
int tim = 0, block = 0;

auto rev = [&amp;amp;](int x)
{
    return x ^ 1;
};
auto add_imp = [&amp;amp;](int x, int y)
{
    adj[x].push_back(y);
    adj[rev(y)].push_back(rev(x));
};
// TODO: 节点编号自行约定，例如变量 i 的两个状态为 2*i 与 2*i+1。

auto tarjan = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void
{
    dfn[x] = low[x] = ++tim;
    sta.push_back(x);
    in_st[x] = true;
    for (auto v : adj[x])
    {
        if (!dfn[v])
        {
            self(self, v);
            low[x] = min(low[x], low[v]);
        }
        else if (in_st[v])
            low[x] = min(low[x], dfn[v]);
    }
    if (dfn[x] == low[x])
    {
        block++;
        while (true)
        {
            int v = sta.back();
            sta.pop_back();
            in_st[v] = false;
            scc[v] = block;
            if (v == x)
                break;
        }
    }
};

for (int i = 0; i &amp;lt; 2 * n; i++)
    if (!dfn[i])
        tarjan(tarjan, i);
// TODO: 若 scc[i] == scc[rev(i)] 则无解；赋值顺序按 SCC 编号性质决定。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-20&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.20 二分图最大匹配 (匈牙利算法 / Kuhn 算法)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：增广路交替搜索，解决二分图最大匹配问题。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;int&amp;gt; match(m + 5, 0), vis(m + 5);

auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; bool
{
    for (auto y : adj[x])
    {
        if (vis[y])
            continue;
        vis[y] = 1;
        if (!match[y] || self(self, match[y]))
        {
            match[y] = x;
            return true;
        }
    }
    return false;
};

int ans = 0;
for (int i = 1; i &amp;lt;= n; i++)
{
    fill(vis.begin(), vis.end(), 0);
    ans += dfs(dfs, i);
}
// TODO: ans 是匹配数；左右部点数按题目修改 n、m。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-21&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.21 Hall 婚姻定理 (Hall&apos;s Marriage Theorem)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：二分图完美匹配存在性充要条件 $|N(S)| \ge |S|$，结合线段树进行贪心区间判定。&lt;/p&gt;
&lt;h3&gt;Hall 婚姻定理与可用的区间匹配判定&lt;/h3&gt;
&lt;p&gt;对于二分图G=(L,R,E)，覆盖L的匹配存在，当且仅当每个S⊆L满足|N(S)|≥|S|。最大匹配大小为|L|-max_S(|S|-|N(S)|)，其中包含空集，故最大亏损非负。&lt;/p&gt;
&lt;h4&gt;区间邻域的正确使用方式&lt;/h4&gt;
&lt;p&gt;若右部是槽位1..m，每个左部对象i可放在[L_i,R_i]，且每个对象需要一个槽位，可以按R_i从小到大，将它放进当前最小的、不小于L_i的空槽位。如果这个槽位超过R_i，则无法匹配；否则继续。交换论证：把任一可行匹配中当前对象使用的槽位，与贪心选中的更早槽位交换，不会破坏之后截止时间更晚对象的可行性。&lt;/p&gt;
&lt;p&gt;对于此模型，Hall也等价于：任意右部区间[a,b]内，允许区间完全包含于[a,b]的对象数量不能超过b-a+1。这里枚举的是&lt;strong&gt;右部槽位区间&lt;/strong&gt;，不是任意给左部对象按输入编号切出的连续片段。&lt;/p&gt;
&lt;p&gt;反例：m=3，三个左部对象的区间按输入顺序为[1,1]、[2,3]、[1,1]。所有连续左部片段都能满足计数检查，但对象1和3无法同时匹配到唯一槽位1。&lt;/p&gt;
&lt;p&gt;只有证明了当前模型的亏损恰可表达为特定序列的区间和，才可用最大子段和线段树优化判定。&lt;/p&gt;
&lt;h4&gt;可直接使用的区间匹配函数&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// 右部槽位1..m；返回每个原始对象所配槽位；无解nullopt。
// 用set显式存槽位，时间O(m log m+n log n+n log m)，空间O(m+n)。
optional&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; interval_matching(vector&amp;lt;pair&amp;lt;int,int&amp;gt;&amp;gt; ranges,int m){
    assert(m&amp;gt;=0);
    int n=ranges.size();vector&amp;lt;int&amp;gt;order(n),answer(n);iota(order.begin(),order.end(),0);
    sort(order.begin(),order.end(),[&amp;amp;](int a,int b){return ranges[a].second&amp;lt;ranges[b].second;});
    set&amp;lt;int&amp;gt;free_slots;for(int i=1;i&amp;lt;=m;++i)free_slots.insert(i);
    for(int id:order){
        auto[l,r]=ranges[id];assert(1&amp;lt;=l&amp;amp;&amp;amp;l&amp;lt;=r&amp;amp;&amp;amp;r&amp;lt;=m);
        auto it=free_slots.lower_bound(l);
        if(it==free_slots.end()||*it&amp;gt;r)return nullopt;
        answer[id]=*it;free_slots.erase(it);
    }
    return answer;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;多个单位需求可以展开为多个对象；较大的m或特殊邻域结构需要另外设计存储。一般二分图用二分匹配/网络流，不能按本节的区间贪心处理任意邻域。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-22&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.22 网络流：Dinic 最大流算法&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：分层图 BFS + 多路增广 DFS + 当前弧优化的经典 Dinic 算法。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
vector&amp;lt;pair&amp;lt;int, ll&amp;gt;&amp;gt; edges;

auto add = [&amp;amp;](int x, int y, ll w)
{
    adj[x].push_back(edges.size());
    edges.push_back({y, w});
    adj[y].push_back(edges.size());
    edges.push_back({x, 0});
};

vector&amp;lt;int&amp;gt; dep(n + 5), cur(n + 5);
auto bfs = [&amp;amp;](int st, int en) -&amp;gt; bool
{
    fill(dep.begin(), dep.end(), 0);
    queue&amp;lt;int&amp;gt; que;
    que.push(st);
    dep[st] = 1;
    while (que.size())
    {
        int x = que.front();
        que.pop();
        for (auto id : adj[x])
        {
            auto [v, w] = edges[id];
            if (w &amp;amp;&amp;amp; !dep[v])
                dep[v] = dep[x] + 1, que.push(v);
        }
    }
    return dep[en];
};

auto dinic = [&amp;amp;](int st, int en) -&amp;gt; ll
{
    auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, ll flow) -&amp;gt; ll
    {
        if (x == en)
            return flow;
        ll res = 0;
        for (int &amp;amp;i = cur[x]; i &amp;lt; (int)adj[x].size(); i++)
        {
            int id = adj[x][i];
            auto &amp;amp;[v, w] = edges[id];
            if (w &amp;amp;&amp;amp; dep[v] == dep[x] + 1)
            {
                ll tem = self(self, v, min(flow, w));
                w -= tem;
                edges[id ^ 1].second += tem;
                res += tem;
                flow -= tem;
                if (!flow)
                    break;
            }
        }
        if (!res)
            dep[x] = 0;
        return res;
    };

    ll flow = 0;
    while (bfs(st, en))
    {
        fill(cur.begin(), cur.end(), 0);
        flow += dfs(dfs, st, (ll)4e18);
    }
    return flow;
};

// TODO: add(u, v, capacity); cout &amp;lt;&amp;lt; dinic(source, sink);
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-23&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.23 网络流：Dinic 独立实现版&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：包含残量网络反向边异或编号的独立 Dinic 实现。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 100005
#define ll long long
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
ll n,m,cnt;
struct ed
{
    ll next,to,w;
}edges[N];
vector&amp;lt;ll&amp;gt; head;
vector&amp;lt;ll&amp;gt; cur;
vector&amp;lt;ll&amp;gt; d;

void add(int x,int y,ll w)
{
    edges[cnt]={head[x],y,w};
    head[x]=cnt;
    cnt++;
}
bool bfs(int s,int t)
{
    queue&amp;lt;int&amp;gt;q;
    q.push(s);
    fill(d.begin(),d.end(),0);
    d[s]=1;
    int flag=0;
    while(q.size())
    {
        auto x=q.front();
        q.pop();
        for(int i=head[x];~i;i=edges[i].next)
        {
            int v=edges[i].to;
            ll w=edges[i].w;
            if(w &amp;amp;&amp;amp; !d[v])
            {
                d[v]=d[x]+1;
                q.push(v);
                if(v==t) flag=1;
            }
        }
    }
    return flag;
}
ll dfs(int x,int t,ll tol_f)
{
    if(x==t) return tol_f;
    ll sum=0;
    for(int i=cur[x];~i;i=edges[i].next)
    {
        cur[x]=i;
        int v=edges[i].to;
        ll w=edges[i].w;
        if(w &amp;amp;&amp;amp; d[v]==d[x]+1)
        {
            ll tem=dfs(v,t,min(tol_f,w));
            sum+=tem;
            tol_f-=tem;
            edges[i].w-=tem;
            edges[i^1].w+=tem;
            if(!tol_f) break;
        }
    }
    if(!sum) d[x]=0;
    return sum;
}
ll dinic(int s,int t)
{
    ll flow=0;
    while(bfs(s,t))
    {
        cur=head;
        flow+=dfs(s,t,1e8);
    }
    return flow;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int s,t;
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m&amp;gt;&amp;gt;s&amp;gt;&amp;gt;t;
    assert(s!=t);
    head.assign(n+1,-1);cur.resize(n+1);d.resize(n+1);
    for(int i=1;i&amp;lt;=m;i++)
    {
        ll a,b,c;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;c;
        add(a,b,c);
        add(b,a,0);
    }
    cout&amp;lt;&amp;lt;dinic(s,t);
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-24&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.24 网络流：Edmonds-Karp (EK 增广路算法)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：单路 BFS 增广的最大流算法，适合点数较小或特定费用流变形。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 700
#define ll long long
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
ll n,m,cnt;
struct ed
{
    ll next,to,w;
}edges[N];
ll head[N];
ll pre[N];
ll f[N];
void add(int x,int y,ll w)
{
    edges[cnt]={head[x],y,w};
    head[x]=cnt;
    cnt++;
}
bool bfs(int s,int t)
{
    queue&amp;lt;int&amp;gt;q;
    q.push(s);
    memset(f,0,sizeof f);
    memset(pre,-1,sizeof pre);
    f[s]=1e9;
    while(q.size())
    {
        auto x=q.front();
        q.pop();
        for(int i=head[x];~i;i=edges[i].next)
        {
            int v=edges[i].to;
            ll w=edges[i].w;
            if(w &amp;amp;&amp;amp; !f[v])
            {
                pre[v]=i;
                f[v]=min(f[x],w);
                q.push(v);
                if(v==t)
                    return 1;
            }
        }
    }
    return 0;
}
ll ek(int s,int t)
{
    ll flow=0;
    while(bfs(s,t))
    {

        for(int i=pre[t];~i;i=pre[edges[i^1].to])
        {
            edges[i].w-=f[t];
            edges[i^1].w+=f[t];
        }
        flow+=f[t];
    }
    return flow;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin&amp;gt;&amp;gt;m&amp;gt;&amp;gt;n;
    memset(head,-1,sizeof head);
    for(int i=1;i&amp;lt;=m;i++)
    {
        ll a,b,c;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;c;
        add(a,b,c);
        add(b,a,0);
    }
    cout&amp;lt;&amp;lt;ek(1,n);
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-25&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.25 第 K 短路 A*（允许重复点边的 walk）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：反图Dijkstra作下界，A*枚举第K短walk；排除起终点相同的空路径。非简单路径算法，非负边，K与枚举规模须可承受。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 5000005
#define sp &amp;lt;&amp;lt; &quot; &quot;&amp;lt;&amp;lt;
#define mp make_pair
#define pr pair&amp;lt;ll,ll&amp;gt;
#define MOD 998244353
#define inf 0x3f3f3f3f3f3f3f3f
using namespace std;
ll n,m,s,e,k;
vector&amp;lt;ll&amp;gt;revd;
vector&amp;lt;ll&amp;gt;times;
vector&amp;lt;vector&amp;lt;pr&amp;gt;&amp;gt;map1;
vector&amp;lt;vector&amp;lt;pr&amp;gt;&amp;gt;map2;
bitset&amp;lt;N&amp;gt;vis;

void dij(int s)
{
    priority_queue&amp;lt;pr&amp;gt;q;
    vis.reset();
    revd.assign(n+1,inf);
    q.push({0,s});
    revd[s]=0;
    while(q.size())
    {
        auto p=q.top().second;
        q.pop();
        if(vis[p]) continue;
        vis[p]=1;
        for(auto tem:map2[p])
        {
            int v=tem.first;
            ll w=tem.second;
            if(revd[v]&amp;gt;revd[p]+w)
            {
                revd[v]=revd[p]+w;
                q.push({-revd[v],v});
            }
        }
    }
}
bool astar(int s,int t,ll tol)
{
    priority_queue&amp;lt;pair&amp;lt;ll,pair&amp;lt;ll,ll&amp;gt;&amp;gt;&amp;gt;q;
    times.assign(n+1,0);
    if(revd[s]&amp;gt;=inf) return false;
    q.push({-revd[s],{0,s}});
    while(q.size())
    {
        auto p=q.top().second.second;
        auto dis=q.top().second.first;
        q.pop();
        if(times[p]&amp;gt;=k) continue;
        times[p]++;
        if(times[p]==k &amp;amp;&amp;amp; p==t)
        {
            return dis&amp;lt;=tol;
        }
        for(auto tem:map1[p])
        {
            int v=tem.first;
            ll w=tem.second;
            ll dis_=dis+w;
            if(revd[v]+dis_&amp;lt;=tol &amp;amp;&amp;amp;times[v]&amp;lt;k)
            {
                q.push({-(revd[v]+dis_),{dis_,v}});
            }
        }
    }
    return 0;
}
int main()
{
    ll t;
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    while(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m)
    {
        cin&amp;gt;&amp;gt;s&amp;gt;&amp;gt;e&amp;gt;&amp;gt;k&amp;gt;&amp;gt;t;
        map1.assign(n+5,{});
        map2.assign(n+5,{});
        for(int i=1;i&amp;lt;=m;i++)
        {
            ll a,b,c;
            cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;c;
            map1[a].push_back({b,c});
            map2[b].push_back({a,c});//反向图
        }
        if(s==e) k++;
        dij(e);
        if(astar(s,e,t)) cout&amp;lt;&amp;lt;&quot;yareyaredawa\n&quot;;
        else cout&amp;lt;&amp;lt;&quot;Whitesnake!\n&quot;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-26&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.26 欧拉回路 (Eulerian Circuit / Path)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：Hierholzer 算法当前弧优化，在线性时间内寻找欧拉回路与路径输出。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 100005
#define inf 0x3f3f3f3f3f3f3f3f
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
int n, m, q, ma, k, cnt;
vector&amp;lt;vector&amp;lt;tuple&amp;lt;int, int, int&amp;gt;&amp;gt;&amp;gt; map1;
const ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    if (n == 1) {
        cout &amp;lt;&amp;lt; &quot;10&quot;;
        return 0;
    }
    map1.assign(1 &amp;lt;&amp;lt; n, {});
    for (int i = 0; i &amp;lt; (1 &amp;lt;&amp;lt; (n - 1)); i++) {
        auto x = i;
        x &amp;gt;&amp;gt;= 1;
        map1[i].push_back({++cnt, 0, x});
        map1[i].push_back({++cnt, 1, x ^ (1 &amp;lt;&amp;lt; (n - 2))});
    }
    vector&amp;lt;int&amp;gt; ans;
    vector&amp;lt;bool&amp;gt; vis(cnt + 10, 0);
    vector&amp;lt;int&amp;gt; cur(1 &amp;lt;&amp;lt; n, 0);
    auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void {
        for (int &amp;amp;i = cur[x]; i &amp;lt; map1[x].size(); i++) {
            auto [id, num, y] = map1[x][i];
            if (!vis[id]) {
                vis[id] = 1;
                self(self, y);
                ans.push_back(num);
            }
        }
    };
    dfs(dfs, 0);
    reverse(ans.begin(), ans.end());
    for (int i = 1; i &amp;lt; n; i++)
        cout &amp;lt;&amp;lt; 0;
    for (auto x : ans)
        cout &amp;lt;&amp;lt; x;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-27&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.27 0-1 BFS（边权仅0或1）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：只支持0/1边权；0权松弛放队首，1权放队尾；一般非负权使用Dijkstra。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// 边权严格限于0/1；无向实例输入n,m,target及m条(u,v,w)，起点1。
vector&amp;lt;long long&amp;gt; zero_one_bfs(const vector&amp;lt;vector&amp;lt;pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;gt;&amp;amp; adj,int source){
    const long long INF=1LL&amp;lt;&amp;lt;60;vector&amp;lt;long long&amp;gt;d(adj.size(),INF);deque&amp;lt;pair&amp;lt;long long,int&amp;gt;&amp;gt;q;
    d[source]=0;q.push_back({0,source});
    while(!q.empty()){
        auto[du,u]=q.front();q.pop_front();if(du!=d[u])continue;
        for(auto[v,w]:adj[u]){
            assert(w==0||w==1);
            if(d[v]&amp;gt;du+w){d[v]=du+w;if(w==0)q.push_front({d[v],v});else q.push_back({d[v],v});}
        }
    }
    return d;
}
int main(){int n,m,t;if(!(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m&amp;gt;&amp;gt;t))return 0;vector&amp;lt;vector&amp;lt;pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;gt;a(n);while(m--){int u,v,w;cin&amp;gt;&amp;gt;u&amp;gt;&amp;gt;v&amp;gt;&amp;gt;w;--u;--v;a[u].push_back({v,w});a[v].push_back({u,w});}auto d=zero_one_bfs(a,0);cout&amp;lt;&amp;lt;(d[t-1]==(1LL&amp;lt;&amp;lt;60)?-1:d[t-1])&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-28&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.28 树上启发式合并 (DSU on Tree / 来自知乎专栏)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：离线处理无修改子树统计询问，轻重儿子划分保留重儿子状态，时间复杂度 $O(N \log N)$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;queue&amp;gt;
#define ll long long
#define N 100005
#define sp &amp;lt;&amp;lt; &quot; &quot;&amp;lt;&amp;lt;
using namespace std;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;map1;
ll n,m,mx,sum;
ll a,b,k;
ll t;
ll col[N];
ll cnt[N];
ll siz[N];
ll ans[N];
ll son[N];
void dfs(int x,int fa)
{
    siz[x]=1;
    for(auto v:map1[x])
    {
        if(v==fa) continue;
        dfs(v,x);
        siz[x]+=siz[v];
        if(siz[v]&amp;gt;siz[son[x]]) son[x]=v;
    }
}
void add(int x,int fa,int hs)
{
    cnt[col[x]]++;
    if(cnt[col[x]]&amp;gt;mx)
    {
        mx=cnt[col[x]];
        sum=col[x];
    }else if(cnt[col[x]]==mx) sum+=col[x];
    for(auto v:map1[x])
    {
        if(v==hs||v==fa) continue;
        add(v,x,hs);
    }
}
void sub(int x,int fa)
{
    cnt[col[x]]--;
    for(auto v:map1[x])
    {
        if(v==fa) continue;
        sub(v,x);
    }
}
void cal(int x,int fa)
{
    for(auto v:map1[x])
    {
        if(v==son[x]||v==fa) continue;
        cal(v,x);
        sub(v,x);
        mx=sum=0;//减去轻子树的贡献不会清除重儿子的贡献
    }
    if(son[x])
        cal(son[x],x);
    add(x,fa,son[x]);
    ans[x]=sum;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin&amp;gt;&amp;gt;n;
    for(int i=1;i&amp;lt;=n;i++)
    {
        cin&amp;gt;&amp;gt;col[i];
    }
    map1.resize(n+5,{});
    for(int i=1;i&amp;lt;n;i++)
    {
        ll x,y;
        cin&amp;gt;&amp;gt;x&amp;gt;&amp;gt;y;
        map1[x].push_back(y);
        map1[y].push_back(x);
    }
    dfs(1,0);
    cal(1,0);
    for(int i=1;i&amp;lt;=n;i++)
    {
        cout&amp;lt;&amp;lt;ans[i]&amp;lt;&amp;lt;&apos; &apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-5-29&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;5.29 基环树森林与倍增跳环 (CSES Planets Queries II)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：出度为 1 的内向基环树森林，通过 Tarjan 缩环结合二进制倍增跳环快速计算两点最短到达距离。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iterator&amp;gt;
#include &amp;lt;queue&amp;gt;
#include &amp;lt;set&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#define N 100005
#define inf 0x3f3f3f3f3f3f3f3f
#define ll long long
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n,m,q;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;map1;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;fa;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;ring;

vector&amp;lt;ll&amp;gt;scc;
vector&amp;lt;ll&amp;gt;siz;
vector&amp;lt;ll&amp;gt;dis;
vector&amp;lt;ll&amp;gt;ancestor;
vector&amp;lt;ll&amp;gt;priority;

const ll mod=1e9+7;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;q;

    map1.assign(n+5,{});
    ring.assign(n+5,{});
    fa.assign(n+5,vector&amp;lt;int&amp;gt;(30,0));
    scc.assign(n+5,0);
    priority.assign(n+5,0);
    ancestor.assign(n+5,0); //在环上的祖先
    siz.assign(n+5,0);
    dis.assign(n+5,0);

    for(int i=1;i&amp;lt;=n;i++)
    {
        ll x;
        cin&amp;gt;&amp;gt;x;
        fa[i][0]=x;
        map1[i].push_back(x);
    }
    for(int j=1;j&amp;lt;=25;j++)
    {
        for(int i=1;i&amp;lt;=n;i++)
        {
            fa[i][j]=fa[fa[i][j-1]][j-1];
        }
    }
    auto tarjan=[&amp;amp;]()
    {
        int tim=0;
        stack&amp;lt;int&amp;gt;st;
        vector&amp;lt;ll&amp;gt;dfn(n+5,0);vector&amp;lt;ll&amp;gt;low(n+5,0);
        vector&amp;lt;bool&amp;gt;insta(n+5,0);

        auto dfs=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x)-&amp;gt;void
        {
            dfn[x]=low[x]=++tim;
            st.push(x);
            insta[x]=1;
            for(auto v:map1[x])
            {
                if(!dfn[v])
                {
                    self(self,v);
                    low[x]=min(low[x],low[v]);
                }else if(insta[v])
                {
                    low[x]=min(low[x],dfn[v]);
                }
            }
            if(low[x]==dfn[x])
            {
                int y=-1;
                while(y!=x)
                {
                    y=st.top(),st.pop();
                    insta[y]=0;
                    scc[y]=x,ring[x].push_back(y);
                    priority[y]=(++siz[scc[y]]);
                }
            }
        };
        auto dfs2=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x)-&amp;gt;void
        {
            if(ancestor[x]) return ;
            auto v=map1[x][0];
            self(self,v);
            ancestor[x]=ancestor[v];
            dis[x]=dis[v]+1;
        };
        for(int i=1;i&amp;lt;=n;i++)
        {
            if(!dfn[i]) dfs(dfs,i);
        }
        for(int i=1;i&amp;lt;=n;i++)
        {
            if(map1[i][0]==i) ancestor[i]=i;
            else if(ring[i].size()&amp;gt;1)
            {
                for(auto x:ring[i]) ancestor[x]=x;
            }
        }
        for(int i=1;i&amp;lt;=n;i++) dfs2(dfs2,i);
    };
    auto query=[&amp;amp;](int a,int b)
    {
        auto query=[&amp;amp;](int x,int k)
        {
            if(k&amp;lt;=0) return x;
            for(int i=25;i&amp;gt;=0;i--)
            {
                if((k&amp;gt;&amp;gt;i)&amp;amp;1)
                {
                    x=fa[x][i];
                }
            }
            return x;
        };
        int ans=-1;
        if(scc[ancestor[a]]!=scc[ancestor[b]]) return -1;

        if(ancestor[a]==a &amp;amp;&amp;amp; ancestor[b]!=b) return -1; //a在环上 b在树上
        else if(ancestor[a]!=a &amp;amp;&amp;amp; ancestor[b]!=b) //都在树上
        {
            ans=dis[a]-dis[b];
            if(query(a, ans)==b) return ans;
            else return -1;
        }
        else
        {
            ans=dis[a]-dis[ancestor[a]];
            a=ancestor[a];
            ll tem=(priority[a]-priority[b]+siz[scc[a]])%siz[scc[a]];
            ans+=tem;
            return ans;
        }

    };
    tarjan();
    while(q--)
    {
        ll a,b;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;
        cout&amp;lt;&amp;lt;query(a, b)&amp;lt;&amp;lt;&apos;\n&apos;;
    }


    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第六章 数论与数学算法&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.1 快速幂与模乘 (Binary Exponentiation)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：$O(\log B)$ 整数幂次模运算，内置 &lt;code&gt;__int128&lt;/code&gt; 防止防溢出。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto qpow = [&amp;amp;](ll a, ll b, ll mod) -&amp;gt; ll
{
    ll res = 1 % mod;
    while (b)
    {
        if (b &amp;amp; 1)
            res = (__int128)res * a % mod;
        a = (__int128)a * a % mod;
        b &amp;gt;&amp;gt;= 1;
    }
    return res;
};

// TODO: qpow(a, b, mod); 模数为 1 时注意边界。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.2 质数判定与试除法分解&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：$O(\sqrt{N})$ 试除判定质数与质因数幂次分解。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto is_prime = [&amp;amp;](ll x) -&amp;gt; bool
{
    if (x &amp;lt; 2)
        return false;
    for (ll i = 2; i * i &amp;lt;= x; i++)
        if (x % i == 0)
            return false;
    return true;
};

auto factor = [&amp;amp;](ll x)
{
    vector&amp;lt;pair&amp;lt;ll, int&amp;gt;&amp;gt; res;
    for (ll p = 2; p * p &amp;lt;= x; p++)
    {
        if (x % p)
            continue;
        int cnt = 0;
        while (x % p == 0)
            x /= p, cnt++;
        res.push_back({p, cnt});
    }
    if (x &amp;gt; 1)
        res.push_back({x, 1});
    return res;
};

// TODO: 大数判素使用 Miller-Rabin；分解结果按题意使用。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.3 埃氏筛与欧拉线性筛 (Euler Sieve)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：$O(N)$ 线性时间内筛选出范围内的全部素数，便于扩展积性函数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;int&amp;gt; primes;
vector&amp;lt;bool&amp;gt; vis(n + 5, false);

auto euler = [&amp;amp;](int lim)
{
    primes.clear();
    vis.assign(lim + 5, false);
    for (int i = 2; i &amp;lt;= lim; i++)
    {
        if (!vis[i])
            primes.push_back(i);
        for (auto p : primes)
        {
            if (1LL * i * p &amp;gt; lim)
                break;
            vis[i * p] = true;
            if (i % p == 0)
                break;
        }
    }
};

// TODO: euler(limit); 若求 phi、mu 等积性函数，在 i*p 处补转移。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.4 扩展欧几里得算法 (EXGCD)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：求解 $ax + by = \gcd(a, b)$ 的一组整数特解及模逆元。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto exgcd = [&amp;amp;](auto &amp;amp;&amp;amp;self, ll a, ll b, ll &amp;amp;x, ll &amp;amp;y) -&amp;gt; ll
{
    if (!b)
    {
        x = 1;
        y = 0;
        return a;
    }
    ll xx, yy;
    ll g = self(self, b, a % b, xx, yy);
    x = yy;
    y = xx - (a / b) * yy;
    return g;
};

// TODO: exgcd(exgcd, a, b, x, y) 得到 a*x + b*y = gcd(a,b)。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.5 扩展欧几里得与一次同余方程 (独立例程)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：结合裴蜀定理求解一般线性同余方程 $ax \equiv c \pmod b$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
using namespace std;

ll t;

// 扩展欧几里得：求解 a*x + b*y = gcd(a, b)
ll exgcd(ll a, ll b, ll &amp;amp;x, ll &amp;amp;y) {
  if (!b) {
    x = 1;
    y = 0;
    return a;
  }
  ll xx, yy;
  ll gc = exgcd(b, a % b, xx, yy);
  x = yy;
  y = xx - (a / b) * yy;
  return gc;
}

int main() {
  ios::sync_with_stdio(0);
  cin.tie(NULL);
  cout.tie(NULL);

  cin &amp;gt;&amp;gt; t;
  ll a, b, c, x, y;
  while (t--) {
    cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b &amp;gt;&amp;gt; c;
    ll gc = exgcd(a, b, x, y);
    if (c % gc != 0) {
      cout &amp;lt;&amp;lt; -1 &amp;lt;&amp;lt; &apos;\n&apos;;
      continue;
    }

    // 基础特解满足 a*x0 + b*y0 = c
    ll step_x = b / gc;
    ll step_y = a / gc;
    ll mul = c / gc;
    ll x0 = (__int128)x * mul % step_x;
    if (x0 &amp;lt;= 0)
      x0 += step_x; // 最小正整数 x
    ll y0 = (c - (__int128)a * x0) / b;

    if (y0 &amp;gt; 0) {
      // 存在正整数解
      ll kx = (y0 - 1) / step_y; // 还可以往后增加的解个数
      ll num = kx + 1;           // 正整数解的个数
      ll min_x = x0;
      ll max_x = x0 + kx * step_x;
      ll min_y = y0 - kx * step_y;
      ll max_y = y0;
      cout &amp;lt;&amp;lt; num sp min_x sp min_y sp max_x sp max_y &amp;lt;&amp;lt; &apos;\n&apos;;
    } else {
      // 无正整数解，输出 x 的最小正整数值，以及 y 的最小正整数值
      ll min_x = x0;
      ll y_pos = (__int128)y * mul % step_y;
      if (y_pos &amp;lt;= 0)
        y_pos += step_y;
      ll min_y = y_pos;
      cout &amp;lt;&amp;lt; min_x sp min_y &amp;lt;&amp;lt; &apos;\n&apos;;
    }
  }

  return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.6 裴蜀定理应用 (Bezout&apos;s Identity)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：多变量裴蜀定理与最大公约数判断。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
using namespace std;

ll n,p;

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

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    cin&amp;gt;&amp;gt;n;
    ll ans=1;
    for(int i=1;i&amp;lt;=n;i++)
    {
        ll k;
        cin&amp;gt;&amp;gt;k;
        if(i==1) ans=k;
        ans=gcd(ans,abs(k));
    }
    cout&amp;lt;&amp;lt;ans;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-7&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.7 费马小定理与逆元 (Fermat&apos;s Little Theorem)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：质数模数下 $a^{-1} \equiv a^{p-2} \pmod p$ 的求法。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
using namespace std;

ll n,p;

ll qpow(ll a,ll p,ll pp)
{

    ll res=1;
    while(p)
    {
        if(p&amp;amp;1) res=res*a%pp;
        a=(a*a)%pp;
        p&amp;gt;&amp;gt;=1;
    }
    return res;

}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;p;

    for(int i=1;i&amp;lt;=n;i++)
    {
        cout&amp;lt;&amp;lt;qpow(i,p-2,p)&amp;lt;&amp;lt;&apos;\n&apos;;
    }

    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-8&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.8 扩展欧拉降幂（十进制大指数）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：模数非质数且底数与模数不互质时，降幂公式 $a^b \equiv a^{b \bmod \varphi(m) + \varphi(m)} \pmod m$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;using ll=long long;using i128=__int128_t;
ll phi(ll n){ll ans=n;for(ll p=2;p&amp;lt;=n/p;++p)if(n%p==0){ans=ans/p*(p-1);while(n%p==0)n/=p;}if(n&amp;gt;1)ans=ans/n*(n-1);return ans;}
// 十进制非负大指数；a是64位整数，模数m&amp;gt;0。试除phi复杂度O(sqrt m)。
ll huge_power(ll a,ll m,const string&amp;amp; exponent){
    assert(m&amp;gt;0&amp;amp;&amp;amp;!exponent.empty());if(m==1)return 0;
    ll ph=phi(m),rem=0;bool large=false;
    for(char c:exponent){assert(&apos;0&apos;&amp;lt;=c&amp;amp;&amp;amp;c&amp;lt;=&apos;9&apos;);i128 now=i128(rem)*10+c-&apos;0&apos;;if(now&amp;gt;=ph)large=true;rem=now%ph;}
    i128 e=i128(rem)+(large?ph:0);a%=m;if(a&amp;lt;0)a+=m;ll result=1%m;
    while(e){if(e&amp;amp;1)result=i128(result)*a%m;a=i128(a)*a%m;e&amp;gt;&amp;gt;=1;}
    return result;
}
int main(){ll a,m;string b;if(cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;m&amp;gt;&amp;gt;b)cout&amp;lt;&amp;lt;huge_power(a,m,b)&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-9&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.9 组合数：阶乘与逆元预处理&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：$O(N)$ 预处理阶乘与倒序递推阶乘逆元，单次 $O(1)$ 查询 $\binom{n}{m} \bmod p$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const ll MOD = 998244353;
vector&amp;lt;ll&amp;gt; fac(n + 5), ifac(n + 5);

auto qpow = [&amp;amp;](ll a, ll b)
{
    ll res = 1;
    while (b)
    {
        if (b &amp;amp; 1)
            res = res * a % MOD;
        a = a * a % MOD;
        b &amp;gt;&amp;gt;= 1;
    }
    return res;
};

fac[0] = 1;
for (int i = 1; i &amp;lt;= n; i++)
    fac[i] = fac[i - 1] * i % MOD;
ifac[n] = qpow(fac[n], MOD - 2);
for (int i = n; i; i--)
    ifac[i - 1] = ifac[i] * i % MOD;

auto C = [&amp;amp;](int x, int y) -&amp;gt; ll
{
    if (y &amp;lt; 0 || y &amp;gt; x)
        return 0;
    return fac[x] * ifac[y] % MOD * ifac[x - y] % MOD;
};

// TODO: MOD 为质数且 n &amp;lt; MOD；其他模数按题目替换。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-10&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.10 范德蒙德卷积公式与组合恒等式&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：$\sum_{k=0}^r \binom{m}{k}\binom{n}{r-k} = \binom{m+n}{r}$，二重组合计数化简为单次 $O(1)$ 组合数。&lt;/p&gt;
&lt;h3&gt;范德蒙德卷积 (Vandermonde&apos;s Convolution)&lt;/h3&gt;
&lt;h4&gt;1. 核心恒等式&lt;/h4&gt;
&lt;p&gt;$$
\sum_{k=0}^r \binom{m}{k} \binom{n}{r - k} = \binom{m + n}{r}
$$&lt;/p&gt;
&lt;h4&gt;2. 组合意义证明&lt;/h4&gt;
&lt;p&gt;考虑一个大小为 $m + n$ 的集合，其中前 $m$ 个元素标记为红色，后 $n$ 个元素标记为蓝色。
从这 $m + n$ 个元素中任意选取 $r$ 个元素的总方案数为 $\binom{m+n}{r}$。
若按选出的红色元素个数 $k$ 分类（$0 \le k \le r$），则需要从 $m$ 个红色中选 $k$ 个，同时从 $n$ 个蓝色中选 $r-k$ 个，方案数为 $\binom{m}{k}\binom{n}{r-k}$。
对所有可能的 $k$ 求和，二者必然相等。&lt;/p&gt;
&lt;h4&gt;3. 常用推论与变形&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;对称平方和&lt;/strong&gt;：
$$
\sum_{k=0}^n \binom{n}{k}^2 = \sum_{k=0}^n \binom{n}{k} \binom{n}{n - k} = \binom{2n}{n}
$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;上指标求和 (朱世杰恒等式)&lt;/strong&gt;：
$$
\sum_{i=0}^n \binom{i}{k} = \binom{n + 1}{k + 1}
$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;带权范德蒙德卷积&lt;/strong&gt;：
$$
\sum_{k=0}^r k \binom{m}{k} \binom{n}{r - k} = m \binom{m + n - 1}{r - 1}
$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;4. 竞赛实战应用：二重计数化简模板&lt;/h4&gt;
&lt;p&gt;在很多组合计数问题中，面对形如 $\sum_{k} \binom{m}{k} \binom{n}{r-k}$ 的二重求和，直接计算为 $O(N)$；使用范德蒙德卷积可化简为单次 $O(1)$ 的组合数 $\binom{m+n}{r}$ 查询。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;
const int MOD = 998244353;
const int N = 200005;
ll fac[N], ifac[N];
ll qpow(ll a, ll b) {
    ll res = 1;
    while (b) {
        if (b &amp;amp; 1)
            res = res * a % MOD;
        a = a * a % MOD;
        b &amp;gt;&amp;gt;= 1;
    }
    return res;
}
void init_comb(int n) {
    fac[0] = 1;
    for (int i = 1; i &amp;lt;= n; i++)
        fac[i] = fac[i - 1] * i % MOD;
    ifac[n] = qpow(fac[n], MOD - 2);
    for (int i = n; i &amp;gt;= 1; i--)
        ifac[i - 1] = ifac[i] * i % MOD;
}
ll C(int n, int m) {
    if (m &amp;lt; 0 || m &amp;gt; n)
        return 0;
    return fac[n] * ifac[m] % MOD * ifac[n - m] % MOD;
}
// 范德蒙德卷积求和：sum_{k=0}^r C(m, k) * C(n, r-k) = C(m+n, r)
ll vandermonde(int m, int n, int r) {
    if (r &amp;lt; 0 || r &amp;gt; m + n)
        return 0;
    return C(m + n, r);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-11&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.11 高斯普通消元法 (Gauss-Jordan Elimination)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：浮点矩阵主元选取消元，求解线性方程组并判别无解/无穷多解。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;

// n行、m个未知量，增广矩阵每行m+1项。返回0无解、1唯一解、2无穷多解。
// 部分主元浮点高斯；病态方程仍需按题目改精度/EPS。
int gauss(vector&amp;lt;vector&amp;lt;long double&amp;gt;&amp;gt; a, vector&amp;lt;long double&amp;gt;&amp;amp; ans, long double eps = 1e-12L) {
    int n = a.size();
    assert(n &amp;gt; 0 &amp;amp;&amp;amp; !a[0].empty());
    int m = int(a[0].size()) - 1, row = 0;
    vector&amp;lt;int&amp;gt; where(m, -1);
    for (auto&amp;amp; r : a) assert(int(r.size()) == m + 1);
    for (int col = 0; col &amp;lt; m &amp;amp;&amp;amp; row &amp;lt; n; ++col) {
        int pivot = row;
        for (int i = row + 1; i &amp;lt; n; ++i) if (fabsl(a[i][col]) &amp;gt; fabsl(a[pivot][col])) pivot = i;
        if (fabsl(a[pivot][col]) &amp;lt;= eps) continue;
        swap(a[pivot], a[row]);
        where[col] = row;
        long double d = a[row][col];
        for (int j = col; j &amp;lt;= m; ++j) a[row][j] /= d;
        for (int i = 0; i &amp;lt; n; ++i) if (i != row) {
            long double t = a[i][col];
            for (int j = col; j &amp;lt;= m; ++j) a[i][j] -= t * a[row][j];
        }
        ++row;
    }
    for (int i = row; i &amp;lt; n; ++i) if (fabsl(a[i][m]) &amp;gt; eps) return 0;
    ans.assign(m, 0);
    for (int col = 0; col &amp;lt; m; ++col) if (where[col] != -1) ans[col] = a[where[col]][m];
    return row == m ? 1 : 2;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-12&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.12 高斯异或消元法 (XOR Gauss Elimination)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：基于 &lt;code&gt;std::bitset&lt;/code&gt; 的模 2 线性方程组消元，处理异或开关状态问题。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;bitset&amp;lt;1005&amp;gt;&amp;gt; a(n + 1);
// a[i][1..n] 是系数，a[i][n+1] 是常数项。

int row = 1;
for (int col = 1; col &amp;lt;= n &amp;amp;&amp;amp; row &amp;lt;= n; col++)
{
    int pivot = -1;
    for (int i = row; i &amp;lt;= n; i++)
        if (a[i][col])
        {
            pivot = i;
            break;
        }
    if (pivot == -1)
        continue;
    swap(a[row], a[pivot]);
    for (int i = 1; i &amp;lt;= n; i++)
        if (i != row &amp;amp;&amp;amp; a[i][col])
            a[i] ^= a[row];
    row++;
}

// TODO: 检查左侧全零而右侧为 1 的行；自由元处理按题意补充。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-13&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.13 Miller-Rabin 素性测试 (大素数判定)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：基于费马检验与二次探测定理，在 64 位整型范围内使用固定基数达到 100% 确定性判定。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto mul = [&amp;amp;](ll a, ll b, ll mod) -&amp;gt; ll
{
    return (__int128)a * b % mod;
};
auto qpow = [&amp;amp;](ll a, ll b, ll mod) -&amp;gt; ll
{
    ll res = 1;
    while (b)
    {
        if (b &amp;amp; 1)
            res = mul(res, a, mod);
        a = mul(a, a, mod);
        b &amp;gt;&amp;gt;= 1;
    }
    return res;
};

auto is_prime = [&amp;amp;](ll x) -&amp;gt; bool
{
    if (x &amp;lt; 2)
        return false;
    for (ll p : {2LL, 3LL, 5LL, 7LL, 11LL, 13LL, 17LL, 19LL, 23LL, 29LL, 31LL, 37LL})
    {
        if (x == p)
            return true;
        if (x % p == 0)
            return false;
    }
    ll d = x - 1, r = 0;
    while (!(d &amp;amp; 1))
        d &amp;gt;&amp;gt;= 1, r++;
    for (ll a : {2LL, 325LL, 9375LL, 28178LL, 450775LL, 9780504LL, 1795265022LL})
    {
        if (a % x == 0)
            continue;
        ll y = qpow(a % x, d, x);
        if (y == 1 || y == x - 1)
            continue;
        bool ok = false;
        for (int i = 1; i &amp;lt; r; i++)
        {
            y = mul(y, y, x);
            if (y == x - 1)
            {
                ok = true;
                break;
            }
        }
        if (!ok)
            return false;
    }
    return true;
};

// TODO: 本接口支持0到LLONG_MAX；完整uint64范围需改为uint64_t和无符号128位模乘。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-14&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.14 BSGS 离散对数算法 (Baby-step Giant-step)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：块大小 $M = \lceil\sqrt{P}\rceil$ 分块哈希，求解 $a^x \equiv b \pmod p$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;
using i128 = __int128_t;

// 求最小非负x使a^x=b(mod m)。要求m&amp;gt;=1、gcd(a,m)=1；返回-1表示无解。
// O(sqrt(m))时间与空间；这不是非互质exBSGS。
ll bsgs(ll a, ll b, ll m) {
    assert(m &amp;gt;= 1);
    if (m == 1) return 0;
    a %= m; if (a &amp;lt; 0) a += m;
    b %= m; if (b &amp;lt; 0) b += m;
    assert(gcd(a, m) == 1);
    auto power = [&amp;amp;](ll x, ll e) {
        ll r = 1;
        while (e) { if (e &amp;amp; 1) r = i128(r) * x % m; x = i128(x) * x % m; e &amp;gt;&amp;gt;= 1; }
        return r;
    };
    ll step = sqrtl((long double)m);
    while (i128(step) * step &amp;lt; m) ++step;
    unordered_map&amp;lt;ll, ll&amp;gt; baby;
    ll cur = 1;
    for (ll j = 0; j &amp;lt; step; ++j) { baby.emplace(cur, j); cur = i128(cur) * a % m; }
    // 扩展欧几里得求(a^step)^(-1)，不假设m为素数。
    i128 r0 = power(a, step), r1 = m, s0 = 1, s1 = 0;
    while (r1) {
        i128 q = r0 / r1, nr = r0 - q * r1, ns = s0 - q * s1;
        r0 = r1; r1 = nr; s0 = s1; s1 = ns;
    }
    ll factor = (s0 % m + m) % m;
    cur = b;
    for (ll i = 0; i &amp;lt;= step; ++i) {
        auto it = baby.find(cur);
        if (it != baby.end()) return ll(i128(i) * step + it-&amp;gt;second);
        cur = i128(cur) * factor % m;
    }
    return -1;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-15&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.15 中国剩余定理 CRT (Chinese Remainder Theorem)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：一般CRT合并接口，正模数可非互质，返回最小非负解和lcm；lcm必须在signed long long内。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;
using i128 = __int128_t;

// 任意正模数，允许非互质。返回{最小非负解,lcm}；无解返回nullopt。
// 约定所有模数的lcm&amp;lt;=LLONG_MAX；超出时抛overflow_error，不静默截断。
optional&amp;lt;pair&amp;lt;ll,ll&amp;gt;&amp;gt; crt(const vector&amp;lt;ll&amp;gt;&amp;amp; residues, const vector&amp;lt;ll&amp;gt;&amp;amp; moduli) {
    assert(residues.size() == moduli.size());
    ll r = 0, m = 1;
    for (size_t i = 0; i &amp;lt; residues.size(); ++i) {
        ll n = moduli[i]; assert(n &amp;gt; 0);
        ll s = residues[i] % n; if (s &amp;lt; 0) s += n;
        i128 a = m, b = n, u = 1, v = 0;
        while (b) {
            i128 q = a / b, nb = a - q * b, nv = u - q * v;
            a = b; b = nb; u = v; v = nv;
        }
        ll g = ll(a), reduced = n / g;
        i128 diff = i128(s) - r;
        if (diff % g) return nullopt;
        i128 step = (diff / g * u) % reduced;
        if (step &amp;lt; 0) step += reduced;
        i128 next_m = i128(m) * reduced;
        if (next_m &amp;gt; LLONG_MAX) throw overflow_error(&quot;CRT lcm exceeds signed 64-bit range&quot;);
        r = (i128(r) + i128(m) * step) % next_m;
        m = ll(next_m);
    }
    return pair&amp;lt;ll,ll&amp;gt;{r,m};
}

// 输入n及n组(模数,余数)，输出最小非负解；无解输出-1。
int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int n; if (!(cin &amp;gt;&amp;gt; n)) return 0;
    vector&amp;lt;ll&amp;gt; r(n), m(n);
    for (int i = 0; i &amp;lt; n; ++i) cin &amp;gt;&amp;gt; m[i] &amp;gt;&amp;gt; r[i];
    auto result = crt(r,m);
    cout &amp;lt;&amp;lt; (result ? result-&amp;gt;first : -1) &amp;lt;&amp;lt; &apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-16&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.16 扩展中国剩余定理 EXCRT (Extended CRT)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：与6.15共用经验证的CRT实现，包含无解与lcm溢出处理。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;
using i128 = __int128_t;

// 任意正模数，允许非互质。返回{最小非负解,lcm}；无解返回nullopt。
// 约定所有模数的lcm&amp;lt;=LLONG_MAX；超出时抛overflow_error，不静默截断。
optional&amp;lt;pair&amp;lt;ll,ll&amp;gt;&amp;gt; crt(const vector&amp;lt;ll&amp;gt;&amp;amp; residues, const vector&amp;lt;ll&amp;gt;&amp;amp; moduli) {
    assert(residues.size() == moduli.size());
    ll r = 0, m = 1;
    for (size_t i = 0; i &amp;lt; residues.size(); ++i) {
        ll n = moduli[i]; assert(n &amp;gt; 0);
        ll s = residues[i] % n; if (s &amp;lt; 0) s += n;
        i128 a = m, b = n, u = 1, v = 0;
        while (b) {
            i128 q = a / b, nb = a - q * b, nv = u - q * v;
            a = b; b = nb; u = v; v = nv;
        }
        ll g = ll(a), reduced = n / g;
        i128 diff = i128(s) - r;
        if (diff % g) return nullopt;
        i128 step = (diff / g * u) % reduced;
        if (step &amp;lt; 0) step += reduced;
        i128 next_m = i128(m) * reduced;
        if (next_m &amp;gt; LLONG_MAX) throw overflow_error(&quot;CRT lcm exceeds signed 64-bit range&quot;);
        r = (i128(r) + i128(m) * step) % next_m;
        m = ll(next_m);
    }
    return pair&amp;lt;ll,ll&amp;gt;{r,m};
}

// 输入n及n组(模数,余数)，输出最小非负解；无解输出-1。
int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int n; if (!(cin &amp;gt;&amp;gt; n)) return 0;
    vector&amp;lt;ll&amp;gt; r(n), m(n);
    for (int i = 0; i &amp;lt; n; ++i) cin &amp;gt;&amp;gt; m[i] &amp;gt;&amp;gt; r[i];
    auto result = crt(r,m);
    cout &amp;lt;&amp;lt; (result ? result-&amp;gt;first : -1) &amp;lt;&amp;lt; &apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-17&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.17 莫比乌斯反演与数论分块 (P3455 ZAP-Queries)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：线性筛预处理 $\mu$ 前缀和，利用整除分块 (数论分块) 在 $O(\sqrt{N})$ 内快速计算 $\sum [\gcd(i, j) = k]$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 50005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
ll k,n,q;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n;
    vector&amp;lt;ll&amp;gt;primes;
    bitset&amp;lt;N+1&amp;gt;vis;
    vector&amp;lt;ll&amp;gt;mu(N+5,0);
    auto init=[&amp;amp;]()
    {
        mu[1]=1;
        for(int i=2;i&amp;lt;=N;i++)
        {
            if(!vis[i]) primes.push_back(i),mu[i]=-1;
            for(auto p:primes)
            {
                if(i*p&amp;gt;N) break;
                vis[i*p]=1;
                if(i%p==0)
                {
                    mu[i*p]=0;
                    break;
                }else {
                    mu[i*p]=-mu[i];
                }
            }
        }
        for(int i=1;i&amp;lt;=N;i++) mu[i]+=mu[i-1];
    };
    init();
    auto cal=[&amp;amp;](ll a,ll b,ll d)
    {
        if(a&amp;gt;b) swap(a,b);
        a/=d,b/=d;
        ll res=0;
        for(ll l=1,r;l&amp;lt;=a;l=r+1)
        {
            r=min(a/(a/l),b/(b/l));
            res+=(mu[r]-mu[l-1])*(a/l)*(b/l);
        }
        return res;
    };
    while(n--)
    {
        ll a,b,d;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;d;
        cout&amp;lt;&amp;lt;cal(a,b,d)&amp;lt;&amp;lt;&apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-18&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.18 Dirichlet 卷积与莫比乌斯反演理论&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：数论函数卷积运算、单位元 $\epsilon$、莫比乌斯函数与欧拉函数转换恒等式 $\mu * id = \varphi$。&lt;/p&gt;
&lt;h3&gt;Dirichlet生成函数&lt;/h3&gt;
&lt;p&gt;$F(x)=\sum_{i=1}^{\infty}\frac{a_{i}}{i^x}$&lt;/p&gt;
&lt;p&gt;其乘法运算运算为
$\sum_{i=1}^{\infty}\frac{a_{i}}{i^x} \sum_{i=1}^{\infty}\frac{b_i}{i^x}=\sum_{i=1}^{\infty}\frac{1}{i^x}\sum_{d|i}^{}a_{d}b_{\frac{i}{d}}$&lt;/p&gt;
&lt;h3&gt;积性函数&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;定义&lt;/strong&gt;
1.$f(1)=1$&lt;/p&gt;
&lt;p&gt;2.当$gcd(a,b)=1$时,有$f(ab)=f(a)f(b)$&lt;/p&gt;
&lt;h3&gt;欧拉函数&lt;/h3&gt;
&lt;p&gt;$\varphi(n)=\sum_{i=1}^{n}[\gcd(i,n)=1]$
&lt;strong&gt;性质&lt;/strong&gt;
$\sum_{d|n}^{}\phi(d)=n$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;不严谨证明&lt;/strong&gt;
对于n的所有真分数集合
$\frac{0}{n},\frac{1}{n},\dots,\frac{n-1}{n}$,其数量显然为n
将其约分,对于分母d,显然有约分后的集合$\frac{a_{1}}{d},\dots \frac{a_{\phi(d)}}{d}$,其中$a_{i}集合为d所有互质的数,$且显然$d|n$
即$\sum_{d|n}^{}\phi(d)=n$,得证&lt;/p&gt;
&lt;h3&gt;莫比乌斯函数&lt;/h3&gt;
&lt;p&gt;定义
$$\mu(n)=\begin{cases}
1,&amp;amp;n=1 \
(-1)^s,&amp;amp;n=p_{1}p_{2}\dots p_{s} \
0, &amp;amp;n包含相同质因子
\end{cases}$$
&lt;strong&gt;性质&lt;/strong&gt;
$\sum_{d|n}^{}\mu(d)=[n=1]$
&lt;strong&gt;证明&lt;/strong&gt;
当n=1时,显然成立
n&amp;gt;1时,由算术基本定理,$n=p_1^{s_1}p_2^{s_2}\dots p_r^{s_r}$
令$n&apos;=p_1p_2\dots p_r$
显然,$\sum_{d|n}\mu(d)=\sum_{d|n&apos;}\mu(d)$
其中 $\sum_{d|n&apos;}\mu(d)=1 + (-1)\binom{r}{1}+(-1)^{2}\binom{r}{2}+\dots +(-1)^r\binom{r}{r}=(1+(-1))^r=0$,得证&lt;/p&gt;
&lt;h3&gt;莫比乌斯函数与欧拉函数联系&lt;/h3&gt;
&lt;p&gt;$$\sum_{d|n}\mu(d) \frac{n}{d}=\phi(n)$$
&lt;strong&gt;证明&lt;/strong&gt;
当$n=1$时显然成立
当$n&amp;gt;1$时,由算术基本定理,$n=p_1^{s_1}p_2^{s_2}\dots p_r^{s_r}$
令$n&apos;=p_1p_2\dots p_r$
则$\sum_{d|n}\mu(d)\frac{n}{d}=n\sum^{}_{d|n&apos;}\frac{\mu(d)}{d}$
展开得 $n(1-(\frac{1}{p_1}+\frac{1}{p_2}+\dots)+(\frac{1}{p_1 p_2} +\frac{1}{p_1 p_3}+\dots)-\dots)$
$=n(1-\frac{1}{p_1})(1-\frac{1}{p_2})\dots(1-\frac{1}{p_n})$
$=\phi(n)$&lt;/p&gt;
&lt;h3&gt;Dirichlet卷积&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;定义&lt;/strong&gt;
$f,g$ 是任意两个算术函数，其 Dirichlet 卷积定义为
$$(f*g)(n)=\sum^{}_{d|n}f(d)g(\frac{n}{d})$$
Dirichlet卷积的意义是取遍n的所有约数对
&lt;strong&gt;规律&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;交换律: $f&lt;em&gt;g=g&lt;/em&gt;f$&lt;/li&gt;
&lt;li&gt;结合律 $f*(g&lt;em&gt;h)=(f&lt;/em&gt;g)*h$&lt;/li&gt;
&lt;li&gt;分配律 $(f+g)&lt;em&gt;h=f&lt;/em&gt;h+g*h$&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;其单位元为$\epsilon(n)=[n=1]$
其他常用函数为$常数函数1(n)=1,恒等函数id(n)=n$&lt;/p&gt;
&lt;h5&gt;常用卷积关系&lt;/h5&gt;
&lt;ol&gt;
&lt;li&gt;$\sum_{d|n} \mu(d) = [n = 1] \iff \mu * 1 = \epsilon$&lt;/li&gt;
&lt;li&gt;$\sum_{d|n} \varphi(d) = n \iff \varphi * 1 = id$&lt;/li&gt;
&lt;li&gt;$\sum_{d|n} \mu(d) \frac{n}{d} = \varphi(n) \iff \mu * id = \varphi$&lt;/li&gt;
&lt;li&gt;$f * \epsilon = f$&lt;/li&gt;
&lt;li&gt;$f * 1 \neq f$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h5&gt;证明&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;1. 证明 $\mu * 1 = \epsilon$：&lt;/strong&gt;
$$(\mu * 1)(n) = \sum_{d|n} \mu(d) 1\left(\frac{n}{d}\right) = \sum_{d|n} \mu(d) = [n = 1] = \epsilon(n)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2. 证明 $\varphi * 1 = id$：&lt;/strong&gt;
$$(\varphi * 1)(n) = \sum_{d|n} \varphi(d) 1\left(\frac{n}{d}\right) = \sum_{d|n} \varphi(d) = n = id(n)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;3. 证明 $\mu * id = \varphi$：&lt;/strong&gt;
$$(\mu * id)(n) = \sum_{d|n} \mu(d) id\left(\frac{n}{d}\right) = \sum_{d|n} \mu(d) \frac{n}{d} = \varphi(n)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;4. 证明 $f * \epsilon = f$：&lt;/strong&gt;
$$(f * \epsilon)(n) = \sum_{d|n} f(d) \epsilon\left(\frac{n}{d}\right) = \sum_{d|n} f(d) \left[\frac{n}{d} = 1\right] = f(n)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;5. 关于 $f * 1$：&lt;/strong&gt;
$$(f * 1)(n) = \sum_{d|n} f(d) 1\left(\frac{n}{d}\right) = \sum_{d|n} f(d)$$&lt;/p&gt;
&lt;h3&gt;莫比乌斯反演 (Möbius Inversion)&lt;/h3&gt;
&lt;h6&gt;核心公式&lt;/h6&gt;
&lt;p&gt;$$f(n) = \sum_{d|n} g(d) \iff g(n) = \sum_{d|n} \mu(d) f\left(\frac{n}{d}\right)$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$f,g$ 为任意算术函数，不要求积性；若二者积性，其卷积也积性。&lt;/li&gt;
&lt;li&gt;$f(n)$ 称为 $g(n)$ 的&lt;strong&gt;莫比乌斯变换&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;$g(n)$ 称为 $f(n)$ 的&lt;strong&gt;莫比乌斯逆变换&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h6&gt;证明方法（利用迪利克雷卷积）&lt;/h6&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;充分性证明&lt;/strong&gt;：
若 $f = g * 1$，则：
$$\mu * f = \mu * g * 1 = g * \mu * 1 = g * \epsilon = g$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必要性证明&lt;/strong&gt;：
若 $g = \mu * f$，则：
$$g * 1 = \mu * f * 1 = f * \mu * 1 = f * \epsilon = f$$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-19&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.19 异或线性基 (Linear Basis)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：高位贪心插入维护一组异或空间基底，支持最大异或和与子集异或判定。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define N 1000050
#define lc p&amp;lt;&amp;lt;1
#define rc p&amp;lt;&amp;lt;1|1
#define ll long long

using namespace std;
vector&amp;lt;ll&amp;gt;bas;
int gassu(int n)
{
    int k=1;
    for(int j=62;j&amp;gt;=0;j--)
    {
        for(int i=k;i&amp;lt;=n;i++)
        {
            if(bas[i]&amp;gt;&amp;gt;j&amp;amp;1)
            {
                swap(bas[i],bas[k]);
                break;
            }
        }
        if(!(bas[k]&amp;gt;&amp;gt;j&amp;amp;1)) continue;
        for(int i=1;i&amp;lt;=n;i++)
        {
            if(i==k) continue;
            if(bas[i]&amp;gt;&amp;gt;j&amp;amp;1) bas[i]^=bas[k];
        }
        k++;
        if(k==n+1) break;
    }
    return k;
}
int main(){
    int n,q;
    char flag;
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cin&amp;gt;&amp;gt;n;
    bas.resize(n+10,{});
    for(int i=1;i&amp;lt;=n;i++)
    {
        cin&amp;gt;&amp;gt;bas[i];
    }
    ll ans=0;
    int k=gassu(n);
    for(int i=1;i&amp;lt;k;i++)
    {
        ans^=bas[i];
    }
    cout&amp;lt;&amp;lt;ans;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-20&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.20 K 个数的异或最大/特定统计&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：异或线性基在序列查询与特定值统计中的变形拓展。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define N 1000050
#define lc p&amp;lt;&amp;lt;1
#define rc p&amp;lt;&amp;lt;1|1
#define ll long long

using namespace std;
vector&amp;lt;ll&amp;gt;bas;
int t,q;
int gassu(int n)
{
    int k=1;
    for(int i=63;i&amp;gt;=0;i--)
    {
        for(int j=k;j&amp;lt;=n;j++)
        {
            if(bas[j]&amp;gt;&amp;gt;i&amp;amp;1)
            {
                swap(bas[j],bas[k]);
                break;
            }
        }
        if(!(bas[k]&amp;gt;&amp;gt;i&amp;amp;1)) continue;
        for(int j=1;j&amp;lt;=n;j++)
        {
            if(j==k) continue;
            if(bas[j]&amp;gt;&amp;gt;i&amp;amp;1)
                bas[j]^=bas[k];
        }
        k++;
        if(k==n+1)
            break;
    }
    return k-1;
}
int main(){
    int n,q;
    char flag;
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cin&amp;gt;&amp;gt;t;
    for(int tt=1;tt&amp;lt;=t;tt++)
    {
        cout&amp;lt;&amp;lt;&quot;Case #&quot;&amp;lt;&amp;lt;tt&amp;lt;&amp;lt;&quot;:\n&quot;;
        cin&amp;gt;&amp;gt;n;
        bas.assign(n+10,{});
        for(int i=1;i&amp;lt;=n;i++)
        {
            cin&amp;gt;&amp;gt;bas[i];
        }
        ll k=gassu(n);
        cin&amp;gt;&amp;gt;q;
        for(int i=1;i&amp;lt;=q;i++)
        {
            ll x;
            cin&amp;gt;&amp;gt;x;
            if(k!=n) x--;
            if(x&amp;gt;=(1ULL&amp;lt;&amp;lt;k)) cout&amp;lt;&amp;lt;-1&amp;lt;&amp;lt;&apos;\n&apos;;
            else
            {
                ll ans=0;
                for(int j=0;j&amp;lt;k;j++)
                {
                    if(x&amp;gt;&amp;gt;j&amp;amp;1) ans^=bas[k-j];
                }
                cout&amp;lt;&amp;lt;ans&amp;lt;&amp;lt;&apos;\n&apos;;
            }
        }
    }

    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-21&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.21 逆序对统计 (树状数组 / 归并排序求法)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：使用树状数组离散化统计序列反序对数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 500005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
class fenwick_tree
{
    public:
    int tree[N],n;//tree[i] 代表了i上有没有元素存在
    int lowbit(int x){return x&amp;amp;-x;};

    void change(int x)
    {
        while(x&amp;lt;=n)
        {
            tree[x]++;
            x+=lowbit(x);
        }
    }
    ll sum(int x)
    {
        ll ans=0;
        while(x)
        {
            ans+=tree[x];
            x-=lowbit(x);
        }
        return ans;
    }
}t;
int n;
struct kk
{
    int v,pos;

}s[N];
bool cmp(kk a,kk b)
{
    if(a.v==b.v) return a.pos&amp;gt;b.pos;
    else return a.v&amp;gt;b.v;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n;
    t.n=n;
    for(int i=1;i&amp;lt;=n;i++)
    {
        s[i].pos=i;
        cin&amp;gt;&amp;gt;s[i].v;
    }
    sort(s+1,s+n+1,cmp);
    ll ans=0;
    for(int i=1;i&amp;lt;=n;i++)
    {
        ans+=t.sum(s[i].pos-1);
        t.change(s[i].pos);
    }
    cout&amp;lt;&amp;lt;ans;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-22&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.22 高精度乘法（幂的数位统计实例）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：非负十进制大整数乘法类；原实例指数n&amp;gt;=1，主程序输出奇数位数减偶数位数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 9999
#define sp &amp;lt;&amp;lt; &quot; &quot;&amp;lt;&amp;lt;
#define mp make_pair
#define pr pair&amp;lt;ll,ll&amp;gt;
#define MOD 998244353
using namespace std;

ll n,m,b,sum,a,c,max_,cnt;
ll ans1,ans2,ans3;
ll k;



class large{
    public:
        vector &amp;lt;int&amp;gt;num;
        int len;

    large(string s)
    {
        reverse(s.begin(),s.end());
        for(auto x:s) num.push_back(x-&apos;0&apos;);
        len=s.length();
    }

    large operator *(const large&amp;amp; other) const{
        vector &amp;lt;int&amp;gt;tem(len+other.len+1,0);
        for(int i=0;i&amp;lt;len;i++)
        for(int j=0;j&amp;lt;other.len;j++)
        {
            tem[i+j]+=num[i]*other.num[j];
            tem[i+j+1]+=tem[i+j]/10;
            tem[i+j]%=10;
        }
        while(tem.back()==0&amp;amp;&amp;amp;tem.size()!=1) tem.pop_back();
        // reverse(tem.begin(),tem.end());
        string s;
        for(auto x:tem) s.push_back(x+&apos;0&apos;);
        reverse(s.begin(),s.end());
        large tt(s);
        return tt;
    }

};



int main()
{
    string a;
    cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;n;

    large s(a);
    large t(a);
    for(int i=1;i&amp;lt;n;i++)
    {
        s=s*t;
    }
    for(auto x:s.num)
    {
        if((x)%2) cnt++;
        else sum++;
    }
    cout&amp;lt;&amp;lt;cnt-(sum);
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-23&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.23 有界生成函数计数（滑动窗口DP）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：变量上下界非负，求恰好总量m的精确方案数；滑动窗口DP，自带非负大整数加减，无第三方依赖。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// 本题只需要非负大整数的加减，无第三方依赖。
struct BigCount {
    static constexpr int BASE=1000000000;
    vector&amp;lt;int&amp;gt;d;
    BigCount(long long x=0){do{d.push_back(x%BASE);x/=BASE;}while(x);}
    BigCount&amp;amp; operator+=(const BigCount&amp;amp;o){
        long long carry=0;size_t n=max(d.size(),o.d.size());d.resize(n);
        for(size_t i=0;i&amp;lt;n||carry;++i){if(i==d.size())d.push_back(0);long long x=d[i]+carry+(i&amp;lt;o.d.size()?o.d[i]:0LL);d[i]=x%BASE;carry=x/BASE;}return *this;
    }
    BigCount&amp;amp; operator-=(const BigCount&amp;amp;o){
        int borrow=0;
        for(size_t i=0;i&amp;lt;d.size();++i){long long x=(long long)d[i]-borrow-(i&amp;lt;o.d.size()?o.d[i]:0LL);borrow=x&amp;lt;0;if(borrow)x+=BASE;d[i]=x;}
        assert(!borrow);while(d.size()&amp;gt;1&amp;amp;&amp;amp;d.back()==0)d.pop_back();return *this;
    }
    bool operator==(long long x)const{return d==BigCount(x).d;}
    friend ostream&amp;amp;operator&amp;lt;&amp;lt;(ostream&amp;amp;out,const BigCount&amp;amp;x){out&amp;lt;&amp;lt;x.d.back();char old=out.fill(&apos;0&apos;);for(int i=int(x.d.size())-2;i&amp;gt;=0;--i)out&amp;lt;&amp;lt;setw(9)&amp;lt;&amp;lt;x.d[i];out.fill(old);return out;}
};
// 每种物品数量在[l_i,r_i]，求总数量恰为m的方案数；非负上下界。
// O(n*m)次大整数加减；滑动窗口维护上一层可贡献的总量。
BigCount bounded_composition(const vector&amp;lt;pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;amp; bounds,int m){
    assert(m&amp;gt;=0);vector&amp;lt;BigCount&amp;gt;dp(m+1),next(m+1);dp[0]=1;
    for(auto[l,r]:bounds){
        assert(0&amp;lt;=l&amp;amp;&amp;amp;l&amp;lt;=r);BigCount window=0;
        for(int s=0;s&amp;lt;=m;++s){
            if(s&amp;gt;=l)window+=dp[s-l];
            if(s&amp;gt;r)window-=dp[s-r-1];
            next[s]=window;
        }
        dp.swap(next);
    }
    return dp[m];
}
int main(){int n,m;while(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m){vector&amp;lt;pair&amp;lt;int,int&amp;gt;&amp;gt;b(n);for(auto&amp;amp;[l,r]:b)cin&amp;gt;&amp;gt;l&amp;gt;&amp;gt;r;cout&amp;lt;&amp;lt;bounded_composition(b,m)&amp;lt;&amp;lt;&apos;\n&apos;;}}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-24&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.24 卡特兰与括号前缀补全&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：合法括号串的前缀补全实例，反射原理O(total)预处理；total&amp;lt;1e9+7且能开数组。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;const ll MOD=1000000007;
// 长度为total的合法括号串，必须以前缀s开头。要求0&amp;lt;=total&amp;lt;MOD且可开数组。
ll complete_brackets(int total,const string&amp;amp;s){
    if(total&amp;lt;0||int(s.size())&amp;gt;total)return 0;
    int b=0;for(char c:s){assert(c==&apos;(&apos;||c==&apos;)&apos;);b+=c==&apos;(&apos;?1:-1;if(b&amp;lt;0)return 0;}
    int rem=total-int(s.size());if(rem&amp;lt;b||(rem-b)%2)return 0;
    assert(total&amp;lt;MOD);
    auto power=[](ll a,ll e){ll r=1;while(e){if(e&amp;amp;1)r=r*a%MOD;a=a*a%MOD;e&amp;gt;&amp;gt;=1;}return r;};
    vector&amp;lt;ll&amp;gt;fac(rem+1,1),inv(rem+1,1);
    for(int i=1;i&amp;lt;=rem;++i)fac[i]=fac[i-1]*i%MOD;
    inv[rem]=power(fac[rem],MOD-2);for(int i=rem;i;--i)inv[i-1]=inv[i]*i%MOD;
    auto C=[&amp;amp;](int k){return k&amp;lt;0||k&amp;gt;rem?0:fac[rem]*inv[k]%MOD*inv[rem-k]%MOD;};
    int up=(rem-b)/2;return (C(up)-C(up-1)+MOD)%MOD;
}
int main(){int n;string s;if(!(cin&amp;gt;&amp;gt;n))return 0;cin&amp;gt;&amp;gt;s;cout&amp;lt;&amp;lt;complete_brackets(n,s)&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-25&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.25 康托展开与逆康托展开 (Cantor Expansion / Obsidian / 知乎)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：1..n互异排列的排名/逆排名，1-based rank，n&amp;lt;=20，rank在1..n!内。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bit&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iterator&amp;gt;
#include &amp;lt;set&amp;gt;
#include &amp;lt;tuple&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#define N 2000005
#define inf 0x3f3f3f3f3f3f3f3f
#define ll unsigned long long
#define pr pair&amp;lt;int, int&amp;gt;
#define i128 __int128
using namespace std;
ll n, m, q, ans, ma, t, product, k;
const ll mod = 1000000007;
ll f[N];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    vector&amp;lt;ll&amp;gt; f(30);
    vector&amp;lt;int&amp;gt; tem;
    f[0] = 1;
    for (ll i = 1; i &amp;lt;= 20; i++)
        f[i] = f[i - 1] * i;
    cin &amp;gt;&amp;gt; t;
    auto reset = [&amp;amp;](int n) {
        tem.clear();
        for (int i = 1; i &amp;lt;= n; i++)
            tem.push_back(i);
        ;
    };
    auto find = [&amp;amp;](int n, ll k) {
        k--;
        reset(n);
        vector&amp;lt;int&amp;gt; res;
        for (int i = n - 1; i &amp;gt;= 0; i--) {
            auto x = k / (f[i]);
            k %= (f[i]);
            res.push_back(tem[x]);
            tem.erase(tem.begin() + x);
        }
        return res;
    };
    auto cal = [&amp;amp;](int n, vector&amp;lt;ll&amp;gt; &amp;amp;p) -&amp;gt; ll {
        reset(n);
        int cnt = n - 1;
        ll res = 0;

        for (auto num : p) {
            auto pos = lower_bound(tem.begin(), tem.end(), num) - tem.begin();
            res += f[cnt--] * pos;
            tem.erase(tem.begin() + pos);
        }
        return res;
    };
    while (t--) {
        int flag;
        cin &amp;gt;&amp;gt; flag;
        if (flag == 1) {
            cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k;
            auto res = find(n, k);
            for (auto x : res)
                cout &amp;lt;&amp;lt; x &amp;lt;&amp;lt; &apos; &apos;;
            cout &amp;lt;&amp;lt; &apos;\n&apos;;
        } else {
            cin &amp;gt;&amp;gt; n;
            vector&amp;lt;ll&amp;gt; t;
            for (int i = 1; i &amp;lt;= n; i++) {
                ll x;
                cin &amp;gt;&amp;gt; x, t.push_back(x);
            }
            cout &amp;lt;&amp;lt; cal(n, t) + 1 &amp;lt;&amp;lt; &apos;\n&apos;;
        }
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-26&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.26 斯特林数 (Stirling Numbers / 递推与组合意义)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：第一类与第二类斯特林数的递推公式、圆排列与盒子放球模型。&lt;/p&gt;
&lt;h3&gt;斯特林数 (Stirling Numbers)&lt;/h3&gt;
&lt;h5&gt;第一类斯特林数（斯特林轮换数）&lt;/h5&gt;
&lt;p&gt;将 $n$ 个不同元素，划分为 $m$ 个非空圆排列的方案数，记作 $\begin{bmatrix} n \ m \end{bmatrix}$ 或 $s(n, m)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;递推式&lt;/strong&gt;：
$$
\begin{bmatrix} n \ m \end{bmatrix} = \begin{bmatrix} n - 1 \ m - 1 \end{bmatrix} + (n - 1) \begin{bmatrix} n - 1 \ m \end{bmatrix}
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;组合意义&lt;/strong&gt;：
$n$ 个人坐 $m$ 张圆桌的方案数。考虑第 $n$ 个人：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若单独坐一桌，前面 $n-1$ 人坐 $m-1$ 张桌子，方案数为 $\begin{bmatrix} n-1 \ m-1 \end{bmatrix}$；&lt;/li&gt;
&lt;li&gt;若坐到已有人的桌子上，先让前 $n-1$ 个人坐 $m$ 张桌子，第 $n$ 个人可以坐到这 $n-1$ 个人中任意一个人的左边，方案数为 $(n-1) \begin{bmatrix} n-1 \ m \end{bmatrix}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h5&gt;第二类斯特林数（斯特林子集数）&lt;/h5&gt;
&lt;p&gt;将 $n$ 个不同元素，划分为 $m$ 个非空子集的方案数，记作 $\begin{Bmatrix} n \ m \end{Bmatrix}$ 或 $S(n, m)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;递推式&lt;/strong&gt;：
$$
\begin{Bmatrix} n \ m \end{Bmatrix} = \begin{Bmatrix} n - 1 \ m - 1 \end{Bmatrix} + m \begin{Bmatrix} n - 1 \ m \end{Bmatrix}
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;组合意义&lt;/strong&gt;：
$n$ 个不同的小球放入 $m$ 个无标号盒子的方案数。考虑第 $n$ 个小球：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若单独放入一个新盒子，前面 $n-1$ 个球放入 $m-1$ 个盒子，方案数为 $\begin{Bmatrix} n-1 \ m-1 \end{Bmatrix}$；&lt;/li&gt;
&lt;li&gt;若放入已有球的盒子中，前面 $n-1$ 个球已放入 $m$ 个盒子，第 $n$ 个球有 $m$ 种选择，方案数为 $m \begin{Bmatrix} n-1 \ m \end{Bmatrix}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;容斥通项公式&lt;/strong&gt;：
$$
\begin{Bmatrix} n \ m \end{Bmatrix} = \frac{1}{m!} \sum_{i=0}^m (-1)^{m-i} \binom{m}{i} i^n
$$&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;经典应用一：P4609 [FJOI2016] 建筑师&lt;/h4&gt;
&lt;p&gt;高度为 $n$ 的建筑是一个分水岭，在它左边有 $a-1$ 个建筑群（每个建筑群左边一个最高建筑，剩下的建筑自由排列，数量等于圆排列的数量），在它右边有 $b-1$ 个建筑群。每个建筑群构成一个圆排列，共计 $a+b-2$ 个圆排列。即把 $n-1$ 个建筑划分成 $a+b-2$ 个圆排列，即 $\begin{bmatrix} n-1 \ a+b-2 \end{bmatrix}$。然后从圆排列数中拿出 $a-1$ 个放在 $n$ 的左边，即 $\binom{a+b-2}{a-1}$。&lt;/p&gt;
&lt;p&gt;答案：$\begin{bmatrix} n-1 \ a+b-2 \end{bmatrix} \times \binom{a+b-2}{a-1}$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 50005
#define M 205
using namespace std;
ll t;
ll c[N][M];
ll s[N][M];
const int mod = 1e9 + 7;
void init() {
    for (int i = 0; i &amp;lt; N; i++) {
        c[i][0] = 1;
        s[i][0] = (i == 0 ? 1 : 0);
    }
    for (int i = 1; i &amp;lt; N; i++) {
        for (int j = 1; j &amp;lt; M; j++) {
            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
        }
    }
    for (int i = 1; i &amp;lt; N; i++) {
        for (int j = 1; j &amp;lt; M; j++) {
            s[i][j] = (s[i - 1][j - 1] + (i - 1) * s[i - 1][j]) % mod;
        }
    }
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    init();
    cin &amp;gt;&amp;gt; t;
    while (t--) {
        ll n, a, b;
        cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b;
        if (a + b - 2 &amp;gt;= M || a + b - 2 &amp;lt; 0) {
            cout &amp;lt;&amp;lt; 0 &amp;lt;&amp;lt; &apos;\n&apos;;
            continue;
        }
        cout &amp;lt;&amp;lt; (s[n - 1][a + b - 2] * c[a + b - 2][a - 1]) % mod &amp;lt;&amp;lt; &apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h4&gt;经典应用二：第二类斯特林数递推与高精度 (P3904)&lt;/h4&gt;
&lt;p&gt;将 $n$ 个互不相同的元素划分为 $m$ 个非空集合的方案数，递推关系 $S(i, j) = S(i-1, j-1) + j \cdot S(i-1, j)$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// 高精度整数辅助类
struct BigInt {
    vector&amp;lt;int&amp;gt; a;
    BigInt(long long v = 0) {
        if (v == 0)
            a.push_back(0);
        while (v &amp;gt; 0) {
            a.push_back(v % 10);
            v /= 10;
        }
    }
    BigInt operator+(const BigInt &amp;amp;o) const {
        BigInt c;
        c.a.clear();
        int carry = 0, n = max(a.size(), o.a.size());
        for (int i = 0; i &amp;lt; n || carry; i++) {
            if (i &amp;lt; a.size())
                carry += a[i];
            if (i &amp;lt; o.a.size())
                carry += o.a[i];
            c.a.push_back(carry % 10);
            carry /= 10;
        }
        return c;
    }
    BigInt operator*(int m) const {
        BigInt c;
        c.a.clear();
        long long carry = 0;
        for (int i = 0; i &amp;lt; a.size() || carry; i++) {
            if (i &amp;lt; a.size())
                carry += 1LL * a[i] * m;
            c.a.push_back(carry % 10);
            carry /= 10;
        }
        while (c.a.size() &amp;gt; 1 &amp;amp;&amp;amp; c.a.back() == 0)
            c.a.pop_back();
        return c;
    }
    void print() const {
        for (int i = (int)a.size() - 1; i &amp;gt;= 0; i--)
            cout &amp;lt;&amp;lt; a[i];
        cout &amp;lt;&amp;lt; &apos;\n&apos;;
    }
};
BigInt S[105][105];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    int n, m;
    if (!(cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m))
        return 0;
    S[0][0] = BigInt(1);
    for (int i = 1; i &amp;lt;= n; i++) {
        for (int j = 1; j &amp;lt;= m; j++) {
            S[i][j] = S[i - 1][j - 1] + S[i - 1][j] * j;
        }
    }
    S[n][m].print();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-6-27&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;6.27 错排问题 (Derangement)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：错排递推公式 $D_n = (n-1)(D_{n-1} + D_{n-2})$ 与容斥原理推导。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// D(0)=1,D(1)=0；非负n，模数为正。中间乘法使用128位。
long long derangement(int n,long long mod=1000000007){
    assert(n&amp;gt;=0&amp;amp;&amp;amp;mod&amp;gt;0);long long a=1%mod,b=0;if(n==0)return a;
    for(int i=2;i&amp;lt;=n;++i){long long c=(__int128)(i-1)*((__int128)a+b)%mod;a=b;b=c;}return b;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-7&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第七章 计算几何&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.1 二维向量与点类基础结构 (Point &amp;amp; Vector)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：点与向量运算重载、点积 (&lt;code&gt;dot&lt;/code&gt;)、叉积 (&lt;code&gt;cross&lt;/code&gt; / &lt;code&gt;cross3&lt;/code&gt;)、模长 (&lt;code&gt;len&lt;/code&gt;)、符号函数 (&lt;code&gt;sgn&lt;/code&gt;)。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct Point
{
    double x, y;
    Point operator + (const Point &amp;amp;o) const { return {x + o.x, y + o.y}; }
    Point operator - (const Point &amp;amp;o) const { return {x - o.x, y - o.y}; }
    Point operator * (double k) const { return {x * k, y * k}; }
};

auto dot = [&amp;amp;](Point a, Point b) -&amp;gt; double
{
    return a.x * b.x + a.y * b.y;
};
auto cross = [&amp;amp;](Point a, Point b) -&amp;gt; double
{
    return a.x * b.y - a.y * b.x;
};
auto cross3 = [&amp;amp;](Point a, Point b, Point c) -&amp;gt; double
{
    return cross(b - a, c - a);
};
auto len = [&amp;amp;](Point a) -&amp;gt; double
{
    return sqrt(dot(a, a));
};
auto sgn = [&amp;amp;](double x) -&amp;gt; int
{
    const double EPS = 1e-9;
    return (x &amp;gt; EPS) - (x &amp;lt; -EPS);
};

// TODO: 点、向量、线段关系均建立在这些基础运算上。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.2 整数点极角排序（128位叉积）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：原点在前、从正x轴逆时针排序，同向按距离；坐标建议绝对值&amp;lt;=10^12。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
struct PolarPoint{long long x,y;};
// 整数坐标，建议绝对值&amp;lt;=10^12；原点放最前，同向按距离递增。
void polar_sort(vector&amp;lt;PolarPoint&amp;gt;&amp;amp;p,PolarPoint origin={0,0}){
    using I=__int128_t;
    sort(p.begin(),p.end(),[&amp;amp;](PolarPoint a,PolarPoint b){
        I x=I(a.x)-origin.x,y=I(a.y)-origin.y,u=I(b.x)-origin.x,v=I(b.y)-origin.y;
        bool az=x==0&amp;amp;&amp;amp;y==0,bz=u==0&amp;amp;&amp;amp;v==0;
        if(az||bz)return az&amp;amp;&amp;amp;!bz;
        bool ha=y&amp;gt;0||(y==0&amp;amp;&amp;amp;x&amp;gt;=0),hb=v&amp;gt;0||(v==0&amp;amp;&amp;amp;u&amp;gt;=0);
        if(ha!=hb)return ha&amp;gt;hb;
        I c=x*v-y*u;if(c)return c&amp;gt;0;
        return x*x+y*y&amp;lt;u*u+v*v;
    });
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.3 Andrew 二维凸包算法 (Convex Hull)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：按 $x$ 坐标排序后分上下凸壳分别单调栈维护，生成二维点集的凸多边形外包。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// 依赖：Point、cross3；points 为待处理点集。
sort(points.begin(), points.end(), [&amp;amp;](Point a, Point b)
{
    if (a.x != b.x)
        return a.x &amp;lt; b.x;
    return a.y &amp;lt; b.y;
});
points.erase(unique(points.begin(), points.end(), [&amp;amp;](Point a, Point b)
{
    return fabs(a.x - b.x) &amp;lt; 1e-9 &amp;amp;&amp;amp; fabs(a.y - b.y) &amp;lt; 1e-9;
}), points.end());

vector&amp;lt;Point&amp;gt; hull;
for (auto p : points)
{
    while (hull.size() &amp;gt;= 2 &amp;amp;&amp;amp; cross3(hull[hull.size() - 2], hull.back(), p) &amp;lt;= 0)
        hull.pop_back();
    hull.push_back(p);
}
int lower_size = hull.size();
for (int i = (int)points.size() - 2; i &amp;gt;= 0; i--)
{
    auto p = points[i];
    while ((int)hull.size() &amp;gt; lower_size &amp;amp;&amp;amp; cross3(hull[hull.size() - 2], hull.back(), p) &amp;lt;= 0)
        hull.pop_back();
    hull.push_back(p);
}
if (hull.size() &amp;gt; 1)
    hull.pop_back();
// TODO: &amp;lt;= 保留严格凸包；需要保留边界共线点时调整判断。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.4 Andrew 凸包独立实现 (带周长与多边形面积计算)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：包含凸包完整点集排序、周长求和与面积计算的独立代码。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;double,double&amp;gt;
using namespace std;
ll n,ans,top;
pr s[N];
pr sta[N];
double cal(pr a,pr b,pr c)
{
    return (b.first-a.first)*(c.second-a.second)-(b.second-a.second)*(c.first-a.first);
}
double len(pr a,pr b)
{
    double tem1=a.first-b.first;
    double tem2=a.second-b.second;
    return sqrt(tem1*tem1+tem2*tem2);
}
double andrew()
{
    top=0;
    sort(s+1,s+n+1);
    for(int i=1;i&amp;lt;=n;i++)
    {
        while(top&amp;gt;1 &amp;amp;&amp;amp;cal(sta[top-1],sta[top],s[i])&amp;lt;=0) top--;
        sta[++top]=s[i];
    }
    int t=top;
    for(int i=n-1;i&amp;gt;=1;i--)
    {
        while(top&amp;gt;t &amp;amp;&amp;amp;cal(sta[top-1],sta[top],s[i])&amp;lt;=0) top--;
        sta[++top]=s[i];
    }
    double ans=0;
    for(int i=1;i&amp;lt;top;i++)
    {
        ans+=len(sta[i],sta[i+1]);

    }
    return ans;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n;
    for(int i=1;i&amp;lt;=n;i++)
    {
        double a,b;
        cin&amp;gt;&amp;gt;s[i].first&amp;gt;&amp;gt;s[i].second;
    }
    double ans=andrew();
    ans=ans*100;
    ans=round(ans);
    ans=ans/100;
    cout&amp;lt;&amp;lt;fixed&amp;lt;&amp;lt;setprecision(2)&amp;lt;&amp;lt;ans;
    return 0;
}

// 1. 叉积的计算
// 代码中的 cross 函数如下：
// code
// C++
// double cross(Point a, Point b, Point c){
//     return (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);
// }
// 这个公式看起来有点复杂，但如果我们用向量来理解就非常清晰了。
// 首先，我们定义两个向量，都以点 a 为起点：
// 向量 AB = (b.x - a.x, b.y - a.y)
// 向量 AC = (c.x - a.x, c.y - a.y)
// 然后，我们将这两个向量代入公式：
// (b.x - a.x) 就是向量 AB 的 x 分量。
// (c.y - a.y) 就是向量 AC 的 y 分量。
// (b.y - a.y) 就是向量 AB 的 y 分量。
// (c.x - a.x) 就是向量 AC 的 x 分量。
// 所以，这个公式实际上计算的是：
// cross(a, b, c) = (AB.x * AC.y) - (AB.y * AC.x)
// 这就是二维向量 AB 和 AC 的叉积。
// 2. 叉积的几何意义（这部分是关键！）
// 叉积的结果是一个数值（标量），这个值的正负号有非常重要的几何意义。它告诉我们向量 AC 相对于向量 AB 的方向，或者说，点 C 相对于有向线段 AB 的位置。
// 想象你站在点 a，面朝点 b 的方向：
// cross(a, b, c) &amp;gt; 0
// 这意味着向量 AC 在向量 AB 的逆时针方向。
// 换句话说，点 c 在有向直线 ab 的左侧。
// 从 a 到 b 再到 c 形成一个“左转”。
// cross(a, b, c) &amp;lt; 0
// 这意味着向量 AC 在向量 AB 的顺时针方向。
// 换句话- 话说，点 c 在有向直线 ab 的右侧。
// 从 a 到 b 再到 c 形成一个“右转”。
// cross(a, b, c) = 0
// 这意味着向量 AB 和 AC 共线。
// 换句话说，点 a、b、c 在同一条直线上。
// 3. 在 Andrew 算法中的应用
// Andrew 算法通过维护一个栈来构建凸包。在遍历所有点时，我们需要判断新加入的点是否会使已形成的凸包“向内凹陷”。这个判断就是通过叉积来完成的。
// 让我们看一下算法中求下凸包的核心代码：
// code
// C++
// // s[] 是维护凸包的栈, top 是栈顶指针
// // p[i] 是当前要考虑的新点
// while(top &amp;gt; 1 &amp;amp;&amp;amp; cross(s[top-1], s[top], p[i]) &amp;lt;= 0) {
//     top--; // 弹出栈顶
// }
// s[++top] = p[i]; // 新点入栈
// 这里的 cross(s[top-1], s[top], p[i]) 是在做什么呢？
// s[top-1] 是栈顶下面的那个点（我们称之为 A）。
// s[top] 是栈顶的点（我们称之为 B）。
// p[i] 是当前要考察的新点（我们称之为 C）。
// 这个 while 循环的条件 cross(A, B, C) &amp;lt;= 0 意味着：
// 从路径 A -&amp;gt; B -&amp;gt; C 形成了一个右转（结果 &amp;lt; 0）或者三点共线（结果 = 0）。
// 为什么出现这种情况就要弹出栈顶？
// 因为凸包的边界在逆时针前进时，每一步都应该是左转。如果新加入的点 C 导致了 A-&amp;gt;B-&amp;gt;C 是一个右转，说明点 B 在新的凸包的内部，它不再是凸包的顶点了，所以必须把它从栈中弹出 (top--)。
// 算法会一直弹出栈顶，直到 A-&amp;gt;B-&amp;gt;C 形成一个左转 (cross &amp;gt; 0)，这时才安全地将新点 C 加入栈中，维持了凸包的“凸”性。
// 总结一下：
// 这个 cross 函数通过计算两个向量的叉积，来判断三个点的相对位置关系（左转、右转或共线）。这是在构建凸包时，决定一个点是否应该被保留在凸包边界上的关键依据。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.5 二维凸包 (CSES g_andrew.cpp 实战版)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：128位叉积，保留凸包边界共线点；重复点只输出一次，全共线时输出按字典序排序的全部点。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#include &amp;lt;type_traits&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#include &amp;lt;utility&amp;gt;
#define N 1000005
#define pr pair&amp;lt;ll,ll&amp;gt;
#define ll __int128
using namespace std;
long long  n,m,ans,x;
const ll mod=1e9+7;
class Point
{
    public:
    ll x=0,y=0;
    ll operator *(const Point &amp;amp;oth) const
    {
        return x*oth.x+y*oth.y;
    }
    ll operator ^(const Point &amp;amp;oth) const
    {
        return x*oth.y-y*oth.x;
    }
    Point operator +(const Point &amp;amp;oth) const
    {
        return {x+oth.x,y+oth.y};
    }
    Point operator -(const Point &amp;amp;oth)
    {
        return {x-oth.x,y-oth.y};
    }
    ll dis(const Point &amp;amp;oth)
    {
        return (x-oth.x)*(x-oth.x)+(y-oth.y)*(y-oth.y);
    }
    bool operator&amp;lt;(const Point&amp;amp;oth)
    {
        return make_pair(x, y)&amp;lt;make_pair(oth.x, oth.y);
    }
};
ll cross(Point a,Point b,Point c)
{
    return (b-a)^(c-a);
};
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n;
    vector&amp;lt;Point&amp;gt;s;
    int id=0;
    for(int i=1;i&amp;lt;=n;i++)
    {
        long long x,y;
        cin&amp;gt;&amp;gt;x&amp;gt;&amp;gt;y;
        s.push_back({x,y});
    }
    sort(s.begin(),s.end());
    s.erase(unique(s.begin(),s.end(),[](const Point&amp;amp;a,const Point&amp;amp;b){return a.x==b.x&amp;amp;&amp;amp;a.y==b.y;}),s.end());
    n=s.size();
    bool collinear=true;
    for(int i=2;i&amp;lt;n;i++) if(cross(s[0],s[1],s[i])!=0) collinear=false;
    if(n&amp;lt;=2||collinear){cout&amp;lt;&amp;lt;n&amp;lt;&amp;lt;&apos;\n&apos;;for(auto p:s)cout&amp;lt;&amp;lt;(long long)p.x&amp;lt;&amp;lt;&apos; &apos;&amp;lt;&amp;lt;(long long)p.y&amp;lt;&amp;lt;&apos;\n&apos;;return 0;}

    vector&amp;lt;Point&amp;gt;sta;
    for(int i=0;i&amp;lt;n;i++)
    {
        auto x=s[i];
        while(sta.size()&amp;gt;1 &amp;amp;&amp;amp;cross(sta[sta.size()-2], sta[sta.size()-1],x)&amp;lt;0) sta.pop_back();
        sta.push_back(x);
    }
    int t=sta.size();
    for(int i=n-2;i&amp;gt;=0;i--)
    {
        auto x=s[i];
        while(sta.size()&amp;gt;t &amp;amp;&amp;amp;cross(sta[sta.size()-2], sta[sta.size()-1],x)&amp;lt;0) sta.pop_back();
        sta.push_back(x);
    }
    sta.pop_back();
    cout&amp;lt;&amp;lt;sta.size()&amp;lt;&amp;lt;&apos;\n&apos;;
    for(auto x:sta)
    {
        cout&amp;lt;&amp;lt;(long long)x.x&amp;lt;&amp;lt;&apos; &apos;&amp;lt;&amp;lt;(long long)x.y&amp;lt;&amp;lt;&apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.6 半平面交（有界多边形裁剪）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：求半平面与[-B,B]^2的交，最坏O(k^2)，不是O(k log k)无界半平面交；B必须按题意选择。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ld = long double;
struct Point {
    ld x = 0, y = 0;
    Point operator+(Point b) const { return {x+b.x,y+b.y}; }
    Point operator-(Point b) const { return {x-b.x,y-b.y}; }
    Point operator*(ld k) const { return {x*k,y*k}; }
};
ld dot(Point a, Point b) { return a.x*b.x+a.y*b.y; }
ld cross(Point a, Point b) { return a.x*b.y-a.y*b.x; }
ld norm2(Point a) { return dot(a,a); }

// 有界半平面交：初始边界[-B,B]^2，逐条保留有向直线ab左侧。
// O(k*h)，最坏O(k^2)；返回与该边界的交，不判定无界性。
vector&amp;lt;Point&amp;gt; halfplane_clip(const vector&amp;lt;pair&amp;lt;Point,Point&amp;gt;&amp;gt;&amp;amp; lines, ld B) {
    assert(B&amp;gt;0);
    vector&amp;lt;Point&amp;gt; poly{{-B,-B},{B,-B},{B,B},{-B,B}};
    for (auto [a,b] : lines) {
        Point v=b-a; assert(norm2(v)&amp;gt;0);
        vector&amp;lt;Point&amp;gt; next;
        for (int i=0;i&amp;lt;int(poly.size());++i) {
            Point p=poly[i],q=poly[(i+1)%poly.size()];
            ld s=cross(v,p-a),t=cross(v,q-a);
            bool in_p=s&amp;gt;=0,in_q=t&amp;gt;=0;
            if (in_p) next.push_back(p);
            if (in_p!=in_q) next.push_back(p+(q-p)*(s/(s-t)));
        }
        poly.swap(next);
        if (poly.empty()) break;
    }
    return poly;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-7&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.7 线段相交判定 (CSES Line Segment Intersection)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：整数几何，建议|坐标|&amp;lt;=10^12；点在多边形要求简单多边形；面积输出为两倍面积，Pick另输出内部点与边界点数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;
using i128=__int128_t;
struct IntPoint { ll x,y; };
// 推荐|坐标|&amp;lt;=10^12；所有叉积与总和仍须在有符号128位内。
i128 orient(IntPoint a,IntPoint b,IntPoint c) {
    return (i128(b.x)-a.x)*(i128(c.y)-a.y)-(i128(b.y)-a.y)*(i128(c.x)-a.x);
}
int sign128(i128 x) { return (x&amp;gt;0)-(x&amp;lt;0); }
bool on_segment(IntPoint a,IntPoint b,IntPoint p) {
    return orient(a,b,p)==0 &amp;amp;&amp;amp; min(a.x,b.x)&amp;lt;=p.x &amp;amp;&amp;amp; p.x&amp;lt;=max(a.x,b.x)
        &amp;amp;&amp;amp; min(a.y,b.y)&amp;lt;=p.y &amp;amp;&amp;amp; p.y&amp;lt;=max(a.y,b.y);
}
bool segments_intersect(IntPoint a,IntPoint b,IntPoint c,IntPoint d) {
    if (max(a.x,b.x)&amp;lt;min(c.x,d.x)||max(c.x,d.x)&amp;lt;min(a.x,b.x)
      ||max(a.y,b.y)&amp;lt;min(c.y,d.y)||max(c.y,d.y)&amp;lt;min(a.y,b.y)) return false;
    return sign128(orient(a,b,c))*sign128(orient(a,b,d))&amp;lt;=0
        &amp;amp;&amp;amp; sign128(orient(c,d,a))*sign128(orient(c,d,b))&amp;lt;=0;
}
// -1边界，0外部，1内部；简单多边形，可顺/逆时针。
int point_in_polygon(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p,IntPoint q) {
    bool inside=false;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        IntPoint a=p[i],b=p[(i+1)%p.size()];
        if (on_segment(a,b,q)) return -1;
        if ((a.y&amp;gt;q.y)!=(b.y&amp;gt;q.y)) {
            i128 c=orient(a,b,q);
            if ((b.y&amp;gt;a.y &amp;amp;&amp;amp; c&amp;gt;0)||(b.y&amp;lt;a.y &amp;amp;&amp;amp; c&amp;lt;0)) inside=!inside;
        }
    }
    return inside;
}
i128 doubled_area(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p) {
    i128 s=0;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        auto a=p[i],b=p[(i+1)%p.size()]; s+=i128(a.x)*b.y-i128(a.y)*b.x;
    }
    return s&amp;lt;0?-s:s;
}
string print128(i128 x) {
    if (x==0) return &quot;0&quot;;
    bool neg=x&amp;lt;0; if (neg) x=-x;
    string s; while(x){s+=char(&apos;0&apos;+x%10);x/=10;}
    if(neg)s+=&apos;-&apos;; reverse(s.begin(),s.end()); return s;
}

int main(){int t;if(!(cin&amp;gt;&amp;gt;t))return 0;while(t--){IntPoint a,b,c,d;cin&amp;gt;&amp;gt;a.x&amp;gt;&amp;gt;a.y&amp;gt;&amp;gt;b.x&amp;gt;&amp;gt;b.y&amp;gt;&amp;gt;c.x&amp;gt;&amp;gt;c.y&amp;gt;&amp;gt;d.x&amp;gt;&amp;gt;d.y;cout&amp;lt;&amp;lt;(segments_intersect(a,b,c,d)?&quot;YES&quot;:&quot;NO&quot;)&amp;lt;&amp;lt;&apos;\n&apos;;}}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-8&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.8 多边形面积计算 (CSES Polygon Area)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：整数几何，建议|坐标|&amp;lt;=10^12；点在多边形要求简单多边形；面积输出为两倍面积，Pick另输出内部点与边界点数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;
using i128=__int128_t;
struct IntPoint { ll x,y; };
// 推荐|坐标|&amp;lt;=10^12；所有叉积与总和仍须在有符号128位内。
i128 orient(IntPoint a,IntPoint b,IntPoint c) {
    return (i128(b.x)-a.x)*(i128(c.y)-a.y)-(i128(b.y)-a.y)*(i128(c.x)-a.x);
}
int sign128(i128 x) { return (x&amp;gt;0)-(x&amp;lt;0); }
bool on_segment(IntPoint a,IntPoint b,IntPoint p) {
    return orient(a,b,p)==0 &amp;amp;&amp;amp; min(a.x,b.x)&amp;lt;=p.x &amp;amp;&amp;amp; p.x&amp;lt;=max(a.x,b.x)
        &amp;amp;&amp;amp; min(a.y,b.y)&amp;lt;=p.y &amp;amp;&amp;amp; p.y&amp;lt;=max(a.y,b.y);
}
bool segments_intersect(IntPoint a,IntPoint b,IntPoint c,IntPoint d) {
    if (max(a.x,b.x)&amp;lt;min(c.x,d.x)||max(c.x,d.x)&amp;lt;min(a.x,b.x)
      ||max(a.y,b.y)&amp;lt;min(c.y,d.y)||max(c.y,d.y)&amp;lt;min(a.y,b.y)) return false;
    return sign128(orient(a,b,c))*sign128(orient(a,b,d))&amp;lt;=0
        &amp;amp;&amp;amp; sign128(orient(c,d,a))*sign128(orient(c,d,b))&amp;lt;=0;
}
// -1边界，0外部，1内部；简单多边形，可顺/逆时针。
int point_in_polygon(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p,IntPoint q) {
    bool inside=false;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        IntPoint a=p[i],b=p[(i+1)%p.size()];
        if (on_segment(a,b,q)) return -1;
        if ((a.y&amp;gt;q.y)!=(b.y&amp;gt;q.y)) {
            i128 c=orient(a,b,q);
            if ((b.y&amp;gt;a.y &amp;amp;&amp;amp; c&amp;gt;0)||(b.y&amp;lt;a.y &amp;amp;&amp;amp; c&amp;lt;0)) inside=!inside;
        }
    }
    return inside;
}
i128 doubled_area(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p) {
    i128 s=0;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        auto a=p[i],b=p[(i+1)%p.size()]; s+=i128(a.x)*b.y-i128(a.y)*b.x;
    }
    return s&amp;lt;0?-s:s;
}
string print128(i128 x) {
    if (x==0) return &quot;0&quot;;
    bool neg=x&amp;lt;0; if (neg) x=-x;
    string s; while(x){s+=char(&apos;0&apos;+x%10);x/=10;}
    if(neg)s+=&apos;-&apos;; reverse(s.begin(),s.end()); return s;
}

int main(){int n;if(!(cin&amp;gt;&amp;gt;n))return 0;vector&amp;lt;IntPoint&amp;gt;p(n);for(auto&amp;amp;v:p)cin&amp;gt;&amp;gt;v.x&amp;gt;&amp;gt;v.y;cout&amp;lt;&amp;lt;print128(doubled_area(p))&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-9&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.9 点在多边形内部判定 (CSES Point in Polygon)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：整数几何，建议|坐标|&amp;lt;=10^12；点在多边形要求简单多边形；面积输出为两倍面积，Pick另输出内部点与边界点数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;
using i128=__int128_t;
struct IntPoint { ll x,y; };
// 推荐|坐标|&amp;lt;=10^12；所有叉积与总和仍须在有符号128位内。
i128 orient(IntPoint a,IntPoint b,IntPoint c) {
    return (i128(b.x)-a.x)*(i128(c.y)-a.y)-(i128(b.y)-a.y)*(i128(c.x)-a.x);
}
int sign128(i128 x) { return (x&amp;gt;0)-(x&amp;lt;0); }
bool on_segment(IntPoint a,IntPoint b,IntPoint p) {
    return orient(a,b,p)==0 &amp;amp;&amp;amp; min(a.x,b.x)&amp;lt;=p.x &amp;amp;&amp;amp; p.x&amp;lt;=max(a.x,b.x)
        &amp;amp;&amp;amp; min(a.y,b.y)&amp;lt;=p.y &amp;amp;&amp;amp; p.y&amp;lt;=max(a.y,b.y);
}
bool segments_intersect(IntPoint a,IntPoint b,IntPoint c,IntPoint d) {
    if (max(a.x,b.x)&amp;lt;min(c.x,d.x)||max(c.x,d.x)&amp;lt;min(a.x,b.x)
      ||max(a.y,b.y)&amp;lt;min(c.y,d.y)||max(c.y,d.y)&amp;lt;min(a.y,b.y)) return false;
    return sign128(orient(a,b,c))*sign128(orient(a,b,d))&amp;lt;=0
        &amp;amp;&amp;amp; sign128(orient(c,d,a))*sign128(orient(c,d,b))&amp;lt;=0;
}
// -1边界，0外部，1内部；简单多边形，可顺/逆时针。
int point_in_polygon(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p,IntPoint q) {
    bool inside=false;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        IntPoint a=p[i],b=p[(i+1)%p.size()];
        if (on_segment(a,b,q)) return -1;
        if ((a.y&amp;gt;q.y)!=(b.y&amp;gt;q.y)) {
            i128 c=orient(a,b,q);
            if ((b.y&amp;gt;a.y &amp;amp;&amp;amp; c&amp;gt;0)||(b.y&amp;lt;a.y &amp;amp;&amp;amp; c&amp;lt;0)) inside=!inside;
        }
    }
    return inside;
}
i128 doubled_area(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p) {
    i128 s=0;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        auto a=p[i],b=p[(i+1)%p.size()]; s+=i128(a.x)*b.y-i128(a.y)*b.x;
    }
    return s&amp;lt;0?-s:s;
}
string print128(i128 x) {
    if (x==0) return &quot;0&quot;;
    bool neg=x&amp;lt;0; if (neg) x=-x;
    string s; while(x){s+=char(&apos;0&apos;+x%10);x/=10;}
    if(neg)s+=&apos;-&apos;; reverse(s.begin(),s.end()); return s;
}

int main(){int n,q;if(!(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;q))return 0;vector&amp;lt;IntPoint&amp;gt;p(n);for(auto&amp;amp;v:p)cin&amp;gt;&amp;gt;v.x&amp;gt;&amp;gt;v.y;while(q--){IntPoint x;cin&amp;gt;&amp;gt;x.x&amp;gt;&amp;gt;x.y;int t=point_in_polygon(p,x);cout&amp;lt;&amp;lt;(t&amp;lt;0?&quot;BOUNDARY&quot;:t?&quot;INSIDE&quot;:&quot;OUTSIDE&quot;)&amp;lt;&amp;lt;&apos;\n&apos;;}}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-10&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.10 二维最小圆覆盖（随机增量）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：期望O(n)、最坏O(n^3)；long double，几何误差依赖坐标尺度，空集半径0。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ld = long double;
struct Point {
    ld x = 0, y = 0;
    Point operator+(Point b) const { return {x+b.x,y+b.y}; }
    Point operator-(Point b) const { return {x-b.x,y-b.y}; }
    Point operator*(ld k) const { return {x*k,y*k}; }
};
ld dot(Point a, Point b) { return a.x*b.x+a.y*b.y; }
ld cross(Point a, Point b) { return a.x*b.y-a.y*b.x; }
ld norm2(Point a) { return dot(a,a); }

struct Circle { Point o; ld r=-1; };
bool contains(Circle c, Point p) {
    return c.r&amp;gt;=0 &amp;amp;&amp;amp; norm2(p-c.o)&amp;lt;=c.r*c.r+1e-12L*max(1.L,c.r*c.r);
}
Circle diameter_circle(Point a, Point b) {
    Point o=(a+b)*.5L; return {o,sqrtl(norm2(a-o))};
}
Circle circle_through_three(Point a, Point b, Point c) {
    Point u=b-a,v=c-a;
    ld d=2*cross(u,v);
    if (d==0) {
        Circle best=diameter_circle(a,b);
        for (Circle candidate : {diameter_circle(a,c),diameter_circle(b,c)})
            if (candidate.r&amp;gt;best.r) best=candidate;
        return best;
    }
    Point offset{(norm2(u)*v.y-norm2(v)*u.y)/d,
                 (u.x*norm2(v)-v.x*norm2(u))/d};
    return {a+offset,sqrtl(norm2(offset))};
}
// 二维最小圆覆盖；随机增量期望O(n)，最坏O(n^3)。空集半径0。
Circle minimum_enclosing_circle(vector&amp;lt;Point&amp;gt; p) {
    if (p.empty()) return {{0,0},0};
    mt19937_64 rng(20261025);
    shuffle(p.begin(),p.end(),rng);
    Circle ball;
    for (int i=0;i&amp;lt;int(p.size());++i) if (!contains(ball,p[i])) {
        ball={p[i],0};
        for (int j=0;j&amp;lt;i;++j) if (!contains(ball,p[j])) {
            ball=diameter_circle(p[i],p[j]);
            for (int k=0;k&amp;lt;j;++k) if (!contains(ball,p[k]))
                ball=circle_through_three(p[i],p[j],p[k]);
        }
    }
    return ball;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-11&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.11 三维最小包围球概念&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义与退化情形；本节为理论说明，不含三维实现。&lt;/p&gt;
&lt;h3&gt;三维最小包围球&lt;/h3&gt;
&lt;p&gt;给定三维点集，寻找半径最小且覆盖全部点的闭球。球面边界上至多需要四个支撑点确定最小球。&lt;/p&gt;
&lt;p&gt;实现时需分别处理单点、两点直径球、三点最小球与四点外接球；共线、共面及重复点可能让直接解外心的方程退化，应退回较小支撑集。浮点包含判定需与坐标尺度匹配。本节不含三维实现；二维最小圆不能仅增加一个坐标维度便直接使用。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-12&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.12 两直线交点计算 (Line Intersection)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：完整Point依赖与直线交点接口，浮点误差阈值按题目调整。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ld = long double;
struct Point {
    ld x = 0, y = 0;
    Point operator+(Point b) const { return {x+b.x,y+b.y}; }
    Point operator-(Point b) const { return {x-b.x,y-b.y}; }
    Point operator*(ld k) const { return {x*k,y*k}; }
};
ld dot(Point a, Point b) { return a.x*b.x+a.y*b.y; }
ld cross(Point a, Point b) { return a.x*b.y-a.y*b.x; }
ld norm2(Point a) { return dot(a,a); }

// 平行/重合/退化直线均返回nullopt；阈值按坐标精度调整。
optional&amp;lt;Point&amp;gt; line_intersection(Point a, Point b, Point c, Point d) {
    Point u=b-a,v=d-c;
    ld den=cross(u,v);
    if (fabsl(den)&amp;lt;=1e-15L*sqrtl(norm2(u)*norm2(v))) return nullopt;
    return a+u*(cross(c-a,v)/den);
}
// 直线ab与圆(o,r)；退化成单点时只判断该点是否在圆上。
vector&amp;lt;Point&amp;gt; line_circle(Point a, Point b, Point o, ld r) {
    assert(r&amp;gt;=0);
    Point v=b-a;
    ld vv=norm2(v), eps=1e-12L*max(1.L,r*r);
    if (vv==0) return fabsl(norm2(a-o)-r*r)&amp;lt;=eps ? vector&amp;lt;Point&amp;gt;{a} : vector&amp;lt;Point&amp;gt;{};
    Point foot=a+v*(dot(o-a,v)/vv);
    ld h2=r*r-norm2(foot-o);
    if (h2 &amp;lt; -eps) return {};
    if (h2&amp;lt;=eps) return {foot};
    Point offset=v*sqrtl(h2/vv); // 交点沿原直线方向，而非其法向
    return {foot+offset,foot-offset};
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-13&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.13 直线与圆的交点计算 (Line-Circle Intersection)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：完整Point依赖；返回直线ab与圆的0/1/2个交点，线段需另筛参数范围。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ld = long double;
struct Point {
    ld x = 0, y = 0;
    Point operator+(Point b) const { return {x+b.x,y+b.y}; }
    Point operator-(Point b) const { return {x-b.x,y-b.y}; }
    Point operator*(ld k) const { return {x*k,y*k}; }
};
ld dot(Point a, Point b) { return a.x*b.x+a.y*b.y; }
ld cross(Point a, Point b) { return a.x*b.y-a.y*b.x; }
ld norm2(Point a) { return dot(a,a); }

// 平行/重合/退化直线均返回nullopt；阈值按坐标精度调整。
optional&amp;lt;Point&amp;gt; line_intersection(Point a, Point b, Point c, Point d) {
    Point u=b-a,v=d-c;
    ld den=cross(u,v);
    if (fabsl(den)&amp;lt;=1e-15L*sqrtl(norm2(u)*norm2(v))) return nullopt;
    return a+u*(cross(c-a,v)/den);
}
// 直线ab与圆(o,r)；退化成单点时只判断该点是否在圆上。
vector&amp;lt;Point&amp;gt; line_circle(Point a, Point b, Point o, ld r) {
    assert(r&amp;gt;=0);
    Point v=b-a;
    ld vv=norm2(v), eps=1e-12L*max(1.L,r*r);
    if (vv==0) return fabsl(norm2(a-o)-r*r)&amp;lt;=eps ? vector&amp;lt;Point&amp;gt;{a} : vector&amp;lt;Point&amp;gt;{};
    Point foot=a+v*(dot(o-a,v)/vv);
    ld h2=r*r-norm2(foot-o);
    if (h2 &amp;lt; -eps) return {};
    if (h2&amp;lt;=eps) return {foot};
    Point offset=v*sqrtl(h2/vv); // 交点沿原直线方向，而非其法向
    return {foot+offset,foot-offset};
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-14&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.14 平面最近点对 (Closest Pair of Points / 分治法)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：整数点最近距离，n&amp;gt;=2，建议坐标绝对值&amp;lt;=10^12；128位平方与long double开方。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 1000005
#define pr pair&amp;lt;ll, ll&amp;gt;
#define ll __int128
using namespace std;
long long n, m, ans, x;
const ll mod = 1e9 + 7;
class Point {
  public:
    ll x = 0, y = 0;
    ll operator*(const Point &amp;amp;oth) const { return x * oth.x + y * oth.y; }
    ll mul(const Point &amp;amp;oth) const { return x * oth.y - y * oth.x; }
    Point operator+(const Point &amp;amp;oth) const { return {x + oth.x, y + oth.y}; }
    Point operator-(const Point &amp;amp;oth) { return {x - oth.x, y - oth.y}; }
    ll dis(const Point &amp;amp;oth) { return (x - oth.x) * (x - oth.x) + (y - oth.y) * (y - oth.y); }
    bool operator&amp;lt;(const Point &amp;amp;oth) { return make_pair(x, y) &amp;lt; make_pair(oth.x, oth.y); }
};
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    vector&amp;lt;Point&amp;gt; s(n + 5);
    for (int i = 1; i &amp;lt;= n; i++) {
        long long x, y;
        cin &amp;gt;&amp;gt; x &amp;gt;&amp;gt; y;
        s[i] = {x, y};
    }
    auto abs = [](ll x) { return x &amp;lt; 0 ? -x : x; };
    sort(s.begin() + 1, s.begin() + n + 1);
    auto merge_sort = [&amp;amp;](auto &amp;amp;&amp;amp;self, int l, int r) -&amp;gt; ll {
        if (l == r)
            return (__int128(1)&amp;lt;&amp;lt;120);
        int mid = (l + r) &amp;gt;&amp;gt; 1;
        ll M = s[mid].x; // 一定要记录中点 不然排序后就不是原来的中点了
        ll d = min(self(self, l, mid), self(self, mid + 1, r));
        inplace_merge(s.begin() + l, s.begin() + mid + 1, s.begin() + 1 + r,
                      [](const Point &amp;amp;a, const Point &amp;amp;b) { return a.y &amp;lt; b.y; });
        vector&amp;lt;int&amp;gt; tem;
        for (int i = l; i &amp;lt;= r; i++) {
            if (abs(s[i].x - M) * abs(s[i].x - M) &amp;lt; d)
                tem.push_back(i);
        }
        for (int i = 0; i &amp;lt; tem.size(); i++) {
            int a = tem[i];
            for (int j = i + 1;
                 j &amp;lt; tem.size() &amp;amp;&amp;amp; abs(s[a].y - s[tem[j]].y) * abs(s[a].y - s[tem[j]].y) &amp;lt; d;
                 j++) // 这一层实际上的复杂度只有常数
            {
                d = min(d, s[a].dis(s[tem[j]]));
            }
        }
        return d;
    };
    cout &amp;lt;&amp;lt; fixed &amp;lt;&amp;lt; setprecision(4) &amp;lt;&amp;lt; sqrtl((long double)(merge_sort(merge_sort, 1, n)));
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-15&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.15 Pick 定理与多边形格点 (Pick&apos;s Theorem &amp;amp; Polygon Area)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：整数几何，建议|坐标|&amp;lt;=10^12；点在多边形要求简单多边形；面积输出为两倍面积，Pick另输出内部点与边界点数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;
using i128=__int128_t;
struct IntPoint { ll x,y; };
// 推荐|坐标|&amp;lt;=10^12；所有叉积与总和仍须在有符号128位内。
i128 orient(IntPoint a,IntPoint b,IntPoint c) {
    return (i128(b.x)-a.x)*(i128(c.y)-a.y)-(i128(b.y)-a.y)*(i128(c.x)-a.x);
}
int sign128(i128 x) { return (x&amp;gt;0)-(x&amp;lt;0); }
bool on_segment(IntPoint a,IntPoint b,IntPoint p) {
    return orient(a,b,p)==0 &amp;amp;&amp;amp; min(a.x,b.x)&amp;lt;=p.x &amp;amp;&amp;amp; p.x&amp;lt;=max(a.x,b.x)
        &amp;amp;&amp;amp; min(a.y,b.y)&amp;lt;=p.y &amp;amp;&amp;amp; p.y&amp;lt;=max(a.y,b.y);
}
bool segments_intersect(IntPoint a,IntPoint b,IntPoint c,IntPoint d) {
    if (max(a.x,b.x)&amp;lt;min(c.x,d.x)||max(c.x,d.x)&amp;lt;min(a.x,b.x)
      ||max(a.y,b.y)&amp;lt;min(c.y,d.y)||max(c.y,d.y)&amp;lt;min(a.y,b.y)) return false;
    return sign128(orient(a,b,c))*sign128(orient(a,b,d))&amp;lt;=0
        &amp;amp;&amp;amp; sign128(orient(c,d,a))*sign128(orient(c,d,b))&amp;lt;=0;
}
// -1边界，0外部，1内部；简单多边形，可顺/逆时针。
int point_in_polygon(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p,IntPoint q) {
    bool inside=false;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        IntPoint a=p[i],b=p[(i+1)%p.size()];
        if (on_segment(a,b,q)) return -1;
        if ((a.y&amp;gt;q.y)!=(b.y&amp;gt;q.y)) {
            i128 c=orient(a,b,q);
            if ((b.y&amp;gt;a.y &amp;amp;&amp;amp; c&amp;gt;0)||(b.y&amp;lt;a.y &amp;amp;&amp;amp; c&amp;lt;0)) inside=!inside;
        }
    }
    return inside;
}
i128 doubled_area(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p) {
    i128 s=0;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        auto a=p[i],b=p[(i+1)%p.size()]; s+=i128(a.x)*b.y-i128(a.y)*b.x;
    }
    return s&amp;lt;0?-s:s;
}
string print128(i128 x) {
    if (x==0) return &quot;0&quot;;
    bool neg=x&amp;lt;0; if (neg) x=-x;
    string s; while(x){s+=char(&apos;0&apos;+x%10);x/=10;}
    if(neg)s+=&apos;-&apos;; reverse(s.begin(),s.end()); return s;
}

int main(){int n;if(!(cin&amp;gt;&amp;gt;n))return 0;vector&amp;lt;IntPoint&amp;gt;p(n);for(auto&amp;amp;v:p)cin&amp;gt;&amp;gt;v.x&amp;gt;&amp;gt;v.y;i128 b=0;for(int i=0;i&amp;lt;n;++i){auto u=p[i],v=p[(i+1)%n];b+=gcd(llabs(u.x-v.x),llabs(u.y-v.y));}cout&amp;lt;&amp;lt;print128((doubled_area(p)-b+2)/2)&amp;lt;&amp;lt;&apos; &apos;&amp;lt;&amp;lt;print128(b)&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-7-16&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;7.16 光线投射算法 (Point in Polygon / 射线法判定点在多边形内部)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：整数几何，建议|坐标|&amp;lt;=10^12；点在多边形要求简单多边形；面积输出为两倍面积，Pick另输出内部点与边界点数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;
using i128=__int128_t;
struct IntPoint { ll x,y; };
// 推荐|坐标|&amp;lt;=10^12；所有叉积与总和仍须在有符号128位内。
i128 orient(IntPoint a,IntPoint b,IntPoint c) {
    return (i128(b.x)-a.x)*(i128(c.y)-a.y)-(i128(b.y)-a.y)*(i128(c.x)-a.x);
}
int sign128(i128 x) { return (x&amp;gt;0)-(x&amp;lt;0); }
bool on_segment(IntPoint a,IntPoint b,IntPoint p) {
    return orient(a,b,p)==0 &amp;amp;&amp;amp; min(a.x,b.x)&amp;lt;=p.x &amp;amp;&amp;amp; p.x&amp;lt;=max(a.x,b.x)
        &amp;amp;&amp;amp; min(a.y,b.y)&amp;lt;=p.y &amp;amp;&amp;amp; p.y&amp;lt;=max(a.y,b.y);
}
bool segments_intersect(IntPoint a,IntPoint b,IntPoint c,IntPoint d) {
    if (max(a.x,b.x)&amp;lt;min(c.x,d.x)||max(c.x,d.x)&amp;lt;min(a.x,b.x)
      ||max(a.y,b.y)&amp;lt;min(c.y,d.y)||max(c.y,d.y)&amp;lt;min(a.y,b.y)) return false;
    return sign128(orient(a,b,c))*sign128(orient(a,b,d))&amp;lt;=0
        &amp;amp;&amp;amp; sign128(orient(c,d,a))*sign128(orient(c,d,b))&amp;lt;=0;
}
// -1边界，0外部，1内部；简单多边形，可顺/逆时针。
int point_in_polygon(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p,IntPoint q) {
    bool inside=false;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        IntPoint a=p[i],b=p[(i+1)%p.size()];
        if (on_segment(a,b,q)) return -1;
        if ((a.y&amp;gt;q.y)!=(b.y&amp;gt;q.y)) {
            i128 c=orient(a,b,q);
            if ((b.y&amp;gt;a.y &amp;amp;&amp;amp; c&amp;gt;0)||(b.y&amp;lt;a.y &amp;amp;&amp;amp; c&amp;lt;0)) inside=!inside;
        }
    }
    return inside;
}
i128 doubled_area(const vector&amp;lt;IntPoint&amp;gt;&amp;amp; p) {
    i128 s=0;
    for (int i=0;i&amp;lt;int(p.size());++i) {
        auto a=p[i],b=p[(i+1)%p.size()]; s+=i128(a.x)*b.y-i128(a.y)*b.x;
    }
    return s&amp;lt;0?-s:s;
}
string print128(i128 x) {
    if (x==0) return &quot;0&quot;;
    bool neg=x&amp;lt;0; if (neg) x=-x;
    string s; while(x){s+=char(&apos;0&apos;+x%10);x/=10;}
    if(neg)s+=&apos;-&apos;; reverse(s.begin(),s.end()); return s;
}

int main(){int n,q;if(!(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;q))return 0;vector&amp;lt;IntPoint&amp;gt;p(n);for(auto&amp;amp;v:p)cin&amp;gt;&amp;gt;v.x&amp;gt;&amp;gt;v.y;while(q--){IntPoint x;cin&amp;gt;&amp;gt;x.x&amp;gt;&amp;gt;x.y;int t=point_in_polygon(p,x);cout&amp;lt;&amp;lt;(t&amp;lt;0?&quot;BOUNDARY&quot;:t?&quot;INSIDE&quot;:&quot;OUTSIDE&quot;)&amp;lt;&amp;lt;&apos;\n&apos;;}}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-8&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第八章 动态规划与博弈论&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.1 矩阵快速幂 (Matrix Exponentiation)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：方阵相乘与矩阵快速幂，解决线性递推常系数加速。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;using Matrix = vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt;;
const ll MOD = 998244353;

auto mul = [&amp;amp;](const Matrix &amp;amp;a, const Matrix &amp;amp;b) -&amp;gt; Matrix
{
    int n = a.size(), m = b[0].size(), k = b.size();
    Matrix c(n, vector&amp;lt;ll&amp;gt;(m, 0));
    for (int i = 0; i &amp;lt; n; i++)
        for (int x = 0; x &amp;lt; k; x++)
            for (int j = 0; j &amp;lt; m; j++)
                c[i][j] = (c[i][j] + a[i][x] * b[x][j]) % MOD;
    return c;
};
auto mpow = [&amp;amp;](Matrix a, ll b)
{
    int n = a.size();
    Matrix res(n, vector&amp;lt;ll&amp;gt;(n, 0));
    for (int i = 0; i &amp;lt; n; i++)
        res[i][i] = 1;
    while (b)
    {
        if (b &amp;amp; 1)
            res = mul(res, a);
        a = mul(a, a);
        b &amp;gt;&amp;gt;= 1;
    }
    return res;
};

// TODO: 按题目初始化矩阵；MOD、乘法顺序和维度自行调整。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.2 广义矩阵乘法与恰好 K 步最短路 (CSES 1724)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义矩阵 $(\min, +)$ 半环乘法 $C_{i,j} = \min_k (A_{i,k} + B_{k,j})$，利用矩阵快速幂在 $O(N^3 \log K)$ 求解恰好 $K$ 条边的全局最短路。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 105
#define inf 0x3f3f3f3f3f3f3f3f
#define ll long long
#define pr pair&amp;lt;int,int&amp;gt;
#define i128 __int128
using namespace std;
ll n,m,k;
const ll mod=1e9+7;
class matrix{
    public:
    ll matr[N][N]{};
    matrix(){
        for(int i=0;i&amp;lt;n;i++)
        {
            for(int j=0;j&amp;lt;n;j++) matr[i][j]=4e18;
        }
    }
    matrix(bool flag){
        for(int i=0;i&amp;lt;n;i++)
        {
            for(int j=0;j&amp;lt;n;j++)
            if(i==j) matr[i][i]=0;
            else
                matr[i][j]=4e18;
        }
    }


    matrix operator*(const matrix&amp;amp;oth ) const
    {
        matrix res;
        for(int i=0;i&amp;lt;n;i++)
        {
            for(int j=0;j&amp;lt;n;j++)
            {
                for(int k=0;k&amp;lt;n;k++)
                {
                    res.matr[i][j]=min(res.matr[i][j],matr[i][k]+oth.matr[k][j]);
                }
            }
        }
        return std::move(res);
    }
};
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);

    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m&amp;gt;&amp;gt;k;

    matrix base;
    for(int i=0;i&amp;lt;m;i++)
    {
        ll a,b,c;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;c;
        base.matr[a-1][b-1]=min(base.matr[a-1][b-1],c);
    }

    auto qp=[&amp;amp;](matrix base,ll k)
    {
        matrix res(true);
        while(k)
        {
            if(k&amp;amp;1) res=(res*base);
            base=base*base;
            k&amp;gt;&amp;gt;=1;
        }
        return std::move(res);
    };

    matrix pw=qp(base,k);
    if(pw.matr[0][n-1]&amp;gt;=4e18) cout&amp;lt;&amp;lt;-1;
    else cout&amp;lt;&amp;lt;pw.matr[0][n-1];

    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.3 区间博弈 DP (CSES Removal Game)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：区间 DP 求解双人轮流取数博弈，$dp(i, j) = \max(pre - dp(i+1, j), pre - dp(i, j-1))$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 1000005
#define pr pair&amp;lt;int,int&amp;gt;
#define ll long long
#define inf 100000000000
using namespace std;
ll n,m,ans;
const ll mod=1e9+7;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n;
    vector&amp;lt;ll&amp;gt;s(n+5,0);
    vector&amp;lt;ll&amp;gt;pre(n+5,0);
    for(int i=1;i&amp;lt;=n;i++)
    {
        cin&amp;gt;&amp;gt;s[i];
        pre[i]=pre[i-1]+s[i];
    }
    vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt;dp(n+5,vector&amp;lt;ll&amp;gt;(n+5,-1e16));
    for(int i=1;i&amp;lt;=n;i++) dp[i][i]=s[i];
    for(int i=n;i&amp;gt;=1;i--)
    {
        int len=i;
        for(int j=i;j&amp;lt;=n;j++)
        {
            if(i==j) continue;
            dp[i][j]=max({dp[i][j],pre[j]-pre[i-1]-dp[i+1][j],pre[j]-pre[i-1]-dp[i][j-1]});
        }
    }
    cout&amp;lt;&amp;lt;dp[1][n];
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.4 树状数组统计所有严格递增子序列&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：该实现统计所有非空严格递增子序列，不是仅统计最长者。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#define N 200005

#define ll long long
#define inf 100000000000
using namespace std;
ll n,m,ans;
const ll mod=1e9+7;
class segment
{
    public:
    ll tre[N];
    ll n;
    ll lowbit(int x)
    {
        return x&amp;amp;-x;
    }
    void insert(int x,ll val)
    {
        for(int i=x;i&amp;lt;=n;i+=lowbit(i))
        {
            tre[i]=(tre[i]+val)%mod;
        }
    }
    ll query(int x)
    {
        ll res=0;
        for(int i=x;i;i-=lowbit(i))
        {
            res=(res+tre[i])%mod;
        }
        return res;
    }

}t;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n;
    vector&amp;lt;ll&amp;gt;s(n+5,0);
    set&amp;lt;int&amp;gt;all;
    for(int i=1;i&amp;lt;=n;i++)
    {
        cin&amp;gt;&amp;gt;s[i];
        all.insert(s[i]);
    }
    int cnt=0;
    unordered_map&amp;lt;int, int&amp;gt;id;
    for(auto x:all)
    {
        cnt++;
        id[x]=cnt;
    }
    t.n=cnt;
    for(int i=1;i&amp;lt;=n;i++)
    {
        ll res=0;
        res=t.query(id[s[i]]-1);
        t.insert(id[s[i]], (res+1)%mod);
        ans=(ans+res+1)%mod;
    }
    cout&amp;lt;&amp;lt;ans;

    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.5 状压 DP 求解哈密顿路径 (CSES Hamiltonian Flights)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：利用二进制掩码记录已访问节点集合，在有向图上转移经过所有顶点的哈密顿路径数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
const int MOD = 1e9 + 7;
int n, m;
vector&amp;lt;int&amp;gt; adj[21];
int dp[1 &amp;lt;&amp;lt; 20][20];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    for (int i = 0; i &amp;lt; m; i++) {
        int u, v;
        cin &amp;gt;&amp;gt; u &amp;gt;&amp;gt; v;
        --u;
        --v;
        adj[u].push_back(v);
    }
    dp[1][0] = 1; // 从起点 0 开始，集合为 {0} (mask = 1)
    for (int mask = 1; mask &amp;lt; (1 &amp;lt;&amp;lt; n); mask++) {
        // 剪枝：若终点 n-1 提前被访问且未走完所有点，跳过
        if ((mask &amp;amp; (1 &amp;lt;&amp;lt; (n - 1))) &amp;amp;&amp;amp; mask != (1 &amp;lt;&amp;lt; n) - 1)
            continue;
        for (int u = 0; u &amp;lt; n; u++) {
            if (!dp[mask][u])
                continue;
            for (int v : adj[u]) {
                if (!(mask &amp;amp; (1 &amp;lt;&amp;lt; v))) {
                    int next_mask = mask | (1 &amp;lt;&amp;lt; v);
                    dp[next_mask][v] = (dp[next_mask][v] + dp[mask][u]) % MOD;
                }
            }
        }
    }
    cout &amp;lt;&amp;lt; dp[(1 &amp;lt;&amp;lt; n) - 1][n - 1] &amp;lt;&amp;lt; &apos;\n&apos;; return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.6 二次代价 DP（离散李超树优化）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：dp[i]=min(dp[j]+(S[i]-S[j])^2+m)，O(n log n)，128位中间值，前缀和需可放64位。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;using i128=__int128_t;

// dp[i]=min_{j&amp;lt;i}(dp[j]+(S[i]-S[j])^2+cost)。允许负a及重复前缀和。
// 坐标离散Li Chao：O(n log n)；前缀和可放ll，所有中间值绝对值&amp;lt;2^124。
i128 quadratic_dp(const vector&amp;lt;ll&amp;gt;&amp;amp; a,ll cost){
    int n=a.size();vector&amp;lt;ll&amp;gt; s(n+1);
    for(int i=0;i&amp;lt;n;++i)s[i+1]=s[i]+a[i];
    vector&amp;lt;ll&amp;gt; x=s;sort(x.begin(),x.end());x.erase(unique(x.begin(),x.end()),x.end());
    struct Line{i128 k,b;};vector&amp;lt;Line&amp;gt; lines;
    vector&amp;lt;int&amp;gt; tree(4*x.size()+4,-1);
    auto value=[&amp;amp;](int id,ll z){return lines[id].k*z+lines[id].b;};
    auto add=[&amp;amp;](auto&amp;amp;&amp;amp; self,int p,int l,int r,int id)-&amp;gt;void{
        if(tree[p]==-1){tree[p]=id;return;}
        int mid=(l+r)/2;
        if(value(id,x[mid])&amp;lt;value(tree[p],x[mid]))swap(id,tree[p]);
        if(l==r)return;
        if(value(id,x[l])&amp;lt;value(tree[p],x[l]))self(self,p*2,l,mid,id);
        else if(value(id,x[r])&amp;lt;value(tree[p],x[r]))self(self,p*2+1,mid+1,r,id);
    };
    auto query=[&amp;amp;](auto&amp;amp;&amp;amp; self,int p,int l,int r,int at)-&amp;gt;i128{
        i128 ans=tree[p]==-1?(i128(1)&amp;lt;&amp;lt;125):value(tree[p],x[at]);
        if(l==r)return ans;
        int mid=(l+r)/2;
        return min(ans,at&amp;lt;=mid?self(self,p*2,l,mid,at):self(self,p*2+1,mid+1,r,at));
    };
    lines.push_back({0,0});add(add,1,0,int(x.size())-1,0);
    i128 dp=0;
    for(int i=1;i&amp;lt;=n;++i){
        int at=lower_bound(x.begin(),x.end(),s[i])-x.begin();
        dp=query(query,1,0,int(x.size())-1,at)+i128(s[i])*s[i]+cost;
        lines.push_back({-2*i128(s[i]),dp+i128(s[i])*s[i]});
        add(add,1,0,int(x.size())-1,int(lines.size())-1);
    }
    return dp;
}
int main(){
    int n;ll cost;if(!(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;cost))return 0;vector&amp;lt;ll&amp;gt;a(n);for(auto&amp;amp;v:a)cin&amp;gt;&amp;gt;v;
    i128 ans=quadratic_dp(a,cost);if(ans&amp;lt;0)cout&amp;lt;&amp;lt;&apos;-&apos;,ans=-ans;
    string s;do{s+=char(&apos;0&apos;+ans%10);ans/=10;}while(ans);reverse(s.begin(),s.end());cout&amp;lt;&amp;lt;s&amp;lt;&amp;lt;&apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-7&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.7 树形背包（恰选q条与根连通的边）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：根固定为顶点1，恰选q条与根连通的边，支持任意分叉和负权；dp有效值须大于-2^60且总和不溢出。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll=long long;
// 连通树，根为0，恰选q条边且与根连通的最大权值。任意分叉、负权均可。
optional&amp;lt;ll&amp;gt; tree_knapsack(int n,int q,const vector&amp;lt;tuple&amp;lt;int,int,ll&amp;gt;&amp;gt;&amp;amp; edges){
    assert(n&amp;gt;=1&amp;amp;&amp;amp;int(edges.size())==n-1);
    if(q&amp;lt;0||q&amp;gt;=n)return nullopt;
    vector&amp;lt;vector&amp;lt;pair&amp;lt;int,ll&amp;gt;&amp;gt;&amp;gt;adj(n);
    for(auto[u,v,w]:edges)adj[u].push_back({v,w}),adj[v].push_back({u,w});
    vector&amp;lt;int&amp;gt;parent(n,-2),order{0};parent[0]=-1;
    for(size_t i=0;i&amp;lt;order.size();++i)for(auto[v,w]:adj[order[i]])if(parent[v]==-2)parent[v]=order[i],order.push_back(v);
    assert(int(order.size())==n);
    const ll NEG=-(1LL&amp;lt;&amp;lt;60);vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt;dp(n,vector&amp;lt;ll&amp;gt;(q+1,NEG));vector&amp;lt;int&amp;gt;sz(n);
    for(int i=n-1;i&amp;gt;=0;--i){
        int u=order[i];dp[u][0]=0;
        for(auto[v,w]:adj[u])if(parent[v]==u){
            auto next=dp[u];
            for(int a=0;a&amp;lt;=min(q,sz[u]);++a)if(dp[u][a]!=NEG)
                for(int b=0;b&amp;lt;=min(q-a-1,sz[v]);++b)if(dp[v][b]!=NEG)
                    next[a+b+1]=max(next[a+b+1],dp[u][a]+dp[v][b]+w);
            dp[u].swap(next);sz[u]+=sz[v]+1;
        }
    }
    return dp[0][q]==NEG?nullopt:optional&amp;lt;ll&amp;gt;(dp[0][q]);
}
int main(){int n,q;if(!(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;q))return 0;vector&amp;lt;tuple&amp;lt;int,int,ll&amp;gt;&amp;gt;e;for(int i=1;i&amp;lt;n;++i){int u,v;ll w;cin&amp;gt;&amp;gt;u&amp;gt;&amp;gt;v&amp;gt;&amp;gt;w;e.push_back({u-1,v-1,w});}auto a=tree_knapsack(n,q,e);cout&amp;lt;&amp;lt;(a?*a:-1)&amp;lt;&amp;lt;&apos;\n&apos;;}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-8&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.8 树形背包 DP (DFS 序展开优化版)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：后序展开的课程先修树DP，恰选m门；真实状态值须大于-1e9且总分可放int。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define N 1050
#define lc p&amp;lt;&amp;lt;1
#define rc p&amp;lt;&amp;lt;1|1
#define ll long long
using namespace std;
int n,q,m,cnt;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;dp;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;tre;
vector&amp;lt;int&amp;gt;sco;
vector&amp;lt;int&amp;gt;siz;
vector&amp;lt;int&amp;gt;rev;
void dfs(int x)
{
    siz[x]=1;
    for(auto v:tre[x])
    {
        dfs(v);
        siz[x]+=siz[v]; //这个子节点的课已经全部处理过了,加上大小
    }
    rev[++cnt]=x;
}
int main(){

    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m;
    const int NEG = -1000000000;
    dp.resize(n+1,vector&amp;lt;int&amp;gt;(m+1,NEG));
    for(int i=0;i&amp;lt;=n;i++) dp[i][0]=0;
    tre.resize(n+1,{});
    sco.resize(n+1,0);
    siz.resize(n+1,0);
    rev.resize(n+5,0);
    for(int i=1;i&amp;lt;=n;i++)
    {
        ll a,b;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;
        tre[a].push_back(i);
        sco[i]=b;
    }
    dfs(0);
    for(int i=1;i&amp;lt;=n;i++)
    {
        for(int j=m;j&amp;gt;=1;j--)
        {
            dp[i][j]=dp[i-siz[rev[i]]][j];
            if(dp[i-1][j-1]!=NEG) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+sco[rev[i]]);
        }
    }
    cout&amp;lt;&amp;lt;dp[n][m];
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-9&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.9 Nim 博弈 (经典异或和定理)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：多堆石子 Nim 博弈，$a_1 \oplus a_2 \oplus \dots \oplus a_n = 0$ 必败态判定。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 500005
using namespace std;

ll n,t;

int main()
{
    ll a,m;
    string b;
    ios::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    cin&amp;gt;&amp;gt;t;
    while(t--)
    {
    cin&amp;gt;&amp;gt;n;
    ll s;
    ll ss=0;
    for(int i=1;i&amp;lt;=n;i++)
    {
        cin&amp;gt;&amp;gt;s;
        ss^=s;
    }
    if(ss)
    {
        cout&amp;lt;&amp;lt;&quot;first&quot;&amp;lt;&amp;lt;&apos;\n&apos;;
    }
    else cout&amp;lt;&amp;lt;&quot;second&quot;&amp;lt;&amp;lt;&apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-10&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.10 集合 Nim 博弈与 SG 函数 (Sprague-Grundy)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：减法集合SG，步长严格正、石子数&amp;lt;N；记忆化递归可能深，较大值域改迭代。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// #include&amp;lt;bits/stdc++.h&amp;gt;
#include&amp;lt;iostream&amp;gt;
#include&amp;lt;vector&amp;gt;
#include&amp;lt;bitset&amp;gt;
#include&amp;lt;string&amp;gt;
#include&amp;lt;cstring&amp;gt;

#define ll long long
#define N 10005
#define pr pair&amp;lt;ll,ll&amp;gt;
using namespace std;
int n,m,k,max_;
vector&amp;lt;int&amp;gt;ss;
int f[N];
int dfs(int x)
{
    if(f[x]) return f[x]-1;
    bitset&amp;lt;N&amp;gt;vis;
    for(int i=0;i&amp;lt;ss.size();i++)
    {
        int v=ss[i];
        if(x&amp;gt;=v)
            vis[dfs(x-v)]=1;
    }
    for(int i=0;i&amp;lt;N;i++) if(!vis[i])
    {
        f[x]=i+1;
        return i;
    }
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);


    while(cin&amp;gt;&amp;gt;k)
    {
        if(!k ) return 0;
        ss.clear();
        memset(f,0,sizeof f);
        for(int i=1;i&amp;lt;=k;i++)
        {
            ll x;
            cin&amp;gt;&amp;gt;x;
            ss.push_back(x);
        }
        cin&amp;gt;&amp;gt;m;
        string res;
        for(int i=1;i&amp;lt;=m;i++)
        {
            cin&amp;gt;&amp;gt;n;
            ll ans=0;
            for(int j=1;j&amp;lt;=n;j++)
            {
                ll x;
                cin&amp;gt;&amp;gt;x;
                ans^=dfs(x);
            }
            if(ans) res+=&apos;W&apos;;
            else res+=&apos;L&apos;;
        }
        cout&amp;lt;&amp;lt;res&amp;lt;&amp;lt;&apos;\n&apos;;
    }



    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-11&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.11 有向图棋子移动博弈 (Graph Chess Game)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：DAG 拓扑状态上的 SG 函数计算与博弈胜负态判定。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 9999
#define sp &amp;lt;&amp;lt; &quot; &quot;&amp;lt;&amp;lt;
#define mp make_pair
#define pr pair&amp;lt;ll,ll&amp;gt;
#define MOD 998244353
using namespace std;

ll n,m,b,sum,a,c,k,cnt;

vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;map1;
vector&amp;lt;int&amp;gt;f;

int dfs(int x)
{
    if(f[x]) return f[x]-1;
    set&amp;lt;int&amp;gt;tem;
    for(auto v:map1[x])
    {
        tem.insert(dfs(v));
    }
    for(int i=0;i&amp;lt;=n;i++) if(tem.count(i)==0)
    {
        f[x]=i+1;
        return i;
    }
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m&amp;gt;&amp;gt;k;
    map1.resize(n+1,{});
    f.resize(n+1,0);
    for(int i=1;i&amp;lt;=m;i++)
    {
        ll a,b;
        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;
        map1[a].push_back(b);
    }
    ll ans=0;
    for(int i=1;i&amp;lt;=k;i++)
    {
        ll x;
        cin&amp;gt;&amp;gt;x;
        ans^=dfs(x);
    }
    if(ans) cout&amp;lt;&amp;lt;&quot;win&quot;;
    else cout&amp;lt;&amp;lt;&quot;lose&quot;;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-12&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.12 剪纸博弈 (Cutting Game)&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：二维网格剪切游戏的对称性与二维 SG 态转移。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include&amp;lt;bits/stdc++.h&amp;gt;
#define ll __int128
using namespace std;
#define N 505
long long n,m;
ll f[N][N];
int dfs(int n,int m)
{
    if(n==1 &amp;amp;&amp;amp;m==1) return 0;
    if(f[n][m]) return f[n][m]-1;
    set&amp;lt;int&amp;gt;vis;
    for(int i=2;i&amp;lt;n-1;i++)
    {
        vis.insert(dfs(i,m)^dfs(n-i,m));
    }
    for(int i=2;i&amp;lt;m-1;i++)
    {
        vis.insert(dfs(n,i)^dfs(n,m-i));
    }
    for(int i=0;;i++)
    {
        if(!vis.count(i))
        {
            f[n][m]=f[m][n]=i+1;
            return i;
        }
    }
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    while(cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;m)
    {
        if(dfs(n,m))
            cout&amp;lt;&amp;lt;&quot;WIN\n&quot;;
        else cout&amp;lt;&amp;lt;&quot;LOSE\n&quot;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-8-13&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;8.13 模拟退火：赛场可读模板与使用场景&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：用选数、路线、任务分配和坐标等具体场景，解释方案、评分和随机改动；附带中文注释的完整单文件模板。&lt;/p&gt;
&lt;h3&gt;模拟退火：赛场可读模板与使用场景&lt;/h3&gt;
&lt;p&gt;模拟退火就是反复尝试“小改一下当前方案”：改好了就接受，改差了也偶尔接受；开始时比较敢接受变差，后来越来越谨慎。整个过程另外记住见过的最好方案，最后输出它。&lt;/p&gt;
&lt;p&gt;接受变差，是为了给后续更好的改变留机会。例如现在的任务分配暂时比较均衡，但需要先把一个任务挪走，才能再挪另一个任务，得到更好的分配。只允许每一步立即改善，可能一直走不出当前分配。&lt;/p&gt;
&lt;p&gt;本节先用文字和具体例子说明，再给一份有中文注释、能直接编译的单文件程序。代码中的“代价”统一为越小越好。退火属于尝试寻找好方案的方法，不保证找到真正最优解；在必须得到精确答案的普通比赛里，不能仅凭多跑几次就认为一定能过。&lt;a href=&quot;https://img.atcoder.jp/intro-heuristics/editorial.pdf&quot;&gt;AtCoder 官方入门题解的比赛形式与退火说明&lt;/a&gt;&lt;/p&gt;
&lt;h4&gt;1. 什么时候值得考虑&lt;/h4&gt;
&lt;p&gt;题目满足下面几件事，才适合继续考虑退火：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;能先做出一个合法的完整方案。&lt;/li&gt;
&lt;li&gt;给你一个方案，你能算出它有多好，例如总路程、完成时间、冲突数。&lt;/li&gt;
&lt;li&gt;能只改变方案的一小部分，并且这种改变有机会让结果变好。&lt;/li&gt;
&lt;li&gt;所有方案太多，暂时没有找到能保证最优的快速算法，而题目允许近似结果或按得分评价。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;如果题目本来就能用排序、枚举、背包DP或其他确定算法解决，先用那些方法。尤其是“恰选几个数使总和最大”，排序后选最大的即可，不需要退火。&lt;/p&gt;
&lt;p&gt;如果只有完整正确的方案得1分，其余全部得0分，大量尝试都没有区别，退火也很难判断该往哪里走。可以先看能否用“有几处冲突”“还违反几条要求”衡量接近程度，但最后仍必须检查输出是否合法。&lt;/p&gt;
&lt;h4&gt;2. 使用场景：分别存什么、算什么、改什么&lt;/h4&gt;
&lt;p&gt;下面的“方案”就是你在代码中保存的一组数、一个排列、几个坐标或每件物品的归属。&lt;/p&gt;
&lt;h5&gt;场景一：从很多候选中恰好选几个&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 从很多候选店址里选5个，让更多住户附近有店。两家店的覆盖可能重叠，因此不能只给每个店址独立打分后取前5名。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：当前选中的店址，以及其余未选店址。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：统计住户被覆盖的总数；因为本模板比较的是“代价越小越好”，可以把覆盖数取负数作为代价。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：移除一个已选店址，加入一个未选店址。始终还是5个。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：不要只随机翻转一个“选/不选”标记，那样会改变选中数量。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;本节完整代码就采用这种“一换一”的写法，不过评分换成“选中数的总和离目标多远”，方便手算和检查。&lt;/p&gt;
&lt;h5&gt;场景二：调整一个访问顺序或工作顺序&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 所有城市都要访问一次，调整访问顺序，使总路程更短。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：一个城市编号排列。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：按排列顺序累加相邻城市的距离；如果题目要求回到起点，还要加最后一个城市到起点的距离。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：交换两个城市的位置，或把一段访问顺序反过来。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：固定起点、固定终点等限制要保留；如果单行道导致来回距离不同，反转一段后，里面每条路的代价也要重新计算。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;开始时直接重算整条路线最容易写对。以后需要加速，再研究哪些边真的发生了变化；不用一开始就背一个看不懂的距离差公式。&lt;/p&gt;
&lt;h5&gt;场景三：把任务分给几台机器，尽量均衡&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 把若干任务分给3台机器，每个任务有耗时，希望最忙的机器也能尽快做完。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：每个任务分给哪台机器。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：先累加每台机器的总耗时，再取其中最大值作为代价。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：把一个任务移到另一台机器，或交换两台机器上的各一个任务。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：若每台机器还有限额、不能空着或必须恰好分到几件任务，新方案也必须满足这些要求。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;“让最长耗时最小”和“让各组耗时的平方和最小”是不同目标，要按题目要求评分，不能随便互换。若改动先破坏当前方案再检查，拒绝时很容易忘记恢复；本节使用候选副本，被拒绝后直接丢弃。&lt;/p&gt;
&lt;h5&gt;场景四：在一个区域里找一个合适的位置&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 在给定矩形里放一个点，希望它离最近的障碍点尽可能远。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：当前横坐标和纵坐标。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：算出它到每个障碍点的距离，取最小距离；希望这个距离越大越好，因此评分时取负数。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：横坐标、纵坐标各随机加减一点。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：点不能跑出矩形；有禁入区域时也要检查。越界的候选可以直接丢弃，不必强行挤到边界。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;坐标改动幅度和温度分开设。温度决定“多大的代价变差还能容忍”，坐标幅度决定“这一跳能移动多远”。例如区域宽1000，却每次只移动0.001，可能跑很久也走不到别处。&lt;/p&gt;
&lt;p&gt;也不是所有找位置的题都需要退火：一条直线上最小化距离和，可以找中位数；最小化平方距离和，可以找平均位置；覆盖所有点的最小圆，本书有专门算法。先识别这些结构。&lt;/p&gt;
&lt;h5&gt;场景五：调整布局，减少冲突&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 在棋盘上摆放若干对象，希望相互冲突的对数尽量少。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：每个对象的位置。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：统计冲突对数，越少越好。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：移动一个对象，或交换两个对象的位置。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：不能放在禁用格、不能重叠等硬性要求，要在生成候选时检查。不能把“冲突还剩1对”当成已经满足无冲突要求。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;如果只移动一个对象总是无法改善，可以尝试同时移动少量对象，但每次都把整个布局随机重做，通常又很难保留已经得到的好部分。&lt;/p&gt;
&lt;h5&gt;场景六：方案要经过一段模拟才能评分&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 修改任务顺序后，要按题目规则模拟执行，才知道总完成时间。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：当前执行顺序或操作安排。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：完整模拟得到的完成时间或题目给定得分。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：交换少量位置，或者只取出一小段任务重新安排。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：一次评分如果很慢，能尝试的次数就少。先估算运行量，再决定跑几轮；不要只把降温系数改得更接近1。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;“改一小部分，再完整检查候选”是容易写对的起点。官方入门题解也建议，把以后加速用的局部评分与完整重算对照检查。&lt;a href=&quot;https://img.atcoder.jp/intro-heuristics/editorial.pdf&quot;&gt;AtCoder 官方入门题解，第4节&lt;/a&gt;&lt;/p&gt;
&lt;h4&gt;3. 接受规则：只需要看当前、候选、最好这三个词&lt;/h4&gt;
&lt;p&gt;假设代价越小越好：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;候选代价比当前小，接受。&lt;/li&gt;
&lt;li&gt;候选代价和当前相同，也可以接受，给下一次改变换一个起点。&lt;/li&gt;
&lt;li&gt;候选代价比当前大，才按概率决定是否接受。&lt;/li&gt;
&lt;li&gt;一旦遇到比历史最好还好的方案，就把它单独保存。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;一定和当前比较。&lt;/strong&gt; 假设最好代价是0，当前代价是10，候选代价是8。8比当前的10好，应当直接接受；不要因为它比历史最好的0差，就把它误判成一次变差。&lt;/p&gt;
&lt;p&gt;代码使用下面这句计算“接受变差”的概率：&lt;/p&gt;
&lt;p&gt;&lt;code&gt;exp(-变差幅度 / 温度)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;exp&lt;/code&gt; 是 C++ 的指数函数，这里你只需要掌握结果的变化方向：变差幅度越大，概率越小；温度越高，概率越大。注意前面的负号，且只在候选更差的分支计算。&lt;a href=&quot;https://www.gnu.org/software/gsl/doc/html/siman.html&quot;&gt;GSL 官方文档中的接受规则&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;例如当前代价100、候选代价110，变差了10：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;温度&lt;/th&gt;
&lt;th&gt;大约有多大概率接受&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;100&lt;/td&gt;
&lt;td&gt;90%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;37%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;0.005%&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;随机生成一个0到1的小数，若它小于上面算出的概率，就接受。&lt;code&gt;rand()&lt;/code&gt; 的原始返回值是整数，不能直接拿来和这个概率比较。&lt;/p&gt;
&lt;h4&gt;4. 参数怎样在现场调&lt;/h4&gt;
&lt;p&gt;代码里有四个参数需要先看：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;参数&lt;/th&gt;
&lt;th&gt;示例设置&lt;/th&gt;
&lt;th&gt;改动后有什么影响&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;开始温度&lt;/td&gt;
&lt;td&gt;1000&lt;/td&gt;
&lt;td&gt;越大，开始时越愿意接受变差&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;停止温度&lt;/td&gt;
&lt;td&gt;0.01&lt;/td&gt;
&lt;td&gt;越小，后期越不容易接受变差&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;每步降温系数&lt;/td&gt;
&lt;td&gt;0.995&lt;/td&gt;
&lt;td&gt;每尝试一次温度乘它；越接近1，尝试次数越多&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;重启次数&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;从几个不同起点分别跑，始终保存全程最好方案&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;这些只是示例值。先看看随机小改一次时，代价通常会变差多少：如果常常变差几万，开始温度1000可能太低；如果通常只变差1，开始温度1000就会非常宽松。不能把同一组数当作所有题的固定答案。&lt;/p&gt;
&lt;p&gt;用当前参数，每轮大约尝试2300次，5轮共约1.2万次。本模板每次复制整个方案、重新计算代价，所用时间还要乘上方案大小。如果题目有很多数据组，所有数据组的运行量也要相加。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;重启不是继续上一轮。&lt;/strong&gt; 本例第一轮从原顺序开始，后面打乱顺序，换新的初始选择，再恢复开始温度。随机数生成器只初始化一次，不要每次重启都用同一种子重新创建，否则可能把同一条搜索过程重复跑几遍。&lt;/p&gt;
&lt;h4&gt;5. 完整模板在解决什么问题&lt;/h4&gt;
&lt;p&gt;例题：给出若干整数，恰好选出指定个数，让它们的总和尽量接近目标。&lt;/p&gt;
&lt;p&gt;输入：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4 2 14
2 5 9 12
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思是从4个数里选2个，希望总和接近14。可以选2和12，也可以选5和9，误差都是0。输出第一行是找到的最小误差，第二行是选中数的原下标，从1开始；例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0
1 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不同合法选择的输出顺序可以不同。误差必须和输出的选择对应。&lt;/p&gt;
&lt;p&gt;这道例题只是方便展示退火的完整过程：实际遇到选数题，仍应先看能否枚举或用背包DP准确解决。本程序不把“运行结束”当成“已经证明最优”。&lt;/p&gt;
&lt;p&gt;方案用一个下标排列保存：&lt;strong&gt;前面指定数量的位置表示选中，后面的位置表示未选中&lt;/strong&gt;。例如排列 &lt;code&gt;0 3 1 2&lt;/code&gt; 表示选中原下标0和3，也就是数2和12。随机从前半部分和后半部分各取一个位置交换，选中的数量始终不变。&lt;/p&gt;
&lt;p&gt;输入前提：个数不能为负，选取数量在0到总个数之间；所有输入数的绝对值之和，再加目标的绝对值，不超过 &lt;code&gt;10^15&lt;/code&gt;。代码按这个范围使用 &lt;code&gt;long long&lt;/code&gt;，避免求和、做差和取绝对值溢出。&lt;/p&gt;
&lt;h4&gt;6. 带中文注释的完整单文件代码&lt;/h4&gt;
&lt;p&gt;代码里的三处“换题改这里”分别对应：计算代价、调整温度、生成一次合法的小改动。更换方案的数据结构时，也要同步修改初解和输出。&lt;/p&gt;
&lt;p&gt;&amp;lt;!-- annealing-code-start --&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;

// 完整例题：从 n 个整数中恰好选 k 个，让它们的总和尽量接近 target。
// 输入：n k target，下一行 n 个整数。
// 输出：找到的最小误差，下一行输出选中的原下标（从 1 开始）。
// 数值前提：所有数的绝对值之和，再加上 target 的绝对值，不超过 10^15。
// 因此下面的整数求和、相减和取绝对值都不会溢出。
int n, k;
ll target;
vector&amp;lt;ll&amp;gt; value;

// 随机数生成器只初始化一次。固定种子方便本地复现。
mt19937 rng(20261025);
uniform_real_distribution&amp;lt;double&amp;gt; random01(0.0, 1.0);

vector&amp;lt;int&amp;gt; best_order;  // 搜索过程中，见过的最好方案。
ll best_cost = LLONG_MAX;

// 【换题改这里 1】如何计算一个方案的代价。这里代价越小越好。
// order 存所有数的原下标，前 k 个位置表示选中，后面表示未选中。
ll calculate_cost(const vector&amp;lt;int&amp;gt;&amp;amp; order) {
    ll sum = 0;
    for (int i = 0; i &amp;lt; k; ++i) sum += value[order[i]];
    return abs(sum - target);
}

void simulated_annealing(vector&amp;lt;int&amp;gt; current_order) {
    ll current_cost = calculate_cost(current_order);
    if (current_cost &amp;lt; best_cost) {
        best_cost = current_cost;
        best_order = current_order;
    }

    // 全不选或全选时，选中的集合已经固定，不存在“一换一”的改变。
    // 先返回，避免下面构造空范围的随机数分布。
    if (k == 0 || k == n) return;

    uniform_int_distribution&amp;lt;int&amp;gt; pick_selected(0, k - 1);
    uniform_int_distribution&amp;lt;int&amp;gt; pick_unselected(k, n - 1);

    // 【换题改这里 2】根据一次变差的常见幅度调温，下面只是示例参数。
    const double start_temperature = 1000.0;  // 大：开始时较愿意接受变差。
    const double stop_temperature = 0.01;     // 小：结束前主要保留改善。
    const double cooling = 0.995;             // 每尝试一次，温度乘这个数。

    for (double temperature = start_temperature;
         temperature &amp;gt; stop_temperature;
         temperature *= cooling) {

        // 复制一份候选。若不接受它，直接丢弃，当前方案就不会被改坏。
        vector&amp;lt;int&amp;gt; candidate_order = current_order;

        // 【换题改这里 3】随机小改一次，并保证新方案仍然合法。
        // 从选中区和未选中区各取一个位置，交换后仍然恰选 k 个数。
        int selected_pos = pick_selected(rng);
        int unselected_pos = pick_unselected(rng);
        swap(candidate_order[selected_pos], candidate_order[unselected_pos]);

        ll candidate_cost = calculate_cost(candidate_order);

        // 必须和“当前方案”比较，不能和 best_cost 比较。
        bool accept_candidate = candidate_cost &amp;lt;= current_cost;

        if (!accept_candidate) {
            ll worse_by = candidate_cost - current_cost;  // 到这里一定为正。

            // exp 是 C++ 的指数函数。参数越负，返回的概率越接近 0。
            // 变差越多，接受概率越低；温度越高，接受概率越高。
            double probability = exp(-static_cast&amp;lt;double&amp;gt;(worse_by) / temperature);
            accept_candidate = random01(rng) &amp;lt; probability;
        }

        if (accept_candidate) {
            current_order = std::move(candidate_order);
            current_cost = candidate_cost;

            // 接受变差只是为了继续探索，最好方案必须另外保存。
            if (current_cost &amp;lt; best_cost) {
                best_cost = current_cost;
                best_order = current_order;
            }
        }
        // 没接受：候选副本被丢弃，不需要再交换回去。
    }
}

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

    if (!(cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k &amp;gt;&amp;gt; target)) return 0;
    if (n &amp;lt; 0 || k &amp;lt; 0 || k &amp;gt; n) return 0;
    value.resize(n);
    for (ll&amp;amp; x : value) cin &amp;gt;&amp;gt; x;

    // order = [0, 1, ..., n-1]，第一次从原顺序开始。
    vector&amp;lt;int&amp;gt; order(n);
    iota(order.begin(), order.end(), 0);

    const int restarts = 5;
    for (int run = 0; run &amp;lt; restarts; ++run) {
        // 后面几次打乱顺序，换一个起点；沿用同一个随机数生成器。
        if (run &amp;gt; 0) shuffle(order.begin(), order.end(), rng);
        simulated_annealing(order);
    }

    // 输出 best_order 对应的代价和方案，不输出最后停留的 current_order。
    cout &amp;lt;&amp;lt; best_cost &amp;lt;&amp;lt; &apos;\n&apos;;
    for (int i = 0; i &amp;lt; k; ++i) {
        if (i) cout &amp;lt;&amp;lt; &apos; &apos;;
        cout &amp;lt;&amp;lt; best_order[i] + 1;
    }
    cout &amp;lt;&amp;lt; &apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在模板目录编译：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;g++ -std=c++17 -O2 -Wall -Wextra ready/annealing_readable.cpp -o /tmp/cp-annealing
/tmp/cp-annealing
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;7. 改成自己的题时，按这个顺序检查&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;先确定代码里保存什么。例如选中的下标、城市顺序、每件物品的组别、点的坐标。&lt;/li&gt;
&lt;li&gt;写一个完整评分函数，能手算的小例必须和它一致。若原目标越大越好，可用它的相反数作为代价；取负前先检查类型范围。&lt;/li&gt;
&lt;li&gt;写一次随机小改动，确认它不会违反恰选数量、位置范围、容量等限制。非法候选直接丢弃，并继续降温。&lt;/li&gt;
&lt;li&gt;始终比较候选与当前，接受后同时更新当前方案和当前代价；遇到全程最好时，把方案与代价一起保存。&lt;/li&gt;
&lt;li&gt;先保持完整重算的写法。确实太慢时，再只计算受改动影响的部分，并与完整评分对照。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;例如改成城市路线：方案仍然可以是编号排列，评分改成总路程，小改动改为交换两个允许移动的位置，输出改为访问顺序。改成点坐标：方案要改成横纵坐标，评分按题目要求计算，随机改动改为坐标加减，并检查范围。&lt;/p&gt;
&lt;p&gt;这份程序会修改全局的最好方案；若改为多组数据，每组开始前重置 &lt;code&gt;best_cost&lt;/code&gt; 并清空 &lt;code&gt;best_order&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E7%BC%96%E8%AF%91%E5%99%A8%E9%A2%84%E5%A4%84%E7%90%86/&quot;&gt;算法竞赛编译器预处理&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-9&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第九章 竞赛经典 Trick 与思维模型&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-9-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;9.1 经典 Trick 全文（A–Z）&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：按题面信号查不变量、计数与状态转化。&lt;/p&gt;
&lt;h3&gt;算法竞赛 Classic Tricks 复习笔记&lt;/h3&gt;
&lt;hr /&gt;
&lt;h4&gt;A. 任意 $n\ge2$ 都能由 2 和 3 凑出&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;区间/长度要拆成若干段，每段长度只能取 2 或 3。&lt;/li&gt;
&lt;li&gt;构造题中需要证明所有 $n\ge2$ 都可写成 $2x+3y$，其中 $x,y\ge0$。&lt;/li&gt;
&lt;li&gt;原题出现“2 和 3 的倍数组合”时，先把它化成非负整数解问题。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;核心结论&lt;/h5&gt;
&lt;p&gt;对任意整数 $n\ge2$，都存在 $x,y\ge0$ 使&lt;/p&gt;
&lt;p&gt;$$
n=2x+3y.
$$&lt;/p&gt;
&lt;p&gt;若 $n$ 为偶数，取 $x=n/2,y=0$；若 $n$ 为奇数，则 $n\ge3$，先取一个 3，剩下 $n-3$ 为偶数。&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;B. Kruskal 瓶颈在排序时不如直接枚举值域&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;边权值域很小（如 $[0,W]$，$W \le 10^6$），但边数很多（$m$ 很大）。&lt;/li&gt;
&lt;li&gt;图由隐式规则生成，值域有限但边数是 $O(n^2)$ 级别。&lt;/li&gt;
&lt;li&gt;需要最小生成树，且排序成本 $O(m\log m)$ 超过 $O(n + W)$ 枚举。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;核心观察&lt;/h5&gt;
&lt;p&gt;Kruskal 真正要求的是“按边权从小到大处理”，不一定非要比较排序。若边权值域 $W$ 很小，并且能把显式边按权值桶化，或能直接生成某个权值的候选边，就可以从小到大枚举权值并做并查集合并。&lt;/p&gt;
&lt;p&gt;显式边桶化时，排序部分可由 $O(m\log m)$ 降到 $O(m+W)$；若图是隐式生成的，还必须把“生成当前权值的候选边”的复杂度一起算进去，不能仅凭值域小就自动省掉 $O(n^2)$ 条边。&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;C. 固定 K 的乘除 → 考虑 K 进制&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;问题中存在某个固定常数 $K$，元素需要乘以 $K$ 或除以 $K$。&lt;/li&gt;
&lt;li&gt;操作反复作用在同一数上，或需要统计&quot;乘了多少次 $K$&quot;。&lt;/li&gt;
&lt;li&gt;权重/贡献与 $K$ 的幂次有关，或题目本质是&quot;进位/借位&quot;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;核心观察&lt;/h5&gt;
&lt;p&gt;若有固定的 $K$，则“乘 $K$”对应 $K$ 进制左移一位；当当前数能被 $K$ 整除时，“除 $K$”对应右移一位。若题目使用整数除法，还要单独处理被舍去的最低位。&lt;/p&gt;
&lt;p&gt;因此看到反复乘/除固定 $K$，可以把数拆成 $K$ 进制各位，检查操作是否变成移位、进位或按位独立处理。&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;D. BFS 遍历所有状态求最值&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;状态空间有限，且每次转移代价均为 $1$（或均匀），问最短步数/最大/最小值。&lt;/li&gt;
&lt;li&gt;问题看似需要 DP 或搜索，但状态之间无拓扑序或转移顺序不固定。&lt;/li&gt;
&lt;li&gt;需要求&quot;从所有合法起点出发能到达哪些状态的最小距离&quot;，多源 BFS。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;核心观察&lt;/h5&gt;
&lt;p&gt;这里的重点不是“BFS 能直接求任意最值”，而是：&lt;strong&gt;BFS 也可以只是一个状态枚举器&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;当状态空间有限，并且每个状态只需被处理一次时，可以从初始状态 BFS，把所有可达状态遍历出来；若目标是“所有可达状态自身的最大/最小属性”，遍历时直接统计即可。多源 BFS 则可同时从所有起点出发，得到到最近起点的最短距离。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning]
BFS 本身不能求一般图最长路，也不能自动保证任意“最大值 DP”正确。若答案依赖路径历史而非状态本身，需要额外的 DAG/DP 性质或重新设计状态。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h4&gt;E. 两物性价比与数量上界&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;有两类物品，各有价值 $v_i$ 与价格 $p_i$（$i=1,2$），要以最低总价达到总价值 $\ge V$。&lt;/li&gt;
&lt;li&gt;背包类题目中物品只有两种，或可以把所有物品归类成&quot;性价比高&quot;与&quot;性价比低&quot;两组。&lt;/li&gt;
&lt;li&gt;需要证明最优解中某类物品的数量有上界。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;核心结论&lt;/h5&gt;
&lt;p&gt;设两类物品价值/价格分别为 $(v_1,p_1)$、$(v_2,p_2)$，且物品 1 的单位价值成本不高于物品 2：&lt;/p&gt;
&lt;p&gt;$$
\frac{p_1}{v_1}\le\frac{p_2}{v_2}.
$$&lt;/p&gt;
&lt;p&gt;令 $g=\gcd(v_1,v_2)$。若物品 2 买了至少 $v_1/g$ 个，可以把其中 $v_1/g$ 个物品 2 替换成 $v_2/g$ 个物品 1：两边提供的价值完全相同，而替换后的总价不会更高。因此一定存在一个最优解满足&lt;/p&gt;
&lt;p&gt;$$
0\le x_2&amp;lt;\frac{v_1}{g}.
$$&lt;/p&gt;
&lt;p&gt;所以可以枚举性价比较低的物品数量，再用高性价比物品补足目标价值。原文“性价比低的数量不会买超过性价比更高的价值”记录的就是这种交换上界思想；具体上界必须由题目参数证明，不能凭性价比直接猜。&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;F. 序列中移动元素 → 观察 $a_i \pm i$&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;序列中可以将某个元素向左或向右移动若干步，移动代价与移动距离（下标差）有关。&lt;/li&gt;
&lt;li&gt;要把一组元素移动到某些目标位置，使总移动距离最小。&lt;/li&gt;
&lt;li&gt;元素相对顺序不变（或只考虑某个元素），操作等价于调整下标。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;核心观察&lt;/h5&gt;
&lt;p&gt;当表达式里同时出现“值 $a_i$”和位置差 $|i-j|$ 时，先按左右关系拆绝对值。例如&lt;/p&gt;
&lt;p&gt;$$
a_i+|i-j|=
\begin{cases}
(a_i-i)+j,&amp;amp;i\le j,\
(a_i+i)-j,&amp;amp;i&amp;gt;j.
\end{cases}
$$&lt;/p&gt;
&lt;p&gt;于是所有与 $i$ 有关的部分只剩 $a_i-i$ 或 $a_i+i$。这经常能把“值 + 移动距离”拆成前缀/后缀最值问题。&lt;/p&gt;
&lt;p&gt;常见触发式：$a_i\pm|i-j|$、$|a_i-a_j|+|i-j|$、需要同时比较数值与位置的最值式。原文只记录了“观察 $a_i\pm i$”这个触发器；具体操作是否真的形成不变量，必须针对题目另证。&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;G. 二进制位运算律速查&lt;/h4&gt;
&lt;p&gt;位运算逐位独立，因此很多恒等式只需在单个 bit 的 $0/1$ 情况下验证。&lt;/p&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;题目涉及位掩码、子集枚举、按位统计。&lt;/li&gt;
&lt;li&gt;需要把 XOR/AND/OR 的前缀和或区间查询转化成等价形式。&lt;/li&gt;
&lt;li&gt;推导某个位运算组合是否满足分配律，或需要把补集写成 XOR。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;G-1. XOR（异或）&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;交换律：$a\oplus b=b\oplus a$&lt;/li&gt;
&lt;li&gt;结合律：$(a\oplus b)\oplus c=a\oplus(b\oplus c)$&lt;/li&gt;
&lt;li&gt;单位元：$a\oplus0=a$&lt;/li&gt;
&lt;li&gt;自反：$a\oplus a=0$&lt;/li&gt;
&lt;li&gt;消去：$a\oplus b\oplus b=a$&lt;/li&gt;
&lt;li&gt;因而前缀异或可直接还原区间：$a_l\oplus\cdots\oplus a_r=pre_r\oplus pre_{l-1}$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;G-2. AND / OR&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;交换律：$a\mathbin{&amp;amp;}b=b\mathbin{&amp;amp;}a$，$a|b=b|a$&lt;/li&gt;
&lt;li&gt;结合律：$(a\mathbin{&amp;amp;}b)\mathbin{&amp;amp;}c=a\mathbin{&amp;amp;}(b\mathbin{&amp;amp;}c)$，OR 同理&lt;/li&gt;
&lt;li&gt;幂等：$a\mathbin{&amp;amp;}a=a$，$a|a=a$&lt;/li&gt;
&lt;li&gt;零元/单位元：$a\mathbin{&amp;amp;}0=0$，$a|0=a$&lt;/li&gt;
&lt;li&gt;吸收律：$a|(a\mathbin{&amp;amp;}b)=a$，$a\mathbin{&amp;amp;}(a|b)=a$&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;AND 与 OR 互相满足分配律：&lt;/p&gt;
&lt;p&gt;$$
a\mathbin{&amp;amp;}(b|c)=(a\mathbin{&amp;amp;}b)|(a\mathbin{&amp;amp;}c),
$$&lt;/p&gt;
&lt;p&gt;$$
a|(b\mathbin{&amp;amp;}c)=(a|b)\mathbin{&amp;amp;}(a|c).
$$&lt;/p&gt;
&lt;p&gt;固定掩码的 AND 对 XOR 也满足分配律：&lt;/p&gt;
&lt;p&gt;$$
(a\oplus b)\mathbin{&amp;amp;}m
=(a\mathbin{&amp;amp;}m)\oplus(b\mathbin{&amp;amp;}m),
$$&lt;/p&gt;
&lt;p&gt;因此&lt;/p&gt;
&lt;p&gt;$$
\left(\bigoplus_{i\in S}a_i\right)\mathbin{&amp;amp;}m
=\bigoplus_{i\in S}(a_i\mathbin{&amp;amp;}m).
$$&lt;/p&gt;
&lt;p&gt;直观上，$m$ 只是逐位过滤器：$m_i=0$ 时该位统一清零，$m_i=1$ 时原样保留 XOR。&lt;/p&gt;
&lt;h5&gt;G-3. NOT 与德摩根律&lt;/h5&gt;
&lt;p&gt;在固定 $B$ 位范围、$MASK=2^B-1$ 时，可把补集写成 $\overline a=a\oplus MASK$。&lt;/p&gt;
&lt;p&gt;$$
\overline{a\mathbin{&amp;amp;}b}=\overline a|\overline b,
\qquad
\overline{a|b}=\overline a\mathbin{&amp;amp;}\overline b.
$$&lt;/p&gt;
&lt;p&gt;C++ 的 &lt;code&gt;~a&lt;/code&gt; 会翻转整数类型的全部位；只关心低 $B$ 位时记得再 &lt;code&gt;&amp;amp; MASK&lt;/code&gt;。&lt;/p&gt;
&lt;h5&gt;G-4. 竞赛常用恒等式&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;判第 $k$ 位：&lt;code&gt;(x &amp;gt;&amp;gt; k) &amp;amp; 1&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;置第 $k$ 位：&lt;code&gt;x |= 1LL &amp;lt;&amp;lt; k&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;清第 $k$ 位：&lt;code&gt;x &amp;amp;= ~(1LL &amp;lt;&amp;lt; k)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;翻转第 $k$ 位：&lt;code&gt;x ^= 1LL &amp;lt;&amp;lt; k&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;最低位的 $1$：&lt;code&gt;lowbit(x) = x &amp;amp; -x&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;删除最低位的 $1$：&lt;code&gt;x &amp;amp;= x - 1&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;判断 $x$ 是否为 $2$ 的幂：&lt;code&gt;x &amp;gt; 0 &amp;amp;&amp;amp; (x &amp;amp; (x - 1)) == 0&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;低 $k$ 位掩码：&lt;code&gt;(1LL &amp;lt;&amp;lt; k) - 1&lt;/code&gt;（注意 $k$ 不能等于类型位宽）&lt;/li&gt;
&lt;li&gt;枚举非空子掩码：&lt;code&gt;for (int s = mask; s; s = (s - 1) &amp;amp; mask)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;G-5. 常见转化&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;XOR 前缀和：$xor(l,r)=pre_r\oplus pre_{l-1}$。&lt;/li&gt;
&lt;li&gt;只关心掩码 $m$ 中的位：可以先做 &lt;code&gt;a[i] &amp;amp; m&lt;/code&gt; 再 XOR，因为 AND 对 XOR 线性。&lt;/li&gt;
&lt;li&gt;要求 &lt;code&gt;mask&lt;/code&gt; 的所有 $1$ 都包含在 $x$ 中：&lt;code&gt;(x &amp;amp; mask) == mask&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;要求 $x$ 的所有 $1$ 都属于 &lt;code&gt;mask&lt;/code&gt;：&lt;code&gt;(x &amp;amp; mask) == x&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning] 不要错误推广
OR 不对 XOR 满足类似分配律。例：$a=0,b=0,m=1$，$(a|m)\oplus(b|m)=0$，但 $(a\oplus b)|m=1$。
移位等价于乘除 $2^k$ 只应在无溢出、且右移对象非负等条件下使用。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h4&gt;H. 质数与质因子：$10^8$ 值域结论&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;题目值域不超过 $10^8$，需要判素、分解质因子、或枚举约数。&lt;/li&gt;
&lt;li&gt;需要对某个 $n$ 的所有互质计数（容斥），或枚举无平方因子约数。&lt;/li&gt;
&lt;li&gt;出现 &lt;code&gt;gcd&lt;/code&gt; 边权，怀疑可用中间质数构造权值为 $1$ 的边。&lt;/li&gt;
&lt;li&gt;题目要求枚举 $n$ 附近的质数，或判断&quot;所有质因子都大于 $10^4$&quot;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;H-1. 判定与筛法的边界&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;若 $n\le 10^8$ 为合数，则它一定有一个不超过 $\sqrt n\le10^4$ 的质因子。因此单次试除只需检查到 $10^4$。&lt;/li&gt;
&lt;li&gt;$10^4$ 以内共有 $1229$ 个质数。先筛出这些质数后，单次分解 $n\le10^8$ 最多试除 $1229$ 次，而不必枚举所有整数。&lt;/li&gt;
&lt;li&gt;$10^8$ 以内共有 $5,761,455$ 个质数，最大质数是 $99,999,989$。&lt;/li&gt;
&lt;li&gt;若要回答大量区间质数问题，埃氏筛的时间复杂度为 $O(N\log\log N)$，普通 &lt;code&gt;bool/uint8_t&lt;/code&gt; 标记约占 $N$ 字节；只存奇数可把空间减半。&lt;/li&gt;
&lt;li&gt;单个 $32$ 位整数的判素也可使用确定性 Miller--Rabin；但在 $10^8$ 内，试除或预筛通常更短且常数稳定。参见 &lt;a href=&quot;/posts/obsidian/miller-rabin%E7%AE%97%E6%B3%95/&quot;&gt;Miller Rabin算法&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E6%AC%A7%E6%8B%89%E7%AD%9B%E6%B3%95-%E7%BA%BF%E6%80%A7%E7%AD%9B/&quot;&gt;欧拉筛法(线性筛)&lt;/a&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!tip] 平方根写法
用 &lt;code&gt;1LL * p * p &amp;lt;= n&lt;/code&gt;，避免 &lt;code&gt;p * p&lt;/code&gt; 在更大值域中发生 &lt;code&gt;int&lt;/code&gt; 溢出。分解结束后若 &lt;code&gt;n &amp;gt; 1&lt;/code&gt;，剩余部分本身就是一个质因子。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;H-2. 不同质因子个数很少&lt;/h5&gt;
&lt;p&gt;令 $\omega(n)$ 表示 $n$ 的不同质因子个数。为了在固定值域内让 $\omega(n)$ 最大，应依次乘最小的不同质数：&lt;/p&gt;
&lt;p&gt;$$
2\cdot3\cdot5\cdot7\cdot11\cdot13\cdot17\cdot19
=9,699,690\le10^8,
$$&lt;/p&gt;
&lt;p&gt;但&lt;/p&gt;
&lt;p&gt;$$
9,699,690\cdot23=223,092,870&amp;gt;10^8.
$$&lt;/p&gt;
&lt;p&gt;因此&lt;/p&gt;
&lt;p&gt;$$
n\le10^8\Longrightarrow \omega(n)\le8.
$$&lt;/p&gt;
&lt;p&gt;直接推论：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;枚举不同质因子的所有子集至多 $2^8=256$ 个状态；&lt;/li&gt;
&lt;li&gt;用容斥统计区间内与 $n$ 互质的数，复杂度可视为常数；&lt;/li&gt;
&lt;li&gt;若只需要无平方因子约数、莫比乌斯式容斥项，同样最多枚举 $256$ 项。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;对 $n$ 的不同质因子集合 $P$，$[1,x]$ 内与 $n$ 互质的数可写为&lt;/p&gt;
&lt;p&gt;$$
C(x)=\sum_{S\subseteq P}(-1)^{|S|}
\left\lfloor\frac{x}{\prod_{p\in S}p}\right\rfloor.
$$&lt;/p&gt;
&lt;p&gt;区间 $[l,r]$ 的答案为 $C(r)-C(l-1)$。&lt;/p&gt;
&lt;h5&gt;H-3. 质因子总数、因子个数与枚举规模&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;令 $\Omega(n)$ 计重数。由于 $2^{26}=67,108,864\le10^8&amp;lt;2^{27}$，故 $\Omega(n)\le26$。&lt;/li&gt;
&lt;li&gt;$10^8$ 内约数个数的最大值为 $768$，例如 $73,513,440$ 达到该值。因此对单个数直接枚举全部约数通常足够快。&lt;/li&gt;
&lt;li&gt;枚举因数对只需循环到 $\sqrt n\le10^4$；发现 $d\mid n$ 时同时处理 $d$ 与 $n/d$，平方数需避免重复。&lt;/li&gt;
&lt;li&gt;质因数分解后，约数个数为 $\tau(n)=\prod_i(e_i+1)$，欧拉函数为 $\varphi(n)=n\prod_i(1-1/p_i)$。两者都只依赖分解结果，适合一次分解后集中计算。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;H-4. 质数间隔可把&quot;大值域&quot;压成&quot;小尾段&quot;&lt;/h5&gt;
&lt;p&gt;在明确值域上界时，相邻质数间隔可作为竞赛中的小常数，但必须区分&quot;严格结论&quot;和&quot;拍脑袋常数&quot;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在 $10^7$ 内，相邻质数的最大间隔为 $154$；在 $10^8$ 内最大间隔为 $220$。&lt;/li&gt;
&lt;li&gt;因而在 $x\le10^8$ 时，向前或向后寻找附近质数，保守扫描约 $220$ 个连续整数即可覆盖内部完整质数间隔；靠近值域端点时仍需显式处理边界。&lt;/li&gt;
&lt;li&gt;这适合把区间拆成&quot;大段统一计数 + 质数附近小尾段 DP/暴力&quot;。例如边权为 $\gcd(u,v)$ 时，夹在两点之间且不整除端点的质数能提供两条权值为 $1$ 的边，从而把最短路封顶为 $2$。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning] 使用条件
&quot;中间有质数&quot;不自动推出两条边的 &lt;code&gt;gcd&lt;/code&gt; 都是 $1$。若质数 $p$ 小于端点 $v$，仍可能有 $p\mid v$。证明中应排除该情形、另选质数，或把同一小质数间隔交给暴力/DP。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;H-5. 常见建模触发器&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;题目出现&quot;与固定 $n$ 互质的区间计数&quot;：分解 $n$ 的不同质因子，做至多 $256$ 项容斥。&lt;/li&gt;
&lt;li&gt;题目出现&quot;寻找 $x$ 附近的质数&quot;且 $x\le10^8$：试除判素配合小范围扫描通常已经足够。&lt;/li&gt;
&lt;li&gt;题目出现&quot;所有质因子都大于 $10^4$&quot;且数不超过 $10^8$：该数只能是 $1$ 或质数，不可能含两个大于 $10^4$ 的质因子。&lt;/li&gt;
&lt;li&gt;题目出现 &lt;code&gt;gcd&lt;/code&gt; 边权且允许向更大的整数跳转：尝试用中间质数制造权值 $1$ 的边，再单独处理质数间隔内的短尾部。&lt;/li&gt;
&lt;li&gt;题目要求枚举 $n$ 的无平方因子约数：只枚举不同质因子子集，不必生成全部约数。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;I. 自由构造模数：同余 → 整除取差&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;题目要求&lt;strong&gt;输出一个模数&lt;/strong&gt; $m$，使得某个关系 $a \equiv b \pmod{m}$ 成立。&lt;/li&gt;
&lt;li&gt;题目允许&quot;任意合法解均可&quot;，模数不是固定输入。&lt;/li&gt;
&lt;li&gt;看到&quot;输出一个数使得……在模该数意义下……&quot;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;I-1. 触发器&lt;/h5&gt;
&lt;p&gt;题目要求构造某个模数 $m$，并满足：&lt;/p&gt;
&lt;p&gt;$$
a\equiv b\pmod m
$$&lt;/p&gt;
&lt;p&gt;或者：&lt;/p&gt;
&lt;p&gt;$$
f(x)\equiv y\pmod m
$$&lt;/p&gt;
&lt;p&gt;且 $m$ 不是输入固定的，而是允许自己输出。&lt;/p&gt;
&lt;p&gt;这时不要急着做同余方程或二次剩余判定，先把同余翻译成整除：&lt;/p&gt;
&lt;p&gt;$$
a\equiv b\pmod m
\Longleftrightarrow
m\mid a-b
$$&lt;/p&gt;
&lt;p&gt;既然 $m$ 可以自己选，若 $a\ne b$，最直接可以取&lt;/p&gt;
&lt;p&gt;$$
m=|a-b|,
$$&lt;/p&gt;
&lt;p&gt;或者取 $|a-b|$ 的某个正因子。若 $a=b$，这条同余对任意合法正模数都成立，再按题目的范围条件选 $m$ 即可。&lt;/p&gt;
&lt;h5&gt;I-2. 核心想法&lt;/h5&gt;
&lt;p&gt;如果模数由我们构造，那么我们可以反过来制造一个&quot;必然成立&quot;的模关系。&lt;/p&gt;
&lt;p&gt;常见模板：&lt;/p&gt;
&lt;p&gt;$$
f(x)\equiv y\pmod m
$$&lt;/p&gt;
&lt;p&gt;等价于：&lt;/p&gt;
&lt;p&gt;$$
m\mid f(x)-y
$$&lt;/p&gt;
&lt;p&gt;若 $f(x)\ne y$，可令&lt;/p&gt;
&lt;p&gt;$$
m=|f(x)-y|.
$$&lt;/p&gt;
&lt;p&gt;这条同余就直接成立；若 $f(x)=y$，任意合法正模数都满足它。之后仍要检查题目对 $m$ 的范围、大小、互异性等额外限制。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!tip] 赛时提醒
看到&quot;输出一个模数 / 输出一个数作为模数 / 任意合法解均可&quot;，优先把同余改写成整除。自由变量不要拿来猜，拿来消掉约束。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%B4%A2%E5%BC%95/&quot;&gt;抽象代数&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/miller-rabin%E7%AE%97%E6%B3%95/&quot;&gt;Miller Rabin算法&lt;/a&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;J. LogTrick：固定端点压缩区间运算状态&lt;/h4&gt;
&lt;p&gt;适用：区间运算满足结合律，并且固定一端后，累计值只会沿某个方向收缩/扩张。典型是 $\gcd$、LCM、按位 AND、按位 OR。&lt;/p&gt;
&lt;p&gt;固定右端点 $r$，看所有&lt;/p&gt;
&lt;p&gt;$$
f(l,r)=a_l\circ a_{l+1}\circ\cdots\circ a_r,\qquad l=r,r-1,\dots,1.
$$&lt;/p&gt;
&lt;p&gt;虽然左端点有 $O(n)$ 个，但不同的 $f(l,r)$ 往往只有 $O(\log V)$ 个，因此可以把连续产生同一结果的一批左端点合并成一个状态。&lt;/p&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;看到&quot;所有子数组的 GCD / AND / OR / 有界 LCM&quot;。&lt;/li&gt;
&lt;li&gt;固定右端点后，区间值只会变小（GCD、AND）或变大（LCM、OR）。&lt;/li&gt;
&lt;li&gt;要统计满足某个区间运算结果等于 $K$ 的子数组个数。&lt;/li&gt;
&lt;li&gt;$n$ 很大，显然不能枚举 $O(n^2)$ 个区间，但值域只有 30/60 位。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;J-1. 为什么状态数是对数级&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;GCD&lt;/strong&gt;：若新值变小，则它是旧值的真因数，因此至少减半：&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
g_{\text{new}}\mid g_{\text{old}},\quad g_{\text{new}}&amp;lt;g_{\text{old}}
\Longrightarrow
g_{\text{new}}\le \frac{g_{\text{old}}}{2}.
$$&lt;/p&gt;
&lt;p&gt;所以从 $V$ 开始最多严格变化 $O(\log V)$ 次。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;LCM&lt;/strong&gt;：若新值变大，则旧值整除新值，因此至少翻倍：&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
L_{\text{old}}\mid L_{\text{new}},\quad L_{\text{new}}&amp;gt;L_{\text{old}}
\Longrightarrow
L_{\text{new}}\ge 2L_{\text{old}}.
$$&lt;/p&gt;
&lt;p&gt;实际使用时通常设上界 $U$ 或要求最终整除目标 $K$。超过上界后直接截断，否则状态数也是 $O(\log U)$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;AND&lt;/strong&gt;：向区间里加入元素后，二进制位只会 $1\to0$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;OR&lt;/strong&gt;：向区间里加入元素后，二进制位只会 $0\to1$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;若有效位数为 $B$，每次值改变至少翻转一个尚未翻转过的 bit，因此不同值最多 $B+1$ 个。&lt;/p&gt;
&lt;h5&gt;J-2. 最稳的 Rolling Vector 写法&lt;/h5&gt;
&lt;p&gt;不要纠结&quot;最远左端点&quot;方向，直接维护 $(value,count)$：表示以当前 $r$ 结尾时，有多少个左端点得到这个 value。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;pair&amp;lt;long long, long long&amp;gt;&amp;gt; cur;

for (int r = 0; r &amp;lt; n; ++r) {
    vector&amp;lt;pair&amp;lt;long long, long long&amp;gt;&amp;gt; nxt;
    nxt.push_back({a[r], 1});          // 区间 [r,r]

    for (auto [v, cnt] : cur) {
        long long nv = std::gcd(v, a[r]); // 可换成 &amp;amp;, |, lcm
        if (!nxt.empty() &amp;amp;&amp;amp; nxt.back().first == nv)
            nxt.back().second += cnt;
        else
            nxt.push_back({nv, cnt});
    }

    cur.swap(nxt);

    // cur 中就是所有以 r 结尾的不同区间值
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么只需要合并相邻相同值：上一轮状态已经按左端点远近排好，加入同一个 $a_r$ 后，GCD / AND / OR / 有界 LCM 的变化仍保持单调，因此相同结果会连续出现。&lt;/p&gt;
&lt;p&gt;总状态数每轮只有 $O(\log V)$，所以总复杂度通常是&lt;/p&gt;
&lt;p&gt;$$
O(n\log V).
$$&lt;/p&gt;
&lt;p&gt;GCD 还要乘上一次 $\gcd$ 的常数/对数代价，但竞赛里通常很小。&lt;/p&gt;
&lt;h5&gt;J-3. 常见用途&lt;/h5&gt;
&lt;ol&gt;
&lt;li&gt;统计所有子数组能得到多少种不同 GCD / AND / OR：每个 $r$ 枚举 &lt;code&gt;cur&lt;/code&gt;，扔进全局 set。&lt;/li&gt;
&lt;li&gt;统计满足 $f(l,r)=K$ 的子数组个数：若某状态 $(K,cnt)$，答案直接加 $cnt$。&lt;/li&gt;
&lt;li&gt;求区间运算结果最接近 $K$：每轮只检查 $O(\log V)$ 个状态。&lt;/li&gt;
&lt;li&gt;最短区间 LCM $=K$：先把不是 $K$ 因子的元素当断点；更新 LCM 后若不再整除 $K$，该状态直接删除。&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;J-4. LCM 溢出保护&lt;/h5&gt;
&lt;p&gt;计算&lt;/p&gt;
&lt;p&gt;$$
\operatorname{lcm}(a,b)=\frac{a}{\gcd(a,b)}\cdot b
$$&lt;/p&gt;
&lt;p&gt;必须先除后乘。若只关心不超过上界 $U$，设&lt;/p&gt;
&lt;p&gt;$$
x=\frac{a}{\gcd(a,b)}.
$$&lt;/p&gt;
&lt;p&gt;乘之前判断&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;if (x &amp;gt; U / b) {
    // lcm &amp;gt; U，直接截断
} else {
    long long l = x * b;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h5&gt;J-5. ST 表 + 二分跳跃&lt;/h5&gt;
&lt;p&gt;另一种写法是先用 ST 表支持静态区间 GCD / AND / OR 查询。&lt;/p&gt;
&lt;p&gt;固定左端点 $l$，当前区间值为 $v$。由于结果沿右端点单调变化，可以二分找到满足&lt;/p&gt;
&lt;p&gt;$$
f(l,x)=v
$$&lt;/p&gt;
&lt;p&gt;的最远位置 $x$，然后从 $x+1$ 开始处理下一个不同值。&lt;/p&gt;
&lt;p&gt;若区间查询 $O(1)$，枚举一个固定端点的全部不同状态约为&lt;/p&gt;
&lt;p&gt;$$
O(\log V\log n).
$$&lt;/p&gt;
&lt;p&gt;这种写法适合需要直接找&quot;下一次值变化位置&quot;或配合离线区间查询的题；单纯扫全部子数组时通常 Rolling Vector 更短。&lt;/p&gt;
&lt;h5&gt;J-6. 赛时触发器&lt;/h5&gt;
&lt;p&gt;看到下面这些特征就想 LogTrick：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&quot;所有子数组的 GCD / AND / OR&quot;&lt;/li&gt;
&lt;li&gt;&quot;固定右端点后，区间值只会变小/变大&quot;&lt;/li&gt;
&lt;li&gt;&quot;要求统计某个区间运算结果等于 $K$&quot;&lt;/li&gt;
&lt;li&gt;&quot;$n$ 很大，显然不能枚举 $O(n^2)$ 个区间，但值域只有 30/60 位&quot;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;一句话：&lt;strong&gt;固定一个端点，把连续产生同一运算结果的左端点压成一个状态；状态数靠因数链或 bit 单调性压到 $O(\log V)$。&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;K. 网格图 Hamilton 路径 / 回路：先看黑白染色&lt;/h4&gt;
&lt;h5&gt;使用场景&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;二维网格要求“一笔走完所有格子”、每格恰好经过一次。&lt;/li&gt;
&lt;li&gt;判断某两个指定端点之间能否存在 Hamilton 路径。&lt;/li&gt;
&lt;li&gt;网格删点、加边、加障碍后，需要先做快速无解判定。&lt;/li&gt;
&lt;li&gt;构造 Hamilton 回路/路径前，先检查奇偶性和黑白点数量。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;K-1. 网格天然是二分图&lt;/h5&gt;
&lt;p&gt;对格点 $(x,y)$ 按&lt;/p&gt;
&lt;p&gt;$$
c(x,y)=(x+y)\bmod 2
$$&lt;/p&gt;
&lt;p&gt;黑白染色。任意网格边都使 $x+y$ 的奇偶性翻转，因此每条边一定连接异色点。&lt;/p&gt;
&lt;p&gt;所以任何路径颜色都严格交替：&lt;/p&gt;
&lt;p&gt;$$
B\to W\to B\to W\to\cdots
$$&lt;/p&gt;
&lt;p&gt;这给 Hamilton 问题提供了最便宜也最常用的必要条件。&lt;/p&gt;
&lt;h5&gt;K-2. 黑白点数量&lt;/h5&gt;
&lt;p&gt;设 $(1,1)$ 为黑点。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $nm$ 为偶数：&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
|V_B|=|V_W|=\frac{nm}{2}.
$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $nm$ 为奇数：&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
|V_B|=\frac{nm+1}{2},\qquad
|V_W|=\frac{nm-1}{2}.
$$&lt;/p&gt;
&lt;p&gt;即黑点恰好多一个。&lt;/p&gt;
&lt;h5&gt;K-3. Hamilton 回路&lt;/h5&gt;
&lt;p&gt;二分图中的任意环长度必为偶数，所以 Hamilton 回路必须满足&lt;/p&gt;
&lt;p&gt;$$
|V_B|=|V_W|.
$$&lt;/p&gt;
&lt;p&gt;对于完整矩形网格 $P_n\times P_m$：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;存在 Hamilton 回路 $\Longleftrightarrow n,m\ge2$ 且 $nm$ 为偶数。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;必要性来自二分图黑白平衡以及单行/单列无法成环；充分性可用标准蛇形构造。&lt;/p&gt;
&lt;p&gt;若其中一维为偶数，例如 $n$ 为偶数，可以保留第一列作为“回边通道”，其余部分蛇形扫描，最后沿边界回到起点。&lt;/p&gt;
&lt;p&gt;赛时记忆：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;矩形完整网格要成 Hamilton 环：不能是一条链，并且总格子数必须是偶数。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;K-4. Hamilton 路径的端点颜色&lt;/h5&gt;
&lt;p&gt;Hamilton 路径经过 $nm$ 个点，有 $nm-1$ 条边。&lt;/p&gt;
&lt;h6&gt;$nm$ 为偶数&lt;/h6&gt;
&lt;p&gt;路径长度为奇数，首尾颜色必须不同：&lt;/p&gt;
&lt;p&gt;$$
c(s)\ne c(t).
$$&lt;/p&gt;
&lt;p&gt;也就是一个黑点、一个白点。&lt;/p&gt;
&lt;h6&gt;$nm$ 为奇数&lt;/h6&gt;
&lt;p&gt;路径长度为偶数，首尾颜色相同；同时因为黑点比白点多一个，所以若 $(1,1)$ 为黑点，则必须&lt;/p&gt;
&lt;p&gt;$$
c(s)=c(t)=0.
$$&lt;/p&gt;
&lt;p&gt;即两个端点都必须取多数色。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning] 颜色条件通常只是必要条件
对“指定任意两个端点”的矩形网格 Hamilton 路径，除了颜色相容，还可能受到窄网格、边界位置、割结构等限制。竞赛中除非已经有对应定理或构造证明，否则不要直接把“颜色满足”当成充分条件。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;所谓 &lt;strong&gt;Hamilton-laceable&lt;/strong&gt;，强调的是二分图中颜色相容的两端点之间总能找到 Hamilton 路径。矩形网格的精确端点可行性有额外边界条件，做题时更实用的是：&lt;strong&gt;先用染色秒掉不可能，再针对剩余情况构造或 DP。&lt;/strong&gt;&lt;/p&gt;
&lt;h5&gt;K-5. 删点 / 加边时的快速判定&lt;/h5&gt;
&lt;h6&gt;删点后想成 Hamilton 回路&lt;/h6&gt;
&lt;p&gt;先统计剩余黑白点：&lt;/p&gt;
&lt;p&gt;$$
|V&apos;_B|\ne|V&apos;_W|
\Longrightarrow
\text{一定无解}.
$$&lt;/p&gt;
&lt;p&gt;但&lt;/p&gt;
&lt;p&gt;$$
|V&apos;_B|=|V&apos;_W|
$$&lt;/p&gt;
&lt;p&gt;只是必要条件，不保证一定存在回路；障碍可能造成割点、死角或局部不可连通。&lt;/p&gt;
&lt;p&gt;带障碍、规模较小的网格 Hamilton 回路通常考虑：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;轮廓线 DP / 插头 DP；&lt;/li&gt;
&lt;li&gt;状压 DP；&lt;/li&gt;
&lt;li&gt;根据题目特殊形状做构造。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;完美匹配、最大流可以提供额外必要条件或辅助建模，但&lt;strong&gt;一般不能单独判定 Hamilton 回路存在性&lt;/strong&gt;。&lt;/p&gt;
&lt;h6&gt;奇数网格额外加一条边&lt;/h6&gt;
&lt;p&gt;原图黑点比白点多 $1$。若想形成经过全部点的 Hamilton 回路，回路中必须“补偿”一次颜色交替被打破。&lt;/p&gt;
&lt;p&gt;因此新增边若仍然是黑白边，整体仍保持二分图，奇数个顶点不可能形成 Hamilton 环。&lt;/p&gt;
&lt;p&gt;若有希望，新增边必须是同色边；在 $(1,1)$ 为黑色的标准染色下，尤其要关注&lt;strong&gt;黑—黑边&lt;/strong&gt;。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning]
“存在一条黑—黑新增边”仍然只是必要方向，不自动保证整张图能构造成 Hamilton 回路。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;K-6. 赛时触发器&lt;/h5&gt;
&lt;p&gt;看到网格“一笔走完 / 每格恰一次 / 回到起点”，先做三件事：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;染色：$c(x,y)=(x+y)\bmod2$。&lt;/li&gt;
&lt;li&gt;数黑白点：回路要求相等；路径看端点颜色。&lt;/li&gt;
&lt;li&gt;再检查结构：边界、障碍、割点、窄网格，最后才进入构造或插头 DP。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;一句话：&lt;strong&gt;网格 Hamilton 问题先别急着搜路径，先用二分图黑白计数把不可能情况砍掉。&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;L. 概率与期望&lt;/h4&gt;
&lt;h5&gt;L-1. 概率计算&lt;/h5&gt;
&lt;p&gt;独立事件的交集概率相乘，互斥事件的并集概率相加。&lt;/p&gt;
&lt;p&gt;$$
P(A\cap B)=P(A)P(B\mid A).
$$&lt;/p&gt;
&lt;p&gt;只有独立时才能把 $P(B\mid A)$ 换成 $P(B)$。不放回抽样通常不独立。&lt;/p&gt;
&lt;p&gt;至少发生一次，先算一次都不发生。各次独立、发生概率为 $p_i$ 时：&lt;/p&gt;
&lt;p&gt;$$
P(\text{至少一次})=1-\prod_i(1-p_i).
$$&lt;/p&gt;
&lt;p&gt;事件不独立时，可用容斥：&lt;/p&gt;
&lt;p&gt;$$
P\left(\bigcup_{i=1}^n A_i\right)
=\sum_{\varnothing\ne S\subseteq[n]}(-1)^{|S|+1}
P\left(\bigcap_{i\in S}A_i\right).
$$&lt;/p&gt;
&lt;h5&gt;L-2. 期望的性质&lt;/h5&gt;
&lt;p&gt;离散变量按概率求和，有密度的连续变量按密度积分：&lt;/p&gt;
&lt;p&gt;$$
E[g(X)]=\sum_x g(x)P(X=x),\qquad
E[g(X)]=\int g(x)f_X(x),dx.
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;线性性不要求独立。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;$$
E\left[c+\sum_i w_iX_i\right]=c+\sum_iw_iE[X_i].
$$&lt;/p&gt;
&lt;p&gt;例如相邻差共享元素，仍然可以拆开算：&lt;/p&gt;
&lt;p&gt;$$
E\left[\sum_{i=2}^n|a_i-a_{i-1}|\right]
=\sum_{i=2}^nE[|a_i-a_{i-1}|].
$$&lt;/p&gt;
&lt;p&gt;若 $X,Y$ 独立，则 $E[XY]=E[X]E[Y]$。但下面这些式子一般不成立：&lt;/p&gt;
&lt;p&gt;$$
E[X^2]=E[X]^2,\qquad E[|X|]=|E[X]|,\qquad
E[X/Y]=E[X]/E[Y].
$$&lt;/p&gt;
&lt;p&gt;按第一步结果分类，就是全期望公式。设 $B_i$ 是互斥且覆盖所有情况的事件：&lt;/p&gt;
&lt;p&gt;$$
E[X]=\sum_iP(B_i)E[X\mid B_i].
$$&lt;/p&gt;
&lt;p&gt;期望 DP 的转移由此得到。&lt;/p&gt;
&lt;h5&gt;L-3. 指示变量与贡献法&lt;/h5&gt;
&lt;p&gt;设 $I_i$ 表示第 $i$ 个对象是否贡献，贡献为 $1$，否则为 $0$。那么&lt;/p&gt;
&lt;p&gt;$$
E[I_i]=P(I_i=1),\qquad
E\left[\sum_i I_i\right]=\sum_iP(I_i=1).
$$&lt;/p&gt;
&lt;p&gt;求数量的期望，往往只需要算单个对象被计入的概率。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;问题&lt;/th&gt;
&lt;th&gt;单个贡献的概率&lt;/th&gt;
&lt;th&gt;期望&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;$n$ 个互异元素的均匀随机排列，逆序对数&lt;/td&gt;
&lt;td&gt;每对下标为 $1/2$&lt;/td&gt;
&lt;td&gt;$n(n-1)/4$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同上，前缀最大值个数&lt;/td&gt;
&lt;td&gt;第 $i$ 位为 $1/i$&lt;/td&gt;
&lt;td&gt;$H_n$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$m$ 个球独立均匀放入 $n$ 个盒子，非空盒子数&lt;/td&gt;
&lt;td&gt;每盒为 $1-(1-1/n)^m$&lt;/td&gt;
&lt;td&gt;$n[1-(1-1/n)^m]$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;这里 $H_n=\sum_{i=1}^n1/i$，$H_0=0$。&lt;/p&gt;
&lt;p&gt;覆盖长度也可以按位置拆：整数位置求 $\sum_xP(x\text{ 被覆盖})$，连续区间求 $\int P(x\text{ 被覆盖}),dx$。&lt;/p&gt;
&lt;h5&gt;L-4. 尾和公式与最值&lt;/h5&gt;
&lt;p&gt;非负整数变量：&lt;/p&gt;
&lt;p&gt;$$
E[X]=\sum_{k=1}^{\infty}P(X\ge k),\qquad
E[X^2]=\sum_{k=1}^{\infty}(2k-1)P(X\ge k).
$$&lt;/p&gt;
&lt;p&gt;证明只需把每个取值拆开：$x=\sum_{k=1}^x1$，$x^2=\sum_{k=1}^x(2k-1)$。&lt;/p&gt;
&lt;p&gt;非负连续变量：&lt;/p&gt;
&lt;p&gt;$$
E[X]=\int_0^{\infty}P(X&amp;gt;t),dt.
$$&lt;/p&gt;
&lt;p&gt;最值先求阈值概率。若 $X_i$ 独立，$F_i(t)=P(X_i\le t)$，则&lt;/p&gt;
&lt;p&gt;$$
P(\max_iX_i\le t)=\prod_iF_i(t),\qquad
P(\min_iX_i&amp;gt;t)=\prod_i(1-F_i(t)).
$$&lt;/p&gt;
&lt;p&gt;求“最长长度、最大值、还能进行多少步”的期望时，可以先枚举阈值，算达到这个阈值的概率。&lt;/p&gt;
&lt;h5&gt;L-5. 成功次数与等待时间&lt;/h5&gt;
&lt;h6&gt;成功次数&lt;/h6&gt;
&lt;p&gt;$n$ 次独立试验，每次成功率都是 $p$，恰好成功 $k$ 次：&lt;/p&gt;
&lt;p&gt;$$
P(X=k)=\binom nkp^k(1-p)^{n-k},\qquad E[X]=np.
$$&lt;/p&gt;
&lt;p&gt;成功率不同为 $p_i$ 时，$E[X]=\sum_i p_i$。恰好成功 $k$ 次的概率用 DP：&lt;/p&gt;
&lt;p&gt;$$
dp[i][k]=dp[i-1]&lt;a href=&quot;1-p_i&quot;&gt;k&lt;/a&gt;+dp[i-1][k-1]p_i,
\qquad dp[0][0]=1.
$$&lt;/p&gt;
&lt;p&gt;从 $N$ 个物品中均匀不放回取 $m$ 个，其中 $K$ 个是目标物品：&lt;/p&gt;
&lt;p&gt;$$
P(X=k)=\frac{\binom Kk\binom{N-K}{m-k}}{\binom Nm},\qquad
E[X]=\frac{mK}{N}.
$$&lt;/p&gt;
&lt;p&gt;不合法的组合数按 $0$ 处理。&lt;/p&gt;
&lt;h6&gt;首次成功&lt;/h6&gt;
&lt;p&gt;每次独立成功率为 $p&amp;gt;0$，$T$ 包含成功那次：&lt;/p&gt;
&lt;p&gt;$$
P(T=k)=(1-p)^{k-1}p,\qquad E[T]=\frac1p.
$$&lt;/p&gt;
&lt;p&gt;也可以写 $E=1+(1-p)E$，移项得 $E=1/p$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;只数成功前的失败次数：$(1-p)/p$。&lt;/li&gt;
&lt;li&gt;等到累计 $k$ 次成功：$k/p$。&lt;/li&gt;
&lt;li&gt;等到连续 $k$ 次成功：$\sum_{j=1}^k p^{-j}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;连续成功的式子可由状态方程推出。$E_j$ 表示当前连续成功 $j$ 次，到结束还需的步数：&lt;/p&gt;
&lt;p&gt;$$
E_j=1+pE_{j+1}+(1-p)E_0\quad(0\le j&amp;lt;k),\qquad E_k=0.
$$&lt;/p&gt;
&lt;h6&gt;分阶段&lt;/h6&gt;
&lt;p&gt;在阶段 $i$，每次独立以概率 $p_i&amp;gt;0$ 进入下一阶段，失败仍停在原阶段。总期望为&lt;/p&gt;
&lt;p&gt;$$
\sum_i\frac1{p_i}.
$$&lt;/p&gt;
&lt;p&gt;每次独立均匀抽取 $n$ 种物品之一，已经有 $k$ 种时，抽到新种类的概率为 $(n-k)/n$。集齐全部的期望为&lt;/p&gt;
&lt;p&gt;$$
E[T]=\sum_{k=0}^{n-1}\frac n{n-k}=nH_n.
$$&lt;/p&gt;
&lt;p&gt;只需集齐任意 $m$ 种，则为 $n(H_n-H_{n-m})$。各种物品概率不相等时，不能套这个式子。&lt;/p&gt;
&lt;h5&gt;L-6. 均匀分布&lt;/h5&gt;
&lt;p&gt;设 $L=r-l$，$m=r-l+1$。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;连续 $U[l,r]$，$L&amp;gt;0$&lt;/th&gt;
&lt;th&gt;整数 $l,l+1,\dots,r$ 等概率&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;密度 / 单点概率&lt;/td&gt;
&lt;td&gt;区间内密度 $1/L$，单点概率为 $0$&lt;/td&gt;
&lt;td&gt;每个整数概率 $1/m$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$E[X]$&lt;/td&gt;
&lt;td&gt;$(l+r)/2$&lt;/td&gt;
&lt;td&gt;$(l+r)/2$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\operatorname{Var}(X)$&lt;/td&gt;
&lt;td&gt;$L^2/12$&lt;/td&gt;
&lt;td&gt;$(m^2-1)/12$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$E[X^2]$&lt;/td&gt;
&lt;td&gt;$(l^2+lr+r^2)/3$&lt;/td&gt;
&lt;td&gt;$((l+r)/2)^2+(m^2-1)/12$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;连续分布除以 $r-l$，整数分布除以 $r-l+1$。$l=r$ 时是常数，期望为 $l$、方差为 $0$。&lt;/p&gt;
&lt;p&gt;连续均匀变量的分布函数：&lt;/p&gt;
&lt;p&gt;$$
F_X(t)=\begin{cases}
0,&amp;amp;t&amp;lt;l,\
(t-l)/L,&amp;amp;l\le t\le r,\
1,&amp;amp;t&amp;gt;r.
\end{cases}
$$&lt;/p&gt;
&lt;p&gt;区间概率等于交集长度除以 $L$；整数分布则数交集中的整数个数，再除以 $m$。&lt;/p&gt;
&lt;p&gt;令 $X=l+LU$，$U\sim U[0,1]$，可以把一般区间化到 $[0,1]$。对整数 $k\ge0$：&lt;/p&gt;
&lt;p&gt;$$
E[U^k]=\frac1{k+1},\qquad
E[X^k]=\frac{r^{k+1}-l^{k+1}}{(k+1)(r-l)}.
$$&lt;/p&gt;
&lt;h6&gt;连续抽样：第 $k$ 小、最值和间隔&lt;/h6&gt;
&lt;p&gt;在 $[l,r]$ 中独立均匀取 $n$ 个点，排序后记为 $X_{(1)},\dots,X_{(n)}$：&lt;/p&gt;
&lt;p&gt;$$
E[X_{(k)}]=l+\frac{kL}{n+1},
$$&lt;/p&gt;
&lt;p&gt;$$
E[\min X_i]=l+\frac L{n+1},\qquad
E[\max X_i]=r-\frac L{n+1},
$$&lt;/p&gt;
&lt;p&gt;$$
E[\max X_i-\min X_i]=\frac{n-1}{n+1}L.
$$&lt;/p&gt;
&lt;p&gt;加上两个端点后，共有 $n+1$ 个间隔。各间隔同分布、总长为 $L$，所以每个间隔的期望都是 $L/(n+1)$。第 $k$ 小距左端点的长度是前 $k$ 个间隔之和。&lt;/p&gt;
&lt;h6&gt;整数抽样：有放回&lt;/h6&gt;
&lt;p&gt;$n$ 次独立均匀取整数 $l,\dots,r$，允许重复：&lt;/p&gt;
&lt;p&gt;$$
E[\max X_i]=l+\sum_{j=1}^{m-1}\left(1-\left(\frac jm\right)^n\right),
$$&lt;/p&gt;
&lt;p&gt;$$
E[\min X_i]=l+\sum_{j=1}^{m-1}\left(\frac{m-j}{m}\right)^n.
$$&lt;/p&gt;
&lt;p&gt;由尾和公式得到，$m=1$ 时空和为 $0$。&lt;/p&gt;
&lt;h6&gt;整数抽样：不放回&lt;/h6&gt;
&lt;p&gt;从 $1,\dots,N$ 中均匀选出 $m$ 个不同数，排序后为 $S_1&amp;lt;\cdots&amp;lt;S_m$：&lt;/p&gt;
&lt;p&gt;$$
E[S_k]=\frac{k(N+1)}{m+1}.
$$&lt;/p&gt;
&lt;p&gt;选中元素前后及之间共有 $m+1$ 个空隙，未选中元素共 $N-m$ 个。每个空隙中未选中元素数的期望为 $(N-m)/(m+1)$，于是 $E[S_k]=k+k(N-m)/(m+1)$。&lt;/p&gt;
&lt;h5&gt;L-7. 均匀分布的距离&lt;/h5&gt;
&lt;h6&gt;点到区间&lt;/h6&gt;
&lt;p&gt;$X\sim U[l,r]$，$L=r-l&amp;gt;0$，固定点为 $p$：&lt;/p&gt;
&lt;p&gt;$$
E[|X-p|]=\frac{(r-p)|r-p|-(l-p)|l-p|}{2L}.
$$&lt;/p&gt;
&lt;p&gt;分段写法：&lt;/p&gt;
&lt;p&gt;$$
E[|X-p|]=\begin{cases}
(l+r)/2-p,&amp;amp;p\le l,\
\big((p-l)^2+(r-p)^2\big)/(2L),&amp;amp;l&amp;lt;p&amp;lt;r,\
p-(l+r)/2,&amp;amp;p\ge r.
\end{cases}
$$&lt;/p&gt;
&lt;h6&gt;两个区间&lt;/h6&gt;
&lt;p&gt;$X\sim U[a,b]$、$Y\sim U[c,d]$ 独立，$A=b-a&amp;gt;0$、$B=d-c&amp;gt;0$：&lt;/p&gt;
&lt;p&gt;$$
\boxed{E[|X-Y|]
=\frac{|b-c|^3+|a-d|^3-|a-c|^3-|b-d|^3}{6AB}}.
$$&lt;/p&gt;
&lt;p&gt;推导：联合密度为 $1/(AB)$，而&lt;/p&gt;
&lt;p&gt;$$
\int_c^d|x-y|,dy
=\frac{(x-c)|x-c|-(x-d)|x-d|}{2},
$$&lt;/p&gt;
&lt;p&gt;$$
\int_a^b\int_c^d|x-y|,dy,dx
=\left[\frac{|x-c|^3-|x-d|^3}{6}\right]_a^b.
$$&lt;/p&gt;
&lt;p&gt;区间相离、相交、包含都适用。一个区间退化为点时用“点到区间”；两个都是点时直接取绝对差。&lt;/p&gt;
&lt;p&gt;若 $b\le c$，直接算 $E[Y]-E[X]=(c+d-a-b)/2$。&lt;/p&gt;
&lt;h6&gt;同一区间&lt;/h6&gt;
&lt;p&gt;$X,Y$ 独立同分布：&lt;/p&gt;
&lt;p&gt;| | $E[|X-Y|]$ | $E[(X-Y)^2]$ |
| --- | --- | --- |
| 连续区间，长度 $L$ | $L/3$ | $L^2/6$ |
| 整数区间，共 $m$ 个数 | $(m^2-1)/(3m)$ | $(m^2-1)/6$ |&lt;/p&gt;
&lt;p&gt;整数绝对差按距离枚举：距离 $k&amp;gt;0$ 的有序数对有 $2(m-k)$ 对，所以&lt;/p&gt;
&lt;p&gt;$$
E[|X-Y|]=\frac2{m^2}\sum_{k=1}^{m-1}k(m-k)=\frac{m^2-1}{3m}.
$$&lt;/p&gt;
&lt;p&gt;同一连续区间中，距离不超过 $t$ 的概率为&lt;/p&gt;
&lt;p&gt;$$
P(|X-Y|\le t)=\frac{2t}{L}-\frac{t^2}{L^2},\qquad 0\le t\le L.
$$&lt;/p&gt;
&lt;p&gt;可在边长为 $L$ 的正方形中，减掉 $|x-y|&amp;gt;t$ 对应的两个三角形来推。&lt;/p&gt;
&lt;h6&gt;两个数的大小关系&lt;/h6&gt;
&lt;p&gt;仍设两个区间非退化且独立，记 $z_+=\max(z,0)$：&lt;/p&gt;
&lt;p&gt;$$
P(X\le Y)=\frac{(d-a)&lt;em&gt;+^2-(d-b)&lt;/em&gt;+^2-(c-a)&lt;em&gt;+^2+(c-b)&lt;/em&gt;+^2}{2AB}.
$$&lt;/p&gt;
&lt;p&gt;由 $P(X\le Y)=\frac1B\int_c^dF_X(y),dy$ 积分得到。&lt;/p&gt;
&lt;p&gt;这里 $P(X=Y)=0$。整数分布则需要另算相等概率，不能混用 $&amp;lt;$ 和 $\le$。&lt;/p&gt;
&lt;h5&gt;L-8. 二阶矩与方差&lt;/h5&gt;
&lt;p&gt;$$
\operatorname{Var}(X)=E[X^2]-E[X]^2.
$$&lt;/p&gt;
&lt;p&gt;计算总贡献平方时，展开成单项和成对贡献：&lt;/p&gt;
&lt;p&gt;$$
E\left[\left(\sum_iX_i\right)^2\right]
=\sum_iE[X_i^2]+2\sum_{i&amp;lt;j}E[X_iX_j].
$$&lt;/p&gt;
&lt;p&gt;对指示变量，$I_i^2=I_i$，$E[I_iI_j]=P(I_i=I_j=1)$。因此计数的方差通常需要算“两件事同时发生”的概率。&lt;/p&gt;
&lt;p&gt;独立时：&lt;/p&gt;
&lt;p&gt;$$
\operatorname{Var}\left(\sum_iX_i\right)=\sum_i\operatorname{Var}(X_i).
$$&lt;/p&gt;
&lt;p&gt;独立试验的成功次数，方差为 $\sum_i p_i(1-p_i)$。&lt;/p&gt;
&lt;p&gt;两个独立变量的平方差：&lt;/p&gt;
&lt;p&gt;$$
E[(X-Y)^2]=\operatorname{Var}(X)+\operatorname{Var}(Y)+(E[X]-E[Y])^2.
$$&lt;/p&gt;
&lt;h5&gt;L-9. 期望 DP&lt;/h5&gt;
&lt;h6&gt;正推&lt;/h6&gt;
&lt;p&gt;按步数分层或在 DAG 上，维护：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$P_s$：到达状态 $s$ 的概率。&lt;/li&gt;
&lt;li&gt;$F_s$：到达状态 $s$ 的所有情况中，累计得分乘概率的和。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;边 $s\to t$ 的转移概率为 $p$，新增得分为 $w$：&lt;/p&gt;
&lt;p&gt;$$
P_t\mathrel{+}=pP_s,\qquad
F_t\mathrel{+}=p(F_s+wP_s).
$$&lt;/p&gt;
&lt;p&gt;初始状态 $P=1,F=0$，答案为所有终止状态的 $F$ 之和。$F_s$ 已经包含到达概率，新增得分仍需乘 $P_s$。&lt;/p&gt;
&lt;h6&gt;倒推&lt;/h6&gt;
&lt;p&gt;$E_s$ 表示从状态 $s$ 出发，到结束还需要的期望代价。转移概率为 $p_{st}$、单步代价为 $w_{st}$：&lt;/p&gt;
&lt;p&gt;$$
E_s=\sum_t p_{st}(w_{st}+E_t).
$$&lt;/p&gt;
&lt;p&gt;没有终点奖励时 $E_{\mathrm{end}}=0$。每步代价都是 $1$ 时：&lt;/p&gt;
&lt;p&gt;$$
E_s=1+\sum_t p_{st}E_t.
$$&lt;/p&gt;
&lt;p&gt;自环概率为 $q&amp;lt;1$，移项：&lt;/p&gt;
&lt;p&gt;$$
E_s=\frac{1+\sum_{t\ne s}p_{st}E_t}{1-q}.
$$&lt;/p&gt;
&lt;p&gt;有一般环依赖时写线性方程组，不能直接记忆化递归。先检查是否可能进入无法到达终点的状态；若能以正概率进入，结束步数的期望为无穷大。&lt;/p&gt;
&lt;p&gt;状态需包含决定后续转移的全部信息。例如连续成功题要记当前连击长度，不能只记已经进行多少次。&lt;/p&gt;
&lt;h6&gt;二阶矩转移&lt;/h6&gt;
&lt;p&gt;$Q_s$ 表示从 $s$ 出发，剩余总代价平方的期望。边代价 $w_{st}$ 固定时：&lt;/p&gt;
&lt;p&gt;$$
Q_s=\sum_t p_{st}(w_{st}^2+2w_{st}E_t+Q_t).
$$&lt;/p&gt;
&lt;p&gt;先求 $E_s$，再求 $Q_s$，方差为 $Q_s-E_s^2$。&lt;/p&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E6%9C%9F%E6%9C%9Bdp/&quot;&gt;期望DP&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;L-10. 取模&lt;/h5&gt;
&lt;p&gt;有理数 $P/Q$ 的模表示为 $P\cdot Q^{-1}$。模数 $M$ 为质数且 $Q\not\equiv0\pmod M$ 时：&lt;/p&gt;
&lt;p&gt;$$
Q^{-1}\equiv Q^{M-2}\pmod M.
$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;百分比转为 $p\cdot100^{-1}$，固定分母的逆元只算一次。&lt;/li&gt;
&lt;li&gt;比较大小、取绝对值、取 $z_+$，都在取模前做。&lt;/li&gt;
&lt;li&gt;连乘逐步取模，三次方不要直接在原整数上计算。&lt;/li&gt;
&lt;li&gt;自环移项的 $1-q$ 也要检查是否可逆。实数意义下非零，不代表模意义下非零。&lt;/li&gt;
&lt;li&gt;大量非零分母可用前缀积和倒推批量求逆，只求一次总乘积的逆元，复杂度 $O(n+\log M)$。&lt;/li&gt;
&lt;li&gt;分母模 $M$ 为 $0$ 时不能硬求逆。先在有理数层面约分，最终分母仍与 $M$ 不互质，则这种模表示不存在。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;M. 切比雪夫距离与曼哈顿距离&lt;/h4&gt;
&lt;p&gt;设 $P=(x_1,y_1),Q=(x_2,y_2)$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;曼哈顿距离&lt;/strong&gt;：$d_1(P,Q)=|x_1-x_2|+|y_1-y_2|$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;切比雪夫距离&lt;/strong&gt;：$d_\infty(P,Q)=\max(|x_1-x_2|,|y_1-y_2|)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;将每个点变换为 $T(x,y)=(x+y,x-y)$，则：&lt;/p&gt;
&lt;p&gt;$$
\boxed{d_1(P,Q)=d_\infty(T(P),T(Q))}
$$&lt;/p&gt;
&lt;p&gt;$$
\boxed{d_\infty(P,Q)=\frac12d_1(T(P),T(Q))}
$$&lt;/p&gt;
&lt;p&gt;即：&lt;strong&gt;原曼哈顿 = 新切比雪夫；原切比雪夫 = 新曼哈顿的一半。&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;N. 离散介值性质与非单调二分&lt;/h4&gt;
&lt;h5&gt;N-1. 使用场景&lt;/h5&gt;
&lt;p&gt;固定长度的窗口每次右移一格，只移出左端点、加入右侧新点。若每个位置的贡献为 0 或 1，窗口统计量每次只能变化 $-1,0,1$。&lt;/p&gt;
&lt;p&gt;当题目要求找到 $f(s)=k$ 的某个位置时，可以检查相邻位置的差值是否至多为 1。此时即使 $f$ 不单调，只要找到函数值位于 $k$ 两侧的两个端点，也能二分出一个解。&lt;/p&gt;
&lt;h5&gt;N-2. 离散介值性质&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;命题&lt;/strong&gt;：设整数区间 $[L, R]$ 上的整数值函数 $f: \mathbb{Z}\cap[L, R]\to\mathbb{Z}$ 满足对任意整数 $x\in[L, R-1]$ 均有 $|f(x+1) - f(x)| \le 1$。
对任意整数 $k$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $f(L) &amp;gt; k \ge f(R)$ 且 $L &amp;lt; R$，则必存在整数 $s \in (L, R]$ 满足 $f(s) = k$。&lt;/li&gt;
&lt;li&gt;（反向跨越版本）若 $f(L) &amp;lt; k \le f(R)$ 且 $L &amp;lt; R$，则同样必存在整数 $s \in (L, R]$ 满足 $f(s) = k$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;证明&lt;/strong&gt;（以 $f(L) &amp;gt; k \ge f(R)$ 为例）：
考虑集合 $S = {x \in [L, R] \mid f(x) \le k}$。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;因为 $R \in S$，故 $S$ 是有限非空整数集，必存在最小元素 $s = \min S$。&lt;/li&gt;
&lt;li&gt;因为 $f(L) &amp;gt; k$，故 $L \notin S$，由此可知 $s &amp;gt; L$。&lt;/li&gt;
&lt;li&gt;由 $s$ 的最小性，其前驱位置 $s - 1 \notin S$，即 $f(s-1) &amp;gt; k$。由于函数值为整数，这意味着 $f(s-1) \ge k + 1$。&lt;/li&gt;
&lt;li&gt;根据单步差分约束，每步至多下降 1：$f(s) \ge f(s-1) - 1 \ge k$。&lt;/li&gt;
&lt;li&gt;结合 $s \in S$ 的定义 $f(s) \le k$，两式夹逼立得 $f(s) = k$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;N-3. 非单调二分&lt;/h5&gt;
&lt;p&gt;这里不要求 $f$ 单调，也不要求判定式 $f(s)&amp;gt;k$ 构成一个连续前缀。&lt;/p&gt;
&lt;p&gt;算法维护当前搜索区间 $[L, R]$，其循环不变式始终为：&lt;/p&gt;
&lt;p&gt;$$
f(L) &amp;gt; k \quad \text{且} \quad f(R) \le k
$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;取 $\mathrm{mid} = \lfloor(L + R) / 2\rfloor$。&lt;/li&gt;
&lt;li&gt;若 $f(\mathrm{mid}) &amp;gt; k$，更新 $L \leftarrow \mathrm{mid}$；否则更新 $R \leftarrow \mathrm{mid}$。&lt;/li&gt;
&lt;li&gt;循环终止条件为 $L + 1 = R$（区间长度缩减为 1，两端点为相邻整数）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;相邻端点收敛正确性&lt;/strong&gt;：终止时由不变式可知 $f(L) \ge k + 1$ 且 $f(R) \le k$。又由单步变化约束 $|f(R) - f(L)| \le 1$，两端至多相差 1，因此两个不等式必然同时取等，推导出 $f(L) = k + 1$ 且 $f(R) = k$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;被丢弃的半边可能也有解，但保留下来的两端始终分别满足 $f(L)&amp;gt;k$ 与 $f(R)\le k$。二分只利用这两个端点的跨越关系，直到它们相邻；并不是在求单调分界点。&lt;/p&gt;
&lt;h5&gt;N-4. 实例：CF Target Infection&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;题意抽象&lt;/strong&gt;：数轴上给定若干互不相交的闭区间 $[l_i, r_i]$（均为感染点，其余为 0）。给定检测窗口长度 $m$ 与目标感染数 $k$，求是否存在窗口 $[s, s + m - 1]$ 使得其中的感染点数恰好为 $k$。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;单步变化性质&lt;/strong&gt;：
设 $a(x) \in {0, 1}$ 为坐标 $x$ 是否被感染的示性函数。窗口以 $s$ 为左端点，包含感染点数为 $f(s)$，则平移一步的变化为：
$$
f(s+1) - f(s) = a(s+m) - a(s) \in {-1, 0, 1}
$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;全局最大值必可在某个 $l_i$ 处取到&lt;/strong&gt;：
设某个窗口 $[s^&lt;em&gt;, s^&lt;/em&gt; + m - 1]$ 取得全局感染点数最大值：
&lt;ul&gt;
&lt;li&gt;若 $s^&lt;em&gt;$ 为非感染点且右侧还有感染区间，向右平移至下一个区间左端点 $l_i$。平移时左端移出的全是 0，右端移入点数非负，$f$ 不减。若 $s^&lt;/em&gt;&amp;gt;r_n$，则 $f(s^*)=0$，而 $f(l_n)\ge1$，因此这不可能是最大值点；&lt;/li&gt;
&lt;li&gt;若 $s^&lt;em&gt;$ 落在某个感染区间内部且 $s^&lt;/em&gt; &amp;gt; l_i$，向左平移窗口至 $l_i$。平移期间左端移入的全是 1，右端移出点数至多等于移入点数，$f$ 不减。&lt;/li&gt;
&lt;li&gt;故枚举所有区间的左端点 $l_i$，必能覆盖到至少一个全局最大值。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;算法流程与边界处理&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;遍历所有 $l_i$ 计算 $f(l_i)$：
&lt;ul&gt;
&lt;li&gt;若中途直接命中 $f(l_i) = k$，直接输出 $l_i$ 即可（包含 $k = 0$ 时若恰好有 $f(l_i) = 0$）；&lt;/li&gt;
&lt;li&gt;若存在 $f(l_i) &amp;gt; k$，记录任意一个满足条件的端点作为二分左端点 $L$；&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;若所有 $l_i$ 均满足 $f(l_i) &amp;lt; k$，由于最大值亦严格小于 $k$，问题直接无解；&lt;/li&gt;
&lt;li&gt;确定 $L$ 后，取右端点 $R = r_n + 1$。因为窗口完全落在所有感染区间右侧，窗口内感染数为 $f(R) = 0$。对于任意非负目标 $k \ge 0$，均满足 $f(R) = 0 \le k$；特别地若 $k = 0$，此处可直接确定有解；&lt;/li&gt;
&lt;li&gt;此时满足 $L &amp;lt; R$ 且 $f(L) &amp;gt; k \ge f(R)$，直接调用非单调二分，返回收敛时的 $R$ 即可。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$O(\log n)$ 快速求 $f(s)$&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;令 $F(x)$ 为坐标 $\le x$ 的感染点总数，则 $f(s) = F(s + m - 1) - F(s - 1)$。&lt;/li&gt;
&lt;li&gt;区间互不相交，维护各区间长度的前缀和。用 &lt;code&gt;std::upper_bound&lt;/code&gt; 找到最后一个满足 $l_j\le x$ 的区间，再计算 $pre[j-1]+\min(x,r_j)-l_j+1$；没有这样的区间时取 0。即使 $x$ 位于两个区间的空隙中，公式也成立。单次计算为 $O(\log n)$。&lt;/li&gt;
&lt;li&gt;坐标与前缀长度可能达到 $10^{15}$，相关计算需统一使用 &lt;code&gt;long long&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;N-5. C++17 核心模板&lt;/h5&gt;
&lt;p&gt;以下代码放在 &lt;code&gt;solve()&lt;/code&gt; 内；&lt;code&gt;f(s)&lt;/code&gt; 已实现，区间数组 &lt;code&gt;l,r&lt;/code&gt; 使用 1-based 下标，&lt;code&gt;n,k&lt;/code&gt; 和坐标均为整数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto find_s = [&amp;amp;]() -&amp;gt; ll {
    if (k == 0) return r[n] + 1;

    ll L = -1;
    for (int i = 1; i &amp;lt;= n; ++i) {
        ll val = f(l[i]);
        if (val == k) return l[i];
        if (val &amp;gt; k) {
            L = l[i];
            break;
        }
    }
    if (L == -1) return -1; // 最大感染数小于 k

    ll R = r[n] + 1;        // f(L) &amp;gt; k，f(R) = 0 &amp;lt;= k
    while (L + 1 &amp;lt; R) {
        ll mid = L + (R - L) / 2;
        if (f(mid) &amp;gt; k) L = mid;
        else R = mid;
    }
    return R; // 相邻时必有 f(R) == k
};

cout &amp;lt;&amp;lt; find_s() &amp;lt;&amp;lt; &apos;\n&apos;;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;局限：若每步可跳过整数目标（如 $2\to0$ 找 1），结论不成立；两端未跨越 $k$ 时也不适用。&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;O. SOS：先把集合包含方向写出来&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：候选满足“至少含有这些位”、与 x 按位不相交、某些位全部为1。&lt;/p&gt;
&lt;p&gt;子集和从缺一位传给有这一位，超集和从有这一位传给缺这一位。用 &lt;code&gt;01&lt;/code&gt; 检查：子集是 &lt;code&gt;00,01&lt;/code&gt;，超集是 &lt;code&gt;01,11&lt;/code&gt;。&lt;code&gt;x&amp;amp;y==0&lt;/code&gt; 则 y 是 &lt;code&gt;FULL^x&lt;/code&gt; 的子集，调用 &lt;code&gt;cp::subset_witness(a,B)&lt;/code&gt; 后查补集即可。&lt;/p&gt;
&lt;p&gt;求非空子集 AND=0：超集统计 c[S]，容斥加减 &lt;code&gt;2^c[S]-1&lt;/code&gt;，符号由 popcount(S) 的奇偶决定。预处理2的幂，避免每个mask重复快速幂。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;cf/165E.cpp&lt;/code&gt;、&lt;code&gt;cf/449D.cpp&lt;/code&gt;。完整公式见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#5-%E9%9B%86%E5%90%88%E5%85%B3%E7%B3%BB-sos-%E6%96%B9%E5%90%91%E4%B8%8E%E5%AE%B9%E6%96%A5&quot;&gt;算法竞赛数学套路&lt;/a&gt;，自包含代码见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;P. 乘积为完全平方：质因子指数奇偶 + 前缀相等&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：区间乘积巨大，但只关心它是否为平方。&lt;/p&gt;
&lt;p&gt;不乘出乘积，而存质因子指数模2。区间乘积为平方 iff 两端前缀向量相同。用质数集合对称差维护，或质数种类小时压成bit。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;12&lt;/code&gt; 和 &lt;code&gt;3&lt;/code&gt; 相乘为平方，指数2必须抵消；不能只记出现的质数，也不能将质数本身数值随意XOR来替代坐标向量。0与负数额外处理。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;cf/cf1125/f.cpp&lt;/code&gt;。完全k次幂改成指数模k，查询互补向量。&lt;/p&gt;
&lt;h4&gt;Q. 严格多数的坏事件互斥&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：每个选择只属一个类别，禁止某类数量超过所选总数的一半。&lt;/p&gt;
&lt;p&gt;两类不能同时严格过半，故“总方案数 - 每类坏方案数之和”即可。固定类别j，用差值 &lt;code&gt;选j个数-选其他个数&lt;/code&gt; 做DP，最后减去差值&amp;gt;0的状态。&lt;/p&gt;
&lt;p&gt;若变为“大于等于一半”，两类各占一半可以同时发生，就不能直接减。空方案是否允许必须独立处理。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;luogu/P5664.cpp&lt;/code&gt;，转移与模减法见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#6-%E4%B8%A5%E6%A0%BC%E5%A4%9A%E6%95%B0-%E5%9D%8F%E4%BA%8B%E4%BB%B6%E5%8F%AF%E8%83%BD%E4%BA%92%E6%96%A5&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;R. mask 已决定的余数，不再增加状态维&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：已选元素集合固定，所有组目标和为T。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;rem=sum[mask]%T&lt;/code&gt; 唯一，删除余数维。但“余数为0”是否完成一个合法组依赖题意；装桶需检查不超过T，计数倍数边界是另一种模型。&lt;code&gt;dp[0]&lt;/code&gt; 根据“已完成非空组数”初始化为0。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;atcoder/atcoder480/f.cpp&lt;/code&gt;。用充分性与可恢复性同时审查状态：未来不同则不能合并，量已唯一决定则不必存。&lt;/p&gt;
&lt;h4&gt;S. 离线缓存：下一次最晚使用者优先淘汰&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：已知完整访问序列，容量有限、载入代价相同，求最少缺失。&lt;/p&gt;
&lt;p&gt;从后往前计算每次访问的下一次位置；标准单项请求模型中，满缓存缺失时淘汰下次使用最远的已有对象，永不再用视为无穷。交换论证：若另一方案淘汰更早要用者，交换这两个淘汰对象，在更早的那次访问前不会更差。&lt;/p&gt;
&lt;p&gt;本地 &lt;code&gt;nowcoder_2026_summer/8/m.cpp&lt;/code&gt; 将Trie前缀映射为访问对象，并用PBDS修改下一次位置。&lt;strong&gt;整批前缀需要共存的规则和逐个请求不同&lt;/strong&gt;，不能把通用单项模板原封不动套到整批模型。是否能提前丢弃、当前批次容量如何约束，均要查原题。&lt;/p&gt;
&lt;p&gt;自包含单项版本 &lt;code&gt;cp::offline_cache_misses&lt;/code&gt; 使用惰性堆，复杂度O(n log n)、空间O(n)，不是O(n log capacity)。容量0单独返回访问数。&lt;/p&gt;
&lt;h4&gt;T. min/max 组成代价：断点与斜率&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：参数t变化，代价为线性项加若干截断区间贡献。&lt;/p&gt;
&lt;p&gt;先标出改变表达式的断点，如l_i,r_i。相邻断点间函数线性，最值在端点或整段取得；不需要先证明整个函数单峰。&lt;/p&gt;
&lt;p&gt;同坐标事件一起处理：旧斜率推值到pos → 更新答案 → 合并pos事件。&lt;code&gt;cp::clipped_cost_min&lt;/code&gt; 对指定的截断模型返回最优值与t；通用推导见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#19-%E5%88%86%E6%AE%B5%E7%BA%BF%E6%80%A7%E5%87%BD%E6%95%B0-%E6%89%AB%E6%96%AD%E7%82%B9-%E4%B8%8D%E7%8C%9C%E5%8D%95%E5%B3%B0&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;reginonals/26xian/h.cpp&lt;/code&gt;。128位必须保护括号内乘法。&lt;/p&gt;
&lt;h4&gt;U. 同步加减的数对：先压缩差值&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：两数一起加减，或者同时除某个公因子。&lt;/p&gt;
&lt;p&gt;一起加减保持差d；共同因子整除d；同除p使差变d/p。因此可先分解初始差，递归只选择其质因子，再记忆化当前(a,d)。向上和向下凑倍数是否都允许，必须服从原题。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;reginonals/21nanjing/j.cpp&lt;/code&gt;。d=0、1及数值是否要求正数需单独分析，不能盲抄非零差的分解过程。&lt;/p&gt;
&lt;h4&gt;V. 乘法统计：转到原根指数域做循环卷积&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：模素数p，非零乘积的余数分布，或重复独立乘法。&lt;/p&gt;
&lt;p&gt;非零值=g^e后，乘法变指数相加mod(p-1)，由线性卷积再按p-1折叠。0单独处理；1对应指数0；多项式快速幂单位元为[1,0,...]。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;reginonals/23xian/f.cpp&lt;/code&gt;。原根、NTT长度、计数模数是三个不同参数；不能把乘法值域素数p直接当NTT模数。见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#13-%E6%A8%A1%E7%B4%A0%E6%95%B0%E7%9A%84%E4%B9%98%E6%B3%95-%E6%8C%87%E6%95%B0%E5%8A%A0%E6%B3%95&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;W. 区间颜色比较：先变前缀差，再看二维偏序&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：同一区间内多种字符数量之间有若干不等式。&lt;/p&gt;
&lt;p&gt;R&amp;gt;=G与R&amp;gt;=B变为两个前缀差X,Y，合法(j,i]等价于X_j&amp;lt;=X_i,Y_j&amp;lt;=Y_i。若答案是所选不交区间总长度，再将i-j拆成i+(-j)，查询历史点的dp[j]-j最大值。&lt;/p&gt;
&lt;p&gt;不要因“二维”就直接选树套树；先说明第三个时间约束j&amp;lt;i由处理顺序保证，查询在插入前。&lt;code&gt;cp::Fenwick2DMax&lt;/code&gt; 预收坐标，后续在线chmax与前缀最大值查询。&lt;/p&gt;
&lt;p&gt;来源：用户提供的9月RGB回顾，未凭题名补造完整题面。见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#23-%E5%8C%BA%E9%97%B4%E6%95%B0%E9%87%8F%E6%AF%94%E8%BE%83-%E5%89%8D%E7%BC%80%E5%B7%AE-%E5%A4%9A%E7%BB%B4%E5%81%8F%E5%BA%8F&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;X. 树上路径差分：用割决定传播方向&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：批量路径对每条树边的覆盖次数或奇偶。&lt;/p&gt;
&lt;p&gt;端点XOR后，边的答案是子树标记XOR，必须从子到父恢复。理由：路径跨越子树割当且仅当一端在子树里。&lt;/p&gt;
&lt;p&gt;若改求普通次数，需要端点+1、LCA-2；点覆盖次数又是另一套LCA修正。根到点前缀的父传子不能替代这一步。&lt;/p&gt;
&lt;p&gt;来源：用户提供的Canal Crossing回顾。迭代代码 &lt;code&gt;cp::tree_path_xor_edges&lt;/code&gt; 不依赖LCA，适用于边覆盖奇偶。&lt;/p&gt;
&lt;h4&gt;Y. 算法退出前，先完成状态恢复&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：DSU on Tree、回溯、虚树多询问、二分check临时统计。&lt;/p&gt;
&lt;p&gt;提前找到答案只允许跳过不再需要的搜索，不能跳过本层负责的回滚。保存found，完成清理后返回，或用局部容器/作用域恢复。keep=false需恢复，keep=true按协议保留，二者不能混淆。&lt;/p&gt;
&lt;p&gt;固定验证：同一个check调用两次结果相同、用例次序交换不影响各自答案、兄弟处理顺序不改变结果。来源：用户提供的10月DSU on Tree回顾。&lt;/p&gt;
&lt;h4&gt;Z. 同key对象：相遇事件、计数还是等价历史？&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：map中用位置、时间、前缀状态等作为key。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;mp[key]=value&lt;/code&gt;默认丢弃旧对象。先判断同key是否应碰撞、累加、保留全部ID，还是只需保留最小代价。树上碰撞最小反例：一个节点、两个对象同一时刻出现，不能互相覆盖。&lt;/p&gt;
&lt;p&gt;同理，前缀平方状态需要累加频次，最短路状态通常保留最小距离。容器操作应来自状态等价证明，而不是按习惯赋值。&lt;/p&gt;
&lt;hr /&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-9-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;9.2 贡献法应用&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：保留推导和公式，不将整篇说明误放进 C++ 代码块。&lt;/p&gt;
&lt;h3&gt;贡献法应用&lt;/h3&gt;
&lt;p&gt;贡献法适用于答案由大量方案、区间或组合共同构成的情形。直接枚举这些整体对象通常会产生重复计算；更有效的方式是选择一个更小的基本对象，统计它在多少个整体答案中出现，并把“出现次数 $\times$ 单次贡献”累加。&lt;/p&gt;
&lt;p&gt;本文的两道题都属于这一类：数组差异题把贡献对象选为排序后的数对或单个元素；函数题把贡献对象选为差分数组中的某个位置。&lt;/p&gt;
&lt;h4&gt;问题 E：数组差异&lt;/h4&gt;
&lt;h5&gt;题目重述&lt;/h5&gt;
&lt;p&gt;给定 $n$ 个数，从中选择 $k$ 个数组成新数组。一个数组的差异度定义为其中任意两数差值的绝对值之和。要求所有 $\binom n k$ 种选择方案的差异度总和，并对 $10^9+7$ 取模。&lt;/p&gt;
&lt;h5&gt;关键观察&lt;/h5&gt;
&lt;p&gt;将数组排序为&lt;/p&gt;
&lt;p&gt;$$
s[1]\le s[2]\le \cdots \le s[n].
$$&lt;/p&gt;
&lt;p&gt;排序后任意一对下标 $i&amp;lt;j$ 的差值为 $s[j]-s[i]$。固定这对数后，若一个 $k$ 元选择方案包含它们，则这对数向该方案的差异度贡献 $s[j]-s[i]$。剩余 $k-2$ 个数可从其余 $n-2$ 个位置中选择，因此该数对被计入&lt;/p&gt;
&lt;p&gt;$$
\binom{n-2}{k-2}
$$&lt;/p&gt;
&lt;p&gt;次。&lt;/p&gt;
&lt;p&gt;也可以进一步按单个元素统计。固定 $s[i]$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;它作为较大值时，与前面 $i-1$ 个数形成正贡献；&lt;/li&gt;
&lt;li&gt;它作为较小值时，与后面 $n-i$ 个数形成负贡献。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;因此 $s[i]$ 的系数为 $(i-1)-(n-i)$。&lt;/p&gt;
&lt;h5&gt;解析&lt;/h5&gt;
&lt;p&gt;根据上面的计数，答案为&lt;/p&gt;
&lt;h1&gt;$$
\text{ans}&lt;/h1&gt;
&lt;p&gt;\binom{n-2}{k-2}
\sum_{i=1}^{n}\bigl((i-1)-(n-i)\bigr)s[i].
$$&lt;/p&gt;
&lt;p&gt;组合数通过阶乘和逆元预处理。由于模数 $10^9+7$ 为质数，使用快速幂计算 $x^{p-2}$ 得到乘法逆元。&lt;/p&gt;
&lt;p&gt;时间复杂度为 $O(n\log n)$，瓶颈在排序；空间复杂度为 $O(n)$。&lt;/p&gt;
&lt;h5&gt;代码&lt;/h5&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#define ll long long
#define N 200005
using namespace std;
ll ans;
ll n, k;
ll t;
const ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k;
    vector&amp;lt;ll&amp;gt; s(n + 5, 0);
    vector&amp;lt;ll&amp;gt; fact(n + 5, 0);
    vector&amp;lt;ll&amp;gt; fact_inv(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++) {
        cin &amp;gt;&amp;gt; s[i];
    }
    sort(s.begin() + 1, s.begin() + n + 1);
    auto qp = [&amp;amp;](ll x, ll k) {
        ll res = 1;
        while (k) {
            if (k &amp;amp; 1)
                res = (res * x) % mod;
            x = (x * x) % mod;
            k &amp;gt;&amp;gt;= 1;
        }
        return res;
    };
    auto init = [&amp;amp;]() {
        fact[0] = 1;
        fact_inv[0] = 1;
        for (int i = 1; i &amp;lt;= n; i++) {
            fact[i] = (fact[i - 1] * i) % mod;
            fact_inv[i] = (fact_inv[i - 1] * i) % mod;
        }
        fact_inv[n] = qp(fact[n], mod - 2);
        for (int i = n - 1; i &amp;gt;= 1; i--) {
            fact_inv[i] = ((i + 1) * fact_inv[i + 1]) % mod;
        }
    };
    init();
    auto c = [&amp;amp;](ll n, ll m) { if(n&amp;lt;0 || m&amp;lt;0 || m&amp;gt;n) return 0LL; return (fact[n] * fact_inv[m] % mod * fact_inv[n - m] % mod); };
    ll res = 0;
    for (int i = 1; i &amp;lt;= n; i++) {
        res = (res + (i - 1 - (n - i)) * s[i]) % mod;
    }
    res = (res * c(n - 2, k - 2)) % mod;
    cout &amp;lt;&amp;lt; (res + mod) % mod;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;问题 C：函数&lt;/h4&gt;
&lt;h5&gt;题目重述&lt;/h5&gt;
&lt;p&gt;给定长度为 $n$ 的序列 $v[1..n]$ 和 $q$ 次询问。对于每个区间 $[l,r]$，要求所有连续子序列 $v[x..y]$（$l\le x&amp;lt;y\le r$）的 Lipschitz 常数之和。&lt;/p&gt;
&lt;p&gt;序列 $v[x..y]$ 的 Lipschitz 常数定义为满足&lt;/p&gt;
&lt;p&gt;$$
|v[a]-v[b]|\le K|a-b|
$$&lt;/p&gt;
&lt;p&gt;的最小整数 $K$，其中 $x\le a&amp;lt;b\le y$。&lt;/p&gt;
&lt;h5&gt;关键观察&lt;/h5&gt;
&lt;p&gt;令相邻差分为&lt;/p&gt;
&lt;p&gt;$$
d[i]=|v[i+1]-v[i]|.
$$&lt;/p&gt;
&lt;p&gt;对任意 $a&amp;lt;b$，由三角不等式可得&lt;/p&gt;
&lt;p&gt;$$
|v[a]-v[b]|
\le \sum_{i=a}^{b-1}|v[i+1]-v[i]|
\le (b-a)\max_{a\le i&amp;lt;b}d[i].
$$&lt;/p&gt;
&lt;p&gt;因此 $K=\max_{a\le i&amp;lt;b}d[i]$ 一定满足 Lipschitz 条件。&lt;/p&gt;
&lt;p&gt;另一方面，若 $d[p]$ 是区间内的最大相邻差分，取相邻两点 $a=p,b=p+1$，则&lt;/p&gt;
&lt;p&gt;$$
|v[p]-v[p+1]|=d[p]\le K.
$$&lt;/p&gt;
&lt;p&gt;所以任意合法的 $K$ 都不能小于最大相邻差分。两边合并，连续子序列 $v[x..y]$ 的 Lipschitz 常数恰好等于差分区间 $d[x..y-1]$ 的最大值。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/lipschitz_diagram.png&quot; alt=&quot;Lipschitz 常数与相邻差分最大值&quot; /&gt;&lt;/p&gt;
&lt;h5&gt;解析&lt;/h5&gt;
&lt;p&gt;询问 $[l,r]$ 被转化为：求差分数组 $d[l..r-1]$ 的所有非空连续子数组最大值之和。&lt;/p&gt;
&lt;p&gt;对每个差分位置 $i$ 计算其作为最大值的贡献。设：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$\text{left}[i]$ 为 $i$ 左侧最近的、满足 $d[\text{left}[i]]&amp;gt;d[i]$ 的位置；若不存在，则为 $l-1$；&lt;/li&gt;
&lt;li&gt;$\text{right}[i]$ 为 $i$ 右侧最近的、满足 $d[\text{right}[i]]\ge d[i]$ 的位置；若不存在，则为 $r$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;左侧使用严格大于、右侧使用大于等于，是为了处理相等最大值。若一个子数组中最大值出现多次，这种边界定义会固定由其中一个位置承担贡献，避免重复计数。&lt;/p&gt;
&lt;p&gt;当 $d[i]$ 作为某个差分子数组的最大值时，左端点可选&lt;/p&gt;
&lt;p&gt;$$
i-\text{left}[i]
$$&lt;/p&gt;
&lt;p&gt;种，右端点可选&lt;/p&gt;
&lt;p&gt;$$
\text{right}[i]-i
$$&lt;/p&gt;
&lt;p&gt;种。因此 $d[i]$ 的总贡献为&lt;/p&gt;
&lt;p&gt;$$
d[i]\cdot(i-\text{left}[i])\cdot(\text{right}[i]-i).
$$&lt;/p&gt;
&lt;p&gt;每次询问用两遍单调栈求出左右边界，再累加所有位置的贡献。由于 $q\le 100$，按询问逐个线性处理区间即可通过。&lt;/p&gt;
&lt;p&gt;单次询问复杂度为 $O(r-l+1)$，总时间复杂度为 $O(nq)$，空间复杂度为 $O(n)$。&lt;/p&gt;
&lt;h5&gt;代码&lt;/h5&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 200005
using namespace std;
ll ans;
ll n, k, m, q;
ll t;
#define pr pair&amp;lt;ll, ll&amp;gt;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; q;
    vector&amp;lt;ll&amp;gt; s(n + 5, 0);
    vector&amp;lt;ll&amp;gt; diff(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++) {
        cin &amp;gt;&amp;gt; s[i];
        diff[i - 1] = abs(s[i] - s[i - 1]);
    }
    vector&amp;lt;int&amp;gt; left(n + 5, 0);
    vector&amp;lt;int&amp;gt; right(n + 5, 0);
    while (q--) {
        ll l, r;
        cin &amp;gt;&amp;gt; l &amp;gt;&amp;gt; r;
        if (l == r) {
            cout &amp;lt;&amp;lt; 0 &amp;lt;&amp;lt; &apos;\n&apos;;
            continue;
        }
        r--;
        stack&amp;lt;int&amp;gt; sta;
        for (int i = l; i &amp;lt;= r; i++) {
            while (sta.size() &amp;amp;&amp;amp; diff[sta.top()] &amp;lt;= diff[i]) {
                sta.pop();
            }
            left[i] = sta.empty() ? l - 1 : sta.top();
            sta.push(i);
        }
        while (sta.size())
            sta.pop();
        for (int i = r; i &amp;gt;= l; i--) {
            while (sta.size() &amp;amp;&amp;amp; diff[sta.top()] &amp;lt; diff[i]) {
                sta.pop();
            }
            right[i] = sta.empty() ? r + 1 : sta.top();
            sta.push(i);
        }
        ll res = 0;
        for (int i = l; i &amp;lt;= r; i++)
            res += diff[i] * (i - left[i]) * (right[i] - i);
        cout &amp;lt;&amp;lt; res &amp;lt;&amp;lt; &apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-10&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第十章 常用可复用模板&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-10-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;10.1 自包含模板、前提与完整示例&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：按题面识别方法，使用前核对适用条件与复杂度。&lt;/p&gt;
&lt;h3&gt;算法竞赛模板增补&lt;/h3&gt;
&lt;blockquote&gt;
&lt;p&gt;[!tip] 直接使用
下方第一份代码是完整自包含头文件，GNU C++17、无需第三方库；第二份是完整调用示例。提交单文件时，将第一份放到 main 前，再去掉第二份中的本地 include。不要只复制函数调用而遗漏依赖。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;本页提供与题面无关的自包含接口。先从下表确认模型、数据范围与复杂度，再复制对应代码。&lt;/p&gt;
&lt;h4&gt;模板选用与前提&lt;/h4&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;接口&lt;/th&gt;
&lt;th&gt;用于什么&lt;/th&gt;
&lt;th&gt;时间 / 空间&lt;/th&gt;
&lt;th&gt;必须满足&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;floor_div / ceil_div / to_string128&lt;/td&gt;
&lt;td&gt;带符号数学整除与128位输出&lt;/td&gt;
&lt;td&gt;O(1) / O(1)，输出按位数&lt;/td&gt;
&lt;td&gt;整除参数64位，除数非0；返回128位&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;norm / pow_mod / inv_mod&lt;/td&gt;
&lt;td&gt;模归一化、模幂、一般模数逆元&lt;/td&gt;
&lt;td&gt;幂O(log e)，逆元O(log m)&lt;/td&gt;
&lt;td&gt;模数正；逆元m&amp;gt;=2且互质，否则nullopt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Comb&amp;lt;MOD&amp;gt;&lt;/td&gt;
&lt;td&gt;阶乘组合数&lt;/td&gt;
&lt;td&gt;预处理O(N)，查询O(1) / O(N)&lt;/td&gt;
&lt;td&gt;MOD为素数、0&amp;lt;=N&amp;lt;MOD，n不超过预处理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;floor_sum_nonnegative&lt;/td&gt;
&lt;td&gt;线性分子整除和&lt;/td&gt;
&lt;td&gt;O(log m) / O(1)&lt;/td&gt;
&lt;td&gt;n,a,b&amp;gt;=0,m&amp;gt;0，精确答案可放有符号128位&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;sos(f,super,inverse)&lt;/td&gt;
&lt;td&gt;子集/超集zeta及逆变换&lt;/td&gt;
&lt;td&gt;O(B2^B) / 原地&lt;/td&gt;
&lt;td&gt;长度是非零2次幂；不是模运算，中间和可放64位&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;subset_witness&lt;/td&gt;
&lt;td&gt;为每个mask找一个输入子掩码&lt;/td&gt;
&lt;td&gt;O(B2^B+n) / O(2^B)&lt;/td&gt;
&lt;td&gt;0&amp;lt;=B&amp;lt;=24，值在[0,2^B)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;count_and_zero&lt;/td&gt;
&lt;td&gt;非空下标子集AND为0计数&lt;/td&gt;
&lt;td&gt;O(n+B2^B) / O(n+2^B)&lt;/td&gt;
&lt;td&gt;0&amp;lt;=B&amp;lt;=24，计数取模；相同值下标可分别选&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;exact_gcd_pairs&lt;/td&gt;
&lt;td&gt;i&amp;lt;j的GCD恰好值频数&lt;/td&gt;
&lt;td&gt;O(n+V log V) / O(V)&lt;/td&gt;
&lt;td&gt;a_i&amp;gt;0，V=max(a)可开数组，n为int规模&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;count_subarray_gcd&lt;/td&gt;
&lt;td&gt;所有连续区间GCD为target&lt;/td&gt;
&lt;td&gt;每轮O(log V)个状态，各调用gcd / O(log V)&lt;/td&gt;
&lt;td&gt;非负64位输入；0额外占一个状态，空输入返回0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;z_function&lt;/td&gt;
&lt;td&gt;字符串每个后缀与原串的LCP&lt;/td&gt;
&lt;td&gt;O(n) / O(n)&lt;/td&gt;
&lt;td&gt;0-based，z[0]=n；空串返回空&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;tree_path_xor_edges&lt;/td&gt;
&lt;td&gt;批量路径对每条边覆盖奇偶&lt;/td&gt;
&lt;td&gt;O(n+q) / O(n)&lt;/td&gt;
&lt;td&gt;连通树，顶点0-based；结果按输入边顺序&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fenwick2DMax&lt;/td&gt;
&lt;td&gt;x&amp;lt;=X且y&amp;lt;=Y的历史点最大值&lt;/td&gt;
&lt;td&gt;单次O(log² n) / O(n log n)&lt;/td&gt;
&lt;td&gt;预先收集所有更新坐标；仅chmax，不支持删点/降值&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;convolution / ntt&lt;/td&gt;
&lt;td&gt;998244353模数多项式乘法&lt;/td&gt;
&lt;td&gt;O(L log L) / O(L)&lt;/td&gt;
&lt;td&gt;L为&amp;gt;=长度和-1的2次幂，L&amp;lt;=2^23；直接ntt的输入需先归一化&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;offline_cache_misses&lt;/td&gt;
&lt;td&gt;单项访问序列的最少缓存缺失&lt;/td&gt;
&lt;td&gt;O(n log n) / O(n)&lt;/td&gt;
&lt;td&gt;容量非负、初始空、等载入代价；不适用整批共存模型&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;clipped_cost_min&lt;/td&gt;
&lt;td&gt;非负参数截断区间代价最小值&lt;/td&gt;
&lt;td&gt;O(n log n) / O(n)&lt;/td&gt;
&lt;td&gt;精确模型见数学套路；x,y&amp;gt;=0,0&amp;lt;=l&amp;lt;=r，128位不溢出&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h4&gt;固定约定与内存&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;SOS数组长度是&lt;code&gt;1&amp;lt;&amp;lt;B&lt;/code&gt;，位外层；子集默认 &lt;code&gt;super=false&lt;/code&gt;，超集传 &lt;code&gt;true&lt;/code&gt;。逆变换传第三个参数 &lt;code&gt;true&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;subset_witness&lt;/code&gt;无解返回-1；存在值0时不能把0当无解。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;inv_mod&lt;/code&gt;可能无解，先判断optional；组合数模板不自动检查MOD是否为素数。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Fenwick2DMax::NEG=-(1LL&amp;lt;&amp;lt;60)&lt;/code&gt;，插入值必须大于NEG，查询无点返回NEG；不要直接拿NEG加代价。&lt;/li&gt;
&lt;li&gt;NTT模数固定，不能随意改常量。循环卷积需再按目标周期折叠。&lt;/li&gt;
&lt;li&gt;有符号128位也有上界，不是任意精度整数。乘法前先提升操作数。&lt;/li&gt;
&lt;li&gt;B=22：int数组约16 MiB，long long数组约32 MiB；B=24时分别约64/128 MiB。先估峰值再选B。&lt;/li&gt;
&lt;li&gt;所有assert表示使用前提，不能代替审题；关闭assert后也必须满足前提。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;完整头文件&lt;/h4&gt;
&lt;p&gt;本地同源文件：&lt;a href=&quot;/home/sanzenin/algo_templates/ready/cp_ready.hpp:1&quot;&gt;cp_ready.hpp&lt;/a&gt;。下面内容与文件逐字一致。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#pragma once
#include &amp;lt;bits/stdc++.h&amp;gt;

// GNU C++17. All public indices below are zero-based unless stated otherwise.
namespace cp {
using i64 = long long;
using i128 = __int128_t;

// Inputs are signed 64-bit; output is widened (LLONG_MIN / -1 is supported).
inline i128 floor_div(i64 a, i64 b) {
    assert(b != 0);
    i128 x = a, y = b, q = x / y, r = x % y;
    return q - (r != 0 &amp;amp;&amp;amp; ((r &amp;lt; 0) != (y &amp;lt; 0)));
}
inline i128 ceil_div(i64 a, i64 b) {
    assert(b != 0);
    i128 x = a, y = b, q = x / y, r = x % y;
    return q + (r != 0 &amp;amp;&amp;amp; ((r &amp;lt; 0) == (y &amp;lt; 0)));
}
inline std::string to_string128(i128 x) {
    bool neg = x &amp;lt; 0;
    __uint128_t y = neg ? __uint128_t(-(x + 1)) + 1 : __uint128_t(x);
    std::string s;
    do { s.push_back(char(&apos;0&apos; + y % 10)); y /= 10; } while (y);
    if (neg) s.push_back(&apos;-&apos;);
    std::reverse(s.begin(), s.end());
    return s;
}
inline i64 norm(i64 a, i64 m) {
    assert(m &amp;gt; 0);
    a %= m;
    return a &amp;lt; 0 ? a + m : a;
}
inline i64 pow_mod(i64 a, i64 e, i64 m) {
    assert(e &amp;gt;= 0 &amp;amp;&amp;amp; m &amp;gt; 0);
    a = norm(a, m);
    i64 r = 1 % m;
    while (e) {
        if (e &amp;amp; 1) r = i128(r) * a % m;
        a = i128(a) * a % m;
        e &amp;gt;&amp;gt;= 1;
    }
    return r;
}
// m &amp;gt;= 2; works for composite moduli too. nullopt means gcd(a,m) != 1.
inline std::optional&amp;lt;i64&amp;gt; inv_mod(i64 a, i64 m) {
    assert(m &amp;gt;= 2);
    i128 r0 = norm(a, m), r1 = m, s0 = 1, s1 = 0;
    while (r1) {
        i128 q = r0 / r1;
        i128 nr = r0 - q * r1, ns = s0 - q * s1;
        r0 = r1; r1 = nr; s0 = s1; s1 = ns;
    }
    if (r0 != 1) return std::nullopt;
    s0 %= m;
    if (s0 &amp;lt; 0) s0 += m;
    return i64(s0);
}

// Prime modulus ONLY; 0 &amp;lt;= prepared N &amp;lt; MOD. No Lucas in this class.
template&amp;lt;int MOD = 998244353&amp;gt; struct Comb {
    std::vector&amp;lt;i64&amp;gt; fac, ifac;
    explicit Comb(int n) : fac(n + 1, 1), ifac(n + 1, 1) {
        assert(0 &amp;lt;= n &amp;amp;&amp;amp; n &amp;lt; MOD);
        for (int i = 1; i &amp;lt;= n; ++i) fac[i] = fac[i - 1] * i % MOD;
        ifac[n] = pow_mod(fac[n], MOD - 2, MOD);
        for (int i = n; i; --i) ifac[i - 1] = ifac[i] * i % MOD;
    }
    i64 C(int n, int k) const {
        if (n &amp;lt; 0 || k &amp;lt; 0 || k &amp;gt; n) return 0;
        assert(n &amp;lt; int(fac.size()));
        return fac[n] * ifac[k] % MOD * ifac[n - k] % MOD;
    }
};

// Sum_{i=0}^{n-1} floor((a*i+b)/m). Nonnegative signed-64 inputs, m &amp;gt; 0.
// The exact answer MUST fit signed __int128. Time O(log m).
inline i128 floor_sum_nonnegative(i64 nn, i64 mm, i64 aa, i64 bb) {
    assert(nn &amp;gt;= 0 &amp;amp;&amp;amp; mm &amp;gt; 0 &amp;amp;&amp;amp; aa &amp;gt;= 0 &amp;amp;&amp;amp; bb &amp;gt;= 0);
    i128 n = nn, m = mm, a = aa, b = bb, ans = 0;
    while (true) {
        if (a &amp;gt;= m) { ans += (n * (n - 1) / 2) * (a / m); a %= m; }
        if (b &amp;gt;= m) { ans += n * (b / m); b %= m; }
        i128 y = a * n + b;
        if (y &amp;lt; m) break;
        n = y / m; b = y % m;
        std::swap(a, m);
    }
    return ans;
}

// f.size() must be a nonzero power of two, with size &amp;lt;= INT_MAX.
// All intermediate sums/differences MUST fit i64; these are not modular sums.
inline void sos(std::vector&amp;lt;i64&amp;gt;&amp;amp; f, bool super = false, bool inverse = false) {
    int n = int(f.size());
    assert(n &amp;gt; 0 &amp;amp;&amp;amp; (n &amp;amp; (n - 1)) == 0);
    for (int bit = 1; bit &amp;lt; n; bit &amp;lt;&amp;lt;= 1)
        for (int mask = 0; mask &amp;lt; n; ++mask)
            if (bool(mask &amp;amp; bit) != super) {
                if (inverse) f[mask] -= f[mask ^ bit];
                else f[mask] += f[mask ^ bit];
            }
}
// Return one input submask for each mask, -1 if absent. 0 &amp;lt;= B &amp;lt;= 24.
inline std::vector&amp;lt;int&amp;gt; subset_witness(const std::vector&amp;lt;int&amp;gt;&amp;amp; a, int B) {
    assert(0 &amp;lt;= B &amp;amp;&amp;amp; B &amp;lt;= 24);
    int n = 1 &amp;lt;&amp;lt; B;
    std::vector&amp;lt;int&amp;gt; f(n, -1);
    for (int x : a) { assert(0 &amp;lt;= x &amp;amp;&amp;amp; x &amp;lt; n); f[x] = x; }
    for (int bit = 1; bit &amp;lt; n; bit &amp;lt;&amp;lt;= 1)
        for (int mask = 0; mask &amp;lt; n; ++mask)
            if (mask &amp;amp; bit) f[mask] = std::max(f[mask], f[mask ^ bit]);
    return f;
}
// Count NONEMPTY index-subsets with bitwise AND == 0, modulo MOD.
// Equal values at different input indices are distinct choices. 0 &amp;lt;= B &amp;lt;= 24.
template&amp;lt;int MOD = 1000000007&amp;gt;
int count_and_zero(const std::vector&amp;lt;int&amp;gt;&amp;amp; a, int B) {
    static_assert(MOD &amp;gt;= 2);
    assert(0 &amp;lt;= B &amp;amp;&amp;amp; B &amp;lt;= 24);
    int n = 1 &amp;lt;&amp;lt; B;
    std::vector&amp;lt;i64&amp;gt; cnt(n);
    for (int x : a) { assert(0 &amp;lt;= x &amp;amp;&amp;amp; x &amp;lt; n); ++cnt[x]; }
    sos(cnt, true);
    std::vector&amp;lt;int&amp;gt; pow2(a.size() + 1, 1);
    for (size_t i = 1; i &amp;lt; pow2.size(); ++i) pow2[i] = 2LL * pow2[i - 1] % MOD;
    i64 ans = 0;
    for (int mask = 0; mask &amp;lt; n; ++mask) {
        i64 ways = (pow2[cnt[mask]] + i64(MOD) - 1) % MOD;
        ans += (__builtin_popcount(unsigned(mask)) &amp;amp; 1) ? -ways : ways;
        ans %= MOD;
    }
    return int((ans + MOD) % MOD);
}

// Positive a[i] &amp;lt;= V; pairs of indices i &amp;lt; j. Empty input returns {0}.
inline std::vector&amp;lt;i64&amp;gt; exact_gcd_pairs(const std::vector&amp;lt;int&amp;gt;&amp;amp; a) {
    if (a.empty()) return {0};
    int V = *std::max_element(a.begin(), a.end());
    assert(V &amp;gt;= 1);
    std::vector&amp;lt;i64&amp;gt; cnt(V + 1), exact(V + 1);
    for (int x : a) { assert(x &amp;gt; 0); ++cnt[x]; }
    for (int d = V; d &amp;gt;= 1; --d) {
        i64 c = 0;
        for (int k = d; k &amp;lt;= V; k += d) c += cnt[k];
        exact[d] = c * (c - 1) / 2;
        for (int k = d + d; k &amp;lt;= V; k += d) exact[d] -= exact[k];
    }
    return exact;
}
// Nonnegative a[i]; all zeros are supported. Answer fits i64 for int-sized n.
inline i64 count_subarray_gcd(const std::vector&amp;lt;i64&amp;gt;&amp;amp; a, i64 target) {
    assert(target &amp;gt;= 0);
    std::vector&amp;lt;std::pair&amp;lt;i64, i64&amp;gt;&amp;gt; cur, nxt;
    i64 ans = 0;
    for (i64 x : a) {
        assert(x &amp;gt;= 0);
        nxt.clear(); nxt.push_back({x, 1});
        for (auto [g, c] : cur) {
            i64 ng = std::gcd(g, x);
            if (nxt.back().first == ng) nxt.back().second += c;
            else nxt.push_back({ng, c});
        }
        cur.swap(nxt);
        for (auto [g, c] : cur) if (g == target) ans += c;
    }
    return ans;
}

// z[0] = n. For i &amp;gt; 0, z[i] = LCP(s, s.substr(i)); half-open [l,r).
inline std::vector&amp;lt;int&amp;gt; z_function(const std::string&amp;amp; s) {
    int n = int(s.size());
    std::vector&amp;lt;int&amp;gt; z(n);
    if (n) z[0] = n;
    for (int i = 1, l = 0, r = 0; i &amp;lt; n; ++i) {
        if (i &amp;lt; r) z[i] = std::min(r - i, z[i - l]);
        while (i + z[i] &amp;lt; n &amp;amp;&amp;amp; s[z[i]] == s[i + z[i]]) ++z[i];
        if (i + z[i] &amp;gt; r) { l = i; r = i + z[i]; }
    }
    return z;
}

// Connected tree, n&amp;gt;=1, zero-based vertices. Edge answers follow input order.
// Each (u,v) path toggles all its edges; no LCA is needed for XOR parity.
inline std::vector&amp;lt;int&amp;gt; tree_path_xor_edges(
        int n, const std::vector&amp;lt;std::pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;amp; edges,
        const std::vector&amp;lt;std::pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;amp; paths) {
    assert(n &amp;gt;= 1 &amp;amp;&amp;amp; int(edges.size()) == n - 1);
    std::vector&amp;lt;std::vector&amp;lt;std::pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;gt; adj(n);
    for (int i = 0; i &amp;lt; n - 1; ++i) {
        auto [u,v] = edges[i];
        assert(0 &amp;lt;= u &amp;amp;&amp;amp; u &amp;lt; n &amp;amp;&amp;amp; 0 &amp;lt;= v &amp;amp;&amp;amp; v &amp;lt; n);
        adj[u].push_back({v,i}); adj[v].push_back({u,i});
    }
    std::vector&amp;lt;int&amp;gt; parent(n, -2), pe(n, -1), order{0}, d(n), ans(n - 1);
    parent[0] = -1;
    for (size_t i = 0; i &amp;lt; order.size(); ++i) {
        int u = order[i];
        for (auto [v,e] : adj[u]) if (parent[v] == -2) {
            parent[v] = u; pe[v] = e; order.push_back(v);
        }
    }
    assert(int(order.size()) == n);
    for (auto [u,v] : paths) {
        assert(0 &amp;lt;= u &amp;amp;&amp;amp; u &amp;lt; n &amp;amp;&amp;amp; 0 &amp;lt;= v &amp;amp;&amp;amp; v &amp;lt; n);
        d[u] ^= 1; d[v] ^= 1;
    }
    for (int i = n - 1; i &amp;gt; 0; --i) {
        int u = order[i];
        ans[pe[u]] = d[u];
        d[parent[u]] ^= d[u];
    }
    return ans;
}

// All potential update coordinates must be supplied at construction.
// Incremental point chmax; query max over x&amp;lt;=X AND y&amp;lt;=Y, including ties.
// Updates never delete or decrease values. O(log^2 n) per operation.
struct Fenwick2DMax {
    static constexpr i64 NEG = -(1LL &amp;lt;&amp;lt; 60);
    std::vector&amp;lt;i64&amp;gt; xs;
    std::vector&amp;lt;std::vector&amp;lt;i64&amp;gt;&amp;gt; ys, bit;
    explicit Fenwick2DMax(const std::vector&amp;lt;std::pair&amp;lt;i64,i64&amp;gt;&amp;gt;&amp;amp; points) {
        for (auto [x,y] : points) xs.push_back(x);
        std::sort(xs.begin(), xs.end());
        xs.erase(std::unique(xs.begin(), xs.end()), xs.end());
        int n = int(xs.size()); ys.resize(n + 1); bit.resize(n + 1);
        for (auto [x,y] : points) {
            int p = int(std::lower_bound(xs.begin(), xs.end(), x) - xs.begin()) + 1;
            for (int i = p; i &amp;lt;= n; i += i &amp;amp; -i) ys[i].push_back(y);
        }
        for (int i = 1; i &amp;lt;= n; ++i) {
            auto&amp;amp; v = ys[i]; std::sort(v.begin(), v.end());
            v.erase(std::unique(v.begin(), v.end()), v.end());
            bit[i].assign(v.size() + 1, NEG);
        }
    }
    void update(i64 x, i64 y, i64 value) {
        assert(value &amp;gt; NEG);
        int p = int(std::lower_bound(xs.begin(), xs.end(), x) - xs.begin());
        assert(p &amp;lt; int(xs.size()) &amp;amp;&amp;amp; xs[p] == x);
        for (int i = p + 1; i &amp;lt;= int(xs.size()); i += i &amp;amp; -i) {
            int j = int(std::lower_bound(ys[i].begin(), ys[i].end(), y) - ys[i].begin());
            assert(j &amp;lt; int(ys[i].size()) &amp;amp;&amp;amp; ys[i][j] == y);
            for (++j; j &amp;lt; int(bit[i].size()); j += j &amp;amp; -j) bit[i][j] = std::max(bit[i][j], value);
        }
    }
    i64 query(i64 X, i64 Y) const {
        i64 ans = NEG;
        int p = int(std::upper_bound(xs.begin(), xs.end(), X) - xs.begin());
        for (int i = p; i; i -= i &amp;amp; -i) {
            int j = int(std::upper_bound(ys[i].begin(), ys[i].end(), Y) - ys[i].begin());
            for (; j; j -= j &amp;amp; -j) ans = std::max(ans, bit[i][j]);
        }
        return ans;
    }
};

// NTT specifically for 998244353, primitive root 3. No external ACL needed.
inline void ntt(std::vector&amp;lt;int&amp;gt;&amp;amp; a, bool inverse) {
    constexpr int P = 998244353;
    int n = int(a.size());
    assert(n &amp;gt;= 1 &amp;amp;&amp;amp; n &amp;lt;= (1 &amp;lt;&amp;lt; 23) &amp;amp;&amp;amp; (n &amp;amp; (n - 1)) == 0);
    for (int i = 1, j = 0; i &amp;lt; n; ++i) {
        int bit = n &amp;gt;&amp;gt; 1;
        for (; j &amp;amp; bit; bit &amp;gt;&amp;gt;= 1) j ^= bit;
        j ^= bit;
        if (i &amp;lt; j) std::swap(a[i], a[j]);
    }
    for (int len = 2; len &amp;lt;= n; len &amp;lt;&amp;lt;= 1) {
        i64 wlen = pow_mod(3, (P - 1) / len, P);
        if (inverse) wlen = pow_mod(wlen, P - 2, P);
        for (int l = 0; l &amp;lt; n; l += len) {
            i64 w = 1;
            for (int j = 0; j &amp;lt; len / 2; ++j) {
                int u = a[l + j], v = a[l + j + len / 2] * w % P;
                a[l + j] = u + v &amp;lt; P ? u + v : u + v - P;
                a[l + j + len / 2] = u - v &amp;gt;= 0 ? u - v : u - v + P;
                w = w * wlen % P;
            }
        }
    }
    if (inverse) {
        i64 inv = pow_mod(n, P - 2, P);
        for (int&amp;amp; x : a) x = x * inv % P;
    }
}
inline std::vector&amp;lt;int&amp;gt; convolution(std::vector&amp;lt;int&amp;gt; a, std::vector&amp;lt;int&amp;gt; b) {
    constexpr int P = 998244353;
    if (a.empty() || b.empty()) return {};
    size_t need = a.size() + b.size() - 1;
    assert(need &amp;lt;= (1 &amp;lt;&amp;lt; 23));
    int n = 1;
    while (size_t(n) &amp;lt; need) n &amp;lt;&amp;lt;= 1;
    for (int&amp;amp; x : a) x = int(norm(x, P));
    for (int&amp;amp; x : b) x = int(norm(x, P));
    a.resize(n); b.resize(n);
    ntt(a, false); ntt(b, false);
    for (int i = 0; i &amp;lt; n; ++i) a[i] = i64(a[i]) * b[i] % P;
    ntt(a, true); a.resize(need);
    return a;
}

// Standard SINGLE-item cache requests. Initially empty; any int item IDs.
// A cache miss loads this item; after each access &amp;lt;= capacity items may remain.
// Lazy heap: O(n log n) time / O(n) space, NOT O(n log capacity).
inline i64 offline_cache_misses(const std::vector&amp;lt;int&amp;gt;&amp;amp; seq, int capacity) {
    assert(capacity &amp;gt;= 0);
    int n = int(seq.size());
    if (!capacity) return n;
    std::vector&amp;lt;int&amp;gt; next(n, n);
    std::unordered_map&amp;lt;int, int&amp;gt; last, in;
    for (int i = n - 1; i &amp;gt;= 0; --i) {
        auto it = last.find(seq[i]);
        if (it != last.end()) next[i] = it-&amp;gt;second;
        last[seq[i]] = i;
    }
    std::priority_queue&amp;lt;std::pair&amp;lt;int, int&amp;gt;&amp;gt; q;
    i64 misses = 0;
    for (int i = 0; i &amp;lt; n; ++i) {
        if (!in.count(seq[i])) {
            ++misses;
            if (int(in.size()) == capacity) {
                while (!q.empty()) {
                    auto [pos, x] = q.top(); q.pop();
                    auto it = in.find(x);
                    if (it != in.end() &amp;amp;&amp;amp; it-&amp;gt;second == pos) { in.erase(it); break; }
                }
            }
        }
        in[seq[i]] = next[i];
        q.push({next[i], seq[i]});
    }
    return misses;
}

// Minimize F(t)=x*t+y*sum(max(0,r_i-max(l_i,t))) for integer t&amp;gt;=0.
// x,y&amp;gt;=0 and 0&amp;lt;=l_i&amp;lt;=r_i, all i64. Returns {minimum, one minimizer}.
// Maximum intermediate absolute value must fit signed __int128.
inline std::pair&amp;lt;i128, i64&amp;gt; clipped_cost_min(
        i64 x, i64 y, const std::vector&amp;lt;std::pair&amp;lt;i64, i64&amp;gt;&amp;gt;&amp;amp; intervals) {
    assert(x &amp;gt;= 0 &amp;amp;&amp;amp; y &amp;gt;= 0);
    std::vector&amp;lt;std::pair&amp;lt;i64, int&amp;gt;&amp;gt; ev;
    i128 value = 0;
    for (auto [l, r] : intervals) {
        assert(0 &amp;lt;= l &amp;amp;&amp;amp; l &amp;lt;= r);
        value += i128(y) * (i128(r) - l);
        if (l &amp;lt; r) { ev.push_back({l, 1}); ev.push_back({r, -1}); }
    }
    std::sort(ev.begin(), ev.end());
    i128 best = value;
    i64 arg = 0, prev = 0, active = 0;
    for (size_t i = 0; i &amp;lt; ev.size();) {
        i64 pos = ev[i].first;
        value += (i128(pos) - prev) * (i128(x) - i128(y) * active);
        if (value &amp;lt; best) { best = value; arg = pos; }
        while (i &amp;lt; ev.size() &amp;amp;&amp;amp; ev[i].first == pos) active += ev[i++].second;
        prev = pos;
    }
    return {best, arg};
}
} // namespace cp
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;完整调用示例&lt;/h4&gt;
&lt;p&gt;本地编译：&lt;code&gt;g++ -std=c++17 -O2 ready/example.cpp -o /tmp/cp-example&lt;/code&gt;，在 &lt;code&gt;/home/sanzenin/algo_templates&lt;/code&gt; 运行。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &quot;cp_ready.hpp&quot;
using namespace std;

int main() {
    cout &amp;lt;&amp;lt; cp::to_string128(cp::floor_div(-3, 2)) &amp;lt;&amp;lt; &apos;\n&apos;; // -2
    cp::Comb&amp;lt;&amp;gt; C(100);
    cout &amp;lt;&amp;lt; C.C(5, 2) &amp;lt;&amp;lt; &apos;\n&apos;; // 10
    cout &amp;lt;&amp;lt; cp::count_and_zero(vector&amp;lt;int&amp;gt;{1, 2, 3}, 2) &amp;lt;&amp;lt; &apos;\n&apos;; // 2
    cout &amp;lt;&amp;lt; cp::count_subarray_gcd({2, 4, 6}, 2) &amp;lt;&amp;lt; &apos;\n&apos;; // 4
    auto poly = cp::convolution({1, 2}, {3, 4});
    for (int x : poly) cout &amp;lt;&amp;lt; x &amp;lt;&amp;lt; &apos; &apos;; // 3 10 8
    cout &amp;lt;&amp;lt; &apos;\n&apos;;
    cout &amp;lt;&amp;lt; cp::offline_cache_misses({1, 2, 3, 1, 2, 3}, 2) &amp;lt;&amp;lt; &apos;\n&apos;; // 4
    auto parity = cp::tree_path_xor_edges(3, {{0, 1}, {1, 2}}, {{0, 2}, {1, 2}});
    for (int x : parity) cout &amp;lt;&amp;lt; x &amp;lt;&amp;lt; &apos; &apos;; // 1 0
    cout &amp;lt;&amp;lt; &apos;\n&apos;;

    // Model: maximize total length of disjoint RGB-balanced segments, gaps allowed.
    string s = &quot;RGB&quot;;
    vector&amp;lt;pair&amp;lt;long long,long long&amp;gt;&amp;gt; prefix{{0,0}};
    for (char c : s) {
        auto [x,y] = prefix.back();
        if (c == &apos;R&apos;) ++x, ++y;
        if (c == &apos;G&apos;) --x;
        if (c == &apos;B&apos;) --y;
        prefix.push_back({x,y});
    }
    cp::Fenwick2DMax ft(prefix);
    ft.update(0, 0, 0);
    long long dp = 0;
    for (int i = 1; i &amp;lt;= int(s.size()); ++i) {
        auto [x,y] = prefix[i];
        auto best = ft.query(x,y); // BEFORE insertion: j &amp;lt; i
        if (best != cp::Fenwick2DMax::NEG) dp = max(dp, i + best);
        ft.update(x,y,dp-i);
    }
    cout &amp;lt;&amp;lt; dp &amp;lt;&amp;lt; &apos;\n&apos;; // 3
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;预期逐行输出：&lt;code&gt;-2&lt;/code&gt;、&lt;code&gt;10&lt;/code&gt;、&lt;code&gt;2&lt;/code&gt;、&lt;code&gt;4&lt;/code&gt;、&lt;code&gt;3 10 8&lt;/code&gt;、&lt;code&gt;4&lt;/code&gt;、&lt;code&gt;1 0&lt;/code&gt;、&lt;code&gt;3&lt;/code&gt;（行末空格无影响）。RGB示例的目标是选不交合法段的最大总长度，允许跳过位置；其他目标需改DP，不能只套数据结构。&lt;/p&gt;
&lt;h4&gt;复制依赖表&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Comb&lt;/code&gt;依赖&lt;code&gt;pow_mod&lt;/code&gt;，后者依赖&lt;code&gt;norm&lt;/code&gt;和i64/i128别名。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;count_and_zero&lt;/code&gt;依赖&lt;code&gt;sos&lt;/code&gt;；&lt;code&gt;convolution&lt;/code&gt;依赖&lt;code&gt;ntt&lt;/code&gt;、&lt;code&gt;pow_mod&lt;/code&gt;、&lt;code&gt;norm&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;其余函数依赖公共头文件和类型别名。省事时直接复制整个namespace cp。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%BB%8F%E5%85%B8trick/&quot;&gt;经典Trick&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B4%E7%90%86%E7%B4%A2%E5%BC%95/&quot;&gt;算法竞赛整理索引&lt;/a&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-11&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第十一章 数学套路与赛时转化&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-11-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;11.1 数学套路&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：按题面识别方法，使用前核对适用条件与复杂度。&lt;/p&gt;
&lt;h3&gt;算法竞赛数学套路&lt;/h3&gt;
&lt;p&gt;这章按“题面长什么样 → 把什么量写出来 → 怎样算”组织。每个模式都给出可手算的小例、成立条件与实现入口。引用的原题用来提供练习模型；没有题解的原题链接，不代表其中已经给出了本章推导。&lt;/p&gt;
&lt;p&gt;实现接口见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;，代数结构与相应代码见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。本章的 &lt;code&gt;cp::&lt;/code&gt; 接口来自配套 &lt;code&gt;ready/cp_ready.hpp&lt;/code&gt;，索引约定以接口说明为准。&lt;/p&gt;
&lt;h4&gt;0. 题面信号 → 第一反应&lt;/h4&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;题面信号&lt;/th&gt;
&lt;th&gt;先定义的量&lt;/th&gt;
&lt;th&gt;应用方向&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;若干数一起平移、要求最终同余&lt;/td&gt;
&lt;td&gt;差值及差值的 GCD&lt;/td&gt;
&lt;td&gt;1、2、27&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;乘积、完全幂、约数、阶乘整除&lt;/td&gt;
&lt;td&gt;每个质数的指数&lt;/td&gt;
&lt;td&gt;3、26&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GCD 恰好是某值、两数互质&lt;/td&gt;
&lt;td&gt;“都被 d 整除”的宽条件&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;区间和整除、数量相等或比较&lt;/td&gt;
&lt;td&gt;前缀余数、前缀差&lt;/td&gt;
&lt;td&gt;25、23&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;非空、至少一个、每类都出现&lt;/td&gt;
&lt;td&gt;坏事件及其交集&lt;/td&gt;
&lt;td&gt;5、6、29&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;不能越界的括号、网格路径&lt;/td&gt;
&lt;td&gt;前缀高度、第一次越界点&lt;/td&gt;
&lt;td&gt;30&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;旋转相同、重复执行置换&lt;/td&gt;
&lt;td&gt;置换循环及固定点&lt;/td&gt;
&lt;td&gt;20、35&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;配对指标相加、二项式加权&lt;/td&gt;
&lt;td&gt;系数序列或生成函数&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;XOR 可达、开关翻转、解的个数&lt;/td&gt;
&lt;td&gt;GF(2) 的秩与自由变量&lt;/td&gt;
&lt;td&gt;31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;巨大步数、固定规则迭代&lt;/td&gt;
&lt;td&gt;状态转移、特征递推&lt;/td&gt;
&lt;td&gt;28、34&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;树的数量、保证联通的选边方案&lt;/td&gt;
&lt;td&gt;拉普拉斯矩阵&lt;/td&gt;
&lt;td&gt;32&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;最大值、第 k 小、等到收集齐&lt;/td&gt;
&lt;td&gt;CDF、指示变量、等待阶段&lt;/td&gt;
&lt;td&gt;15–17、36、37&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;最小绝对偏差、重排、平均分配&lt;/td&gt;
&lt;td&gt;斜率、交换差、边际费用&lt;/td&gt;
&lt;td&gt;18、19、38、39&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;操作很多但每步变化受限&lt;/td&gt;
&lt;td&gt;守恒量、势能、相邻差&lt;/td&gt;
&lt;td&gt;40、41&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h4&gt;一、数论：把数值限制改写成整除与指数&lt;/h4&gt;
&lt;h5&gt;1. 同步操作：先研究差值&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：几个数同时加减；操作似乎要追踪大数，但它们的相对差异很小。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：若 $(a,b)\to(a-t,b-t)$，则 $d=b-a$ 不变。要使平移后两数都被 $p$ 整除，必要且充分的是 $p\mid d$ 且 $t\equiv a\pmod p$。先分解 $d$，再枚举允许的约数或质因子；若随后同时除以 $p$，新差值为 $d/p$，状态可改为 $(a,d)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$(14,20)$ 的差是 6。同时减 2 后变成 $(12,18)$，可同除 6；要同除 5 则无论怎样同步平移都不可能，因为 $5\nmid6$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：题目必须允许相应平移，并核对正数范围、方向和费用。$d=0$ 时不能靠枚举其质因子解决。试除分解 $O(\sqrt{|d|})$；不是对所有“同时操作”题都存在同样递推。&lt;/p&gt;
&lt;h5&gt;2. 自选模数：同余变整除&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：自己选模数，让一组数余数相同；询问最大可行模数或有多少模数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：写出 $a_i\equiv a_1\pmod m$，即 $m\mid(a_i-a_1)$。求&lt;/p&gt;
&lt;p&gt;$$g=\gcd(|a_2-a_1|,\ldots,|a_n-a_1|).$$&lt;/p&gt;
&lt;p&gt;所有候选恰为 $g$ 的正约数，再检查题目额外限制；若求无上界的最大模数且 $g&amp;gt;0$，答案就是 $g$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[8,14,20]$ 的差值 GCD 为 6，可选 $1,2,3,6$；模 6 均余 2。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：$g=0$ 代表原数全相同，可能没有有限最大值。指定余数 $r$ 时还须 $0\le r&amp;lt;m$，并改算 $\gcd(a_i-r)$。求 GCD 为 $O(n\log V)$；列约数可 $O(\sqrt g)$。其基础是扩展欧几里得维护的整数线性组合关系，参见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/number-theory/euclid.h&quot;&gt;KACTL euclid 作者实现&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;3. 乘积条件 → 质因子指数状态&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：乘积为平方、完全 $k$ 次幂；把一个给定整数拆成有序因子的方案数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：正整数 $x=\prod_p p^{e_p}$。完全 $k$ 次幂要求所有指数和模 $k$ 为 0；用前缀指数向量 $P_i$，区间条件成为 $P_r=P_{l-1}$。平方时向量加法就是 XOR，同类前缀有 $c$ 个便贡献 $\binom c2$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[2,8,3,12]$ 的非空平方乘积区间有 $[2,8]$、$[3,12]$、整个数组，共 3 个。若求 $a_1a_2a_3=12$ 的正整数有序解，$12=2^2 3$；分配两个指数分别有 $\binom42$、$\binom32$ 种，乘积为 18。后一类模型见 &lt;a href=&quot;https://img.atcoder.jp/abc110/editorial.pdf&quot;&gt;ABC110 D 官方题解&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：必须存规范指数向量，不能把质数的数值直接 XOR 当作无碰撞编码。$k&amp;gt;2$ 时仍比较两个前缀相等；若做“当前向量与另一个数配成完全幂”的查询，才查相反向量。0 与负号分别处理。筛最小质因子 $O(V\log\log V)$，分解每个数 $O(\log V)$，向量比较/哈希费用另计。&lt;/p&gt;
&lt;h5&gt;4. GCD 恰好值：先算倍数条件，再反演&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：统计 GCD 等于 $d$ 的对、元组，或把所有 GCD 加起来；直接枚举每一对太慢。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：令 $c_d$ 为能被 $d$ 整除的元素数，$e_d$ 为 GCD 恰为 $d$ 的无序下标对数。宽条件包含所有倍数：&lt;/p&gt;
&lt;p&gt;$$\binom{c_d}{2}=\sum_{k\ge1}e_{kd},\qquad e_d=\binom{c_d}{2}-\sum_{k\ge2}e_{kd}.$$&lt;/p&gt;
&lt;p&gt;从大到小消去真倍数即可。若是长度 $N$、每项在 $[1,K]$ 的序列，把 $\binom{c_d}{2}$ 换成 $\lfloor K/d\rfloor^N$；这是 &lt;a href=&quot;https://atcoder.jp/contests/abc162/tasks/abc162_e?lang=en&quot;&gt;ABC162 E 原题&lt;/a&gt; 的可行入口。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[2,3,4]$ 中 $c_1=3,c_2=2$，所以 $e_2=1,e_1=3-1=2$；GCD 之和为 4。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：正整数、值域 $V$ 可开数组时，倍数筛 $O(V\log V)$；接口 &lt;code&gt;cp::exact_gcd_pairs&lt;/code&gt;。只要互质对可用 $\sum_d\mu(d)\binom{c_d}{2}$；求 GCD 和可用 $\sum_d\varphi(d)\binom{c_d}{2}$，依据 $\sum_{d\mid g}\varphi(d)=g$，见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/number-theory/phiFunction.h&quot;&gt;KACTL phi 恒等式&lt;/a&gt;。有序、自配对和含 0 的模型需重新计数。&lt;/p&gt;
&lt;h5&gt;11. 模运算里的除法&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：组合数、平均值、等价类计数中的除法；写出闭式后分母可能与模数不互质。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把“整数先除后取模”和“模数域内求逆”分开。后者只在 $\gcd(b,M)=1$ 时可写 $a/b\equiv a,b^{-1}\pmod M$。一般模数用扩展欧几里得；接口 &lt;code&gt;cp::inv_mod&lt;/code&gt; 返回可选值。其前提见 &lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/math.html&quot;&gt;ACL inv_mod 文档&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$6/2=3$，但模 6 时 2 没有逆元，不能做 &lt;code&gt;6*inv(2)&lt;/code&gt;。若已知整数 $A$ 被正整数 $b$ 整除，可算 $r=A\bmod(bM)$，再用 $r/b\bmod M$；这里取模是非负余数，$6\bmod12=6$，除 2 得 3。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：素数模阶乘组合数 &lt;code&gt;cp::Comb&amp;lt;P&amp;gt;&lt;/code&gt; 要求预处理上界 $N&amp;lt;P$。$N\ge P$ 可考虑 Lucas 的逐位组合数，但小组合数仍要可算。扩欧求逆 $O(\log M)$，组合数预处理 $O(N)$、查询 $O(1)$。模 $bM$ 方法须证明整除并控制乘积范围。&lt;/p&gt;
&lt;h5&gt;13. 模素数的乘法 → 指数加法&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：统计模 $p$ 乘积的分布，反复合并乘积；$p$ 是素数且非零值域可以遍历。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：找原根 $g$，建表 $g^e\leftrightarrow e$。非零乘法满足 $g^i g^j=g^{i+j\bmod(p-1)}$，于是将频数映射到指数域，做长度 $p-1$ 的循环卷积；可先线性卷积再折叠下标。原根与有限循环群的前提见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：模 7 取原根 3，幂依次是 $1,3,2,6,4,5$。$2\cdot4$ 的指数为 $2+4\equiv0\pmod6$，对应结果 1。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：0 单独统计；单位元 1 的指数是 0。合数的全部非零剩余不一定构成循环群，不可照搬。已知原根后建表 $O(p)$，每次卷积 $O(p\log p)$；&lt;code&gt;cp::convolution&lt;/code&gt; 的系数模数与这里的剩余模数 $p$ 是两个不同角色。普通卷积限制见 &lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/convolution.html&quot;&gt;ACL convolution&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;14. 除法：整除分块与 floor_sum 分清&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：$n$ 可到 $10^{12}$，公式含 $\lfloor n/i\rfloor$；或者要数一条直线下面的格点。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：前者从 $l$ 出发，令 $q=\lfloor n/l\rfloor,r=\lfloor n/q\rfloor$，区间 $[l,r]$ 商相同，用前缀权重一次求贡献。比如&lt;/p&gt;
&lt;p&gt;$$\sum_{i=1}^n\sigma(i)=\sum_{d=1}^n d\lfloor n/d\rfloor,$$&lt;/p&gt;
&lt;p&gt;正是 &lt;a href=&quot;https://cses.fi/problemset/task/1082&quot;&gt;CSES Sum of Divisors&lt;/a&gt; 的原题模型。后者 $\sum_{i=0}^{n-1}\lfloor(ai+b)/m\rfloor$ 则用类欧几里得 &lt;code&gt;cp::floor_sum_nonnegative&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$n=5$ 时加权分块为 $1\cdot5+2\cdot2+(3+4+5)\cdot1=21$。另有 $\sum_{i=0}^3\lfloor(3i+1)/5\rfloor=0+0+1+2=3$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：商分块 $O(\sqrt n)$；线性分子 floor_sum 为 $O(\log m)$。配套接口要求非负参数、$m&amp;gt;0$、答案可放进 i128；与 ACL 的溢出约定不同。负数用 &lt;code&gt;cp::floor_div/ceil_div&lt;/code&gt;，C++ 向零截断不等于数学 floor。&lt;/p&gt;
&lt;h5&gt;25. 区间整除与抽屉：把连续段变成两个前缀&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：存在/统计区间和被 $m$ 整除；长度与模数接近，要求证明一定有解。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：令 $P_0=0,P_i=(\sum_{j\le i}a_j)\bmod m$，区间和整除等价于两个前缀余数相同。扫描时先加 &lt;code&gt;cnt[P_i]&lt;/code&gt; 再递增；存在性方面，$m+1$ 个前缀放进 $m$ 个余数类，必有两个相同。&lt;a href=&quot;https://cses.fi/problemset/task/1662&quot;&gt;CSES Subarray Divisibility&lt;/a&gt; 提供了含负数的练习模型。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,2,3]$ 模 3 的前缀是 $[0,1,0,0]$，余数 0 出现 3 次，答案 $\binom32=3$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：$m&amp;gt;0$；负数余数规范为 $(x%m+m)%m$。求余数 $r\ne0$ 的区间应在线查询 $P_i-r$，不能只把频数任意两两配对而忽略顺序。数组 $O(n+m)$ 或哈希期望 $O(n)$；存在性只保证非空区间，不保证题目额外长度限制。&lt;/p&gt;
&lt;h5&gt;26. 阶乘和组合数的整除：数质因子，不构造大整数&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：$n!$ 末尾有几个 0、组合数能否被 $p^k$ 整除、约分后剩多少个 $p$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：每个 $p$ 的倍数贡献一次、$p^2$ 的倍数再贡献一次，因此&lt;/p&gt;
&lt;p&gt;$$v_p(n!)=\sum_{t\ge1}\lfloor n/p^t\rfloor,\quad
v_p\binom nr=v_p(n!)-v_p(r!)-v_p((n-r)!).$$&lt;/p&gt;
&lt;p&gt;循环不断做 &lt;code&gt;n/=p; ans+=n&lt;/code&gt;，避免直接生成 $p^t$ 溢出。十进制尾零取 $\min(v_2,v_5)$；一般基数 $B=\prod p^{b_p}$ 取 $\min_p\lfloor v_p/b_p\rfloor$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$v_5(25!)=5+1=6$，所以 $25!$ 十进制尾零为 6。$\binom52=10$ 的 $v_2=3-1-1=1$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：$p$ 必须是质数；合数基数先分解。每个质数 $O(\log_p n)$。若还要组合数模 $p^k$，须同时维护去掉 $p$ 因子的单位部分，不能只靠指数；可接 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt; 的“单位与可逆元”判断。质因子指数分配的原题对应见 &lt;a href=&quot;https://img.atcoder.jp/abc110/editorial.pdf&quot;&gt;ABC110 D 官方题解&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;27. 周期条件同时满足：广义 CRT 与同余方程&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：多个定期事件同时发生；某量对几个模数的余数分别已知；模数未必互质。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：合并 $x\equiv r\pmod m$ 与 $x\equiv s\pmod n$，代入 $x=r+mt$，得到 $mt\equiv s-r\pmod n$。设 $g=\gcd(m,n)$，无解当且仅当 $g\nmid(s-r)$；否则除以 $g$ 后求逆，得到唯一模 $\operatorname{lcm}(m,n)$ 的解类。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$x\equiv2\pmod6,x\equiv5\pmod9$：$6t\equiv3\pmod9$，约成 $2t\equiv1\pmod3$，故 $t\equiv2$，$x\equiv14\pmod{18}$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：周期为正数，余数先规范化；“没有解”与“最早解为 0”不同。合并 $k$ 条约束约 $O(k\log L)$，$L$ 是合并后的模数规模。板子 &lt;code&gt;crt.cpp&lt;/code&gt; 处理一般正模数，LCM 超过 i64 会报溢出；接口语义可对照 &lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/math.html&quot;&gt;ACL crt&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;28. 幂塔和重复乘法：周期从哪里开始？&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：指数极大、十进制字符串指数、重复乘同一个数；想把指数直接对 $\varphi(M)$ 取模。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先判断 $\gcd(a,M)$。互质时欧拉定理允许周期化；非互质时，序列可能先进入前导段，之后才循环。也可将 $M$ 分解成互质质数幂，对 $v_p(a)$ 分析何时幂变成 0，再 CRT 合并。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：模 8 的 $2^e$ 在 $e=1,2,3,4$ 时为 $2,4,0,0$；直接把 $e=4$ 取成 $e\bmod\varphi(8)=0$，会误得 1。相反，模 7 的 $3^{100}$ 可用 $100\bmod6=4$，结果 4。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：欧拉降幂要求互质；非互质要同时知道指数余数与是否超过阈值，板子 &lt;code&gt;extended_euler.cpp&lt;/code&gt; 处理十进制大指数。0 指数和题目对 $0^0$ 的约定独立检查。&lt;a href=&quot;https://cses.fi/problemset/task/1712&quot;&gt;CSES Exponentiation II&lt;/a&gt; 明确给出了这类边界。读长为 $D$ 的指数加快速幂通常 $O(D+\log M)$，分解 $M$ 费用另计。&lt;/p&gt;
&lt;h4&gt;二、计数：先确定对象、交集和唯一归属&lt;/h4&gt;
&lt;h5&gt;5. 集合关系：SOS 方向与容斥&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：bit 集合包含、两个数 AND 为 0、选择若干数后 AND/OR 的取值。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：子集和 $F(S)=\sum_{T\subseteq S}f(T)$ 从少 bit 向多 bit 传播；超集和反向。&lt;code&gt;x &amp;amp; y == 0&lt;/code&gt; 等价于 $y\subseteq FULL\mathbin{\char94}x$。若数非空下标子集 AND 为 0，令 $c_S$ 为包含 $S$ 所有 bit 的元素数，则&lt;/p&gt;
&lt;p&gt;$$#=\sum_{S\subseteq FULL}(-1)^{|S|}(2^{c_S}-1).$$&lt;/p&gt;
&lt;p&gt;固定某个选择、其 AND 为 $A$，上式把它计算 $\sum_{S\subseteq A}(-1)^{|S|}=[A=\varnothing]$ 次。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,2,3]$ 中 AND 为 0 的非空下标子集只有 ${1,2}$ 与 ${1,2,3}$，共 2 个。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：固定 $B$ 位、$a_i\in[0,2^B)$；相同数值的不同下标仍是不同选择。&lt;code&gt;cp::sos&lt;/code&gt;、&lt;code&gt;subset_witness&lt;/code&gt;、&lt;code&gt;count_and_zero&lt;/code&gt;，$O(n+B2^B)$。位外层才能保证每种选位组合传播一次；整数 SOS 要防溢出。三种位卷积的原作者接口见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/FastSubsetTransform.h&quot;&gt;KACTL FastSubsetTransform&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;6. 严格多数：坏事件可能互斥&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：要求没有一种颜色/类型占所选总数的一半以上；直接做多类别计数状态太大。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：若每个选中对象只属一类，两个类别不可能同时占严格多数。因此合法数等于总数减去每个“类别 $j$ 占严格多数”的方案数。固定 $j$，只需跟踪差 $d=#j-#其他$，把多类变成两类。&lt;/p&gt;
&lt;p&gt;若每行可不选或选一个对象，权重为 $a_{ij}$、行和 $s_i$，则总非空方案 $\prod_i(1+s_i)-1$，转移&lt;/p&gt;
&lt;p&gt;$$new[d]=old[d]+a_{ij}old[d-1]+(s_i-a_{ij})old[d+1].$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：三次独立选 A/B，总数 8。A 严格多数有 4 种，B 有 4 种，所以无严格多数的方案为 0；两次选择则合法的是 AB、BA，共 2 种。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：“至少一半”不是互斥事件；对象可同时属于多类也不适用。$n$ 行、$m$ 类，直接差值 DP 为 $O(mn^2)$、空间 $O(n)$。先写出两个坏事件不可能同时发生的证明，再决定不做高阶容斥。&lt;/p&gt;
&lt;h5&gt;8. 贡献法：先换求和顺序&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：所有区间/点对的和；每个对象在许多答案里重复出现。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把“枚举所有答案再求和”交换成“枚举一个元素/边，数它被用几次”。1-based 数组元素 $a_i$ 对所有子数组元素和贡献 $a_i i(n-i+1)$；树边权 $w$，删边一侧有 $s$ 点，对无序点对距离和贡献 $ws(n-s)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：数组 $[1,2,3]$ 贡献 $1\cdot3+2\cdot4+3\cdot3=20$。三点路径边权 2、3，贡献 $2\cdot1\cdot2+3\cdot2\cdot1=10$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;扩展与前提&lt;/strong&gt;：子数组最大值可令左边最近严格大于为 $L$、右边最近大于等于为 $R$，贡献 $a_i(i-L)(R-i)$；相等元素左右必须一边严格、一边非严格，指定唯一归属。$[2,2]$ 的三个子数组最大值之和是 6。树 DFS/单调栈均为 $O(n)$，乘法在运算前转 i128。贡献求和的概率版本见 36。&lt;/p&gt;
&lt;h5&gt;9. 分球入盒、上下界与组合恒等式&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：相同物品分给有编号的容器；整数解之和固定，每项带上下界。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：$x_1+\cdots+x_k=n,x_i\ge0$，用 $k-1$ 个隔板分出 $k$ 组，数量 $\binom{n+k-1}{k-1}$；&lt;a href=&quot;https://cses.fi/problemset/task/1716&quot;&gt;CSES Distributing Apples&lt;/a&gt; 正是此模型。有下界先令 $y_i=x_i-L_i$；上界 $y_i\le V_i$ 用容斥：&lt;/p&gt;
&lt;p&gt;$$\sum_{S\subseteq[k]}(-1)^{|S|}\binom{n-\sum_iL_i-\sum_{i\in S}(V_i+1)+k-1}{k-1}.$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$x_1+x_2+x_3=4,0\le x_i\le2$，总数 $\binom62-3\binom32=15-9=6$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：容器有编号、物品不可区分；若物品可区分，通常变成多项式系数或 $k^n$。无效上标的组合数视为 0；$k=0$ 单独处理。一般上界容斥 $O(2^k)$，相同上界可按 $|S|$ 合并成 $O(k)$。乘积求和先尝试按选择数分类的范德蒙德恒等式 $\sum_i\binom ai\binom b{r-i}=\binom{a+b}r$。&lt;/p&gt;
&lt;h5&gt;10. 组合题：先固定“哪些位置”，再数“填什么值”&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：先选位置再分颜色/对象；“出现某种结构”的见证可能不唯一；公式看似是几个组合数相乘。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把方案显式写为元组，例如“选出的行集合 $R$、公共颜色 $c$、列集合 $C$”。验证每个最终对象对应几个元组，才能决定相乘后是否除重。多重集排列可依次选每种字符的位置，得到 $n!/\prod_c n_c!$；作者实现见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/combinatorial/multinomial.h&quot;&gt;KACTL multinomial&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：AAB 的不同排列为 $\binom32\binom11=3$。但“统计有相等字母对的长度 3 二元串”不能直接选一对位置再选公共颜色再填另一个：这会得到 $3\cdot2\cdot2=12$，AAA/BBB 各被算 3 次，真实所有 8 个串都满足。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：鸽巢证明需明确“鸽子是什么、巢是什么、每只鸽子是否唯一入巢”。见证不唯一时规定唯一归属、容斥或双计数，不能随意除一个常数。阶乘预处理 $O(n)$ 后多项式系数通常 $O(#类别)$；分母逆元仍受 11 的限制。&lt;/p&gt;
&lt;h5&gt;20. 对称计数：Burnside 的适用边界&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：旋转/翻转后视为同一方案；直接除以对称操作个数会得到非整数或不对的答案。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先确定作用群 $G$，再逐个操作数保持不变的对象：&lt;/p&gt;
&lt;p&gt;$$#\text{等价类}=\frac1{|G|}\sum_{g\in G}|\operatorname{Fix}(g)|.$$&lt;/p&gt;
&lt;p&gt;颜色必须在操作产生的每个位置循环上相同；有 $c$ 个循环、每处任取 $q$ 色时固定点数 $q^c$。该方法见 &lt;a href=&quot;https://cses.fi/book/book.pdf&quot;&gt;Competitive Programmer&apos;s Handbook 第 22 章&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$2\times2$ 黑白格仅按旋转去重，四种旋转的循环数为 $4,1,2,1$，答案 $(16+2+4+2)/4=6$；原题应用见 &lt;a href=&quot;https://cses.fi/problemset/task/2210&quot;&gt;CSES Counting Grids&lt;/a&gt;。长度 4 的二色项链仅旋转去重，同样得到 6。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：合法集合必须在群作用下封闭；固定某个编号位置的限制可能破坏对称。旋转与二面体群（含镜像）分开。直接枚举操作与循环 $O(|G|n)$，规则旋转常能按 GCD/约数合并。模数整除 $|G|$ 时不能直接求逆，回看 11。&lt;/p&gt;
&lt;h5&gt;29. 至少一个、每类都出现、没人拿回原物：显式定义坏事件&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：至少被一个数整除；分配后每类都出现；排列无固定点。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：令 $A_i$ 为第 $i$ 个坏事件，再计算交集而不是凭印象写正负号。$k$ 个有编号盒子都非空，放 $n$ 个有区别的球：&lt;/p&gt;
&lt;p&gt;$$\sum_{j=0}^k(-1)^j\binom kj(k-j)^n.$$&lt;/p&gt;
&lt;p&gt;至少被一个给定数整除则交集是被其 LCM 整除，贡献 $\lfloor N/\operatorname{lcm}\rfloor$；只有两两互质时才能把 LCM 简化为乘积。&lt;a href=&quot;https://cses.fi/problemset/task/2185&quot;&gt;CSES Prime Multiples&lt;/a&gt; 给定的是不同质数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$1\ldots20$ 中被 2 或 5 整除有 $10+4-2=12$ 个。3 个有编号球放入 2 个非空盒子有 $2^3-2=6$ 种。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：直接子集容斥 $O(2^k k)$，构造 LCM 前先检查是否超过 $N$，避免溢出。错排数由相同思路得 $D_n=\sum_j(-1)^j\binom nj(n-j)!$，也可 $D_n=(n-1)(D_{n-1}+D_{n-2})$、$D_0=1,D_1=0$；$D_4=9$，可练 &lt;a href=&quot;https://cses.fi/problemset/task/1717&quot;&gt;CSES Christmas Party&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;30. 前缀不能为负：Catalan 与反射&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：合法括号、上右路径不能越过对角线；总数容易，难点是每个前缀都合法。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把左括号记 $+1$、右括号记 $-1$。从高度 0 走 $2n$ 步回 0，总数 $\binom{2n}n$；把第一次到 $-1$ 之前的步反向，坏路径与终点高度 2 的路径一一对应，数为 $\binom{2n}{n-1}$。两者相减得到 Catalan 数。&lt;/p&gt;
&lt;p&gt;若给定前缀始终合法、当前高度 $h$、余 $m$ 步，则还需 $u=(m-h)/2$ 个上步，完成数为&lt;/p&gt;
&lt;p&gt;$$\binom mu-\binom m{u+h+1}.$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：长度 6、前缀 &lt;code&gt;(()&lt;/code&gt;，$h=1,m=3,u=1$，完成数 $\binom31-\binom33=2$，与 &lt;a href=&quot;https://cses.fi/problemset/task/2187&quot;&gt;CSES Bracket Sequences II&lt;/a&gt; 的样例相符。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：先检查总长奇偶、前缀是否曾负、$u$ 是否为整数且在 $[0,m]$；有多种括号或额外禁区需重新建模。组合数预处理 $O(N)$ 后每问 $O(1)$；用相减形式可避开对 $n+1$ 的模除法。&lt;/p&gt;
&lt;h4&gt;三、代数：把可达、计数和巨大步数变成结构运算&lt;/h4&gt;
&lt;h5&gt;12. 卷积：先判断指标如何组合&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：要对所有 $k$ 计算 $\sum_i a_i b_{k-i}$，或合并两组和、长度、选择数量的分布。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：写 $A(x)=\sum_i a_ix^i$，乘法中 $x^ix^j=x^{i+j}$，所以 $[x^k]AB$ 就是指标和为 $k$ 的配对数。若权重为 $\sum_i\binom ni a_ib_{n-i}$，先除阶乘：卷积 $A_i=a_i/i!,B_i=b_i/i!$，再乘 $n!$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,2]*[3,4]=[3,10,8]$。标记对象分成两部分时，$a_i=b_i=1,n=3$ 得 $\sum_i\binom3i=8$，对应 $3!\sum_i1/(i!(3-i)!)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：指标取模是循环卷积，按 OR/AND/XOR 合并是相应集合变换，$ij=k$ 则是约数卷积；不能把这些直接当普通 NTT。&lt;code&gt;cp::convolution&lt;/code&gt; 固定模 $998244353$，二次幂长度至多 $2^{23}$，$O(N\log N)$；限制见 &lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/convolution.html&quot;&gt;ACL 文档&lt;/a&gt;。阶乘归一化须分母可逆。多模 CRT 还原后再取任意模，必须有真实系数范围保证或拆系数，不能只看目标模数互质。&lt;/p&gt;
&lt;h5&gt;31. XOR 可达与开关系统：先求秩，再数方案&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：每个操作最多用一次且只翻转 0/1；选若干数 XOR 成目标；问多少种选择可达同一结果。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把每次操作写成一列 0/1 向量，是否选择操作记为 $x_i$，要求 $Ax=b$，运算在 GF(2)。消元若产生 $0=1$ 则无解；有解且 $n$ 个变量、秩 $r$，自由变量可任取，所以有 $2^{n-r}$ 组解。所有可达结果共有 $2^r$ 个。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：可选数 $[1,2,3]$ 的向量秩为 2，因为 $1\oplus2=3$。8 种下标选择映到 4 种结果，每个结果恰有 2 种原像；XOR 为 0 的是空集与三个全选。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：这里的加法是 XOR，不是 OR；若要求恰选 $k$ 个，线性方程的解数不能直接套用。单数 $B$ 位的增量线性基 $O(nB)$；一般 $m\times n$ 系统朴素 $O(mn\min(m,n))$，bitset 可并行异或。秩/无解返回语义见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/SolveLinearBinary.h&quot;&gt;KACTL SolveLinearBinary&lt;/a&gt;，实现见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;32. 连通选边方案：Matrix-Tree 把树数变成行列式&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：在给定无向图里选 $n-1$ 条边保持连通；数生成树或其权值乘积之和，边数无法子集枚举。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：构造拉普拉斯矩阵 $L$：一条权为 $w$ 的非自环边 $(u,v)$，给 $L_{uu},L_{vv}$ 加 $w$，给 $L_{uv},L_{vu}$ 减 $w$。删去同一个顶点的行列后求行列式。结果等于每棵生成树中边权乘积的总和；全为 1 时就是树数。定理与多重边实例见 &lt;a href=&quot;https://math.mit.edu/~apost/courses/18.212_2021/lectures/18212_lecture19.pdf&quot;&gt;MIT 18.212 Lecture 19&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：三角形的约化矩阵为 $\begin{pmatrix}2&amp;amp;-1\-1&amp;amp;2\end{pmatrix}$，行列式 $4-1=3$，对应删去三条边中的任一条。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：无向图、允许平行边并累加，自环无贡献；不连通时行列式为 0。模素数可消元 $O(n^3)$、空间 $O(n^2)$，换行要变号，零主元必须找行交换。合数模不能对所有非零主元求逆。带方向的树有朝向约定，不能直接套这份无向构造；代码入口见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;33. 大范围求和但答案低次：插值与有限差分&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：求 $1^k+\cdots+N^k$，$k$ 小而 $N$ 极大；答案随参数像一个固定次数多项式。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先证明次数上界。因为离散差分 $F(N)-F(N-1)=N^k$，$F$ 在有理数上次数至多 $k+1$；求出 $F(0),\ldots,F(k+1)$ 后插值。等距点可用拉格朗日式&lt;/p&gt;
&lt;p&gt;$$F(t)=\sum_{i=0}^d y_i\prod_{j\ne i}\frac{t-j}{i-j}.$$&lt;/p&gt;
&lt;p&gt;一般点插值的作者实现与 $O(d^2)$ 基线见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/PolyInterpolate.h&quot;&gt;KACTL PolyInterpolate&lt;/a&gt;；该文件用浮点，模数题应另用域上的运算。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：平方和前四项 $F(0..3)=[0,1,5,14]$；一阶差 $1,4,9$，二阶差 $3,5$，三阶差 2。延伸下一项得二阶差 7、一阶差 16，$F(4)=30$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：有限数据“看起来多项式”不是证明；取模后采样点必须互异且分母可逆。素数模数 $P$ 下使用本方法求幂和，常规安全条件是 $k+1&amp;lt;P$。等距节点配前后缀积可 $O(d)$ 求一次值，预处理样本费用另计；已有样本点应直接返回其值。&lt;/p&gt;
&lt;h5&gt;34. 固定规则重复巨大次：矩阵、递推与幺半群快速幂&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：步数 $10^{18}$，每一步的线性转移相同；线性递推第 $N$ 项；等比和不能安全做除法。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把状态写成列向量 $v_{t+1}=Tv_t$，答案是 $T^Nv_0$。若是 $s_{t+1}=As_t+1$，增添常数 1 维，转移为 $\begin{pmatrix}A&amp;amp;1\0&amp;amp;1\end{pmatrix}$；&lt;a href=&quot;https://atcoder.jp/contests/abc293/editorial/5955?lang=ja&quot;&gt;ABC293 E 官方题解&lt;/a&gt; 给出了这个应用。&lt;/p&gt;
&lt;p&gt;也可直接维护 $(P_n,S_n)=(A^n,\sum_{i&amp;lt;n}A^i)$，连接长度 $a,b$ 的块：$(P_aP_b,S_a+P_aS_b)$。此结合运算可快速幂，不需要 $A-1$ 可逆。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$A=3,N=4,M=7$，$S_4=1+3+9+27\equiv5$。Fibonacci 初值 $0,1$、递推系数 $1,1$，$F_{10}=55$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：转移若依赖时刻，需先合成周期或增广状态。$d$ 维普通矩阵为 $O(d^3\log N)$；已知 $d$ 阶递推可按特征多项式约化到 $O(d^2\log N)$，见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/LinearRecurrence.h&quot;&gt;KACTL LinearRecurrence&lt;/a&gt;。BM 需要域且已知递推阶数上界，足够多前缀才能保证恢复；有限项拟合不能替代后续递推存在性的证明，见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/BerlekampMassey.h&quot;&gt;作者 BM 接口&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;35. 置换反复执行：循环决定周期与交换次数&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：一次操作是位置重排且可逆；问执行 $k$ 次后的结果、最少交换数或恢复原样的最早时间。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把置换拆成互不相交的有向循环。长度 $\ell$ 的循环上，执行 $k$ 次等于前进 $k\bmod\ell$；所有位置一起恢复的周期是各循环长度的 LCM。长度 $\ell$ 的循环用任意两点交换拆成单点最少需 $\ell-1$ 次，故总计 $n-c$ 次，$c$ 为循环数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：置换由 $(1\ 2\ 3)(4\ 5)$ 构成，周期 $\operatorname{lcm}(3,2)=6$，任意交换复原最少 $(3-1)+(2-1)=3$ 次；执行 4 次后，前三点前进 1 格、后两点不变。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：必须是双射；一般函数图还有入环树与前导段。相邻交换的最少次数是逆序对，不能用 $n-c$。拆环 $O(n)$；LCM 可能溢出，需按题意用大整数或质因子最大指数。用循环数统计对称固定点的进一步应用见 20；结构背景见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;四、概率期望：拆事件、拆贡献、拆等待阶段&lt;/h4&gt;
&lt;h5&gt;15. 精确最大值概率：CDF 做差&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：很多独立随机数的最大值/最小值；“恰好等于 $k$”不好计，所有值都不超过 $k$ 容易计。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：独立均匀 $X_i\in{1,\ldots,m}$，$Y=\max X_i$，则&lt;/p&gt;
&lt;p&gt;$$P(Y\le k)=(k/m)^n,\quad P(Y=k)=(k/m)^n-((k-1)/m)^n.$$&lt;/p&gt;
&lt;p&gt;再用 $E[Y]=\sum_k kP(Y=k)$，或尾和 $E[Y]=\sum_{k=1}^m[1-((k-1)/m)^n]$。独立但不同分布时把幂改成各 CDF 乘积。&lt;a href=&quot;https://cses.fi/problemset/task/1727&quot;&gt;CSES Candy Lottery&lt;/a&gt; 可直接练习。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$n=2,m=3$，最大值的概率是 $1/9,3/9,5/9$，期望 $(1+6+15)/9=22/9$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：精确最大值不是“指定某一个位置等于 $k$、其余不超过 $k$”，后者会因并列最大重复计数。$n\ge1$；不独立时不能乘 CDF。按 $m$ 个取值枚举，通用快速幂 $O(m\log n)$，浮点幂可按误差要求使用；模概率须分母可逆。&lt;/p&gt;
&lt;h5&gt;16. 顺序统计量：先区分连续与离散&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：第 $j$ 小的期望、保留最小若干个样本的期望；动态过程可证明始终只保留历史的前几个小值。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：对 $N\ge1$ 个独立连续均匀 $[0,m]$ 样本（$m&amp;gt;0,1\le j\le r\le N$），排序后 $X_{(j)}$ 满足&lt;/p&gt;
&lt;p&gt;$$E[X_{(j)}]=\frac{jm}{N+1},\qquad E[\sum_{j=1}^r X_{(j)}]=\frac{mr(r+1)}{2(N+1)}.$$&lt;/p&gt;
&lt;p&gt;可以把两端点也加入，$N+1$ 段间距由对称性具有相同期望；正式分布推导见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-443-statistics-for-applications-spring-2015/06daf6d78e7eb0465d6bb53e8f96b2ff_MIT18_443S15_LEC11.pdf&quot;&gt;MIT 18.443 顺序统计讲义&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：3 个 $[0,8]$ 样本最小两个的期望和是 $8(1+2)/4=6$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：离散分布会并列，不能照搬均匀间距。整数 $[1,m]$ 中第 $j$ 小值可用尾和：$P(X_{(j)}&amp;gt;t)=\sum_{h=0}^{j-1}\binom Nh(t/m)^h(1-t/m)^{N-h}$。例 $N=2,m=2$ 的最小值期望是 $5/4$，不是连续公式 $2/3$。先证明“历史样本中第几小”的不变量、数清已生成样本总数，再套公式；连续闭式 $O(1)$，离散直接枚举约 $O(mj)$。&lt;/p&gt;
&lt;h5&gt;17. 期望 DP：自环移项前先问是否有限&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：随机重复操作直到终止；某次尝试可能不改变状态；问平均操作次数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：令 $E_s$ 为从 $s$ 到结束的未来期望代价，一步费用 $c_s$，终态为 0：&lt;/p&gt;
&lt;p&gt;$$E_s=c_s+p_0E_s+\sum_{t\ne s}p_{st}E_t,
\qquad E_s=\frac{c_s+\sum_{t\ne s}p_{st}E_t}{1-p_0}.$$&lt;/p&gt;
&lt;p&gt;先确认除自环外有拓扑顺序，再 DP；无自环的“每次增加一个计数”模型见 &lt;a href=&quot;https://atcoder.jp/contests/abc184/editorial/371?lang=ja&quot;&gt;ABC184 D 官方题解&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：每次一半概率成功终止、一半留在原状态，$E=1+E/2$，故 $E=2$。若从 A 一步必到 B，B 一半结束、一半回 A，则 $E_A=1+E_B,E_B=1+E_A/2$，得 $E_A=4$；这已经不能只移掉局部自环。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：$p_0=1$ 的正费用状态期望无穷；有限状态吸收链也要排除可达的非终止闭类。一般 SCC 可建立线性方程，$s$ 个状态朴素 $O(s^3)$，有向无环依赖则 $O(#状态+#转移)$。若求终止概率，常数项与边界不同，不能套步数方程。&lt;/p&gt;
&lt;h5&gt;22. 分类期望：不要漏掉被状态改变的另一类&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：随机排列中，达到第 $a$ 个特殊对象后规则改变；“在阈值之前/之后”的对象贡献不同。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先固定一个对象，计算它位于阈值之后的概率，再把同类权重求和。设有 $c\ge a\ge1$ 个特殊对象和若干普通对象，均匀随机排列，到第 $a$ 个特殊对象时屏障消失，该对象本身仍被屏障挡住。特殊权重和 $S$ 中，只有后 $c-a$ 个起作用，期望 $S(c-a)/c$。&lt;/p&gt;
&lt;p&gt;某个普通对象与 $c$ 个特殊对象的相对次序均匀，所在 $c+1$ 个间隙等概率；屏障后有 $c-a+1$ 个间隙，所以其作用概率为 $(c-a+1)/(c+1)$，普通权重和 $W$ 贡献 $W(c-a+1)/(c+1)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$c=a=1$，特殊权重 10，普通权重 4。两种相对次序中只有“特殊、普通”产生 4 的贡献，期望 2；特殊自身贡献为 0。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：阈值对象是否生效、未达到阈值如何处理、排列是否等概率，都会改变式子；$a=0$ 应全量生效而不是套原分类；$c&amp;lt;a$ 时本模型屏障始终存在。分类计数 $O(n)$，按阈值有多次询问时可排序、前缀和。思想与 36 的指示变量一致，不能把此特定规则当成通用伤害公式。&lt;/p&gt;
&lt;h5&gt;36. 期望的贡献法：相关事件也能逐项求和&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：问不同颜色数、空盒数、逆序对数、被覆盖点数；整体分布很大，但一个对象是否被计入容易求概率。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：给每个对象定义 $I_i=[\text{它被计入}]$，则 $E[\sum I_i]=\sum P(I_i=1)$，不要求 $I_i$ 之间独立。独立投入 $m$ 个球、每球等概率选 $n$ 个盒子，空盒期望 $n(1-1/n)^m$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：3 球入 2 盒，期望空盒数 $2(1/2)^3=1/4$；两个盒子的空事件不独立，线性求和仍正确。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用与前提&lt;/strong&gt;：&lt;a href=&quot;https://cses.fi/problemset/task/1726&quot;&gt;CSES Moving Robots&lt;/a&gt; 可先对每个起点做随机游走 DP 得到终点概率 $p_{s,t}$，再算空格概率 $\prod_s(1-p_{s,t})$，最后对格子 $t$ 求和。这个乘积要求不同机器人的游走独立，而最后一层求和不要求各格子独立。$V$ 格、$E$ 条可走边、$k$ 步，逐起点计算为 $O(VkE+V^2)$；不能用“进入格子的期望个数为 0”代替“格子为空的概率”。&lt;/p&gt;
&lt;h5&gt;37. 收集和等待：按“下一次取得进展”分阶段&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：重复抽样直到见到新种类、集齐全部、凑够若干次成功；无效尝试会原地停留。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：独立同分布试验成功概率为 $p&amp;gt;0$，包含最终成功的一共尝试次数期望为 $1/p$。如果目前已集齐 $k$ 种、总共 $n$ 种等概率，那么下一次新种类概率是 $(n-k)/n$，该阶段等待期望 $n/(n-k)$，总计 $nH_n$。分阶段推导见 &lt;a href=&quot;https://ocw.mit.edu/courses/6-856j-randomized-algorithms-fall-2002/2e00cd3ccdd9e9e9aa3f4b8305a6abef_n4.pdf&quot;&gt;MIT 6.856 Coupon collecting 讲义&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：3 种等概率卡片，收集齐期望 $1+3/2+3=11/2$ 次。成功概率 $1/4$ 时，成功前失败次数期望为 3，包含成功则为 4。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：若种类不等概率，仅知道“已收集多少种”不能决定下一次进展概率，可能要记录具体集合；试验概率随失败变化也不再是固定几何分布。等概率求和 $O(n)$，重复 $r$ 次固定成功且每次条件不变为 $r/p$。几何变量从 0 还是 1 开始取值必须写清。&lt;/p&gt;
&lt;h4&gt;五、优化：用差分证明最优点在哪里&lt;/h4&gt;
&lt;h5&gt;18. 绝对值：拆方向、找中位数、看顺序&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：把所有数改成同一个数的代价是绝对差；一维移动、相邻交换聚拢、两两距离求和。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：$F(x)=\sum_i|a_i-x|$ 的斜率是左侧数量减右侧数量，故中位数处最小；有正权重时换成左右权重，取加权中位数。固定 $x$ 还可排序加前缀和求值。&lt;a href=&quot;https://cses.fi/problemset/task/1074&quot;&gt;CSES Stick Lengths&lt;/a&gt; 是直接应用。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,2,2,3,5]$ 取 $x=2$，代价 $1+0+0+1+3=5$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;扩展与前提&lt;/strong&gt;：保持顺序的位置 $p_1&amp;lt;\cdots&amp;lt;p_k$ 要移成连续格 $x+1,\ldots,x+k$，先令 $b_i=p_i-i$，再找 $b$ 的中位数。例 $p=[1,4,6]$，$b=[0,2,3]$，选 $x=2$，目标 $[3,4,5]$，代价 3。移动费用是平方差时最优点是均值附近，不能用中位数。排序 $O(n\log n)$，选择中位数可期望 $O(n)$。&lt;/p&gt;
&lt;h5&gt;19. 分段线性函数：扫断点，不猜单峰&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：代价有 $\max(0,x-a)$、$\min(x,b)$、截断区间长度，参数是一维整数或实数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：每一项只在少数断点改变斜率，排序事件后维护当前值与斜率。对&lt;/p&gt;
&lt;p&gt;$$F(t)=x t+y\sum_i\max(0,r_i-\max(l_i,t)),\quad t\ge0,$$&lt;/p&gt;
&lt;p&gt;在不含端点的开区间里，斜率 $x-y\cdot#{i:l_i&amp;lt;t&amp;lt;r_i}$。在 $l_i$ 处减 $y$，在 $r_i$ 处加 $y$，区间内线性，故只需检查端点及定义域边界。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$x=1,y=2,[l,r]=[2,5]$，$F(0)=6,F(2)=8,F(5)=5$。先增、再减、再增，不能仅凭 &lt;code&gt;max&lt;/code&gt; 就断言凸或直接三分。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：接口 &lt;code&gt;cp::clipped_cost_min(x,y,intervals)&lt;/code&gt; 对应以上精确公式，要求 $x,y\ge0$，端点合法，返回整数 $t$ 的最优值和位置。一次排序 $O(n\log n)$，用 i128 推进 $value+=slope\cdot\Delta t$。换一个式子须重推每个事件的斜率增量；同坐标事件合并处理。&lt;/p&gt;
&lt;h5&gt;38. 排列怎样配对最优：计算一次交换的差&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：两个序列可重排配对，目标是乘积和或某种总惩罚；直觉是“大配大”但缺证明。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先比较两个位置的两种配法。若 $a\le b,c\le d$，有&lt;/p&gt;
&lt;p&gt;$$ac+bd-(ad+bc)=(b-a)(d-c)\ge0.$$&lt;/p&gt;
&lt;p&gt;所以乘积和同向排序最大、反向排序最小；反复消去逆序配对就得到全局证明。实数可含负数，关键是两个差同号。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,4]$ 与 $[2,7]$，同向和为 30，反向为 15，差 $(4-1)(7-2)=15$。若最小化平方差，展开 $\sum(a_i-b_{\pi(i)})^2$ 后只有 $-2\sum a_ib_{\pi(i)}$ 受排列影响，所以同向配对最小。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：只适用于目标可按成对交换比较且任意配对合法。存在禁配边、额外跨位置项时，排序结论未必成立，可能回到匹配/DP。通常排序 $O(n\log n)$。上面的等式就是独立完整证明，使用前先写出自己题目的交换差，不能只记“大配大”。&lt;/p&gt;
&lt;h5&gt;39. 总量固定如何分配：凸性等价于边际费用递增&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：固定总和，最小化平方和、负载惩罚、分配资源；每多分配一个单位代价会改变。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：对整数费用 $f$ 定义边际 $\Delta f(x)=f(x+1)-f(x)$。若边际随 $x$ 非降，将一个单位从较大负载移向较小负载不会变差；同一种凸费用、无额外约束时，最优各份最多差 1。不同凸费用 $f_i$ 可从满足下界的配置出发，每次选择最便宜的下一单位，用堆维护边际。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$x+y+z=8,x,y,z\ge0$，最小平方和在 $[2,3,3]$，为 22。若某两项相差至少 2，$a^2+b^2-(a-1)^2-(b+1)^2=2(a-b-1)&amp;gt;0$，因此一定还能改进。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：异权费用并不要求负载尽量相等；取整、容量上下界要进入可行域。边际不单调时，逐单位堆贪心可能错。相同费用直接均分 $O(n)$；分配 $K$ 个增量的堆法 $O((n+K)\log n)$。本条采用显式交换证明，不需要浮点求二阶导数。&lt;/p&gt;
&lt;h4&gt;六、结构与不变量：先决定历史能压缩成什么&lt;/h4&gt;
&lt;h5&gt;7. 分组 DP：余数能算出来就不存&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：选完一个集合之后分组，组目标和相同；DP 同时记录已选 &lt;code&gt;mask&lt;/code&gt; 和当前桶内和。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：在每组和固定为 $T&amp;gt;0$、非负数装桶且当前组和不超过 $T$ 的模型中，当前余数由&lt;/p&gt;
&lt;p&gt;$$rem(mask)=\left(\sum_{i\in mask}a_i\right)\bmod T$$&lt;/p&gt;
&lt;p&gt;唯一决定。只记录 &lt;code&gt;reachable[mask]&lt;/code&gt;；尝试加入未选元素时检查 $rem+a_i\le T$。可预处理子集和，或者递推到达时携带唯一余数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,1,2,2]$ 分成两个和为 3 的组。选过一个 1、一个 2 时总和 3，余数 0；不同加入次序不需要不同状态，下一组从空桶开始。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：还要有总和是 $T$ 的倍数、目标组数一致等整体条件；负数时不能用“不超桶容量”剪枝。零元素与非空组要求单独核对。若还有组大小、顺序、颜色限制，余数仍可推导但其他信息可能不能删除。复杂度 $O(n2^n)$、空间 $O(2^n)$；这里的删维来自公式，不代表所有分组问题都能这么转移。&lt;/p&gt;
&lt;h5&gt;23. 区间数量比较 → 前缀差 → 多维偏序&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：一个区间里 A 的数量至少 B、同时至少 C；求若干不交合法区间的总长最大。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：定义 $X_i=#A-#B,Y_i=#A-#C$ 的前缀值，则 $(j,i]$ 合法当且仅当 $X_j\le X_i,Y_j\le Y_i$。若 $dp[i]$ 为前 $i$ 个位置的最优覆盖总长，&lt;/p&gt;
&lt;p&gt;$$dp[i]=\max\bigl(dp[i-1],\ i+\max_{j&amp;lt;i,X_j\le X_i,Y_j\le Y_i}(dp[j]-j)\bigr).$$&lt;/p&gt;
&lt;p&gt;按时间从左到右，用二维前缀最大值保存坐标 $(X_j,Y_j)$、权 $dp[j]-j$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：字符串 ABB 的前缀坐标为 $(0,0),(1,1),(0,1),(-1,1)$。AB 合法，ABB 因 A 少于 B 不合法，最大覆盖为 2。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：接口 &lt;code&gt;cp::Fenwick2DMax&lt;/code&gt;，提前提供所有可能更新坐标，单次更新/查询 $O(\log^2 n)$、总空间 $O(n\log n)$。先查询再插入当前点以保持 $j&amp;lt;i$；严格不等改压缩下标边界。只支持 &lt;code&gt;chmax&lt;/code&gt;，不能删点或把权值降低。若允许重叠区间，以上 DP 的含义需要改变。&lt;/p&gt;
&lt;h5&gt;24. 树上端点差分：用割证明方向&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：树上给很多条路径，问每条边经过次数或奇偶；逐路径走太慢。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：固定树边，删去后树分成两块。一条路径经过此边，当且仅当其端点分别在两块。因此奇偶模型对每条路径做 $d_u\mathrel{\char94}=1,d_v\mathrel{\char94}=1$，自底向上异或子树，边 $(fa,v)$ 的答案就是汇总后的 $d_v$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：路径树 $1-2-3$ 上加入 $(1,3)$ 与 $(1,2)$ 两条路径，边 $1-2$ 被过两次，奇偶为 0；边 $2-3$ 一次，奇偶为 1。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：这是边覆盖；若数实际次数，使用 $d_u++,d_v++,d_{lca}-=2$ 再子树求和。点覆盖则为 $d_u++,d_v++,d_{lca}--,d_{fa(lca)}--$，根父亲为虚点；模型不同，修正点不同。奇偶接口 &lt;code&gt;cp::tree_path_xor_edges&lt;/code&gt; 不需要 LCA，$O(n+q)$；实际计数加 LCA 预处理约 $O((n+q)\log n)$。&lt;/p&gt;
&lt;h5&gt;40. 不变量与势能：证明不可能，再界定操作次数&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：要求构造操作序列或证明无法到达；每步只改少数位置，直接搜索的状态过大。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先求一个在操作下保持的量，如总和、奇偶、棋盘染色差、置换符号；这给出必要条件。若要证明过程会停止，找非负整数势能 $\Phi$，证明每步至少下降 1。必要条件不自动是充分条件，仍需构造能达到目标。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：黑白染色棋盘上每块多米诺覆盖一黑一白，因此黑白数量不同必不能铺满；数量相同也未必能铺满带洞棋盘。排序时每次交换一对相邻逆序，逆序数恰减 1，所以最多初始逆序数次停止。$[3,1,2]$ 有 2 个逆序，恰需 2 次相邻交换。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：计数势能应保证有下界；实数严格下降但每次降幅可能趋于 0，不足以推出有限步终止。多米诺的标准完整矩形模型可练 &lt;a href=&quot;https://cses.fi/problemset/task/2181&quot;&gt;CSES Counting Tilings&lt;/a&gt;，不要把必要染色条件当完整计数算法。逆序数可树状数组 $O(n\log n)$；势能还可用于证明摊还复杂度，而不是要求实际模拟全部操作。&lt;/p&gt;
&lt;h5&gt;41. 非单调也能找零点：离散介值保持的是异号括区&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：要求找到某个平衡位置；函数可能反复波动，但每移动一个位置只变 $-1,0,1$，两端一负一正。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：设整数函数满足 $|f(i+1)-f(i)|\le1$，已知 $f(L)&amp;lt;0&amp;lt;f(R)$。取中点 $M$，若为 0 立即返回；若负，保留 $[M,R]$；若正，保留 $[L,M]$。每次只维护两端异号，离散介值保证区间内仍有一个 0，不要求全局单调。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[-2,-1,0,-1,0,1,2]$ 不单调。两端异号，中点值 $-1$，保留右半；新中点可取值 0 的位置，找到一个解。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：只能保证找“某个”零点，不能保证最早零点；若相邻可从 $-1$ 跳到 $+1$，零点不再必然存在。要严格证明每次相邻变化界，以及一个已知异号初始区间。本段是根据相邻变化界直接给出的证明；评估一次函数为 $T$，查询复杂度 $O(T\log(R-L))$。&lt;/p&gt;
&lt;h4&gt;21. 赛时落地的五步&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;写量&lt;/strong&gt;：明确元素、位置、下标集合、概率事件分别是什么；先把题意变成一个等式或不等式。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;找宽条件&lt;/strong&gt;：精确 GCD 改成倍数条件，最大值改成 CDF，复杂选择改成固定对象的贡献。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;证明压缩&lt;/strong&gt;：说明删掉的信息为什么不影响后续决策；对不变量用归纳，对最优策略用交换差或上下界。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;匹配计算规模&lt;/strong&gt;：值域能否筛、状态能否 $2^B$、卷积长度能否容纳、模数是否允许求逆；再选择接口。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;算一个小例&lt;/strong&gt;：至少独立手算一个能区分模型的例子，再核对程序的初始化、计数对象与边界。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-12&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;第十二章 抽象代数&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.1 抽象代数的竞赛用法&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：从循环、置换、同态、轨道和有限域识别可用的结构。&lt;/p&gt;
&lt;h3&gt;抽象代数的竞赛用法&lt;/h3&gt;
&lt;p&gt;先把题目中的对象和操作说清楚：对象是余数、排列、向量还是多项式？操作能否结合、交换、撤销？随后才能判断应该用群、环、域中的哪条性质。下列竞赛模型由这些定义推导，例子均为独立构造；完整定义与证明见本章后续八节。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;题面信号&lt;/th&gt;
&lt;th&gt;先问什么&lt;/th&gt;
&lt;th&gt;可落地的方法&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;环上重复跳跃、模意义下加减&lt;/td&gt;
&lt;td&gt;所有操作生成了哪些余数？&lt;/td&gt;
&lt;td&gt;GCD、线性同余、循环群的阶&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同一洗牌执行巨大次数&lt;/td&gt;
&lt;td&gt;每个位置属于哪个循环？&lt;/td&gt;
&lt;td&gt;循环分解，每环对长度取模&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;换位、三轮换、能否复原&lt;/td&gt;
&lt;td&gt;操作改变奇偶性吗？&lt;/td&gt;
&lt;td&gt;符号同态、置换不变量&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;许多输入得到同一个输出&lt;/td&gt;
&lt;td&gt;映射是否保持运算？&lt;/td&gt;
&lt;td&gt;核、陪集、像，计算纤维大小&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;把大量状态归为同一类&lt;/td&gt;
&lt;td&gt;换代表元后，所有后继仍等价吗？&lt;/td&gt;
&lt;td&gt;良定性、商结构，证明状态压缩&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;模除法、模高斯消元&lt;/td&gt;
&lt;td&gt;被除数所在结构中是否有逆元？&lt;/td&gt;
&lt;td&gt;单位群；素数域与合数环分开&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;旋转或翻转视为相同&lt;/td&gt;
&lt;td&gt;各对象的等价类大小相同吗？&lt;/td&gt;
&lt;td&gt;群作用、Burnside，数不动点&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;NTT、异或系数、多项式取模&lt;/td&gt;
&lt;td&gt;系数在哪个域？根的阶和模多项式是什么？&lt;/td&gt;
&lt;td&gt;单位根、有限域、商环&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h4&gt;1. 模环上的移动：可达性先算生成子群&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 状态为 $x\bmod m$，可反复加减固定步长 $a_1,\ldots,a_k$，问能否从 $s$ 到达 $t$、有多少可达状态，或多久回到起点。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; 令 $g=\gcd(m,a_1,\ldots,a_k)$。所有可达增量组成 $\mathbb Z_m$ 的子群，恰为 $g$ 的倍数；因此&lt;/p&gt;
&lt;p&gt;$$
t\text{ 可达}\iff g\mid(t-s),\qquad #\text{可达状态}=m/g.
$$&lt;/p&gt;
&lt;p&gt;单一步长 $a$ 的最小正周期是 $m/\gcd(m,a)$。证明分两边：每个操作保留模 $g$ 的余数；Bezout 恒等式给出 $g$ 的整数线性组合，从而所有 $g$ 的倍数都能生成。若只有“加”、无次数上限，在有限模环上同样能通过重复加法模拟逆操作。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 先约去 GCD 判断可解，再用扩展欧几里得求某个操作次数；若问最短步数，还需考虑允许的操作及边权，不能仅凭可达性得到距离。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 在 12 个位置的环上每次加 8，从 0 出发依次为 $0,8,4,0$：只到达 3 个位置。再允许加 6，则 $g=2$，可到达全部偶数位置。若每种操作次数有上限，以上充分性不再自动成立。&lt;/p&gt;
&lt;p&gt;这是循环群及其子群在加法模环上的应用。基础见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/50c134275caf32dbf4430ab097185157_MIT18_703S13_pra_l_4.pdf&quot;&gt;MIT 18.703：循环群&lt;/a&gt;；对应笔记 &lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/&quot;&gt;02-循环群与生成元&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;2. 巨大次数置换：逐环取模，通常不用算全局 LCM&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 洗牌、重排、轮换的规则固定，每个位置恰有一个前驱和后继，执行 $K$ 次，$K$ 可能是十进制大整数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 把 $p$ 分解成不相交循环 $c_0,c_1,\ldots,c_{\ell-1}$，满足 $p(c_i)=c_{(i+1)\bmod\ell}$。则&lt;/p&gt;
&lt;p&gt;$$
p^K(c_i)=c_{(i+K)\bmod\ell}.
$$&lt;/p&gt;
&lt;p&gt;遍历所有位置 $O(n)$；每个不同环长需要 $K\bmod\ell$，大整数可逐位维护余数。只有题目真的问“整体最早复原次数”时，才计算各环长 LCM；LCM 本身可能超过 64 位。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; $p=(1\ 2\ 3)(4\ 5)$，阶为 6。执行 2026 次后，三环移 1 格，二环不动，所以 $1\mapsto2$、$4\mapsto4$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;方向检查。&lt;/strong&gt; 若规则是“原位置 $i$ 的物品移到 $p(i)$”，则写 &lt;code&gt;new[p[i]]=old[i]&lt;/code&gt;；若定义是 &lt;code&gt;new[i]=old[p[i]]&lt;/code&gt;，移动方向相反。先用一个三环验方向。一般函数图可能带入树，必须先处理进环前的路径，不能把任意映射都当置换。&lt;/p&gt;
&lt;p&gt;不相交循环分解与阶公式见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/1216f598a733ff16876a797b6174bb7b_MIT18_703S13_pra_l_5.pdf&quot;&gt;MIT 18.703：置换群&lt;/a&gt;；证明见 &lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;3. 置换奇偶性：先证明不可能，再讨论怎么构造&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 操作是交换、三轮换，题目要求复原、限制操作次数奇偶，或问状态之间能否互达。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; 置换符号是到 ${+1,-1}$ 的同态。一次任意对换改变符号；三轮换是两个对换的乘积，保留符号。若分解后有 $c$ 个循环（含不动点），则符号为 $(-1)^{n-c}$。任意两位置可交换时，最少交换次数为 $n-c$：一次交换至多增加一个循环，而一个长 $\ell$ 的循环可用 $\ell-1$ 次交换拆开。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; $p=(1\ 2\ 3)(4\ 5)$ 有 $n-c=5-2=3$，是奇置换，不能仅靠三轮换复原。若操作允许任意三个不同位置的三轮换，则偶置换可以复原；若只允许某些局部三轮换，还要证明这些操作能生成全部目标状态。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;使用边界。&lt;/strong&gt; 有重复值时，交换两个相等值可以改变“带标签置换”的奇偶性却不改变可见序列，因此不能直接把互异排列的必要条件搬到重复值排序。滑块拼图也必须把空格位置的变化一起纳入不变量。&lt;/p&gt;
&lt;p&gt;证明见 &lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-6-%E5%AF%B9%E6%8D%A2%E5%A5%87%E5%81%B6%E6%80%A7%E4%B8%8D%E5%8F%98%E9%87%8F%E5%AE%9A%E7%90%86&quot;&gt;06-置换群-内自同构-Cayley&lt;/a&gt;。这一节给出的是从符号同态推导的竞赛判据。&lt;/p&gt;
&lt;h4&gt;4. 同态、核与像：一份解加上所有零解&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 问某种线性/同余变换能产生哪些输出，某个输出有几个原像，或者多个方程解集为什么大小相同。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; 若 $f:G\to H$ 是有限群同态，$f(x_0)=y$，则所有映到 $y$ 的元素恰为陪集 $x_0\ker f$。所以每个可达输出有 $|\ker f|$ 个原像，而且 $|G|=|\ker f|,|\operatorname{Im}f|$。要先检查映射保持运算；任意非线性函数没有这一保证。核与像的基础见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/fd33efba1e39ed8ca373aed383caa3e0_MIT18_703S13_pra_l_8.pdf&quot;&gt;MIT 18.703：同态与核&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例一。&lt;/strong&gt; $f:\mathbb Z_{12}\to\mathbb Z_{12}$，$f(x)=8x$。核是 ${0,3,6,9}$，像是 ${0,4,8}$。因此 $8x\equiv4\pmod{12}$ 有 4 个解，分别为 $2,5,8,11$，而右端为 2 时无解。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例二。&lt;/strong&gt; $\mathbb F_2$ 上 $Ax=b$，有 $n$ 个变量、秩为 $r$。若无矛盾行，零空间有 $n-r$ 个自由变量，解数为 $2^{n-r}$；否则为 0。例如 $x_1\oplus x_2=1$，$x_2\oplus x_3=0$，解为 $(1,0,0)$ 和 $(0,1,1)$，恰为一份解加零空间。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 同余用扩欧先查 GCD；二进制线性方程用 XOR 高斯消元或带方程信息的线性基。不要把“能表示的不同异或值个数 $2^r$”与“每个异或值对应多少下标子集 $2^{n-r}$”混为一谈。进一步理论见 &lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;5. 商结构与 DP 压缩：同类状态的下一步也必须同类&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 想只存余数、排序后的集合、某个哈希值或当前答案，忽略原状态的其他信息。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用步骤。&lt;/strong&gt; 明确等价关系 $x\sim y$；对每个合法操作 $T$ 检查：操作是否合法、代价和可观察收益是否一致，而且 $x\sim y$ 是否推出 $T(x)\sim T(y)$。若选择依赖状态，必须能逐项对应可选操作。这样才可以在等价类上定义转移；计数问题还要保留每类的权重或转移重数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 存 $x\bmod3$ 能支持任意整数加法、乘法，因为换代表元不会改变结果的余数；却不能支持 $T(x)=\lfloor x/2\rfloor$：$0\equiv3\pmod3$，但结果为 0、1，已经不同余。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;如何判断状态不足。&lt;/strong&gt; 主动找两个被合并的历史，并让它们面对同一个后续操作；若合法性或最优剩余值不同，就必须加信息。哈希碰撞控制的是表示错误概率，不能代替这个充分性证明。商集上的良定性见 &lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-8-%E5%95%86%E9%9B%86%E8%AF%B1%E5%AF%BC%E6%98%A0%E5%B0%84%E5%AE%9A%E7%90%86&quot;&gt;00-集合论与映射&lt;/a&gt;；群商还要求正规性，见 &lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态&lt;/a&gt;。&lt;/p&gt;
&lt;h4&gt;6. 群、环、域：为什么有的模数可以除，有的不行&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 公式里出现除法、约分、高斯消元的主元，或要把巨大指数按周期缩小。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;判断。&lt;/strong&gt; $\mathbb Z_m$ 在加法下是群；在乘法下只有与 $m$ 互质的元素有逆元，它们组成单位群。$m=p$ 为素数时，全部非零元素可逆，才可把通常的域上线性代数直接用于模运算。&lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/50c134275caf32dbf4430ab097185157_MIT18_703S13_pra_l_4.pdf&quot;&gt;MIT 循环群讲义&lt;/a&gt;证明了单位群与 Euler 定理；&lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/cef5dd050c4f35579c59cd70288fbd77_MIT18_703S13_pra_l_14.pdf&quot;&gt;MIT 环讲义&lt;/a&gt;给出了模环中的零因子。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 模 12 下 $5^{-1}=5$，但 6 无逆元；$6\cdot2\equiv6\cdot4\equiv0$，不能约去 6 得到 $2\equiv4$。因此复合模高斯消元不能把任意非零主元拿来求逆。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 使用 &lt;code&gt;cp::inv_mod(a,m)&lt;/code&gt; 并处理无逆元；素数模快速幂逆元要求 $a\not\equiv0$。对互质底数，指数可模元素的阶或 $\varphi(m)$；不互质时不能直接套 Euler 缩指数。比如 $2^4\bmod8=0$，把指数模 $\varphi(8)=4$ 后变成 $2^0\bmod8=1$。&lt;/p&gt;
&lt;h4&gt;7. 群作用与去重：不能看到旋转就除以 n&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 染色、项链、棋盘等对象在旋转/翻转下视为相同。先列清允许的变换：只旋转通常是循环群，旋转和翻转是二面体群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与证明。&lt;/strong&gt; 对有限群 $G$ 的作用，每个对象的轨道大小为 $|G|/|\operatorname{Stab}(x)|$；具有对称性的对象会有较小轨道，所以等价类并不统一有 $|G|$ 个元素。轨道与稳定子的基础见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/96221ce2d5b1077b3e5d3c5e08c88afe_MIT18_703S13_pra_l_23.pdf&quot;&gt;MIT 18.703：群作用&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;对固定对 $(g,x)$（满足 $g\cdot x=x$）双计数：一个轨道里所有点的稳定子大小之和恰为 $|G|$，故&lt;/p&gt;
&lt;p&gt;$$
#\text{轨道}=\frac1{|G|}\sum_{g\in G}|\operatorname{Fix}(g)|.
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 先把每个变换看成位置置换。不受其他条件限制的 $q$ 色染色要被该变换固定，同一个位置循环必须同色，因而有 $q^{c(g)}$ 种。圆环旋转 $r$ 格时有 $\gcd(n,r)$ 个位置循环。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 长为 4 的二色圆环，仅视旋转相同：四种旋转的不动点数为 $16,2,4,2$，答案 $(16+2+4+2)/4=6$，直接 $16/4=4$ 会漏算。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;边界。&lt;/strong&gt; 限制某种颜色数量、相邻颜色或图结构时，固定染色数需在循环压缩后的约束上重新计算，不能一律用 $q^{c(g)}$。取模时只有 $|G|$ 与模数互质才可乘逆元；否则在能保留整除信息的模数或整数范围下先求和再除。&lt;/p&gt;
&lt;h4&gt;8. NTT：单位根的阶决定能处理的长度&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 两组数按“下标和”组合，需要求 $c_k=\sum_{i+j=k}a_i b_j$；把它看成多项式乘法。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; 在素数域 $\mathbb F_p$ 中选阶恰为 $L$ 的元素 $\omega$。本册的二进制 NTT 要求 $L$ 是 2 的幂且 $L\mid(p-1)$；若 $g$ 为原根，可取 $\omega=g^{(p-1)/L}$。逆变换还要除以 $L$。ACL 的卷积接口明确给出了素数模与可用二次幂长度条件。&lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/convolution.html&quot;&gt;ACL convolution 官方文档&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 先取 $L\ge|a|+|b|-1$ 的最小 2 次幂，检查根是否存在，再补零。模数 $998244353=119\cdot2^{23}+1$ 支持最长 $2^{23}$；调用本册 &lt;code&gt;cp::convolution&lt;/code&gt;。任意改模数，原根和最大长度都要一起重推。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; $(1+2x)(3+4x)=3+10x+8x^2$，需补到长度 4。模 7 的乘法群阶为 6，没有阶为 4 的元素，不能照搬长度 4 的常规 NTT。若不补零，算的是模 $x^L-1$ 的循环卷积，会让高次项绕回低位。&lt;/p&gt;
&lt;h4&gt;9. 有限域不等于“整数模一个同样大的数”&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 题目使用二进制多项式、CRC、扩域，或声称有 $p^k$ 个域元素。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; $\mathbb F_p[x]/(f)$ 在 $f$ 不可约时是域；若 $\deg f=k$，每个元素可用次数小于 $k$ 的余式表示，共 $p^k$ 个。原因是任意非零余式 $a$ 与 $f$ 互质，扩展 Euclid 给出 $ua+vf=1$，从而 $u$ 是其逆元。二、三次多项式可通过检查基域上有无根判断不可约，高次不能只检查根。&lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/5002c8bba6f97a9f750f2aca8b804db7_MIT18_703S13_pra_l_21.pdf&quot;&gt;MIT 18.703：多项式环&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 在 $\mathbb F_2$ 上，$f=x^2+x+1$ 在 0、1 都不为 0，故不可约。记 $\alpha=[x]$，则 $\alpha^2=\alpha+1$，$\alpha(\alpha+1)=1$。四个元素为 $0,1,\alpha,\alpha+1$；加法按位 XOR，乘法先做无进位多项式乘法，再模 $f$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;边界。&lt;/strong&gt; $\mathbb Z_4$ 中 $2\cdot2=0$，因此不是这个四元域。若模 $x^2+1=(x+1)^2$，非零 $x+1$ 的平方为 0，商环也不是域。CRC 的模多项式按检测需求选取，不保证不可约；不要因此假设所有非零余数都有逆元。&lt;/p&gt;
&lt;h4&gt;阅读顺序&lt;/h4&gt;
&lt;p&gt;竞赛应用先读本节和数学套路中的对应条目；需要证明时按“集合与映射 → 群与子群 → 循环群 / 陪集 → 商群与同态 → 同构定理 → 置换群”阅读。章节末的抽象代数易错点整理的是概念与证明；个人竞赛复盘单独放在全书最后。&lt;/p&gt;
&lt;p&gt;&amp;lt;!-- algebra-code-start --&amp;gt;&lt;/p&gt;
&lt;h4&gt;10. 可直接复制的代数代码&lt;/h4&gt;
&lt;p&gt;完整 GNU C++17 头文件，不依赖 &lt;code&gt;cp_ready.hpp&lt;/code&gt; 或第三方库；命名空间为 &lt;code&gt;cp_algebra&lt;/code&gt;。提交单文件时将头文件放在 &lt;code&gt;main&lt;/code&gt; 前，并删除示例中的本地 &lt;code&gt;include&lt;/code&gt;。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;接口&lt;/th&gt;
&lt;th&gt;输入与返回&lt;/th&gt;
&lt;th&gt;前提与代价&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;solve_binary(n, rows)&lt;/td&gt;
&lt;td&gt;每行是 &lt;code&gt;(系数位掩码,右端0/1)&lt;/code&gt;；返回是否有解、秩、特解、零空间基&lt;/td&gt;
&lt;td&gt;0≤n≤63，位j对应变量j；O(mn+n²)时间，O(m+n)空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;determinant_prime(a,p)&lt;/td&gt;
&lt;td&gt;方阵的行列式模p；空方阵返回1&lt;/td&gt;
&lt;td&gt;p为素数；O(n³+n log p)时间、O(n²)空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;spanning_trees_prime(n,edges,p)&lt;/td&gt;
&lt;td&gt;无向图生成树边权乘积之和，模p&lt;/td&gt;
&lt;td&gt;n≥1，顶点0-based，p素数；平行边累加，自环忽略，单点返回1；O(n³+n log p+m)时间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;lagrange_consecutive(y,t,p)&lt;/td&gt;
&lt;td&gt;y[i]=F(i)，返回F(t)模p&lt;/td&gt;
&lt;td&gt;已证明次数≤d，d=y.size()-1&amp;lt;p，p素数；O(d+log p)时间、O(d)空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;permutation_power(p,K)&lt;/td&gt;
&lt;td&gt;返回每个原位置执行K次后的目的地&lt;/td&gt;
&lt;td&gt;p为0-based双射，K为64位非负整数；O(n)时间/空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;power_sum(A,n,M)&lt;/td&gt;
&lt;td&gt;返回 &lt;code&gt;(A^n, Σ A^i)&lt;/code&gt;，求和i=0..n-1&lt;/td&gt;
&lt;td&gt;M≥2可为合数，n为64位非负整数；O(log n)时间、O(1)空间&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;&lt;strong&gt;解读二进制方程返回值。&lt;/strong&gt; 若无解，不读取特解与零空间基；若有解，全部解为 &lt;code&gt;particular&lt;/code&gt; 异或任意一个零空间基子集，解数为 &lt;code&gt;2^(n-rank)&lt;/code&gt;。题目若要求非空选择且目标为0，需要扣掉空选择。枚举所有解的成本本身是指数级，不要把基向量个数当解数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;检查运算结构。&lt;/strong&gt; &lt;code&gt;prime&lt;/code&gt; 接口将“p是素数”作为调用前提，不进行素性检测。合数模矩阵不能直接套用。生成树权值在这里是每棵树内相乘，不是树边权相加；无解图返回0，权值在模意义下抵消也可能得到0，不能据此反推原图不连通。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#pragma once
#include &amp;lt;bits/stdc++.h&amp;gt;

namespace cp_algebra {
using i64 = long long;
using i128 = __int128_t;
using u64 = std::uint64_t;

inline i64 norm(i64 x, i64 mod) {
    assert(mod &amp;gt;= 2);
    x %= mod;
    return x &amp;lt; 0 ? x + mod : x;
}
inline i64 power(i64 a, u64 e, i64 mod) {
    a = norm(a, mod);
    i64 r = 1;
    for (; e; e &amp;gt;&amp;gt;= 1, a = (i128)a * a % mod)
        if (e &amp;amp; 1) r = (i128)r * a % mod;
    return r;
}

// Each row is (coefficient mask, RHS). Variable j is bit j, 0 &amp;lt;= n &amp;lt;= 63.
// With a solution: x = particular XOR any subset of nullspace vectors.
struct BinarySolution {
    bool consistent;
    int rank;
    u64 particular;
    std::vector&amp;lt;u64&amp;gt; nullspace;
};
inline BinarySolution solve_binary(int n, std::vector&amp;lt;std::pair&amp;lt;u64, bool&amp;gt;&amp;gt; rows) {
    assert(0 &amp;lt;= n &amp;amp;&amp;amp; n &amp;lt;= 63);
    for (auto [a, b] : rows) { (void)b; assert((a &amp;gt;&amp;gt; n) == 0); }
    int m = (int)rows.size(), r = 0;
    std::vector&amp;lt;int&amp;gt; pivot;
    for (int col = 0; col &amp;lt; n &amp;amp;&amp;amp; r &amp;lt; m; ++col) {
        int at = r;
        while (at &amp;lt; m &amp;amp;&amp;amp; !(rows[at].first &amp;gt;&amp;gt; col &amp;amp; 1)) ++at;
        if (at == m) continue;
        std::swap(rows[r], rows[at]);
        for (int i = 0; i &amp;lt; m; ++i) if (i != r &amp;amp;&amp;amp; (rows[i].first &amp;gt;&amp;gt; col &amp;amp; 1)) {
            rows[i].first ^= rows[r].first;
            rows[i].second = rows[i].second != rows[r].second;
        }
        pivot.push_back(col);
        ++r;
    }
    for (auto [a, b] : rows) if (a == 0 &amp;amp;&amp;amp; b) return {false, r, 0, {}};
    BinarySolution ans{true, r, 0, {}};
    std::vector&amp;lt;bool&amp;gt; is_pivot(n, false);
    for (int i = 0; i &amp;lt; r; ++i) {
        is_pivot[pivot[i]] = true;
        if (rows[i].second) ans.particular |= u64(1) &amp;lt;&amp;lt; pivot[i];
    }
    for (int f = 0; f &amp;lt; n; ++f) if (!is_pivot[f]) {
        u64 v = u64(1) &amp;lt;&amp;lt; f;
        for (int i = 0; i &amp;lt; r; ++i)
            if (rows[i].first &amp;gt;&amp;gt; f &amp;amp; 1) v |= u64(1) &amp;lt;&amp;lt; pivot[i];
        ans.nullspace.push_back(v);
    }
    return ans;
}

// Prime mod is a caller precondition. Empty determinant is 1.
// O(n^3 + n log mod) time and O(n^2) copied storage; no primality test.
inline i64 determinant_prime(std::vector&amp;lt;std::vector&amp;lt;i64&amp;gt;&amp;gt; a, i64 mod) {
    assert(mod &amp;gt;= 2);
    int n = (int)a.size();
    for (auto &amp;amp;row : a) {
        assert((int)row.size() == n);
        for (auto &amp;amp;x : row) x = norm(x, mod);
    }
    i64 answer = 1;
    for (int col = 0; col &amp;lt; n; ++col) {
        int at = col;
        while (at &amp;lt; n &amp;amp;&amp;amp; a[at][col] == 0) ++at;
        if (at == n) return 0;
        if (at != col) { std::swap(a[at], a[col]); answer = norm(-answer, mod); }
        i64 p = a[col][col], inv = power(p, (u64)(mod - 2), mod);
        answer = (i128)answer * p % mod;
        for (int i = col + 1; i &amp;lt; n; ++i) {
            i64 factor = (i128)a[i][col] * inv % mod;
            for (int j = col; j &amp;lt; n; ++j) {
                i64 sub = (i128)factor * a[col][j] % mod;
                a[i][j] = a[i][j] &amp;gt;= sub ? a[i][j] - sub : mod - (sub - a[i][j]);
            }
        }
    }
    return answer;
}

struct Edge { int u, v; i64 weight = 1; };
// Undirected weighted Matrix-Tree: sum of products of edge weights, modulo prime.
// Vertices 0..n-1, n &amp;gt;= 1. Parallel edges add; self-loops have no effect.
inline i64 spanning_trees_prime(int n, const std::vector&amp;lt;Edge&amp;gt; &amp;amp;edges, i64 mod) {
    assert(n &amp;gt;= 1 &amp;amp;&amp;amp; mod &amp;gt;= 2);
    std::vector&amp;lt;std::vector&amp;lt;i64&amp;gt;&amp;gt; a(n - 1, std::vector&amp;lt;i64&amp;gt;(n - 1));
    auto add = [&amp;amp;](int u, int v, i64 w) {
        if (u &amp;lt; n - 1 &amp;amp;&amp;amp; v &amp;lt; n - 1) a[u][v] = ((i128)a[u][v] + w) % mod;
    };
    for (auto [u, v, weight] : edges) {
        assert(0 &amp;lt;= u &amp;amp;&amp;amp; u &amp;lt; n &amp;amp;&amp;amp; 0 &amp;lt;= v &amp;amp;&amp;amp; v &amp;lt; n);
        if (u == v) continue;
        i64 w = norm(weight, mod), neg = w ? mod - w : 0;
        add(u, u, w); add(v, v, w); add(u, v, neg); add(v, u, neg);
    }
    return determinant_prime(std::move(a), mod);
}

// Values y[i] = F(i), i=0..d, of a polynomial of degree &amp;lt;= d over F_mod.
// Caller guarantees prime mod and d &amp;lt; mod. O(d + log mod) time, O(d) storage.
inline i64 lagrange_consecutive(const std::vector&amp;lt;i64&amp;gt; &amp;amp;y, i64 t, i64 mod) {
    assert(mod &amp;gt;= 2 &amp;amp;&amp;amp; !y.empty());
    int d = (int)y.size() - 1;
    assert(d &amp;lt; mod);
    t = norm(t, mod);
    if (t &amp;lt;= d) return norm(y[(int)t], mod);
    std::vector&amp;lt;i64&amp;gt; pre(d + 2, 1), suf(d + 2, 1), invfact(d + 1, 1);
    i64 fact = 1;
    for (int i = 1; i &amp;lt;= d; ++i) fact = (i128)fact * i % mod;
    invfact[d] = power(fact, (u64)(mod - 2), mod);
    for (int i = d; i &amp;gt; 0; --i) invfact[i - 1] = (i128)invfact[i] * i % mod;
    for (int i = 0; i &amp;lt;= d; ++i) pre[i + 1] = (i128)pre[i] * norm(t - i, mod) % mod;
    for (int i = d; i &amp;gt;= 0; --i) suf[i] = (i128)suf[i + 1] * norm(t - i, mod) % mod;
    i64 answer = 0;
    for (int i = 0; i &amp;lt;= d; ++i) {
        i64 term = (i128)norm(y[i], mod) * pre[i] % mod * suf[i + 1] % mod;
        term = (i128)term * invfact[i] % mod * invfact[d - i] % mod;
        if ((d - i) &amp;amp; 1) term = term ? mod - term : 0;
        answer = ((i128)answer + term) % mod;
    }
    return answer;
}

// Valid permutation p[i] = destination of original position i; exponent K &amp;gt;= 0.
// Returns p^K(i) for every i; O(n). Apply values as new[result[i]] = old[i].
inline std::vector&amp;lt;int&amp;gt; permutation_power(const std::vector&amp;lt;int&amp;gt; &amp;amp;p, u64 k) {
    int n = (int)p.size();
    std::vector&amp;lt;int&amp;gt; indeg(n), answer(n);
    for (int v : p) { assert(0 &amp;lt;= v &amp;amp;&amp;amp; v &amp;lt; n); ++indeg[v]; }
    for (int count : indeg) { (void)count; assert(count == 1); }
    std::vector&amp;lt;bool&amp;gt; seen(n, false);
    for (int i = 0; i &amp;lt; n; ++i) if (!seen[i]) {
        std::vector&amp;lt;int&amp;gt; cycle;
        for (int v = i; !seen[v]; v = p[v]) { seen[v] = true; cycle.push_back(v); }
        std::size_t shift = k % cycle.size();
        for (std::size_t j = 0; j &amp;lt; cycle.size(); ++j)
            answer[cycle[j]] = cycle[(j + shift) % cycle.size()];
    }
    return answer;
}

// Returns (A^n, 1+A+...+A^(n-1)) mod M, for any M &amp;gt;= 2 (including composite).
// Binary composition of consecutive blocks; O(log n), no modular division.
inline std::pair&amp;lt;i64, i64&amp;gt; power_sum(i64 a, u64 n, i64 mod) {
    i64 result_p = 1, result_s = 0, block_p = norm(a, mod), block_s = 1;
    while (n) {
        if (n &amp;amp; 1) {
            result_s = ((i128)result_s + (i128)result_p * block_s) % mod;
            result_p = (i128)result_p * block_p % mod;
        }
        block_s = ((i128)block_s + (i128)block_p * block_s) % mod;
        block_p = (i128)block_p * block_p % mod;
        n &amp;gt;&amp;gt;= 1;
    }
    return {result_p, result_s};
}
} // namespace cp_algebra
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;11. 完整调用示例&lt;/h4&gt;
&lt;p&gt;下面的输出依次是：方程有解/秩/自由变量数，三角形生成树数，平方和插值值，置换2026次后的目的地，等比和。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &quot;cp_algebra.hpp&quot;
using namespace std;
using namespace cp_algebra;
int main() {
    auto s = solve_binary(3, {{0b011, true}, {0b110, false}});
    cout &amp;lt;&amp;lt; s.consistent &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt; s.rank &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt; s.nullspace.size() &amp;lt;&amp;lt; &apos;\n&apos;;
    cout &amp;lt;&amp;lt; spanning_trees_prime(3, {{0,1,1}, {1,2,1}, {2,0,1}}, 1000000007) &amp;lt;&amp;lt; &apos;\n&apos;;
    cout &amp;lt;&amp;lt; lagrange_consecutive({0,1,5,14}, 4, 1000000007) &amp;lt;&amp;lt; &apos;\n&apos;;
    auto p = permutation_power({1,2,0,4,3}, 2026);
    for (int v : p) cout &amp;lt;&amp;lt; v + 1 &amp;lt;&amp;lt; &apos; &apos;;
    cout &amp;lt;&amp;lt; &apos;\n&apos; &amp;lt;&amp;lt; power_sum(3, 4, 7).second &amp;lt;&amp;lt; &apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;预期输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1 2 1
3
30
2 3 1 4 5
5
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-2&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.2 集合论与映射&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义、定理、证明与例题。&lt;/p&gt;
&lt;h3&gt;00-集合论与映射&lt;/h3&gt;
&lt;p&gt;这一章整理后续群论中用到的集合论与映射知识，主要包括：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;等价关系、等价类与集合划分；&lt;/li&gt;
&lt;li&gt;映射的单射、满射、双射与可逆性；&lt;/li&gt;
&lt;li&gt;选择公理与常见等价命题；&lt;/li&gt;
&lt;li&gt;商集上的映射定义与良定性检验。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;1. 集合与基本运算&lt;/h4&gt;
&lt;h5&gt;1.1 集合、子集与外延公理&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;数学对象 $a$ 属于集合 $A$ 记作 $a \in A$；不属于记作 $a \notin A$。&lt;/li&gt;
&lt;li&gt;子集包含：$A \subseteq B \iff \forall x (x \in A \implies x \in B)$。&lt;/li&gt;
&lt;li&gt;集合相等：由外延公理，两个集合相等当且仅当互为子集：
$$A = B \iff A \subseteq B \text{ 且 } B \subseteq A$$
因此证明两集合相等的通用范式是双向验证包含关系：先任取 $x \in A$ 推导 $x \in B$，再任取 $y \in B$ 推导 $y \in A$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;1.2 交、并、差与补集&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;并集：$A \cup B = {x \mid x \in A \lor x \in B}$。&lt;/li&gt;
&lt;li&gt;交集：$A \cap B = {x \mid x \in A \land x \in B}$。&lt;/li&gt;
&lt;li&gt;差集：$A \setminus B = {x \in A \mid x \notin B}$。&lt;/li&gt;
&lt;li&gt;全集 $U$ 下的绝对补集：$A^c = U \setminus A$。&lt;/li&gt;
&lt;li&gt;对称差：$A \Delta B = (A \setminus B) \cup (B \setminus A) = (A \cup B) \setminus (A \cap B)$。&lt;/li&gt;
&lt;li&gt;De Morgan 律：
$$(A \cup B)^c = A^c \cap B^c, \qquad (A \cap B)^c = A^c \cup B^c$$&lt;/li&gt;
&lt;li&gt;分配律：
$$A \cap (B \cup C) = (A \cap B) \cup (A \cap C)$$
$$A \cup (B \cap C) = (A \cup B) \cap (A \cup C)$$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;1.3 幂集与笛卡尔积&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;幂集：集合 $A$ 的全部子集构成的集合族记作 $\mathcal{P}(A) = {S \mid S \subseteq A}$。若 $|A| = n$，则 $|\mathcal{P}(A)| = 2^n$。&lt;/li&gt;
&lt;li&gt;笛卡尔积：$A \times B = {(a, b) \mid a \in A, b \in B}$。笛卡尔积是有序对集合，代数系统中的二元运算（如映射 $\cdot: G \times G \to G$）与二元关系均基于笛卡尔积定义。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 关系、等价关系与集合划分&lt;/h4&gt;
&lt;h5&gt;2.1 二元关系&lt;/h5&gt;
&lt;p&gt;集合 $A$ 上的二元关系 $R$ 是笛卡尔积的一个子集 $R \subseteq A \times A$。若 $(a, b) \in R$，记作 $a R b$。
常见基本性质：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;自反性：$\forall a \in A,\ a R a$；&lt;/li&gt;
&lt;li&gt;对称性：$\forall a, b \in A,\ a R b \implies b R a$；&lt;/li&gt;
&lt;li&gt;传递性：$\forall a, b, c \in A,\ a R b \land b R c \implies a R c$；&lt;/li&gt;
&lt;li&gt;反对称性：$\forall a, b \in A,\ a R b \land b R a \implies a = b$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;2.2 等价关系与等价类&lt;/h5&gt;
&lt;p&gt;同时满足自反性、对称性与传递性的二元关系称为&lt;strong&gt;等价关系&lt;/strong&gt;，通常记作 $\sim$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;等价类&lt;/strong&gt;：元素 $a \in A$ 所在的等价类定义为：
$$[a] = {x \in A \mid x \sim a}$$
其中 $a$ 称为该等价类的一个代表元。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;商集&lt;/strong&gt;：由关于 $\sim$ 的全体等价类构成的集合族记作：
$$A/\sim = {[a] \mid a \in A}$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;自然投影&lt;/strong&gt;：映射 $\pi: A \to A/\sim$ 定义为 $\pi(a) = [a]$，$\pi$ 恒为满射。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;2.3 等价类的二分性质&lt;/h5&gt;
&lt;h6&gt;定理 0.1（等价类相交即全同）&lt;/h6&gt;
&lt;p&gt;设 $\sim$ 是 $A$ 上的等价关系，$a, b \in A$。下列命题等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$a \sim b$；&lt;/li&gt;
&lt;li&gt;$[a] \cap [b] \neq \emptyset$；&lt;/li&gt;
&lt;li&gt;$[a] = [b]$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;(1) $\implies$ (3)&lt;/strong&gt;：设 $a \sim b$。任取 $x \in [a]$，有 $x \sim a$。由传递性 $x \sim b$，故 $x \in [b]$，即 $[a] \subseteq [b]$。由对称性 $b \sim a$，同理可得 $[b] \subseteq [a]$。两边互含，故 $[a] = [b]$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(3) $\implies$ (2)&lt;/strong&gt;：由自反性 $a \in [a]$。若 $[a] = [b]$，则 $a \in [b]$，从而 $a \in [a] \cap [b]$，交集非空。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(2) $\implies$ (1)&lt;/strong&gt;：若存在 $c \in [a] \cap [b]$，则 $c \sim a$ 且 $c \sim b$。由对称性 $a \sim c$，再由传递性 $a \sim c \land c \sim b \implies a \sim b$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!NOTE] 推论
任意两个等价类要么完全相同，要么互不相交。不存在部分重叠的情况。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;2.4 等价关系与划分的对应定理&lt;/h5&gt;
&lt;p&gt;集合 $A$ 的一个划分是指一族非空子集 $\mathcal{P} = {A_i}_{i \in I}$，满足：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;非空：$\forall i \in I, A_i \neq \emptyset$；&lt;/li&gt;
&lt;li&gt;两两不交：$i \neq j \implies A_i \cap A_j = \emptyset$；&lt;/li&gt;
&lt;li&gt;全覆盖：$\bigcup_{i \in I} A_i = A$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h6&gt;定理 0.2（等价关系与集合划分的对应）&lt;/h6&gt;
&lt;ol&gt;
&lt;li&gt;若 $\sim$ 是 $A$ 上的等价关系，则商集 $A/\sim$ 是 $A$ 的一个划分。&lt;/li&gt;
&lt;li&gt;反之，若 $\mathcal{P}$ 是 $A$ 的一个划分，定义关系 $x \sim_{\mathcal{P}} y \iff \exists P \in \mathcal{P}, x, y \in P$，则 $\sim_{\mathcal{P}}$ 是 $A$ 上的等价关系，且其商集恰为 $\mathcal{P}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;由自反性，每个 $a \in [a]$，故等价类非空且全并为 $A$；由定理 0.1，不同等价类两两不交。因此 $A/\sim$ 构成划分。&lt;/li&gt;
&lt;li&gt;自反性由划分的覆盖性保证；对称性由定义的对称性保证；传递性：若 $x, y \in P_1$ 且 $y, z \in P_2$，则 $y \in P_1 \cap P_2$。因划分两两不交，必有 $P_1 = P_2$，故 $x, z \in P_1$，即 $x \sim_{\mathcal{P}} z$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;3. 映射、像与原像&lt;/h4&gt;
&lt;h5&gt;3.1 映射定义与基本概念&lt;/h5&gt;
&lt;p&gt;映射 $f: A \to B$ 指：对定义域 $A$ 中的每个元素 $x$，在陪域 $B$ 中存在唯一确定的元素 $f(x)$ 与之对应。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;定义域记作 $\operatorname{dom}(f) = A$，陪域记作 $\operatorname{cod}(f) = B$。&lt;/li&gt;
&lt;li&gt;像集：$\operatorname{Im} f = f(A) = {f(x) \mid x \in A}$。&lt;/li&gt;
&lt;li&gt;子集 $S \subseteq A$ 的像：$f(S) = {f(x) \mid x \in S}$。&lt;/li&gt;
&lt;li&gt;子集 $T \subseteq B$ 的原像（逆像）：$f^{-1}(T) = {x \in A \mid f(x) \in T}$。
当 $T = {b}$ 时，$f^{-1}({b})$ 称为点 $b$ 的纤维。原像记号对任意映射均有定义，不依赖可逆性。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;3.2 像与原像的运算性质&lt;/h5&gt;
&lt;h6&gt;定理 0.3（原像对集合运算的保持性质）&lt;/h6&gt;
&lt;p&gt;设 $f: A \to B$，$T \subseteq B$，${T_i}_{i \in I}$ 为 $B$ 的子集族。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f^{-1}\left(\bigcup_{i \in I} T_i\right) = \bigcup_{i \in I} f^{-1}(T_i)$；&lt;/li&gt;
&lt;li&gt;$f^{-1}\left(\bigcap_{i \in I} T_i\right) = \bigcap_{i \in I} f^{-1}(T_i)$；&lt;/li&gt;
&lt;li&gt;$f^{-1}(B \setminus T) = A \setminus f^{-1}(T)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
以 (2) 为例：
$$x \in f^{-1}\left(\bigcap_{i \in I} T_i\right) \iff f(x) \in \bigcap_{i \in I} T_i \iff \forall i \in I, f(x) \in T_i \iff \forall i \in I, x \in f^{-1}(T_i) \iff x \in \bigcap_{i \in I} f^{-1}(T_i)$$
式 (1) 与 (3) 同理可证。 $\blacksquare$&lt;/p&gt;
&lt;h6&gt;定理 0.4（像的运算性质与单射判定）&lt;/h6&gt;
&lt;p&gt;设 $f: A \to B$，$S_1, S_2 \subseteq A$。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f(S_1 \cup S_2) = f(S_1) \cup f(S_2)$；&lt;/li&gt;
&lt;li&gt;$f(S_1 \cap S_2) \subseteq f(S_1) \cap f(S_2)$；&lt;/li&gt;
&lt;li&gt;$f$ 是单射 $\iff$ 对任意 $S_1, S_2 \subseteq A$，恒有 $f(S_1 \cap S_2) = f(S_1) \cap f(S_2)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;(1) 与 (2) 由定义直接推出。&lt;/li&gt;
&lt;li&gt;证明 (3)：
&lt;ul&gt;
&lt;li&gt;充分性：设 $f$ 为单射。任取 $y \in f(S_1) \cap f(S_2)$，存在 $x_1 \in S_1, x_2 \in S_2$ 使得 $f(x_1) = y = f(x_2)$。由单射性，$x_1 = x_2 \in S_1 \cap S_2$，故 $y \in f(S_1 \cap S_2)$，等号成立。&lt;/li&gt;
&lt;li&gt;必要性：反证法。若 $f$ 不是单射，存在 $a_1 \neq a_2$ 使得 $f(a_1) = f(a_2) = y$。令 $S_1 = {a_1}, S_2 = {a_2}$，则 $S_1 \cap S_2 = \emptyset \implies f(S_1 \cap S_2) = \emptyset$，但 $f(S_1) \cap f(S_2) = {y} \neq \emptyset$，矛盾。故 $f$ 必为单射。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;4. 单射、满射与双射&lt;/h4&gt;
&lt;h5&gt;4.1 基本定义与有限集合性质&lt;/h5&gt;
&lt;p&gt;设 $f: A \to B$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;单射&lt;/strong&gt;：若 $\forall a_1, a_2 \in A,\ f(a_1) = f(a_2) \implies a_1 = a_2$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射&lt;/strong&gt;：若 $\forall b \in B,\ \exists a \in A \text{ 使得 } f(a) = b$（即 $\operatorname{Im} f = B$）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;双射&lt;/strong&gt;：$f$ 既是单射又是满射。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;有限集合性质（鸽巢原理）：若 $|A| = |B| &amp;lt; \infty$，则对映射 $f: A \to B$：
$$f \text{ 是单射} \iff f \text{ 是满射} \iff f \text{ 是双射}$$
无限集合中此等价性失效。例如 $f: \mathbb{Z} \to \mathbb{Z}, x \mapsto 2x$ 是单射但非满射；$g(x) = \lfloor x/2 \rfloor$ 是满射但非单射。&lt;/p&gt;
&lt;h5&gt;4.2 单射等价定理&lt;/h5&gt;
&lt;h6&gt;定理 0.5（单射等价定理）&lt;/h6&gt;
&lt;p&gt;设 $A, B$ 非空，$f: A \to B$。下列命题等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f$ 是单射；&lt;/li&gt;
&lt;li&gt;$f$ 存在左逆：存在映射 $g: B \to A$ 使得 $g \circ f = I_A$；&lt;/li&gt;
&lt;li&gt;$f$ 左可消：对任意集合 $C$ 及映射 $h, k: C \to A$，$f \circ h = f \circ k \implies h = k$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;(1) $\implies$ (2)&lt;/strong&gt;：设 $f$ 单射。固定选取 $a_0 \in A$。定义 $g: B \to A$：若 $b \in \operatorname{Im} f$，由单射性满足 $f(a) = b$ 的 $a$ 唯一，令 $g(b) = a$；若 $b \notin \operatorname{Im} f$，令 $g(b) = a_0$。则对任意 $x \in A$，$g(f(x)) = x$，即 $g \circ f = I_A$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(2) $\implies$ (3)&lt;/strong&gt;：设存在左逆 $g$。若 $f \circ h = f \circ k$，两端左复合 $g$：
$$g \circ (f \circ h) = g \circ (f \circ k) \implies (g \circ f) \circ h = (g \circ f) \circ k \implies I_A \circ h = I_A \circ k \implies h = k$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(3) $\implies$ (1)&lt;/strong&gt;：任取 $a_1, a_2 \in A$ 使得 $f(a_1) = f(a_2)$。设单元素集 $C = {&lt;em&gt;}$，构造映射 $h(&lt;/em&gt;)=a_1, k(*)=a_2$，则 $f \circ h = f \circ k$。由左可消性 $h = k$，故 $a_1 = a_2$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;4.3 满射等价定理&lt;/h5&gt;
&lt;h6&gt;定理 0.6（满射等价定理）&lt;/h6&gt;
&lt;p&gt;设 $A, B$ 非空，$f: A \to B$。下列命题等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f$ 是满射；&lt;/li&gt;
&lt;li&gt;$f$ 存在右逆：存在映射 $g: B \to A$ 使得 $f \circ g = I_B$（此方向需要选择公理）；&lt;/li&gt;
&lt;li&gt;$f$ 右可消：对任意集合 $D$ 及映射 $h, k: B \to D$，$h \circ f = k \circ f \implies h = k$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;(1) $\implies$ (2)&lt;/strong&gt;：因 $f$ 为满射，每个纤维 $f^{-1}({b})$ 均非空。根据选择公理，可在每个纤维中选出一个元素 $a_b$。定义 $g(b) = a_b$，则 $f(g(b)) = f(a_b) = b$，即 $f \circ g = I_B$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(2) $\implies$ (3)&lt;/strong&gt;：设存在右逆 $g$。若 $h \circ f = k \circ f$，两端右复合 $g$：
$$(h \circ f) \circ g = (k \circ f) \circ g \implies h \circ (f \circ g) = k \circ (f \circ g) \implies h \circ I_B = k \circ I_B \implies h = k$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(3) $\implies$ (1)&lt;/strong&gt;：反证法。若 $f$ 不是满射，取 $b_0 \in B \setminus \operatorname{Im} f$。设 $D = {0, 1}$，构造映射：
$$h(b) = 0 \quad (\forall b \in B), \qquad k(b) = \begin{cases} 0, &amp;amp; b \neq b_0 \ 1, &amp;amp; b = b_0 \end{cases}$$
对任意 $a \in A$，$f(a) \neq b_0$，故 $h(f(a)) = k(f(a)) = 0$，即 $h \circ f = k \circ f$。由右可消性得 $h = k$。但 $h(b_0) = 0 \neq 1 = k(b_0)$，矛盾。故 $f$ 必为满射。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;4.4 双射与可逆性&lt;/h5&gt;
&lt;h6&gt;定理 0.7（双射与可逆性充要条件）&lt;/h6&gt;
&lt;p&gt;映射 $f: A \to B$ 可逆（即同时存在满足 $g \circ f = I_A$ 与 $f \circ g = I_B$ 的映射 $g$）当且仅当 $f$ 是双射。
此时逆映射唯一，记作 $f^{-1}$。
若 $f: A \to B$ 与 $g: B \to C$ 均为双射，则复合映射 $g \circ f$ 亦为双射，且满足反序求逆：
$$(g \circ f)^{-1} = f^{-1} \circ g^{-1}$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$f$ 为双射当且仅当其同时存在左逆 $g_1$ 和右逆 $g_2$。由结合律：
$$g_1 = g_1 \circ I_B = g_1 \circ (f \circ g_2) = (g_1 \circ f) \circ g_2 = I_A \circ g_2 = g_2$$
故左逆与右逆必重合且唯一。&lt;/li&gt;
&lt;li&gt;复合映射求逆直接代入验证：
$$(f^{-1} \circ g^{-1}) \circ (g \circ f) = f^{-1} \circ (g^{-1} \circ g) \circ f = f^{-1} \circ I_B \circ f = f^{-1} \circ f = I_A$$
反向复合同样成立，由逆映射唯一性结论得证。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;5. 选择公理与常见等价命题&lt;/h4&gt;
&lt;h5&gt;5.1 选择公理的三种等价表述&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;选择函数形式&lt;/strong&gt;：设 $\mathcal{X}$ 是一族非空集合，则存在选择函数 $c: \mathcal{X} \to \bigcup_{A \in \mathcal{X}} A$，满足：
$$\forall A \in \mathcal{X},\ c(A) \in A$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;笛卡尔积形式&lt;/strong&gt;：由非空集合构成的任意集合族 ${A_i}&lt;em&gt;{i \in I}$ 的笛卡尔积非空：
$$\prod&lt;/em&gt;{i \in I} A_i \neq \emptyset$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;两两不交形式&lt;/strong&gt;：设 $\mathcal{X}$ 是一族两两不交的非空集合，则存在集合 $C$，使得对每个 $A \in \mathcal{X}$，恰有 $|C \cap A| = 1$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;5.2 直观理解与使用边界&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;有限个非空集合的选择可用一阶逻辑和归纳法证明，不需要选择公理。&lt;/li&gt;
&lt;li&gt;无限集但有确定排序规则（如正整数集选最小元素），也不需要选择公理。&lt;/li&gt;
&lt;li&gt;罗素隐喻：无穷双鞋子（分左右）选一只不需要选择公理（规定选左脚即可）；对没有指定选择规则的无限多双袜子，ZF 一般不能保证同时选出一只；可数多双对应可数的二元集合选择原则，比完整选择公理弱，完整选择公理足以保证。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;5.3 常见等价命题与 Zorn 引理&lt;/h5&gt;
&lt;p&gt;在 ZF 公理系统下，下列命题与选择公理等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;满射必有右逆&lt;/strong&gt;：任意非空集合间的满射均存在右逆映射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;良序定理&lt;/strong&gt;：任意集合上均可定义一个良序关系（每个非空子集必有最小元）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Zorn 引理&lt;/strong&gt;：设 $(P, \le)$ 是非空偏序集。若 $P$ 的每条链（全序子集）在 $P$ 中都有上界，则 $P$ 至少存在一个极大元。
&lt;ul&gt;
&lt;li&gt;代数应用：证明任意非零含幺环必有极大理想、任意向量空间必有 Hamel 基。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;基数三分律&lt;/strong&gt;：任意两集合的基数均可比较大小。&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;5.4 逻辑地位与典型推论&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;独立性（以 ZF 一致为前提）：哥德尔的可构造宇宙给出选择公理与 ZF 的相对一致性；柯恩的结果给出其独立性，ZF 既不能证明也不能否定选择公理。主流数学通常在 ZFC 公理体系下展开。&lt;/li&gt;
&lt;li&gt;典型推论：实数轴上的 Vitali 不可测集、Banach-Tarski 分球悖论。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;6. 商集上的映射与良定性&lt;/h4&gt;
&lt;h5&gt;6.1 良定性要求&lt;/h5&gt;
&lt;p&gt;在商集 $A/\sim$ 上通过代表元定义映射：
$$F: A/\sim \to B, \qquad F([a]) := \Phi(a)$$
由于同一等价类 $[a]$ 可以取不同的代表元（若 $a \sim a&apos;$ 则 $[a] = [a&apos;]$），必须验证：
$$a \sim a&apos; \implies \Phi(a) = \Phi(a&apos;)$$
若该条件不成立，同一输入会计算出不同输出，规则无法构成映射。这一验证称为良定性检验（代表元无关性）。&lt;/p&gt;
&lt;h5&gt;6.2 商集诱导映射定理&lt;/h5&gt;
&lt;h6&gt;定理 0.8（商集诱导映射定理）&lt;/h6&gt;
&lt;p&gt;设 $\sim$ 是集合 $A$ 上的等价关系，$\pi: A \to A/\sim$（$a \mapsto [a]$）为自然投影。设 $f: A \to B$ 是映射。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;存在映射 $\bar{f}: A/\sim \to B$ 使得 $\bar{f} \circ \pi = f$ 当且仅当：
$$\forall x, y \in A,\ x \sim y \implies f(x) = f(y)$$
此时 $\bar{f}$ 唯一，由 $\bar{f}([a]) = f(a)$ 给出。&lt;/li&gt;
&lt;li&gt;在条件 (1) 成立的前提下，$\bar{f}$ 是单射 $\iff (\forall x, y \in A, f(x) = f(y) \implies x \sim y)$。&lt;/li&gt;
&lt;li&gt;$\operatorname{Im} \bar{f} = \operatorname{Im} f$。特别地，若 $f$ 是满射，则 $\bar{f}$ 也是满射。&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;flowchart LR
    A[&quot;集合 A&quot;] -- &quot;f&quot; --&amp;gt; B[&quot;集合 B&quot;]
    A -- &quot;π&quot; --&amp;gt; Q[&quot;商集 A/~&quot;]
    Q -. &quot;f̄&quot; .-&amp;gt; B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $\bar{f}$ 存在且满足 $\bar{f} \circ \pi = f$，则 $\bar{f}([a]) = \bar{f}(\pi(a)) = f(a)$，定义唯一。若 $x \sim y \implies f(x) = f(y)$，则 $[x] = [y] \implies f(x) = f(y)$，规则良定，且满足 $(\bar{f} \circ \pi)(a) = \bar{f}([a]) = f(a)$。&lt;/li&gt;
&lt;li&gt;由单射定义：$\bar{f}([x]) = \bar{f}([y]) \iff f(x) = f(y)$。该式能推出 $[x] = [y]$（即 $x \sim y$）当且仅当 $f(x) = f(y) \implies x \sim y$。&lt;/li&gt;
&lt;li&gt;$\operatorname{Im}\bar{f} = {\bar{f}([a]) \mid a \in A} = {f(a) \mid a \in A} = \operatorname{Im} f$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;6.3 典型正例与反例&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;正例&lt;/strong&gt;：在模 $n$ 剩余类集合 $\mathbb{Z}_n = \mathbb{Z}/n\mathbb{Z}$ 上定义 $F([a]) = [ka]$（$k \in \mathbb{Z}$）。
若 $[a] = [b]$，则 $a \equiv b \pmod n \implies n \mid (a - b) \implies n \mid k(a - b) \implies [ka] = [kb]$。映射良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;反例 1&lt;/strong&gt;：定义 $F: \mathbb{Z}/n\mathbb{Z} \to \mathbb{Z}, F([a]) = a$。
在模 3 下，$[0] = [3]$，但 $F([0]) = 0 \neq 3 = F([3])$，不良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;反例 2&lt;/strong&gt;：在有理数构造中，对集合 $\mathbb{Z} \times (\mathbb{Z} \setminus {0})$ 定义等价关系 $(a, b) \sim (c, d) \iff ad = bc$。
若尝试定义映射 $H([(a, b)]) = a + b$：因 $(1, 2) \sim (2, 4)$，但 $1 + 2 = 3 \neq 6 = 2 + 4$，同一个等价类给出不同结果，不良定。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;7. 常见易混淆点&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;像交集与原像交集&lt;/strong&gt;：原像完全保持交集 $f^{-1}(T_1 \cap T_2) = f^{-1}(T_1) \cap f^{-1}(T_2)$；像只满足单向包含 $f(S_1 \cap S_2) \subseteq f(S_1) \cap f(S_2)$，等号仅在单射时恒成立。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;原像记号与逆映射&lt;/strong&gt;：集合原像 $f^{-1}(T)$ 对任意映射均合法；元素反函数 $f^{-1}(y)$ 仅在双射时存在。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;商集元素与代表元&lt;/strong&gt;：商集 $A/\sim$ 的元素是等价类（子集），而不是代表元；$[a] = [b]$ 对应 $a \sim b$，并不代表 $a = b$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;复合映射求逆顺序&lt;/strong&gt;：可逆映射复合后求逆必须反序：$(g \circ f)^{-1} = f^{-1} \circ g^{-1}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;8. 与后续章节的对应关系&lt;/h4&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;本章内容&lt;/th&gt;
&lt;th&gt;后续章节位置&lt;/th&gt;
&lt;th&gt;对应代数概念&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;笛卡尔积与二元运算&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/&quot;&gt;01-群与子群&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;群公理（二元运算的封闭性与结合律）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;等价关系与划分&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;模 $H$ 同余、陪集划分群、Lagrange 定理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;消去律与可逆性&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;单同态核判据、变换群置换求逆&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;商集良定性与诱导映射&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;商群乘法良定性、第一同构定理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;选择公理与 Zorn 引理&lt;/td&gt;
&lt;td&gt;环论与模论&lt;/td&gt;
&lt;td&gt;极大理想存在性、向量空间基的存在性&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-3&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.3 群与子群&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义、定理、证明与例题。&lt;/p&gt;
&lt;h3&gt;01-群与子群&lt;/h3&gt;
&lt;h4&gt;1. 群的公理与初等性质&lt;/h4&gt;
&lt;h5&gt;1.1 严格表述&lt;/h5&gt;
&lt;p&gt;设 $G$ 是一个非空集合，$\cdot$ 是定义在 $G$ 上的二元运算（即映射 $\cdot: G \times G \to G$）。代数系统 $(G, \cdot)$ 称为一个&lt;strong&gt;群（Group）&lt;/strong&gt;，若满足以下四条公理：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;封闭性（Closure）&lt;/strong&gt;：$\forall a, b \in G$，$a \cdot b \in G$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结合律（Associativity）&lt;/strong&gt;：$\forall a, b, c \in G$，$(a \cdot b) \cdot c = a \cdot (b \cdot c)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单位元存在性（Identity）&lt;/strong&gt;：$\exists e \in G$，使得 $\forall a \in G$，$a \cdot e = e \cdot a = a$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;逆元存在性（Inverse）&lt;/strong&gt;：$\forall a \in G$，$\exists a^{-1} \in G$，使得 $a \cdot a^{-1} = a^{-1} \cdot a = e$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;若群运算还满足&lt;strong&gt;交换律（Commutativity）&lt;/strong&gt;：$\forall a, b \in G$，$a \cdot b = b \cdot a$，则称 $G$ 为&lt;strong&gt;阿贝尔群（Abelian Group，交换群）&lt;/strong&gt;。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;约定：通常省略乘号，将 $a \cdot b$ 简记为 $ab$。加法运算下的群通常显式写为 $(G, +)$，单位元记为 $0$，逆元记为 $-a$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;1.2 数学直觉&lt;/h5&gt;
&lt;p&gt;群抽象了可逆变换的代数特征。结合律保证了多次变换的复合与加括号次序无关；单位元对应恒等变换；逆元对应反向逆变换。&lt;/p&gt;
&lt;h5&gt;1.3 初等性质及其形式化证明&lt;/h5&gt;
&lt;h6&gt;定理 1.1（单位元与逆元的唯一性）&lt;/h6&gt;
&lt;ol&gt;
&lt;li&gt;群 $G$ 中的单位元 $e$ 是唯一的。&lt;/li&gt;
&lt;li&gt;对任意 $a \in G$，$a$ 的逆元 $a^{-1}$ 是唯一的。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;设 $e_1, e_2$ 均为 $G$ 的单位元。由 $e_1$ 是单位元，有 $e_1 e_2 = e_2$；由 $e_2$ 是单位元，有 $e_1 e_2 = e_1$。因此 $e_1 = e_2$。&lt;/li&gt;
&lt;li&gt;设 $b, c$ 均为 $a$ 的逆元，即 $ab = ba = e$ 且 $ac = ca = e$。由结合律：
$$b = b e = b (a c) = (b a) c = e c = c$$
逆元唯一。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h6&gt;定理 1.2（群的消去律）&lt;/h6&gt;
&lt;p&gt;设 $a, b, c \in G$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $ab = ac$，则 $b = c$（左消去律）。&lt;/li&gt;
&lt;li&gt;若 $ba = ca$，则 $b = c$（右消去律）。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
在 $ab = ac$ 两边左乘 $a^{-1}$：$a^{-1}(ab) = a^{-1}(ac) \implies (a^{-1}a)b = (a^{-1}a)c \implies eb = ec \implies b = c$。同理，在 $ba = ca$ 两边右乘 $a^{-1}$ 得到 $b = c$。 $\blacksquare$&lt;/p&gt;
&lt;h6&gt;定理 1.3（求逆运算性质）&lt;/h6&gt;
&lt;p&gt;对任意 $a, b \in G$，$(ab)^{-1} = b^{-1}a^{-1}$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
直接计算 $(b^{-1}a^{-1})$ 与 $(ab)$ 的复合：
$$(ab)(b^{-1}a^{-1}) = a(b b^{-1})a^{-1} = a e a^{-1} = a a^{-1} = e$$
$$(b^{-1}a^{-1})(ab) = b^{-1}(a^{-1}a)b = b^{-1} e b = b^{-1} b = e$$
由逆元的唯一性，必有 $(ab)^{-1} = b^{-1}a^{-1}$。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 阿贝尔群的核心判定&lt;/h4&gt;
&lt;h5&gt;2.1 严格表述与定理&lt;/h5&gt;
&lt;h6&gt;定理 1.4（平方乘积判定准则）&lt;/h6&gt;
&lt;p&gt;设 $G$ 是群。$G$ 是阿贝尔群当且仅当对任意 $a, b \in G$，均有：
$$(ab)^2 = a^2 b^2$$&lt;/p&gt;
&lt;h6&gt;定理 1.5（高阶幂次判定准则）&lt;/h6&gt;
&lt;p&gt;设 $G$ 是群。$G$ 是阿贝尔群当且仅当对任意 $a, b \in G$ 及任意正整数 $t \in \mathbb{Z}^+$，均有：
$$(ab)^t = a^t b^t$$&lt;/p&gt;
&lt;h5&gt;2.2 形式化证明&lt;/h5&gt;
&lt;h6&gt;证明定理 1.4：&lt;/h6&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：若 $G$ 是阿贝尔群，则 $\forall a, b \in G$，$ab = ba$。
$$(ab)^2 = (ab)(ab) = a(ba)b = a(ab)b = (aa)(bb) = a^2 b^2$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：若对任意 $a, b \in G$ 均有 $(ab)^2 = a^2 b^2$。展开两边：
$$abab = aabb$$
两边利用群的左消去律消去 $a$：$bab = abb$。
再利用群的右消去律消去 $b$：$ba = ab$。
由 $a, b$ 的任意性，$G$ 是阿贝尔群。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h6&gt;证明定理 1.5：&lt;/h6&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：若 $G$ 是阿贝尔群，对 $t$ 施加数学归纳法。
当 $t=1$ 时，$(ab)^1 = ab = a^1 b^1$ 显然成立。
假设 $t=k$ 时结论成立，即 $(ab)^k = a^k b^k$。则：
$$(ab)^{k+1} = (ab)^k (ab) = (a^k b^k)(ab) = a^k (b^k a) b$$
在阿贝尔群中，元素满足交换律，故 $b^k a = a b^k$。因此：
$$a^k (a b^k) b = (a^k a)(b^k b) = a^{k+1} b^{k+1}$$
由归纳原理，必要性得证。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：已知对一切正整数 $t$ 均有 $(ab)^t = a^t b^t$。特别取 $t=2$，即得 $(ab)^2 = a^2 b^2$。由定理 1.4 的充分性证明，推得 $ba = ab$，$G$ 必为阿贝尔群。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;2.3 最小例子与反例&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;最小阿贝尔群&lt;/strong&gt;：平凡群 ${e}$（1 阶），二阶循环群 $\mathbb{Z}_2 = {0, 1}$（模 2 加法）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;最小非阿贝尔群&lt;/strong&gt;：3 次对称群 $S_3$（阶数为 $3! = 6$）。取对换 $\sigma = (1\ 2)$ 与轮换 $\tau = (1\ 2\ 3)$，计算可知 $\sigma\tau = (2\ 3) \neq (1\ 3) = \tau\sigma$。同时 $(\sigma\tau)^2 = (2\ 3)^2 = (1)$，而 $\sigma^2 \tau^2 = (1)(1\ 3\ 2) = (1\ 3\ 2) \neq (1)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;3. 元素的阶（Order）&lt;/h4&gt;
&lt;h5&gt;3.1 严格表述&lt;/h5&gt;
&lt;p&gt;设 $G$ 是群，$a \in G$。
若存在正整数 $m$ 使得 $a^m = e$，则称 $a$ 为&lt;strong&gt;有限阶元素&lt;/strong&gt;，满足该条件的&lt;strong&gt;最小正整数&lt;/strong&gt; $m$ 称为元素 $a$ 的&lt;strong&gt;阶（Order）&lt;/strong&gt;，记作 $\operatorname{ord}(a) = m$（或 $|a| = m$）。
若不存在这样的正整数，则称 $a$ 为&lt;strong&gt;无限阶元素&lt;/strong&gt;，记作 $\operatorname{ord}(a) = \infty$。&lt;/p&gt;
&lt;h5&gt;3.2 形式化证明：阶的整除性质&lt;/h5&gt;
&lt;h6&gt;定理 1.6（阶整除引理）&lt;/h6&gt;
&lt;p&gt;设 $a \in G$ 且 $\operatorname{ord}(a) = m &amp;lt; \infty$。对任意整数 $k \in \mathbb{Z}$：
$$a^k = e \iff m \mid k$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：若 $m \mid k$，存在整数 $q$ 使得 $k = qm$。则 $a^k = a^{qm} = (a^m)^q = e^q = e$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：已知 $a^k = e$。由带余除法，存在唯一整数 $q, r$ 使得：
$$k = qm + r, \quad 0 \le r &amp;lt; m$$
计算幂次：
$$a^k = a^{qm + r} = (a^m)^q a^r = e^q a^r = a^r \implies a^r = e$$
若 $r &amp;gt; 0$，则 $r$ 是一个比 $m$ 更小的严格正整数，满足 $a^r = e$。这与 $m$ 是满足 $a^m = e$ 的最小正整数矛盾。
因此只能有 $r = 0$，即 $k = qm$，故 $m \mid k$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;4. 子群（Subgroup）及其判定&lt;/h4&gt;
&lt;h5&gt;4.1 严格表述&lt;/h5&gt;
&lt;p&gt;设 $(G, \cdot)$ 是群，$H$ 是 $G$ 的非空子集。如果 $H$ 关于 $G$ 原有的运算 $\cdot$ 也构成一个群，则称 $H$ 是 $G$ 的&lt;strong&gt;子群（Subgroup）&lt;/strong&gt;，记作 $H \le G$。若 $H \ne G$，称 $H$ 为真子群，记作 $H &amp;lt; G$。&lt;/p&gt;
&lt;h5&gt;4.2 形式化证明：子群的三种判定定理&lt;/h5&gt;
&lt;h6&gt;定理 1.7（两步判定法）&lt;/h6&gt;
&lt;p&gt;设 $H$ 是群 $G$ 的非空子集。$H \le G$ 当且仅当：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;运算封闭性&lt;/strong&gt;：$\forall a, b \in H \implies ab \in H$；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求逆封闭性&lt;/strong&gt;：$\forall a \in H \implies a^{-1} \in H$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h6&gt;定理 1.8（一步判定法）&lt;/h6&gt;
&lt;p&gt;设 $H$ 是群 $G$ 的非空子集。$H \le G$ 当且仅当：
$$\forall a, b \in H \implies ab^{-1} \in H$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：若 $H \le G$，由子群公理，$H$ 对求逆和乘法均封闭，故 $b \in H \implies b^{-1} \in H \implies ab^{-1} \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：已知 $H \ne \emptyset$ 且 $\forall a, b \in H, ab^{-1} \in H$。
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;单位元存在&lt;/strong&gt;：因为 $H \ne \emptyset$，必存在某个元素 $x \in H$。在已知条件中令 $a = x, b = x$，得 $x x^{-1} = e \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;逆元存在&lt;/strong&gt;：已知 $e \in H$。对任意 $y \in H$，在已知条件中令 $a = e, b = y$，得 $e y^{-1} = y^{-1} \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;封闭性&lt;/strong&gt;：对任意 $a, b \in H$，由逆元存在性可知 $b^{-1} \in H$。在已知条件中令第一个元为 $a$，第二个元为 $b^{-1}$，得 $a(b^{-1})^{-1} = ab \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结合律&lt;/strong&gt;：由于 $H \subseteq G$，$G$ 中运算满足结合律，限制在 $H$ 上同样满足结合律。
综上四点，$H \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h6&gt;定理 1.9（有限子集的判定法）&lt;/h6&gt;
&lt;p&gt;设 $H$ 是群 $G$ 的&lt;strong&gt;有限&lt;/strong&gt;非空子集。若 $H$ 对 $G$ 的运算满足&lt;strong&gt;封闭性&lt;/strong&gt;（即 $\forall a, b \in H \implies ab \in H$），则 $H \le G$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
只需证明 $H$ 对求逆封闭。
任取 $a \in H$。考虑元素幂序列：
$$a^1, a^2, a^3, \dots, a^k, \dots$$
由 $H$ 的运算封闭性，序列中的所有元素都属于 $H$。
因为集合 $H$ 是有限集，该序列中不可能所有元素互不相同，必存在不同的正整数 $i, j$（设 $i &amp;gt; j \ge 1$），使得：
$$a^i = a^j$$
在等式两边右乘 $j$ 次 $a^{-1}$，得到：
$$a^{i-j} = e$$
由于 $i &amp;gt; j$，差值 $i - j \ge 1$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $i - j = 1$，则 $a = e \in H$，其逆元 $a^{-1} = e \in H$。&lt;/li&gt;
&lt;li&gt;若 $i - j &amp;gt; 1$，则 $i - j - 1 \ge 1$。等式两边左乘 $a^{-1}$：
$$a^{-1} = a^{i - j - 1}$$
因为 $i - j - 1$ 是正整数，由封闭性，$a^{i - j - 1} \in H$，所以 $a^{-1} \in H$。
结合封闭性与结合律，得证 $H \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!WARNING] 条件反例
定理 1.9 中“有限”条件不可缺少。
反例：全体正整数集合 $\mathbb{Z}^+$ 在整数加法群 $(\mathbb{Z}, +)$ 中加法封闭，但它不是子群（没有单位元 $0$，也没有负逆元）。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h4&gt;5. 子群的运算与构造&lt;/h4&gt;
&lt;h5&gt;5.1 子群的交集&lt;/h5&gt;
&lt;h6&gt;定理 1.10&lt;/h6&gt;
&lt;p&gt;设 ${H_i}&lt;em&gt;{i \in I}$ 是群 $G$ 的一族子群，则它们的交集仍然是 $G$ 的子群：
$$H = \bigcap&lt;/em&gt;{i \in I} H_i \le G$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;对任意 $i \in I$，$e \in H_i$，故 $e \in \bigcap_{i \in I} H_i = H$，$H \ne \emptyset$。&lt;/li&gt;
&lt;li&gt;任取 $a, b \in H$。则对每个 $i \in I$，均有 $a, b \in H_i$。
因为每个 $H_i \le G$，所以 $ab^{-1} \in H_i$。
从而 $ab^{-1} \in \bigcap_{i \in I} H_i = H$。
由一步判定法，$H \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;5.2 子群的并集与真子群覆盖定理&lt;/h5&gt;
&lt;h6&gt;定理 1.11&lt;/h6&gt;
&lt;p&gt;群 $G$ 不能表示为两个真子群的并集。即若 $H_1 &amp;lt; G$ 且 $H_2 &amp;lt; G$，则 $G \ne H_1 \cup H_2$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明（反证法）：&lt;/strong&gt;
假设 $G = H_1 \cup H_2$。
由于 $H_1, H_2$ 均为真子群，必有 $H_1 \not\subseteq H_2$ 且 $H_2 \not\subseteq H_1$（若有包含关系，例如 $H_1 \subseteq H_2$，则 $H_1 \cup H_2 = H_2 = G$，与 $H_2 &amp;lt; G$ 矛盾）。
因此，存在元素 $a \in H_1 \setminus H_2$，以及元素 $b \in H_2 \setminus H_1$。
考虑元素 $c = ab$。由群封闭性，$c \in G$。因此 $c \in H_1 \cup H_2$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $c \in H_1$：则 $b = a^{-1}c$。因为 $a \in H_1 \implies a^{-1} \in H_1$，且 $c \in H_1$，由子群封闭性，$b \in H_1$，与 $b \notin H_1$ 矛盾。&lt;/li&gt;
&lt;li&gt;若 $c \in H_2$：则 $a = c b^{-1}$。因为 $b \in H_2 \implies b^{-1} \in H_2$，且 $c \in H_2$，由子群封闭性，$a \in H_2$，与 $a \notin H_2$ 矛盾。
两种情况均导出矛盾，故假设不成立，$G \ne H_1 \cup H_2$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;5.3 子群乘积集 $H_1 H_2$&lt;/h5&gt;
&lt;h6&gt;定理 1.12&lt;/h6&gt;
&lt;p&gt;设 $H_1, H_2 \le G$，定义集合乘积：
$$H_1 H_2 = {h_1 h_2 \mid h_1 \in H_1, h_2 \in H_2}$$
则 $H_1 H_2 \le G \iff H_1 H_2 = H_2 H_1$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：设 $H_1 H_2 \le G$。
对任意 $x \in H_1 H_2$，由于子群对求逆封闭，$x^{-1} \in H_1 H_2$，设 $x^{-1} = h_1 h_2$（$h_1 \in H_1, h_2 \in H_2$）。
则 $x = (x^{-1})^{-1} = (h_1 h_2)^{-1} = h_2^{-1} h_1^{-1}$。
因为 $h_2^{-1} \in H_2, h_1^{-1} \in H_1$，所以 $x \in H_2 H_1$。由此 $H_1 H_2 \subseteq H_2 H_1$。
反之，任取 $y \in H_2 H_1$，设 $y = h_2 h_1$。则 $y^{-1} = h_1^{-1} h_2^{-1} \in H_1 H_2$。
因为 $H_1 H_2$ 是子群，其逆元 $(y^{-1})^{-1} = y \in H_1 H_2$。由此 $H_2 H_1 \subseteq H_1 H_2$。
故 $H_1 H_2 = H_2 H_1$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：设 $H_1 H_2 = H_2 H_1$。
&lt;ol&gt;
&lt;li&gt;$e = ee \in H_1 H_2 \implies H_1 H_2 \ne \emptyset$。&lt;/li&gt;
&lt;li&gt;任取 $x, y \in H_1 H_2$。设 $x = h_1 h_2, y = k_1 k_2$。
则 $x y^{-1} = (h_1 h_2)(k_2^{-1} k_1^{-1}) = h_1 (h_2 k_2^{-1}) k_1^{-1}$。
记 $h_3 = h_2 k_2^{-1} \in H_2$。则 $h_3 k_1^{-1} \in H_2 H_1$。
利用条件 $H_2 H_1 = H_1 H_2$，存在 $h&apos;_1 \in H_1, h&apos;_2 \in H_2$ 使得 $h_3 k_1^{-1} = h&apos;_1 h&apos;_2$。
代入可得：$x y^{-1} = h_1 (h&apos;_1 h&apos;_2) = (h_1 h&apos;_1) h&apos;_2 \in H_1 H_2$。
由一步判定法，$H_1 H_2 \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;推论&lt;/strong&gt;：若 $G$ 是阿贝尔群，则对任意两个子群 $H_1, H_2 \le G$，乘积集 $H_1 H_2$ 恒为 $G$ 的子群。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;5.4 群的中心（Center）&lt;/h5&gt;
&lt;h6&gt;定义 1.13&lt;/h6&gt;
&lt;p&gt;群 $G$ 的**中心（Center）**定义为所有与全群每一个元素都可交换的元素构成的集合：
$$Z(G) = {z \in G \mid \forall x \in G, zx = xz}$$&lt;/p&gt;
&lt;h6&gt;定理 1.14&lt;/h6&gt;
&lt;p&gt;对任意群 $G$，$Z(G) \le G$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;对一切 $x \in G$，$ex = xe = x$，故 $e \in Z(G)$，$Z(G) \ne \emptyset$。&lt;/li&gt;
&lt;li&gt;任取 $a, b \in Z(G)$。首先验证 $b^{-1} \in Z(G)$：
由于 $bx = xb$，两边左乘 $b^{-1}$、右乘 $b^{-1}$：
$$b^{-1}(bx)b^{-1} = b^{-1}(xb)b^{-1} \implies xb^{-1} = b^{-1}x$$
故 $b^{-1} \in Z(G)$。&lt;/li&gt;
&lt;li&gt;对任意 $x \in G$：
$$(ab^{-1})x = a(b^{-1}x) = a(xb^{-1}) = (ax)b^{-1} = (xa)b^{-1} = x(ab^{-1})$$
故 $ab^{-1} \in Z(G)$。由一步判定法，$Z(G) \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;6. 核心易错点&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;求逆次序&lt;/strong&gt;：$(ab)^{-1} = b^{-1}a^{-1}$，不可直接写为 $a^{-1}b^{-1}$（除非已知群满足交换律）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;消去律的适用范围&lt;/strong&gt;：群中的消去律由逆元保证；一般半群或环不能直接套用。反过来，有消去律不代表有逆元，例如正整数加法半群也满足消去律。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;有限子群判定条件&lt;/strong&gt;：只有在子集非空且有限时，“封闭性”才能单独保证逆元存在；无限子集必须显式证明对求逆封闭。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子群并集通常不是子群&lt;/strong&gt;：两个子群的并集通常不是子群。例如在 $(\mathbb{Z}, +)$ 中，$2\mathbb{Z} \cup 3\mathbb{Z}$ 不是子群，因为 $2+3=5 \notin 2\mathbb{Z} \cup 3\mathbb{Z}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子群乘积的封闭性&lt;/strong&gt;：非交换群中两个子群的集合乘积 $H_1 H_2$ 通常不构成子群，充要条件是 $H_1 H_2 = H_2 H_1$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;7. 前后知识连接&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;（二元运算、映射可逆性、结合律下左右逆元唯一性）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;子群概念是后续构造循环子群（&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/&quot;&gt;02-循环群与生成元.md&lt;/a&gt;）的基础。&lt;/li&gt;
&lt;li&gt;子群用于对全群进行陪集划分（&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群.md&lt;/a&gt;）。&lt;/li&gt;
&lt;li&gt;群的中心 $Z(G)$ 是后续内自同构群同构定理 $G/Z(G) \cong \operatorname{Inn}(G)$（&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley.md&lt;/a&gt;）中的同态核。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与方法套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（子群一步判定法模板、抽屉原理逆元构造模板）。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-4&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.4 循环群与生成元&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义、定理、证明与例题。&lt;/p&gt;
&lt;h3&gt;02-循环群与生成元&lt;/h3&gt;
&lt;h4&gt;1. 循环群的定义与表示&lt;/h4&gt;
&lt;h5&gt;1.1 严格表述&lt;/h5&gt;
&lt;p&gt;设 $G$ 是一个群。如果存在元素 $a \in G$，使得群中的每一个元素都可以表示为 $a$ 的整数次幂，即：
$$G = {a^k \mid k \in \mathbb{Z}} =: \langle a \rangle$$
则称 $G$ 为由元素 $a$ 生成的&lt;strong&gt;循环群（Cyclic Group）&lt;/strong&gt;，元素 $a$ 称为群 $G$ 的一个&lt;strong&gt;生成元（Generator）&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;在加法记号下，循环群的元素表示为整数倍：
$$G = {k a \mid k \in \mathbb{Z}} =: \langle a \rangle$$&lt;/p&gt;
&lt;h5&gt;1.2 数学直觉&lt;/h5&gt;
&lt;p&gt;循环群是由单个元素通过重复运算（乘方或倍数）展开生成的群。其元素分布取决于生成元的阶：若生成元阶为无限，元素序列不发生循环；若生成元阶为有限，元素序列呈周期性循环。&lt;/p&gt;
&lt;h5&gt;1.3 基础性质：交换性&lt;/h5&gt;
&lt;h6&gt;定理 2.1&lt;/h6&gt;
&lt;p&gt;任何循环群都是阿贝尔群（交换群）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $G = \langle a \rangle$。任取 $x, y \in G$，由循环群定义，存在整数 $s, t \in \mathbb{Z}$ 使得 $x = a^s, y = a^t$。
利用指数运算性质：
$$xy = a^s a^t = a^{s+t} = a^{t+s} = a^t a^s = yx$$
因此 $G$ 是交换群。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 循环群分类定理&lt;/h4&gt;
&lt;h5&gt;2.1 严格表述与定理&lt;/h5&gt;
&lt;h6&gt;定理 2.2（循环群分类定理）&lt;/h6&gt;
&lt;p&gt;设 $G = \langle a \rangle$ 是循环群：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $\operatorname{ord}(a) = \infty$（无限循环群），则 $G \cong (\mathbb{Z}, +)$；&lt;/li&gt;
&lt;li&gt;若 $\operatorname{ord}(a) = m$（$m$ 阶有限循环群），则 $G \cong (\mathbb{Z}_m, +)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;2.2 形式化证明&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;证明情形 1（无限循环群）：&lt;/strong&gt;
定义映射 $f: \mathbb{Z} \to G$ 为 $f(k) = a^k$（$\forall k \in \mathbb{Z}$）。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：$f(k_1 + k_2) = a^{k_1 + k_2} = a^{k_1} a^{k_2} = f(k_1) f(k_2)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：由 $G = \langle a \rangle$，任何元素均形如 $a^k = f(k)$，故 $f$ 为满射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射性&lt;/strong&gt;：若 $f(k_1) = f(k_2)$，则 $a^{k_1} = a^{k_2} \implies a^{k_1 - k_2} = e$。
若 $k_1 \ne k_2$，不妨设 $k_1 &amp;gt; k_2$，则 $k_1 - k_2$ 为正整数且使得 $a^{k_1 - k_2} = e$，这与 $\operatorname{ord}(a) = \infty$ 矛盾。
因此必有 $k_1 = k_2$，$f$ 为单射。
综上，$f$ 是同构映射，故 $G \cong (\mathbb{Z}, +)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明情形 2（有限循环群）：&lt;/strong&gt;
定义映射 $\phi: \mathbb{Z}_m \to G$ 为 $\phi([k]) = a^k$（其中 $[k] \in \mathbb{Z}_m$）。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;良定性&lt;/strong&gt;：若 $[k_1] = [k_2]$，则 $k_1 \equiv k_2 \pmod m \implies k_1 - k_2 = qm$。
从而 $a^{k_1} = a^{k_2 + qm} = a^{k_2} (a^m)^q = a^{k_2} e^q = a^{k_2}$。映射良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：$\phi([k_1] + [k_2]) = \phi([k_1 + k_2]) = a^{k_1 + k_2} = a^{k_1} a^{k_2} = \phi([k_1]) \phi([k_2])$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射性&lt;/strong&gt;：若 $\phi([k_1]) = \phi([k_2])$，则 $a^{k_1 - k_2} = e$。由定理 1.6（阶整除引理），$m \mid (k_1 - k_2)$，即 $[k_1] = [k_2]$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：对任意 $x \in G$，由循环群定义存在 $0 \le k &amp;lt; m$ 使得 $x = a^k = \phi([k])$，故为满射。
故 $\phi$ 是群同构，即 $G \cong (\mathbb{Z}_m, +)$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;3. 有限循环群元素阶的计算公式&lt;/h4&gt;
&lt;h5&gt;3.1 严格表述与定理&lt;/h5&gt;
&lt;h6&gt;定理 2.3（元素阶公式）&lt;/h6&gt;
&lt;p&gt;设 $G = \langle a \rangle$ 是 $n$ 阶有限循环群，则对任意整数 $k \in \mathbb{Z}$，元素 $a^k$ 的阶为：
$$\operatorname{ord}(a^k) = \frac{n}{\gcd(n, k)}$$&lt;/p&gt;
&lt;h5&gt;3.2 形式化证明&lt;/h5&gt;
&lt;p&gt;记 $m = \operatorname{ord}(a^k)$，$d = \gcd(n, k)$。
设 $n = d n_1$，$k = d k_1$，其中 $\gcd(n_1, k_1) = 1$。
根据元素阶的定义：
$$(a^k)^m = e \iff a^{km} = e$$
由于 $\operatorname{ord}(a) = n$，由定理 1.6（阶整除引理）：
$$a^{km} = e \iff n \mid km$$
代入 $n = d n_1$ 与 $k = d k_1$：
$$d n_1 \mid d k_1 m \iff n_1 \mid k_1 m$$
因为 $\gcd(n_1, k_1) = 1$，由数论中的欧几里得引理（若互质数整除乘积，则必整除另一因子）：
$$n_1 \mid m$$
因此，使得 $(a^k)^m = e$ 成立的最小正整数 $m$ 必须取为：
$$m = n_1 = \frac{n}{d} = \frac{n}{\gcd(n, k)}$$
即 $\operatorname{ord}(a^k) = \frac{n}{\gcd(n, k)}$。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;4. 生成元的判定与分布定理&lt;/h4&gt;
&lt;h5&gt;4.1 有限循环群生成元定理&lt;/h5&gt;
&lt;h6&gt;定理 2.4&lt;/h6&gt;
&lt;p&gt;设 $G = \langle a \rangle$ 是 $n$ 阶有限循环群。元素 $a^k$ 是 $G$ 的生成元当且仅当：
$$\gcd(k, n) = 1$$
因此，群 $G$ 的生成元总个数等于欧拉函数值 $\phi(n)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
$a^k$ 是 $G$ 的生成元当且仅当由它生成的子群包含 $n$ 个元素，即其阶达到全群的阶：
$$\operatorname{ord}(a^k) = n$$
由定理 2.3：
$$\frac{n}{\gcd(n, k)} = n \iff \gcd(n, k) = 1$$
在区间 $1 \le k \le n$ 内，满足 $\gcd(k, n) = 1$ 的整数个数定义为欧拉函数 $\phi(n)$。 $\blacksquare$&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;推论（素数阶群的生成元）&lt;/strong&gt;：若群阶 $n = p$ 为素数，则群内除了单位元 $e = a^0$ 之外的任意元素 $a^k$（$1 \le k \le p-1$）均满足 $\gcd(k, p) = 1$，因此全部都是生成元，生成元总数为 $\phi(p) = p - 1$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;4.2 无限循环群的生成元&lt;/h5&gt;
&lt;h6&gt;定理 2.5&lt;/h6&gt;
&lt;p&gt;任何无限循环群 $G = \langle a \rangle$ 只有且仅有两个生成元，即 $a$ 与 $a^{-1}$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $x = a^k$ 是 $G$ 的生成元。
因为 $x$ 能生成全群，基准元素 $a \in G$ 必须能被 $x$ 生成，即存在整数 $s \in \mathbb{Z}$ 使得：
$$a = x^s = (a^k)^s = a^{ks}$$
两边左乘 $a^{-1}$ 得 $a^{ks - 1} = e$。
由于 $G$ 是无限循环群，其生成元不存在使 $a^m = e$ 的非零整数指数：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $ks - 1 &amp;gt; 0$，则 $ks - 1$ 为正整数，直接与 $\operatorname{ord}(a) = \infty$ 矛盾；&lt;/li&gt;
&lt;li&gt;若 $ks - 1 &amp;lt; 0$，两边取逆得到 $a^{-(ks-1)} = e$，其中 $-(ks-1) &amp;gt; 0$ 为正整数，同样与 $\operatorname{ord}(a) = \infty$ 矛盾。
因此指数只能严格为 0：
$$ks - 1 = 0 \implies ks = 1$$
因为 $k, s \in \mathbb{Z}$，该整数方程仅有两组整数解：
$$k = 1 \quad \text{或} \quad k = -1$$
因此 $x = a^1 = a$ 或 $x = a^{-1}$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;5. 循环群的子群结构定理&lt;/h4&gt;
&lt;h5&gt;5.1 子群必为循环群&lt;/h5&gt;
&lt;h6&gt;定理 2.6&lt;/h6&gt;
&lt;p&gt;循环群的任何子群都必定是循环群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $G = \langle a \rangle$ 是循环群，$H \le G$。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $H = {e}$，则 $H = \langle e \rangle$ 显然为循环群。&lt;/li&gt;
&lt;li&gt;若 $H \ne {e}$，因为 $H \subseteq G$，存在非零整数 $t$ 使得 $a^t \in H$。
由于 $H$ 是子群，$(a^t)^{-1} = a^{-t} \in H$。因此 $H$ 中必定包含正整数次幂。
根据正整数的良序原则，取集合 ${k \in \mathbb{Z}^+ \mid a^k \in H}$ 中的&lt;strong&gt;最小正整数&lt;/strong&gt;，记为 $m$。
我们证明：$H = \langle a^m \rangle$。
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;包含性 $\langle a^m \rangle \subseteq H$&lt;/strong&gt;：由于 $a^m \in H$ 且 $H$ 是子群，由封闭性知对一切 $q \in \mathbb{Z}$ 均有 $(a^m)^q \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;包含性 $H \subseteq \langle a^m \rangle$&lt;/strong&gt;：任取 $h \in H$，设 $h = a^k$。
由带余除法，存在唯一整数 $q, r$ 使得：
$$k = qm + r, \quad 0 \le r &amp;lt; m$$
变形得：$a^r = a^{k - qm} = a^k (a^m)^{-q}$。
因为 $a^k \in H$ 且 $(a^m)^{-q} \in H$，由子群封闭性，必有 $a^r \in H$。
若 $r &amp;gt; 0$，则 $r$ 是满足 $a^r \in H$ 且 $r &amp;lt; m$ 的正整数，与 $m$ 的最小性产生矛盾。
因此必有 $r = 0$，即 $k = qm$。
从而 $h = a^k = (a^m)^q \in \langle a^m \rangle$。
综上，$H = \langle a^m \rangle$ 必为循环群。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;5.2 有限循环群子群的因数一一对应定理&lt;/h5&gt;
&lt;h6&gt;定理 2.7&lt;/h6&gt;
&lt;p&gt;设 $G = \langle a \rangle$ 是 $n$ 阶有限循环群：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$G$ 的任意子群的阶必定整除 $n$；&lt;/li&gt;
&lt;li&gt;反之，对于 $n$ 的每一个正因数 $d$（$d \mid n$），$G$ &lt;strong&gt;有且仅有一个&lt;/strong&gt;阶为 $d$ 的子群，且该子群显式由元素 $a^{n/d}$ 生成：
$$H_d = \left\langle a^{n/d} \right\rangle$$&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;整除性&lt;/strong&gt;：由后续 Lagrange 定理，有限群的子群阶必整除群阶。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;存在性&lt;/strong&gt;：令 $b = a^{n/d}$。由定理 2.3 阶计算公式：
$$\operatorname{ord}(b) = \frac{n}{\gcd(n, n/d)} = \frac{n}{n/d} = d$$
故由 $b$ 生成的子群 $H_d = \langle a^{n/d} \rangle$ 其阶恰好为 $d$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;唯一性&lt;/strong&gt;：设 $H$ 是 $G$ 中任意一个阶为 $d$ 的子群。
由定理 2.6，$H$ 必为循环群，设 $H = \langle a^k \rangle$。
因为 $|H| = d$，所以 $\operatorname{ord}(a^k) = d$。由阶计算公式：
$$\frac{n}{\gcd(n, k)} = d \implies \gcd(n, k) = \frac{n}{d}$$
因此整数 $k$ 可以写成：
$$k = \frac{n}{d} t, \quad \text{其中 } \gcd(t, d) = 1$$
这说明生成元 $a^k = \left(a^{n/d}\right)^t = b^t$。
因为 $\gcd(t, d) = 1$，由定理 2.4，在 $d$ 阶循环群 $\langle b \rangle$ 中，$b^t$ 也是该群的生成元，即：
$$\langle b^t \rangle = \langle b \rangle$$
因此：
$$H = \langle a^k \rangle = \langle b^t \rangle = \langle b \rangle = \left\langle a^{n/d} \right\rangle = H_d$$
这就证明了 $d$ 阶子群的唯一性。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;推论&lt;/strong&gt;：$n$ 阶有限循环群的子群总数，严格等于整数 $n$ 的正因数个数 $\tau(n)$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h4&gt;6. 循环群的同态传递与自同构群&lt;/h4&gt;
&lt;h5&gt;6.1 同态像的循环性&lt;/h5&gt;
&lt;h6&gt;定理 2.8&lt;/h6&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态。若 $G = \langle a \rangle$ 是循环群，则其同态像 $\operatorname{Im}f$ 也是循环群，并且由像点 $f(a)$ 生成：
$$\operatorname{Im}f = \langle f(a) \rangle$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
任取 $y \in \operatorname{Im}f$，存在 $x \in G$ 使得 $f(x) = y$。
由 $G = \langle a \rangle$，存在整数 $k$ 使得 $x = a^k$。
利用同态保持乘积的性质：
$$y = f(a^k) = (f(a))^k \in \langle f(a) \rangle$$
反之，对任意 $(f(a))^k \in \langle f(a) \rangle$，由 $(f(a))^k = f(a^k)$ 知其属于 $\operatorname{Im}f$。
故 $\operatorname{Im}f = \langle f(a) \rangle$。 $\blacksquare$&lt;/p&gt;
&lt;h5&gt;6.2 有限循环群满同态的存在条件&lt;/h5&gt;
&lt;h6&gt;定理 2.9&lt;/h6&gt;
&lt;p&gt;设 $G$ 是 $m$ 阶有限循环群，$G&apos;$ 是 $n$ 阶有限循环群。
存在满同态 $f: G \to G&apos;$ 当且仅当：
$$n \mid m$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：若存在满同态 $f: G \to G&apos;$，根据后续同态基本定理，$G/\operatorname{Ker}f \cong G&apos;$。
由 Lagrange 定理，群阶满足 $|G&apos;| = |G| / |\operatorname{Ker}f| \implies n = m / |\operatorname{Ker}f|$，因此 $n \mid m$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：若 $n \mid m$，设 $G = \langle a \rangle, G&apos; = \langle b \rangle$。
定义映射 $f(a^k) = b^k$。
验证良定性：若 $a^{k_1} = a^{k_2}$，则 $m \mid (k_1 - k_2)$。因为 $n \mid m$，必有 $n \mid (k_1 - k_2)$，从而 $b^{k_1} = b^{k_2}$。
直接验证可得 $f(a^{k_1} a^{k_2}) = f(a^{k_1 + k_2}) = b^{k_1 + k_2} = b^{k_1} b^{k_2} = f(a^{k_1}) f(a^{k_2})$，且像包含生成元 $b$，故为满同态。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;6.3 循环群自同构群的完整形式化证明&lt;/h5&gt;
&lt;h6&gt;定理 2.10&lt;/h6&gt;
&lt;ol&gt;
&lt;li&gt;无限循环群的自同构群：$\operatorname{Aut}(\mathbb{Z}) \cong \mathbb{Z}_2$。&lt;/li&gt;
&lt;li&gt;有限循环群的自同构群：$\operatorname{Aut}(\mathbb{Z}_n) \cong \mathbb{Z}_n^\times$（模 $n$ 简化剩余系乘法群），阶数为 $\phi(n)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;严格形式化证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;无限循环群情形&lt;/strong&gt;：
设 $f \in \operatorname{Aut}(\mathbb{Z})$。因为 $f$ 是同构，$f$ 必须将生成元映射为生成元。
由定理 2.5，$\mathbb{Z}$ 的生成元只有 $1$ 和 $-1$。
&lt;ul&gt;
&lt;li&gt;若 $f(1) = 1$，由加群同态性质，对任意 $n \in \mathbb{Z}$，$f(n) = f(n \cdot 1) = n f(1) = n$，即 $f = \operatorname{id}_{\mathbb{Z}}$（恒等映射）；&lt;/li&gt;
&lt;li&gt;若 $f(1) = -1$，同理 $f(n) = -n$，即 $f = -\operatorname{id}&lt;em&gt;{\mathbb{Z}}$。
直接验证可知这两个映射均为自同构。复合运算满足 $(-\operatorname{id}) \circ (-\operatorname{id}) = \operatorname{id}$，因此 $\operatorname{Aut}(\mathbb{Z}) = {\operatorname{id}&lt;/em&gt;{\mathbb{Z}}, -\operatorname{id}_{\mathbb{Z}}} \cong \mathbb{Z}_2$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;有限循环群情形&lt;/strong&gt;：
考察群 $(\mathbb{Z}_n, +)$。定义映射：
$$\Psi: \operatorname{Aut}(\mathbb{Z}_n) \to \mathbb{Z}_n^\times, \quad \Psi(f) = f([1])$$
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;值域良定&lt;/strong&gt;：因 $f$ 为自同构，必定将生成元映射为生成元。$[1]$ 是 $\mathbb{Z}_n$ 的生成元，故 $f([1])$ 也是生成元。由定理 2.4，若 $f([1]) = [k]$，则必有 $\gcd(k, n) = 1$，即 $f([1]) \in \mathbb{Z}_n^\times$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;群同态性&lt;/strong&gt;：任取 $f, g \in \operatorname{Aut}(\mathbb{Z}_n)$。设 $g([1]) = [b]$。
利用加法群同态性质：
$$\Psi(f \circ g) = (f \circ g)([1]) = f(g([1])) = f([b]) = f(b[1]) = b f([1])$$
在乘法群 $\mathbb{Z}_n^\times$ 中，其乘积为 $[b] f([1]) = \Psi(g) \Psi(f) = \Psi(f) \Psi(g)$（因为 $\mathbb{Z}_n^\times$ 是交换群）。故 $\Psi$ 是同态映射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射性&lt;/strong&gt;：设 $\Psi(f) = \Psi(g)$，即 $f([1]) = g([1])$。对任意 $[x] \in \mathbb{Z}_n$：
$$f([x]) = f(x[1]) = x f([1]) = x g([1]) = g(x[1]) = g([x])$$
故映射 $f = g$。因此 $\Psi$ 是单射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：任取 $[k] \in \mathbb{Z}_n^\times$，即 $\gcd(k, n) = 1$。
定义映射 $f_k: \mathbb{Z}_n \to \mathbb{Z}_n$ 为 $f_k([x]) = [kx]$。
容易验证 $f_k$ 良定且满足加法同态；由 $\gcd(k, n) = 1$，同态核为 ${[x] \mid [kx] = [0]} = {[0]}$，故 $f_k$ 是单同态，有限集上的单同态必为双射，故 $f_k \in \operatorname{Aut}(\mathbb{Z}_n)$。
且 $\Psi(f_k) = f_k([1]) = [k]$。故 $\Psi$ 是满射。
综上，$\Psi$ 是群同构，即 $\operatorname{Aut}(\mathbb{Z}_n) \cong \mathbb{Z}_n^\times$，其阶数为 $|\mathbb{Z}_n^\times| = \phi(n)$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;7. 最小例子与反面典型&lt;/h4&gt;
&lt;h5&gt;最小例子&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;模 12 加群 $\mathbb{Z}_{12}$ 的因数对应&lt;/strong&gt;：
$12$ 的因数集合为 ${1, 2, 3, 4, 6, 12}$。子群恰好有 6 个：
&lt;ul&gt;
&lt;li&gt;$1$ 阶：$\langle [0] \rangle = {[0]}$；&lt;/li&gt;
&lt;li&gt;$2$ 阶：$\langle [6] \rangle = {[0], [6]}$；&lt;/li&gt;
&lt;li&gt;$3$ 阶：$\langle [4] \rangle = {[0], [4], [8]}$；&lt;/li&gt;
&lt;li&gt;$4$ 阶：$\langle [3] \rangle = {[0], [3], [6], [9]}$；&lt;/li&gt;
&lt;li&gt;$6$ 阶：$\langle [2] \rangle = {[0], [2], [4], [6], [8], [10]}$；&lt;/li&gt;
&lt;li&gt;$12$ 阶：$\langle [1] \rangle = \mathbb{Z}_{12}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;反面典型：不是循环群的交换群&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;克莱因四元群（Klein 4-group, $V_4$ 或 $K_4$）&lt;/strong&gt;：
$V_4 = {e, a, b, c}$，运算规律为 $a^2 = b^2 = c^2 = e$，$ab = c$。
$V_4$ 是阿贝尔群，阶为 4，但群内非单位元的最大阶仅为 2，不存在 4 阶元，因此不是循环群。这证明了&lt;strong&gt;阿贝尔群不一定是循环群&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;8. 核心易错点&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;生成元判定条件&lt;/strong&gt;：在有限循环群中，元素成为生成元的充要条件是指数与模数互质。在偶数加群 $2\mathbb{Z}$ 中只有 $2$ 和 $-2$ 能生成全群；在 $\mathbb{Z}_m$ 中只有与 $m$ 互质的数才能当生成元。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;素数阶群元素的阶&lt;/strong&gt;：素数阶群中非单位元的阶直接等于素数 $p$，而不是“与 $p$ 互质”。正因为阶达到了全阶，才成为生成元。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同构映射单位元对齐&lt;/strong&gt;：复数乘法群 $U_4 = {1, i, -1, -i}$ 同构于 $(\mathbb{Z}_4, +)$ 时，乘法单位元 $1$ 对应加法零元 $[0]$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;生成元个数计算&lt;/strong&gt;：$\phi(n)$ 计算公式为 $n \prod_{p \mid n} (1 - 1/p)$，例如 $\phi(20) = 20 \times (1 - 1/2) \times (1 - 1/5) = 8$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;9. 前后知识连接&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：群公理、阿贝尔群判定、元素阶引理（&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/&quot;&gt;01-群与子群.md&lt;/a&gt;）、初等数论（带余除法、欧几里得引理、欧拉函数）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;循环群分类定理给出了最标准的群同构原型，为商群与自然同态（&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态.md&lt;/a&gt;）提供基础模型。&lt;/li&gt;
&lt;li&gt;素数阶必循环的推论在 Lagrange 定理推论（&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群.md&lt;/a&gt;）中由因数整除性直接导出。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与证明套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（易错点 5、易错点 6；模板 4 带余除法最小正整数法证明循环性）。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-5&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.5 陪集-Lagrange-正规子群&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义、定理、证明与例题。&lt;/p&gt;
&lt;h3&gt;03-陪集-Lagrange-正规子群&lt;/h3&gt;
&lt;h4&gt;1. 陪集的严格定义与性质&lt;/h4&gt;
&lt;h5&gt;1.1 严格表述&lt;/h5&gt;
&lt;p&gt;设 $H$ 是群 $G$ 的子群。对于任意 $a \in G$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;左陪集（Left Coset）&lt;/strong&gt;：集合 $aH := {ah \mid h \in H}$ 称为子群 $H$ 在 $G$ 中关于代表元 $a$ 的左陪集。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;右陪集（Right Coset）&lt;/strong&gt;：集合 $Ha := {ha \mid h \in H}$ 称为子群 $H$ 在 $G$ 中关于代表元 $a$ 的右陪集。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;元素 $a$ 称为该陪集的&lt;strong&gt;代表元（Representative）&lt;/strong&gt;。&lt;/p&gt;
&lt;h5&gt;1.2 数学直觉&lt;/h5&gt;
&lt;p&gt;陪集是用子群 $H$ 作为基准结构对全群 $G$ 进行的平移划分。陪集本身通常不包含单位元，因而不是子群；当且仅当代表元属于 $H$ 时，陪集才等于 $H$ 本身。&lt;/p&gt;
&lt;h5&gt;1.3 陪集的核心性质及其证明&lt;/h5&gt;
&lt;h6&gt;定理 3.1（代表元包含性与平凡陪集）&lt;/h6&gt;
&lt;ol&gt;
&lt;li&gt;$\forall a \in G$，$a \in aH$ 且 $a \in Ha$；&lt;/li&gt;
&lt;li&gt;$eH = H = He$；&lt;/li&gt;
&lt;li&gt;$a \in H \iff aH = H$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;因 $H \le G$，单位元 $e \in H$。故 $a = ae \in aH$，$a = ea \in Ha$。&lt;/li&gt;
&lt;li&gt;$eH = {eh \mid h \in H} = {h \mid h \in H} = H$。&lt;/li&gt;
&lt;li&gt;若 $a \in H$，对任意 $h \in H$，由封闭性 $ah \in H \implies aH \subseteq H$；又对任意 $h \in H$，$h = a(a^{-1}h) \in aH \implies H \subseteq aH$，故 $aH = H$。反之，若 $aH = H$，由 $a \in aH$ 得 $a \in H$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h6&gt;定理 3.2（陪集相等的充要判定准则）&lt;/h6&gt;
&lt;p&gt;设 $H \le G$，$a, b \in G$。下列命题等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$aH = bH$；&lt;/li&gt;
&lt;li&gt;$aH \cap bH \ne \emptyset$；&lt;/li&gt;
&lt;li&gt;$b \in aH$；&lt;/li&gt;
&lt;li&gt;$a^{-1}b \in H$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;$1 \implies 2$&lt;/strong&gt;：若 $aH = bH$，由 $b = be \in bH = aH$，交集非空。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$2 \implies 3$&lt;/strong&gt;：设 $x \in aH \cap bH$。存在 $h_1, h_2 \in H$ 使得 $x = ah_1 = bh_2$。
两边右乘 $h_2^{-1}$，得 $b = a(h_1 h_2^{-1})$。因为 $H \le G$，故 $h_1 h_2^{-1} \in H$，所以 $b \in aH$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$3 \implies 4$&lt;/strong&gt;：若 $b \in aH$，存在 $h \in H$ 使得 $b = ah$。两边左乘 $a^{-1}$，得 $a^{-1}b = h \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$4 \implies 1$&lt;/strong&gt;：若 $a^{-1}b \in H$，设 $h_0 = a^{-1}b \in H$，则 $b = ah_0$。
对任意 $bh \in bH$，有 $bh = (ah_0)h = a(h_0 h) \in aH \implies bH \subseteq aH$。
同理，由 $a^{-1}b \in H \implies (a^{-1}b)^{-1} = b^{-1}a \in H$，推得 $aH \subseteq bH$。
因此 $aH = bH$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!NOTE] 代数直觉
$a^{-1}b \in H$ 表示 $a$ 与 $b$ 的代数差异落在了子群 $H$ 内部。在加法群中，该条件对应于差值 $b - a \in H$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h6&gt;定理 3.3（模 $H$ 同余与等价划分）&lt;/h6&gt;
&lt;p&gt;定义群 $G$ 上的二元关系 $\equiv_L$ 为：
$$a \equiv_L b \pmod H \iff a^{-1}b \in H$$
则 $\equiv_L$ 是群 $G$ 上的一个&lt;strong&gt;等价关系&lt;/strong&gt;。其等价类集合正是子群 $H$ 在 $G$ 中的全体左陪集：
$$[a] = aH$$
因此，所有互不相交的左陪集构成群 $G$ 的一个严格无缝划分：
$$G = \bigcup_{i \in I} a_i H, \quad \text{且 } a_i H \cap a_j H = \emptyset\ (i \ne j)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;自反性&lt;/strong&gt;：$\forall a \in G$，$a^{-1}a = e \in H \implies a \equiv_L a$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;对称性&lt;/strong&gt;：若 $a \equiv_L b$，则 $a^{-1}b \in H$。由子群对求逆封闭，$(a^{-1}b)^{-1} = b^{-1}a \in H \implies b \equiv_L a$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;传递性&lt;/strong&gt;：若 $a \equiv_L b$ 且 $b \equiv_L c$，则 $a^{-1}b \in H$ 且 $b^{-1}c \in H$。
由子群对乘法封闭：$(a^{-1}b)(b^{-1}c) = a^{-1}(bb^{-1})c = a^{-1}c \in H \implies a \equiv_L c$。
由集合论基本定理，等价关系唯一确定集合划分，等价类 $[a] = {x \in G \mid a^{-1}x \in H} = {ah \mid h \in H} = aH$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 陪集的等势性与拉格朗日定理（Lagrange）&lt;/h4&gt;
&lt;h5&gt;2.1 陪集大小的等势性&lt;/h5&gt;
&lt;h6&gt;定理 3.4&lt;/h6&gt;
&lt;p&gt;设 $H \le G$。对任意 $a \in G$，左陪集 $aH$ 与子群 $H$ 等势，即：
$$|aH| = |H|$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
构造映射 $f: H \to aH$，定义为 $f(h) = ah$（$\forall h \in H$）。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;单射性&lt;/strong&gt;：设 $h_1, h_2 \in H$。若 $f(h_1) = f(h_2)$，即 $ah_1 = ah_2$。
根据群的左消去律，两边左乘 $a^{-1}$ 得出 $h_1 = h_2$。故 $f$ 是单射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：任取 $y \in aH$，由左陪集定义，存在 $h \in H$ 使得 $y = ah = f(h)$。故 $f$ 是满射。
因此 $f$ 是双射，集合 $aH$ 与 $H$ 具有相同的基数。对于有限群，必然有 $|aH| = |H|$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;2.2 拉格朗日定理（Lagrange&apos;s Theorem）&lt;/h5&gt;
&lt;h6&gt;定理 3.5（Lagrange 定理）&lt;/h6&gt;
&lt;p&gt;设 $G$ 是有限群，$H$ 是 $G$ 的任意子群。则子群的阶 $|H|$ 必定整除大群的阶 $|G|$，且有：
$$|G| = [G : H] \cdot |H|$$
其中 $[G : H]$ 称为子群 $H$ 在群 $G$ 中的&lt;strong&gt;指数（Index）&lt;/strong&gt;，即群 $G$ 中互不相交的左陪集总数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
由定理 3.3，群 $G$ 可以无重叠、无遗漏地划分成有限个互不相同的左陪集：
$$G = a_1 H \cup a_2 H \cup \cdots \cup a_k H$$
其中 $k = [G : H]$，且对任意 $i \ne j$ 有 $a_i H \cap a_j H = \emptyset$。
对划分两边的元素个数求和：
$$|G| = \sum_{i=1}^k |a_i H|$$
由定理 3.4，每一个陪集的大小均严格等于 $|H|$：
$$|G| = \sum_{i=1}^k |H| = k \cdot |H| = [G : H] \cdot |H|$$
两边除以 $|H|$，得出 $[G : H] = \frac{|G|}{|H|}$ 为正整数，故 $|H| \mid |G|$。 $\blacksquare$&lt;/p&gt;
&lt;h5&gt;2.3 核心推论&lt;/h5&gt;
&lt;h6&gt;推论 3.6（元素的阶整除群阶）&lt;/h6&gt;
&lt;p&gt;设 $G$ 是有限群。对任意元素 $a \in G$：
$$\operatorname{ord}(a) \mid |G|$$
从而：
$$a^{|G|} = e$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
考察由元素 $a$ 生成的循环子群 $H = \langle a \rangle$。
由定义，$|H| = \operatorname{ord}(a)$。
根据 Lagrange 定理，$|H| \mid |G|$，即 $\operatorname{ord}(a) \mid |G|$。
设 $|G| = q \cdot \operatorname{ord}(a)$，则 $a^{|G|} = (a^{\operatorname{ord}(a)})^q = e^q = e$。 $\blacksquare$&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;数论应用&lt;/strong&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;欧拉定理&lt;/strong&gt;：在模 $m$ 简化剩余系乘法群 $(\mathbb{Z}_m^\times, \times)$ 中，群阶为 $\phi(m)$。对任意与 $m$ 互质的整数 $a$，由该推论立得 $a^{\phi(m)} \equiv 1 \pmod m$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;费马小定理&lt;/strong&gt;：当 $m = p$ 为素数时，$\phi(p) = p - 1$，立得 $a^{p-1} \equiv 1 \pmod p$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;h6&gt;推论 3.7（素数阶群必为循环群）&lt;/h6&gt;
&lt;p&gt;若有限群 $G$ 的阶 $|G| = p$ 是一个素数，则 $G$ 必为循环群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
任取非单位元 $a \in G$（$a \ne e$）。
考察其阶 $\operatorname{ord}(a)$。由推论 3.6，$\operatorname{ord}(a) \mid p$。
因为 $p$ 是素数，其正因数仅有 $1$ 和 $p$。
又因 $a \ne e$，$\operatorname{ord}(a) &amp;gt; 1$，所以只能是 $\operatorname{ord}(a) = p$。
由此，由 $a$ 生成的循环子群包含 $p$ 个元素，即 $\langle a \rangle = G$。
群 $G$ 由单元素生成，故必为循环群。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;3. 拉格朗日定理逆命题的反思与反例&lt;/h4&gt;
&lt;h5&gt;3.1 逆命题的不成立性&lt;/h5&gt;
&lt;p&gt;Lagrange 定理给出了子群阶数的&lt;strong&gt;必要条件&lt;/strong&gt;（必须是因数），但并不构成&lt;strong&gt;充分条件&lt;/strong&gt;：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;若 $d \mid |G|$，群 $G$ 中&lt;strong&gt;不一定&lt;/strong&gt;存在阶为 $d$ 的子群。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h5&gt;3.2 经典反例：交代群 $A_4$ 没有 6 阶子群&lt;/h5&gt;
&lt;h6&gt;定理 3.8&lt;/h6&gt;
&lt;p&gt;4 次交代群 $A_4$ 的阶数为 $|A_4| = \frac{4!}{2} = 12$。虽然 $6 \mid 12$，但 $A_4$ 内部不存在任何 6 阶子群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;形式化证明（反证法）：&lt;/strong&gt;
假设 $A_4$ 存在一个 6 阶子群 $H$（$|H| = 6$）。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;子群的指数与正规性&lt;/strong&gt;：
$$[A_4 : H] = \frac{|A_4|}{|H|} = \frac{12}{6} = 2$$
由后续定理 3.10（指数为 2 的子群必正规），必有 $H \triangleleft A_4$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;商群平方性质&lt;/strong&gt;：
既然 $H$ 正规，商群 $A_4 / H$ 存在且阶为 2：
$$|A_4 / H| = [A_4 : H] = 2$$
二阶群中的任何元素其平方必为单位元（商群的单位元即陪集 $H$）。
因此，对全群中任意元素 $g \in A_4$，在商群中均有：
$$(gH)^2 = H \implies g^2 H = H \implies g^2 \in H$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;引入 3-轮换导出矛盾&lt;/strong&gt;：
任取 $A_4$ 中的任意一个 3-轮换 $\tau = (a\ b\ c)$。
由上述推导，必有 $\tau^2 \in H$。
根据 3-轮换的运算性质，$\tau^3 = (1) \implies \tau^2 = \tau^{-1}$。
因此 $\tau^{-1} \in H$。因为 $H$ 是子群，对求逆封闭，所以：
$$\tau = (\tau^{-1})^{-1} \in H$$
这表明：$A_4$ 中的所有 3-轮换都必须属于子群 $H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;元素计数矛盾&lt;/strong&gt;：
在 $A_4$ 中，3-轮换一共有 $\binom{4}{3} \times 2 = 8$ 个。
加上单位元 $(1)$，$H$ 中至少必须包含 $8 + 1 = 9$ 个互不相同的元素：
$$|H| \ge 9$$
这与假设 $|H| = 6$ 矛盾。
因此假设不成立，$A_4$ 绝无 6 阶子群。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;4. 正规子群（Normal Subgroup）&lt;/h4&gt;
&lt;h5&gt;4.1 严格定义&lt;/h5&gt;
&lt;p&gt;设 $N$ 是群 $G$ 的子群。如果对任意 $g \in G$，都有：
$$g N g^{-1} = N$$
（或者等价地：$\forall g \in G, \forall n \in N \implies g n g^{-1} \in N$），
则称 $N$ 是群 $G$ 的&lt;strong&gt;正规子群（Normal Subgroup，或不变子群）&lt;/strong&gt;，记作：
$$N \triangleleft G$$&lt;/p&gt;
&lt;h5&gt;4.2 等价判据定理&lt;/h5&gt;
&lt;h6&gt;定理 3.9&lt;/h6&gt;
&lt;p&gt;设 $N \le G$。下列条件等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$N \triangleleft G$；&lt;/li&gt;
&lt;li&gt;$\forall g \in G$，$g N g^{-1} \subseteq N$；&lt;/li&gt;
&lt;li&gt;$\forall g \in G$，$gN = Ng$（左陪集等于右陪集）；&lt;/li&gt;
&lt;li&gt;$\forall g \in G$，$gN g^{-1} = N$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$1 \iff 2$：若 $\forall g \in G, gNg^{-1} \subseteq N$。任取 $g \in G$，以 $g^{-1}$ 代替 $g$，有 $g^{-1}N(g^{-1})^{-1} \subseteq N \implies g^{-1}Ng \subseteq N$。
两边左乘 $g$、右乘 $g^{-1}$，得 $N \subseteq gNg^{-1}$。结合两式即得 $gNg^{-1} = N$。&lt;/li&gt;
&lt;li&gt;$1 \iff 3$：在 $gNg^{-1} = N$ 两边右乘 $g$，由结合律直接化为 $gN = Ng$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;4.3 指数为 2 的正规性定理&lt;/h5&gt;
&lt;h6&gt;定理 3.10&lt;/h6&gt;
&lt;p&gt;若子群 $H \le G$ 满足指数 $[G : H] = 2$，则 $H$ 必为 $G$ 的正规子群（$H \triangleleft G$）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
验证左陪集是否等于右陪集：
任取 $g \in G$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $g \in H$：由子群封闭性，$gH = H = Hg$。&lt;/li&gt;
&lt;li&gt;若 $g \notin H$：因为指数 $[G : H] = 2$，全群只能划分成两个互不相交的左陪集，其中一个是平凡陪集 $H$。因此另一个左陪集必为补集：
$$gH = G \setminus H$$
同理，全群也只能划分成两个互不相交的右陪集，故右陪集也必为补集：
$$Hg = G \setminus H$$
两者完全相同：
$$gH = Hg$$
综上，对一切 $g \in G$ 均有 $gH = Hg$，故 $H \triangleleft G$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;5. 群的作用与轨道-稳定子定理&lt;/h4&gt;
&lt;h5&gt;5.1 严格表述&lt;/h5&gt;
&lt;p&gt;设 $G$ 是群，$X$ 是非空集合。群 $G$ 在集合 $X$ 上的一个**作用（Group Action）**是指一个映射 $\cdot: G \times X \to X$，满足：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$\forall x \in X$，$e \cdot x = x$；&lt;/li&gt;
&lt;li&gt;$\forall g_1, g_2 \in G, \forall x \in X$，$(g_1 g_2) \cdot x = g_1 \cdot (g_2 \cdot x)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;在此作用下，定义两个核心对象：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;轨道（Orbit）&lt;/strong&gt;：点 $x$ 在群操作下能达到的全体目标点集合：
$$\operatorname{Orb}(x) = {g \cdot x \mid g \in G} \subseteq X$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;稳定子（Stabilizer）&lt;/strong&gt;：所有保持点 $x$ 保持不动的群元素集合：
$$\operatorname{Stab}(x) = {g \in G \mid g \cdot x = x} \subseteq G$$&lt;/li&gt;
&lt;/ul&gt;
&lt;h6&gt;引理 3.11&lt;/h6&gt;
&lt;p&gt;对任意 $x \in X$，$\operatorname{Stab}(x)$ 是群 $G$ 的子群（$\operatorname{Stab}(x) \le G$）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$e \cdot x = x \implies e \in \operatorname{Stab}(x)$，非空。&lt;/li&gt;
&lt;li&gt;任取 $a, b \in \operatorname{Stab}(x)$。则 $a \cdot x = x, b \cdot x = x$。
在 $b \cdot x = x$ 两边作用 $b^{-1}$，得 $b^{-1} \cdot x = x$。
则 $(ab^{-1}) \cdot x = a \cdot (b^{-1} \cdot x) = a \cdot x = x$。
故 $ab^{-1} \in \operatorname{Stab}(x)$。由一步判定法，$\operatorname{Stab}(x) \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;5.2 轨道-稳定子定理（Orbit-Stabilizer Theorem）&lt;/h5&gt;
&lt;h6&gt;定理 3.12&lt;/h6&gt;
&lt;p&gt;设有限群 $G$ 作用在集合 $X$ 上。对于任意 $x \in X$：
$$|G| = |\operatorname{Orb}(x)| \times |\operatorname{Stab}(x)|$$
即：轨道的大小等于稳定子群在 $G$ 中的指数：
$$|\operatorname{Orb}(x)| = [G : \operatorname{Stab}(x)]$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
记 $H = \operatorname{Stab}(x)$。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;特别说明&lt;/strong&gt;：记号 $G/H = {gH \mid g \in G}$ 在此处&lt;strong&gt;仅表示子群 $H$ 在 $G$ 中的左陪集集合&lt;/strong&gt;。因为 $H$ 不一定是正规子群，所以此处 $G/H$ &lt;strong&gt;不是商群&lt;/strong&gt;，只作为一个普通的商集合。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;构造从左陪集集合 $G/H$ 到轨道 $\operatorname{Orb}(x)$ 的映射：
$$\Psi: G/H \to \operatorname{Orb}(x), \quad \Psi(gH) = g \cdot x$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;良定性与单射性&lt;/strong&gt;：
设 $g_1, g_2 \in G$。根据定理 3.2：
$$g_1 H = g_2 H \iff g_1^{-1} g_2 \in H = \operatorname{Stab}(x)$$
$$\iff (g_1^{-1} g_2) \cdot x = x \iff g_2 \cdot x = g_1 \cdot x \iff \Psi(g_1 H) = \Psi(g_2 H)$$
正向推导证明了映射 $\Psi$ 的&lt;strong&gt;良定性&lt;/strong&gt;（取值与代表元选取无关）；
逆向推导证明了 $\Psi$ 的&lt;strong&gt;单射性&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：
任取轨道中的点 $y \in \operatorname{Orb}(x)$，由轨道定义，存在 $g \in G$ 使得 $g \cdot x = y$。
从而 $\Psi(gH) = g \cdot x = y$。故 $\Psi$ 是满射。
综上，$\Psi$ 是双射。因此：
$$|\operatorname{Orb}(x)| = |G/H| = [G : \operatorname{Stab}(x)]$$
再由 Lagrange 定理 $|G| = [G : H] \cdot |H|$，代入即得：
$$|G| = |\operatorname{Orb}(x)| \times |\operatorname{Stab}(x)| \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;6. 核心易错点&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;陪集判定的左逆次序&lt;/strong&gt;：左陪集相等是 $a^{-1}b \in H$，而非 $ab^{-1} \in H$（后者对应右陪集相等 $Ha = Hb$）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;陪集与子群的区别&lt;/strong&gt;：陪集 $aH$ 通常不含单位元，因而通常不是子群；当且仅当 $a \in H$ 时，$aH = H$ 才是子群。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;正规子群判定的左右颠倒&lt;/strong&gt;：$gN = Ng$ 并不要求群元素满足逐点交换 $gn = ng$；它表示的是集合相等，即对任意 $n \in N$，存在 $n&apos; \in N$ 使得 $gn = n&apos;g$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;拉格朗日逆命题误区&lt;/strong&gt;：不能认为只要 $d$ 整除群阶就一定存在 $d$ 阶子群，例如 $A_4$ 没有 6 阶子群。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;7. 前后知识连接&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：集合等价关系与划分（&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;）、子群一步判定、阿贝尔群交换性（&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/&quot;&gt;01-群与子群.md&lt;/a&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;正规子群是构造商群（&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态.md&lt;/a&gt;）的先决条件。&lt;/li&gt;
&lt;li&gt;$a^{-1}b \in N$ 是证明商群乘法良定性与第一同构定理双射性（&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理.md&lt;/a&gt;）的核心工具。&lt;/li&gt;
&lt;li&gt;轨道-稳定子定理是后续证明 Cayley 定理与内自同构群（&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley.md&lt;/a&gt;）的理论基石。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与证明套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（易错点 8 Lagrange 逆命题反例、模板 5 指数为 2 子群必正规证明法）。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-6&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.6 商群与同态&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义、定理、证明与例题。&lt;/p&gt;
&lt;h3&gt;04-商群与同态&lt;/h3&gt;
&lt;h4&gt;1. 商群的构造与良定性&lt;/h4&gt;
&lt;h5&gt;1.1 严格表述&lt;/h5&gt;
&lt;p&gt;设 $N$ 是群 $G$ 的&lt;strong&gt;正规子群&lt;/strong&gt;（$N \triangleleft G$）。定义集合：
$$G/N := {aN \mid a \in G}$$
为 $G$ 关于 $N$ 的全体左（右）陪集构成的集合。
在集合 $G/N$ 上定义二元运算（陪集乘法）：
$$(aN)(bN) := (ab)N, \quad \forall aN, bN \in G/N$$
代数系统 $(G/N, \cdot)$ 称为群 $G$ 关于正规子群 $N$ 的&lt;strong&gt;商群（Quotient Group）&lt;/strong&gt;。&lt;/p&gt;
&lt;h5&gt;1.2 数学直觉&lt;/h5&gt;
&lt;p&gt;商群是通过忽略正规子群 $N$ 内部差异而构造的同余类系统。由于陪集是用其中的代表元来写出的，必须保证选取的代表元不同时，陪集相乘的结果仍然落在同一个陪集中，这一前提由 $N$ 的正规性（$gN = Ng$）所保证。&lt;/p&gt;
&lt;h5&gt;1.3 商群乘法的良定性（Well-definedness）证明&lt;/h5&gt;
&lt;h6&gt;定理 4.1（良定性充要定理）&lt;/h6&gt;
&lt;p&gt;运算 $(aN)(bN) = (ab)N$ 在陪集集合 $G/N$ 上是良定的，当且仅当 $N$ 是群 $G$ 的正规子群（$N \triangleleft G$）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;严格形式化证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;充分性（$N \triangleleft G \implies$ 运算良定）&lt;/strong&gt;：
设 $a_1 N = a_2 N$ 且 $b_1 N = b_2 N$。
由定理 3.2，存在 $n_a, n_b \in N$，使得：
$$a_2 = a_1 n_a, \quad b_2 = b_1 n_b$$
计算两个新代表元的乘积：
$$a_2 b_2 = (a_1 n_a)(b_1 n_b) = a_1 (n_a b_1) n_b$$
因为 $N \triangleleft G$，由左陪集等于右陪集（$N b_1 = b_1 N$），存在 $n&apos;_a \in N$ 使得：
$$n_a b_1 = b_1 n&apos;_a$$
将此式代入乘积中：
$$a_2 b_2 = a_1 (b_1 n&apos;_a) n_b = (a_1 b_1)(n&apos;_a n_b)$$
因为 $N$ 是子群，对运算封闭，故 $n&apos;_a n_b \in N$。
因此：
$$(a_1 b_1)^{-1}(a_2 b_2) = n&apos;_a n_b \in N$$
由定理 3.2，得：
$$(a_2 b_2)N = (a_1 b_1)N$$
这证明了运算结果与代表元的选择无关，商群乘法良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必要性（运算良定 $\implies N \triangleleft G$）&lt;/strong&gt;：
设运算良定。任取 $g \in G, n \in N$。
因为 $n \in N$，故 $nN = eN = N$。
由良定性，陪集乘法 $(gN)(nN)(g^{-1}N)$ 的结果与代表元选取无关：
$$(gN)(nN)(g^{-1}N) = (gN)(eN)(g^{-1}N) = (g e g^{-1})N = eN = N$$
直接按运算定义计算左边：
$$(gN)(nN)(g^{-1}N) = (g n g^{-1})N$$
因此必有 $(g n g^{-1})N = N \implies g n g^{-1} \in N$。
由定义，$N \triangleleft G$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!CAUTION] 非正规子群的反例
在 3 次对称群 $S_3$ 中，取 2 阶子群 $H = {(1), (1\ 2)}$。$H$ 不是正规子群。
$H$ 在 $S_3$ 中的全部左陪集为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$H = {(1), (1\ 2)}$；&lt;/li&gt;
&lt;li&gt;$(1\ 3)H = {(1\ 3)(1), (1\ 3)(1\ 2)} = {(1\ 3), (1\ 2\ 3)}$；&lt;/li&gt;
&lt;li&gt;$(2\ 3)H = {(2\ 3)(1), (2\ 3)(1\ 2)} = {(2\ 3), (1\ 3\ 2)}$。
考虑左陪集 $A = (1\ 3)H = {(1\ 3), (1\ 2\ 3)}$ 与 $B = (2\ 3)H = {(2\ 3), (1\ 3\ 2)}$ 的乘法：&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;若选代表元 $(1\ 3) \in A$ 与 $(2\ 3) \in B$：乘积为 $(1\ 3)(2\ 3) = (1\ 3\ 2)$，其所在左陪集为 $(1\ 3\ 2)H = (2\ 3)H = {(2\ 3), (1\ 3\ 2)}$；&lt;/li&gt;
&lt;li&gt;若选代表元 $(1\ 2\ 3) \in A$ 与 $(2\ 3) \in B$：乘积为 $(1\ 2\ 3)(2\ 3) = (1\ 2)$，其所在左陪集为 $(1\ 2)H = H = {(1), (1\ 2)}$。
两种代表元选取给出了完全不同的左陪集 $(2\ 3)H \ne H$。这证明了非正规子群无法良定陪集乘法。&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;
&lt;h5&gt;1.4 商群公理的形式化验证&lt;/h5&gt;
&lt;h6&gt;定理 4.2&lt;/h6&gt;
&lt;p&gt;设 $N \triangleleft G$，则 $(G/N, \cdot)$ 构成一个群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;封闭性&lt;/strong&gt;：由定理 4.1，对任意 $aN, bN \in G/N$，乘积 $(ab)N \in G/N$ 且良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结合律&lt;/strong&gt;：任取 $aN, bN, cN \in G/N$：
$$((aN)(bN))(cN) = ((ab)N)(cN) = ((ab)c)N$$
由群 $G$ 的结合律 $(ab)c = a(bc)$：
$$= (a(bc))N = (aN)((bc)N) = (aN)((bN)(cN))$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单位元&lt;/strong&gt;：$N = eN$ 为单位元。对任意 $aN \in G/N$：
$$(eN)(aN) = (ea)N = aN, \quad (aN)(eN) = (ae)N = aN$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;逆元&lt;/strong&gt;：对任意 $aN \in G/N$，其逆元为 $a^{-1}N$：
$$(aN)(a^{-1}N) = (a a^{-1})N = eN = N, \quad (a^{-1}N)(aN) = (a^{-1}a)N = eN = N$$
综上，$(G/N, \cdot)$ 构成一个群。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 商群的阶与塔式法则&lt;/h4&gt;
&lt;h5&gt;2.1 商群的阶&lt;/h5&gt;
&lt;h6&gt;定理 4.3&lt;/h6&gt;
&lt;p&gt;设 $G$ 是有限群，$N \triangleleft G$，则商群 $G/N$ 的阶为：
$$|G/N| = [G : N] = \frac{|G|}{|N|}$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
商群 $G/N$ 的元素即为 $N$ 在 $G$ 中的全体左陪集。由 Lagrange 定理（定理 3.5），互不相交的陪集总数恰为 $[G : N] = \frac{|G|}{|N|}$。 $\blacksquare$&lt;/p&gt;
&lt;h5&gt;2.2 塔式法则（指数乘法公式）&lt;/h5&gt;
&lt;h6&gt;定理 4.4（子群链指数公式）&lt;/h6&gt;
&lt;p&gt;设 $K \le H \le G$ 是群 $G$ 的子群链（无需正规性假设）。则：
$$[G : K] = [G : H][H : K]$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $H$ 在 $G$ 中的互不相交左陪集划分为：
$$G = \bigcup_{i \in I} g_i H, \quad |I| = [G : H]$$
设 $K$ 在 $H$ 中的互不相交左陪集划分为：
$$H = \bigcup_{j \in J} h_j K, \quad |J| = [H : K]$$
将 $H$ 的划分代入 $G$ 中：
$$G = \bigcup_{i \in I} g_i \left( \bigcup_{j \in J} h_j K \right) = \bigcup_{i \in I, j \in J} (g_i h_j) K$$
需证明所有陪集 $(g_i h_j) K$ 两两互不相交：
设 $(g_i h_j) K = (g_{i&apos;} h_{j&apos;}) K$。
两边同时右乘 $H$（因为 $K \subseteq H \implies KH = H$）：
$$g_i h_j H = g_{i&apos;} h_{j&apos;} H$$
因为 $h_j, h_{j&apos;} \in H$，故 $h_j H = H = h_{j&apos;} H$。
因此：
$$g_i H = g_{i&apos;} H$$
由于 ${g_i H}&lt;em&gt;{i \in I}$ 是互不相同的左陪集，必有 $i = i&apos;$。
将 $i = i&apos;$ 代入原式，两边左乘 $g_i^{-1}$：
$$(g_i h_j)K = (g_i h&lt;/em&gt;{j&apos;})K \implies h_j K = h_{j&apos;} K$$
由于 ${h_j K}_{j \in J}$ 是互不相同的左陪集，必有 $j = j&apos;$。
因此，指标对 $(i, j) \in I \times J$ 唯一确定 $G$ 关于 $K$ 的一个左陪集，无遗漏且两两不交。
其总个数为 $|I| \times |J|$，即 $[G : K] = [G : H][H : K]$。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;3. 群同态与群同构&lt;/h4&gt;
&lt;h5&gt;3.1 严格定义&lt;/h5&gt;
&lt;p&gt;设 $(G, \cdot)$ 与 $(G&apos;, *)$ 是群，$f: G \to G&apos;$ 是一个映射。
如果对任意 $a, b \in G$，均有：
$$f(ab) = f(a) * f(b)$$
则称 $f$ 是群 $G$ 到群 $G&apos;$ 的&lt;strong&gt;群同态（Homomorphism）&lt;/strong&gt;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;单同态（Monomorphism）&lt;/strong&gt;：$f$ 是单射；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满同态（Epimorphism）&lt;/strong&gt;：$f$ 是满射；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同构（Isomorphism）&lt;/strong&gt;：$f$ 是双射（既单又满），称群 $G$ 与 $G&apos;$ 同构，记作 $G \cong G&apos;$；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;自同态 / 自同构&lt;/strong&gt;：目标群 $G&apos; = G$ 时的同态 / 同构。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;3.2 群同态的保持性质&lt;/h5&gt;
&lt;h6&gt;定理 4.5&lt;/h6&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态，$e, e&apos;$ 分别为 $G, G&apos;$ 的单位元。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f(e) = e&apos;$；&lt;/li&gt;
&lt;li&gt;$\forall a \in G$，$f(a^{-1}) = (f(a))^{-1}$；&lt;/li&gt;
&lt;li&gt;$\forall a \in G, \forall k \in \mathbb{Z}$，$f(a^k) = (f(a))^k$；&lt;/li&gt;
&lt;li&gt;若 $\operatorname{ord}(a) = m &amp;lt; \infty$，则 $\operatorname{ord}(f(a))$ 有限且 $\operatorname{ord}(f(a)) \mid \operatorname{ord}(a)$；&lt;/li&gt;
&lt;li&gt;若 $f$ 是同构（或单同态），则对任意有限阶元素 $a \in G$，$\operatorname{ord}(f(a)) = \operatorname{ord}(a)$（同构严格保阶）。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;在群 $G$ 中 $ee = e$。施加映射 $f(ee) = f(e) \implies f(e)f(e) = f(e) = f(e)e&apos;$。
在 $G&apos;$ 中两边左乘 $(f(e))^{-1}$，得 $f(e) = e&apos;$。&lt;/li&gt;
&lt;li&gt;$f(a)f(a^{-1}) = f(a a^{-1}) = f(e) = e&apos;$，且 $f(a^{-1})f(a) = f(a^{-1}a) = f(e) = e&apos;$。
由逆元唯一性，$f(a^{-1}) = (f(a))^{-1}$。&lt;/li&gt;
&lt;li&gt;当 $k &amp;gt; 0$ 时，对 $k$ 施加数学归纳法：$f(a^{k+1}) = f(a^k a) = f(a^k)f(a) = (f(a))^k f(a) = (f(a))^{k+1}$；当 $k = 0$ 时由第 1 条成立；当 $k &amp;lt; 0$ 时，令 $k = -m$（$m &amp;gt; 0$），$f(a^k) = f((a^m)^{-1}) = (f(a^m))^{-1} = ((f(a))^m)^{-1} = (f(a))^{-m} = (f(a))^k$。&lt;/li&gt;
&lt;li&gt;设 $\operatorname{ord}(a) = m$，即 $a^m = e$。
$(f(a))^m = f(a^m) = f(e) = e&apos;$。
由定理 1.6（阶整除引理），必有 $\operatorname{ord}(f(a)) \mid m$。&lt;/li&gt;
&lt;li&gt;若 $f$ 是同构，逆映射 $f^{-1}: G&apos; \to G$ 也是同构。
由第 4 条，$\operatorname{ord}(f(a)) \mid \operatorname{ord}(a)$，且 $\operatorname{ord}(a) = \operatorname{ord}(f^{-1}(f(a))) \mid \operatorname{ord}(f(a))$。
两个正整数互相整除，必有 $\operatorname{ord}(f(a)) = \operatorname{ord}(a)$。若 $f$ 仅为单同态，记 $d = \operatorname{ord}(f(a))$，则 $f(a^d) = (f(a))^d = e&apos;$，故 $a^d \in \operatorname{Ker}f = {e} \implies a^d = e \implies \operatorname{ord}(a) \mid d$，同理得 $\operatorname{ord}(a) = \operatorname{ord}(f(a))$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;4. 同态像、同态核与单同态判定&lt;/h4&gt;
&lt;h5&gt;4.1 严格定义&lt;/h5&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;同态像（Image）&lt;/strong&gt;：
$$\operatorname{Im}f := f(G) = {f(x) \mid x \in G} \subseteq G&apos;$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态核（Kernel）&lt;/strong&gt;：
$$\operatorname{Ker}f := f^{-1}(e&apos;) = {x \in G \mid f(x) = e&apos;} \subseteq G$$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;4.2 核心结构定理：同态核的正规性&lt;/h5&gt;
&lt;h6&gt;定理 4.6&lt;/h6&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$\operatorname{Im}f$ 是 $G&apos;$ 的子群（$\operatorname{Im}f \le G&apos;$）；&lt;/li&gt;
&lt;li&gt;$\operatorname{Ker}f$ 是 $G$ 的&lt;strong&gt;正规子群&lt;/strong&gt;（$\operatorname{Ker}f \triangleleft G$）。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;证明 $\operatorname{Im}f \le G&apos;$&lt;/strong&gt;：
$e&apos; = f(e) \in \operatorname{Im}f \implies \operatorname{Im}f \ne \emptyset$。
任取 $y_1, y_2 \in \operatorname{Im}f$，存在 $x_1, x_2 \in G$ 使得 $f(x_1) = y_1, f(x_2) = y_2$。
则 $y_1 y_2^{-1} = f(x_1)(f(x_2))^{-1} = f(x_1)f(x_2^{-1}) = f(x_1 x_2^{-1})$。
由于 $x_1 x_2^{-1} \in G$，故 $y_1 y_2^{-1} \in \operatorname{Im}f$。由一步判定法，$\operatorname{Im}f \le G&apos;$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;证明 $\operatorname{Ker}f \triangleleft G$&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;先证 $\operatorname{Ker}f \le G$：$f(e) = e&apos; \implies e \in \operatorname{Ker}f$。
任取 $a, b \in \operatorname{Ker}f$，即 $f(a) = e&apos;, f(b) = e&apos;$。
$f(ab^{-1}) = f(a)(f(b))^{-1} = e&apos;(e&apos;)^{-1} = e&apos; \implies ab^{-1} \in \operatorname{Ker}f$。故 $\operatorname{Ker}f \le G$。&lt;/li&gt;
&lt;li&gt;再证正规性：任取 $g \in G, k \in \operatorname{Ker}f$。
检验共轭元素 $g k g^{-1}$ 在 $f$ 下的像：
$$f(g k g^{-1}) = f(g) f(k) f(g^{-1}) = f(g) e&apos; (f(g))^{-1} = f(g)(f(g))^{-1} = e&apos;$$
根据同态核定义，映射结果为 $e&apos;$，必有：
$$g k g^{-1} \in \operatorname{Ker}f$$
因此 $\operatorname{Ker}f \triangleleft G$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;4.3 单同态判定准则&lt;/h5&gt;
&lt;h6&gt;定理 4.7&lt;/h6&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态。则：
$$f \text{ 是单同态（单射）} \iff \operatorname{Ker}f = {e}$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：设 $f$ 是单射。
已知 $f(e) = e&apos;$，故 $e \in \operatorname{Ker}f$。
若 $x \in \operatorname{Ker}f$，则 $f(x) = e&apos; = f(e)$。由单射定义，必有 $x = e$。
因此 $\operatorname{Ker}f = {e}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：设 $\operatorname{Ker}f = {e}$。
任取 $x, y \in G$，设 $f(x) = f(y)$。
两边右乘 $(f(y))^{-1}$：
$$f(x)(f(y))^{-1} = e&apos; \implies f(x)f(y^{-1}) = e&apos; \implies f(x y^{-1}) = e&apos;$$
由同态核定义：
$$x y^{-1} \in \operatorname{Ker}f$$
因为已知 $\operatorname{Ker}f = {e}$，故必有 $x y^{-1} = e \implies x = y$。
这证明了 $f$ 必定是单射。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;5. 自然同态（Canonical Homomorphism）&lt;/h4&gt;
&lt;h5&gt;5.1 严格表述与定理&lt;/h5&gt;
&lt;h6&gt;定理 4.8&lt;/h6&gt;
&lt;p&gt;设 $N \triangleleft G$。定义映射：
$$\pi: G \to G/N, \quad \pi(a) = aN \quad (\forall a \in G)$$
则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$\pi$ 是满同态，称为 $G$ 到商群 $G/N$ 的&lt;strong&gt;自然同态（规范同态）&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;自然同态的核恰好等于子群 $N$，即 $\operatorname{Ker}\pi = N$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;任取 $a, b \in G$。根据商群乘法定义：
$$\pi(ab) = (ab)N = (aN)(bN) = \pi(a)\pi(b)$$
故 $\pi$ 是群同态。
对任意陪集 $aN \in G/N$，均有 $a \in G$ 使得 $\pi(a) = aN$，故 $\pi$ 是满射。&lt;/li&gt;
&lt;li&gt;考察商群 $G/N$ 的单位元为 $N = eN$。由核的定义：
$$\operatorname{Ker}\pi = {x \in G \mid \pi(x) = N} = {x \in G \mid xN = N}$$
由定理 3.1，陪集 $xN = N \iff x \in N$。
因此 $\operatorname{Ker}\pi = N$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;blockquote&gt;
&lt;p&gt;[!NOTE] 结构联系
定理 4.6 与定理 4.8 确立了如下对应：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;任何群同态的核都是正规子群；&lt;/li&gt;
&lt;li&gt;任何正规子群 $N \triangleleft G$ 都必然是某个从 $G$ 出发的群同态（即自然同态 $\pi: G \to G/N$）的核。&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h4&gt;6. 核心易错点&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;商群良定性前提&lt;/strong&gt;：构造商群乘法时，必须以 $N \triangleleft G$ 为前提并严格验证良定性，不可直接默认“封闭性显然”。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态与同构的保阶差异&lt;/strong&gt;：一般同态下仅有像的阶整除原像的阶（$\operatorname{ord}(f(a)) \mid \operatorname{ord}(a)$）；只有在同构（或单同态）下阶才严格不变。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射判定化简&lt;/strong&gt;：验证群同态为单射时，无需验证 $f(x)=f(y) \implies x=y$，只需计算同态核 $\operatorname{Ker}f$，确认其只有单位元 ${e}$ 即可。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;塔式法则适用条件&lt;/strong&gt;：在子群链 $K \le H \le G$ 中，指数公式 $[G:K] = [G:H][H:K]$ 对任意子群均成立，不需要 $K$ 或 $H$ 正规。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;7. 前后知识连接&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：映射单射/满射等价性质（&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;）、陪集相等充要条件、正规子群判据（&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群.md&lt;/a&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;商群与同态核是建立三大同构定理（&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理.md&lt;/a&gt;）的核心载体。&lt;/li&gt;
&lt;li&gt;自然同态 $\pi$ 是诱导同态基本定理双射映射的原型。&lt;/li&gt;
&lt;li&gt;单同态核判据是后续证明 Cayley 定理单射性（&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley.md&lt;/a&gt;）的核心工具。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与证明套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（易错点 7 商群良定性前提、易错点 10 塔式法则、模板 3 核判单射法）。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-7&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.7 三大同构定理&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义、定理、证明与例题。&lt;/p&gt;
&lt;h3&gt;05-三大同构定理&lt;/h3&gt;
&lt;h4&gt;1. 群同态基本定理（第一同构定理）&lt;/h4&gt;
&lt;h5&gt;1.1 严格表述与定理&lt;/h5&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$\operatorname{Ker}f$ 是群 $G$ 的正规子群（$\operatorname{Ker}f \triangleleft G$）；&lt;/li&gt;
&lt;li&gt;商群 $G/\operatorname{Ker}f$ 与同态像 $\operatorname{Im}f$ 同构：
$$G/\operatorname{Ker}f \cong \operatorname{Im}f$$&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;特别地，如果 $f$ 是满同态（即 $\operatorname{Im}f = G&apos;$），则有：
$$G/\operatorname{Ker}f \cong G&apos;$$&lt;/p&gt;
&lt;h5&gt;1.2 数学直觉&lt;/h5&gt;
&lt;p&gt;同态映射会在目标群中产生重叠与压缩。代数证明表明，原群中映射到同一个像点的所有元素，恰好构成核的正规陪集 $a\operatorname{Ker}f$。商群 $G/\operatorname{Ker}f$ 将这些具有相同像点的陪集视为单个元素，从而消除了原同态中的重叠现象，诱导出与同态像之间的双射同构。&lt;/p&gt;
&lt;h5&gt;1.3 严格形式化证明&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
第 1 部分 $\operatorname{Ker}f \triangleleft G$ 已在定理 4.6 中证明，此处证明第 2 部分。
记 $K = \operatorname{Ker}f$。
定义从商群 $G/K$ 到像集 $\operatorname{Im}f$ 的映射：
$$\bar{f}: G/K \to \operatorname{Im}f, \quad \bar{f}(aK) = f(a) \quad (\forall a \in G)$$&lt;/p&gt;
&lt;p&gt;逐步验证以下四项：&lt;/p&gt;
&lt;h6&gt;步骤 1：验证映射良定性（Well-defined）&lt;/h6&gt;
&lt;p&gt;设 $aK = bK \in G/K$。
由定理 3.2，$a^{-1}b \in K = \operatorname{Ker}f$。
由同态核定义：
$$f(a^{-1}b) = e&apos;$$
利用同态保持运算与逆元性质：
$$(f(a))^{-1} f(b) = e&apos; \implies f(a) = f(b)$$
因此：
$$\bar{f}(aK) = f(a) = f(b) = \bar{f}(bK)$$
映射结果与代表元的选择无关，$\bar{f}$ 是良定的。&lt;/p&gt;
&lt;h6&gt;步骤 2：验证映射是单射（Injective）&lt;/h6&gt;
&lt;p&gt;设 $aK, bK \in G/K$，且满足：
$$\bar{f}(aK) = \bar{f}(bK) \implies f(a) = f(b)$$
在群 $G&apos;$ 中两边左乘 $(f(a))^{-1}$：
$$(f(a))^{-1} f(b) = e&apos; \implies f(a^{-1}b) = e&apos;$$
由同态核定义：
$$a^{-1}b \in \operatorname{Ker}f = K$$
由定理 3.2，推得：
$$aK = bK$$
故 $\bar{f}$ 是单射。&lt;/p&gt;
&lt;h6&gt;步骤 3：验证映射是满射（Surjective）&lt;/h6&gt;
&lt;p&gt;任取 $y \in \operatorname{Im}f$。
由像集定义，存在 $a \in G$ 使得 $f(a) = y$。
选取陪集元素 $aK \in G/K$，代入映射规则：
$$\bar{f}(aK) = f(a) = y$$
因此像集中的每一个元素都存在原像，$\bar{f}$ 是满射。&lt;/p&gt;
&lt;h6&gt;步骤 4：验证映射保持群运算（Homomorphism）&lt;/h6&gt;
&lt;p&gt;任取 $aK, bK \in G/K$。
利用商群的乘法定义 $(aK)(bK) = (ab)K$，以及 $f$ 本身的同态性质：
$$\bar{f}((aK)(bK)) = \bar{f}((ab)K) = f(ab) = f(a)f(b) = \bar{f}(aK)\bar{f}(bK)$$
故 $\bar{f}$ 保持乘法运算。&lt;/p&gt;
&lt;p&gt;综合以上四步，$\bar{f}$ 是 $G/K$ 到 $\operatorname{Im}f$ 的双射同态（群同构）。
因此：
$$G/\operatorname{Ker}f \cong \operatorname{Im}f \quad \blacksquare$$&lt;/p&gt;
&lt;hr /&gt;
&lt;h5&gt;1.4 五大经典应用实例&lt;/h5&gt;
&lt;p&gt;利用同态基本定理证明 $G/N \cong H$ 的标准方法是：构造从 $G$ 到 $H$ 的满同态 $f$，并验证 $\operatorname{Ker}f = N$。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;序号&lt;/th&gt;
&lt;th&gt;经典实例&lt;/th&gt;
&lt;th&gt;满同态构造 $f$&lt;/th&gt;
&lt;th&gt;同态核 $\operatorname{Ker}f$&lt;/th&gt;
&lt;th&gt;同构结论&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;1&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;整数模运算&lt;/td&gt;
&lt;td&gt;$f: \mathbb{Z} \to \mathbb{Z}_m, \ f(n) = [n]$&lt;/td&gt;
&lt;td&gt;$m\mathbb{Z}$&lt;/td&gt;
&lt;td&gt;$\mathbb{Z}/m\mathbb{Z} \cong \mathbb{Z}_m$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;2&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;实数乘法正负符号&lt;/td&gt;
&lt;td&gt;$f: \mathbb{R}^* \to ({1, -1}, \cdot), \ f(x) = \frac{x}{|x|}$&lt;/td&gt;
&lt;td&gt;$\mathbb{R}^+$（正实数乘法群）&lt;/td&gt;
&lt;td&gt;$\mathbb{R}^*/\mathbb{R}^+ \cong ({1, -1}, \cdot) \cong \mathbb{Z}_2$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;3&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;复平面单位圆缠绕&lt;/td&gt;
&lt;td&gt;$f: \mathbb{R} \to S^1, \ f(x) = \mathrm{e}^{2\pi \mathrm{i} x}$&lt;/td&gt;
&lt;td&gt;$\mathbb{Z}$（所有周期整点）&lt;/td&gt;
&lt;td&gt;$\mathbb{R}/\mathbb{Z} \cong S^1$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;4&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;矩阵行列式群&lt;/td&gt;
&lt;td&gt;$f: \mathrm{GL}_n(\mathbb{R}) \to \mathbb{R}^*, \ f(A) = \det(A)$&lt;/td&gt;
&lt;td&gt;$\mathrm{SL}_n(\mathbb{R})$（行列式为 1 的矩阵群）&lt;/td&gt;
&lt;td&gt;$\mathrm{GL}_n(\mathbb{R})/\mathrm{SL}_n(\mathbb{R}) \cong \mathbb{R}^*$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;5&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;置换符号映射（$n\ge2$）&lt;/td&gt;
&lt;td&gt;$f: S_n \to ({1, -1}, \cdot), \ f(\sigma) = \operatorname{sgn}(\sigma)$&lt;/td&gt;
&lt;td&gt;$A_n$（全体偶置换构成的交代群）&lt;/td&gt;
&lt;td&gt;$S_n/A_n \cong \mathbb{Z}_2$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 第二同构定理（菱形同构定理 / Diamond Isomorphism Theorem）&lt;/h4&gt;
&lt;h5&gt;2.1 严格表述与定理&lt;/h5&gt;
&lt;p&gt;设 $G$ 是群，$H \le G$ 是 $G$ 的子群，$N \triangleleft G$ 是 $G$ 的正规子群。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;乘积集 $HN$ 是 $G$ 的子群（$HN \le G$），且 $N \triangleleft HN$；&lt;/li&gt;
&lt;li&gt;交集 $H \cap N$ 是 $H$ 的正规子群（$H \cap N \triangleleft H$）；&lt;/li&gt;
&lt;li&gt;存在自然同构：
$$HN/N \cong H/(H \cap N)$$&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    HN[&quot;HN (顶端乘积子群)&quot;]
    H[&quot;H (左侧普通子群)&quot;]
    N[&quot;N (右侧正规子群)&quot;]
    HN_CAP[&quot;H ∩ N (底端交集子群)&quot;]

    HN --- H
    HN --- N
    H --- HN_CAP
    N --- HN_CAP
&lt;/code&gt;&lt;/pre&gt;
&lt;h5&gt;2.2 形式化证明&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;证明步骤 1：证明 $HN \le G$ 且 $N \triangleleft HN$&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$e = ee \in HN \implies HN \ne \emptyset$。&lt;/li&gt;
&lt;li&gt;任取 $x_1, x_2 \in HN$，设 $x_1 = h_1 n_1, x_2 = h_2 n_2$（$h_i \in H, n_i \in N$）。
$$x_1 x_2^{-1} = (h_1 n_1)(n_2^{-1} h_2^{-1}) = h_1 (n_1 n_2^{-1}) h_2^{-1}$$
记 $n_3 = n_1 n_2^{-1} \in N$。因为 $N \triangleleft G$，对全群共轭封闭，故：
$$n_3 h_2^{-1} = h_2^{-1} (h_2 n_3 h_2^{-1}) = h_2^{-1} n_4, \quad \text{其中 } n_4 \in N$$
代入得：
$$x_1 x_2^{-1} = h_1 (h_2^{-1} n_4) = (h_1 h_2^{-1}) n_4$$
因为 $h_1 h_2^{-1} \in H, n_4 \in N$，所以 $x_1 x_2^{-1} \in HN$。由定理 1.8（一步判定法），$HN \le G$。&lt;/li&gt;
&lt;li&gt;对任意 $n \in N$，有 $n = e n \in HN$，故包含关系 $N \subseteq HN$ 成立。对任意 $x = hn \in HN$ 及 $n_0 \in N$：
$$x n_0 x^{-1} = (hn) n_0 (hn)^{-1} = h (n n_0 n^{-1}) h^{-1}$$
因为 $N \triangleleft G$，所以 $n n_0 n^{-1} \in N$ 且 $h (n n_0 n^{-1}) h^{-1} \in N$。故 $x n_0 x^{-1} \in N$。因此 $N \triangleleft HN$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;证明步骤 2：利用第一同构定理证明同构&lt;/strong&gt;
定义映射：
$$\phi: H \to HN/N, \quad \phi(h) = hN \quad (\forall h \in H)$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：任取 $h_1, h_2 \in H$。
$$\phi(h_1 h_2) = (h_1 h_2)N = (h_1 N)(h_2 N) = \phi(h_1)\phi(h_2)$$
故 $\phi$ 是群同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：任取商群 $HN/N$ 中的元素 $y$。
根据乘积集定义，$y = (hn)N$（其中 $h \in H, n \in N$）。
因为 $n \in N \implies nN = N$，由陪集性质：
$$(hn)N = h(nN) = hN = \phi(h)$$
这说明商群中的每一个陪集都能在 $H$ 中找到原像，故 $\phi$ 是满射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求解同态核 $\operatorname{Ker}\phi$&lt;/strong&gt;：
商群 $HN/N$ 的单位元是陪集 $N$。
$$\operatorname{Ker}\phi = {h \in H \mid \phi(h) = N} = {h \in H \mid hN = N}$$
由定理 3.1，$hN = N \iff h \in N$。
因此：
$$\operatorname{Ker}\phi = {h \in H \mid h \in N} = H \cap N$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;得出结论&lt;/strong&gt;：
因为 $\phi: H \to HN/N$ 是满同态，且 $\operatorname{Ker}\phi = H \cap N$。
由群同态基本定理（定理 5.1），直接得出：
$$H \cap N \triangleleft H \quad \text{且} \quad H/(H \cap N) \cong HN/N \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;2.3 最小例子&lt;/h5&gt;
&lt;p&gt;在克莱因四元群 $K_4 = {e, a, b, c}$ 中，所有子群均为正规子群。
取 $H = {e, a}, N = {e, b}$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;乘积群 $HN = {e, a, b, ab} = {e, a, b, c} = K_4$；&lt;/li&gt;
&lt;li&gt;交集 $H \cap N = {e}$；&lt;/li&gt;
&lt;li&gt;代入第二同构定理：
$$HN/N = K_4 / {e, b} \cong \mathbb{Z}_2$$
$$H / (H \cap N) = {e, a} / {e} \cong {e, a} \cong \mathbb{Z}_2$$
两边阶数均为 2，结构相同。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;3. 第三同构定理（商群约分定理）&lt;/h4&gt;
&lt;h5&gt;3.1 严格表述与定理&lt;/h5&gt;
&lt;p&gt;设 $H, K$ 都是群 $G$ 的正规子群，且满足包含关系 $K \subseteq H \subseteq G$。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$H/K$ 是商群 $G/K$ 的正规子群（$H/K \triangleleft G/K$）；&lt;/li&gt;
&lt;li&gt;存在自然同构：
$$(G/K) / (H/K) \cong G/H$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;3.2 形式化证明&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
构造从商群 $G/K$ 到商群 $G/H$ 的映射：
$$f: G/K \to G/H, \quad f(aK) = aH \quad (\forall a \in G)$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;良定性&lt;/strong&gt;：
设 $aK = bK$。由定理 3.2，$a^{-1}b \in K$。
因为已知 $K \subseteq H$，所以 $a^{-1}b \in H$。
由定理 3.2，推得 $aH = bH$，即 $f(aK) = f(bK)$。
故映射 $f$ 良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：
任取 $aK, bK \in G/K$：
$$f((aK)(bK)) = f(abK) = abH = (aH)(bH) = f(aK)f(bK)$$
故 $f$ 是同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：
对任意 $aH \in G/H$，取 $aK \in G/K$ 即可得到 $f(aK) = aH$。故 $f$ 是满射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求解同态核 $\operatorname{Ker}f$&lt;/strong&gt;：
商群 $G/H$ 的单位元是陪集 $H$。
$$\operatorname{Ker}f = {aK \in G/K \mid f(aK) = H} = {aK \in G/K \mid aH = H}$$
在群中，$aH = H \iff a \in H$。因此：
$$\operatorname{Ker}f = {aK \in G/K \mid a \in H} = H/K$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;套用第一同构定理&lt;/strong&gt;：
因为 $f: G/K \to G/H$ 是满同态，且 $\operatorname{Ker}f = H/K$。
由群同态基本定理直接得出：
$$H/K \triangleleft G/K \quad \text{且} \quad (G/K)/(H/K) \cong G/H \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;3.3 最小例子与计算实例&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;整数加群的连续商群&lt;/strong&gt;：
取 $G = \mathbb{Z}$，$H = 2\mathbb{Z}$（偶数群），$K = 6\mathbb{Z}$（6 的倍数群）。
包含关系 $6\mathbb{Z} \subseteq 2\mathbb{Z} \subseteq \mathbb{Z}$ 成立。
&lt;ul&gt;
&lt;li&gt;$G/K = \mathbb{Z}/6\mathbb{Z} = \mathbb{Z}_6 = {[0], [1], [2], [3], [4], [5]}$；&lt;/li&gt;
&lt;li&gt;$H/K = 2\mathbb{Z}/6\mathbb{Z} = {[0], [2], [4]} \le \mathbb{Z}_6$；&lt;/li&gt;
&lt;li&gt;商群 $\mathbb{Z}_6 / {[0], [2], [4]}$ 的阶为 $6/3 = 2$；&lt;/li&gt;
&lt;li&gt;代入第三同构定理：
$$\frac{\mathbb{Z}/6\mathbb{Z}}{2\mathbb{Z}/6\mathbb{Z}} \cong \frac{\mathbb{Z}}{2\mathbb{Z}} \cong \mathbb{Z}_2$$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;4. 满同态下的正规性保持定理&lt;/h4&gt;
&lt;h5&gt;4.1 严格表述与定理&lt;/h5&gt;
&lt;h6&gt;定理 5.2&lt;/h6&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群的&lt;strong&gt;满同态&lt;/strong&gt;。若 $N \triangleleft G$，则其同态像也是目标群的正规子群：
$$f(N) \triangleleft G&apos;$$&lt;/p&gt;
&lt;h5&gt;4.2 形式化证明&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
由定理 4.6(1)，子群的同态像仍为子群，故 $f(N) \le G&apos;$。
验证正规性：任取 $y \in G&apos;$，以及任意 $x \in f(N)$。
需证明：
$$y x y^{-1} \in f(N)$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;因为 $f$ 是满射，对任意 $y \in G&apos;$，存在 $g \in G$ 使得 $f(g) = y$；&lt;/li&gt;
&lt;li&gt;因为 $x \in f(N)$，由像集定义，存在 $n \in N$ 使得 $f(n) = x$。
代入共轭式中，利用群同态保持运算与求逆的性质：
$$y x y^{-1} = f(g) f(n) (f(g))^{-1} = f(g) f(n) f(g^{-1}) = f(g n g^{-1})$$
因为已知 $N \triangleleft G$，对任意 $g \in G, n \in N$，必有：
$$g n g^{-1} \in N$$
因此，其像点 $f(g n g^{-1})$ 属于集合 $f(N)$：
$$y x y^{-1} = f(g n g^{-1}) \in f(N)$$
由正规子群定义，$f(N) \triangleleft G&apos;$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!WARNING] 条件反例：非满同态不成立
若 $f$ 不是满射，结论不成立。
反例：取包含映射 $i: H \to G$（其中 $H \le G$ 且 $H$ 不是 $G$ 的正规子群）。$H \triangleleft H$ 在自身中是正规的，但 $i(H) = H$ 在群 $G$ 中不是正规子群。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h4&gt;5. 核心易错点&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态基本定理证明的良定性前提&lt;/strong&gt;：定义 $\bar{f}(aK) = f(a)$ 时，必须优先证明代表元选取无关性，否则映射不成立。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第二同构定理的正规子群位置&lt;/strong&gt;：第二同构定理要求至少有一个子群是正规子群（$N \triangleleft G$）；若两个均仅为普通子群，乘积 $HN$ 甚至不是子群。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第三同构定理的包含链&lt;/strong&gt;：必须满足 $K \subseteq H \subseteq G$ 且两者均正规，才能构成商群之间的同构。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;定理 5.2 对满射的依赖&lt;/strong&gt;：正规性取决于全群环境，只有满同态才能保证任意共轭元素 $y$ 存在原像 $g$ 来调动母群正规性。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;6. 前后知识连接&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：商集与映射分解（&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;）、商群乘法良定性、同态核正规性、单同态核判据（&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态.md&lt;/a&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;第一同构定理是证明内自同构群定理 $G/Z(G) \cong \operatorname{Inn}(G)$（&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley.md&lt;/a&gt;）的核心工具。&lt;/li&gt;
&lt;li&gt;第一同构定理是近世代数中判定商代数系统同构结构的普适方法。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与证明套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（模板 2 第一同构定理构建商群同构四步法）。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-8&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.8 置换群-内自同构-Cayley&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义、定理、证明与例题。&lt;/p&gt;
&lt;h3&gt;06-置换群-内自同构-Cayley&lt;/h3&gt;
&lt;h4&gt;1. 对称群 $S_n$ 与一一变换群&lt;/h4&gt;
&lt;h5&gt;1.1 严格表述&lt;/h5&gt;
&lt;p&gt;设 $A$ 是一个非空集合。从 $A$ 到 $A$ 自身的一个双射（一一对应映射）称为 $A$ 上的一个&lt;strong&gt;一一变换&lt;/strong&gt;。
全体一一变换构成的集合记作 $E(A)$（或 $\operatorname{Sym}(A)$）。
当集合 $A = {1, 2, \dots, n}$ 时，从 $A$ 到 $A$ 的双射称为 &lt;strong&gt;$n$ 次置换（Permutation）&lt;/strong&gt;。
包含所有 $n$ 次置换的集合记作 $S_n$（或 $\operatorname{Sym}(n)$），称为 &lt;strong&gt;$n$ 次对称群（Symmetric Group）&lt;/strong&gt;。对称群 $S_n$ 的任何一个子群都称为&lt;strong&gt;置换群&lt;/strong&gt;。&lt;/p&gt;
&lt;h5&gt;1.2 运算方向约定&lt;/h5&gt;
&lt;p&gt;在置换的乘法（函数复合）中，本文遵循函数作用的标准次序——&lt;strong&gt;从右向左复合&lt;/strong&gt;：
$$(\sigma \tau)(x) := \sigma(\tau(x)), \quad \forall x \in A$$
即右侧置换 $\tau$ 先作用，左侧置换 $\sigma$ 后作用。&lt;/p&gt;
&lt;h5&gt;1.3 形式化证明：$E(A)$ 在映射复合下构成群&lt;/h5&gt;
&lt;h6&gt;定理 6.1&lt;/h6&gt;
&lt;p&gt;设 $A$ 是非空集合，代数系统 $(E(A), \circ)$ 构成一个群。特别地，对称群 $S_n$ 构成阶为 $n!$ 的有限群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;封闭性&lt;/strong&gt;：任取 $\sigma, \tau \in E(A)$。
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;单射&lt;/strong&gt;：若 $(\sigma \circ \tau)(x_1) = (\sigma \circ \tau)(x_2) \implies \sigma(\tau(x_1)) = \sigma(\tau(x_2))$。因 $\sigma$ 为单射，故 $\tau(x_1) = \tau(x_2)$；又因 $\tau$ 为单射，故 $x_1 = x_2$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射&lt;/strong&gt;：任取 $z \in A$。因 $\sigma$ 为满射，存在 $y \in A$ 使得 $\sigma(y) = z$；因 $\tau$ 为满射，存在 $x \in A$ 使得 $\tau(x) = y$。从而 $(\sigma \circ \tau)(x) = \sigma(\tau(x)) = \sigma(y) = z$。
故 $\sigma \circ \tau$ 仍为双射，$\sigma \circ \tau \in E(A)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结合律&lt;/strong&gt;：映射复合满足结合律：$&lt;a href=&quot;x&quot;&gt;(\sigma \circ \tau) \circ \mu&lt;/a&gt; = \sigma(\tau(\mu(x))) = &lt;a href=&quot;x&quot;&gt;\sigma \circ (\tau \circ \mu)&lt;/a&gt;$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单位元&lt;/strong&gt;：恒等映射 $I_A(x) = x$ 为双射，且满足 $\sigma \circ I_A = I_A \circ \sigma = \sigma$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;逆元&lt;/strong&gt;：因 $\sigma$ 是双射，其反函数 $\sigma^{-1}: A \to A$ 存在且同为双射，满足 $\sigma \circ \sigma^{-1} = \sigma^{-1} \circ \sigma = I_A$。
综上，$(E(A), \circ)$ 构成群。
当 $|A| = n$ 时，集合 $A$ 到自身的不同双射总数等于 $n$ 个元素的全排列数 $n!$，故 $|S_n| = n!$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 循环置换（轮换）与不相交分解&lt;/h4&gt;
&lt;h5&gt;2.1 循环置换的定义&lt;/h5&gt;
&lt;p&gt;设 $\sigma \in S_n$。若存在互不相同的下标序列 $(j_1, j_2, \dots, j_r)$（$r \ge 2$），使得：
$$\sigma(j_1) = j_2, \quad \sigma(j_2) = j_3, \quad \dots, \quad \sigma(j_r) = j_1$$
并且对不属于该序列的其余元素 $k$ 均有 $\sigma(k) = k$，则称 $\sigma$ 为一个 &lt;strong&gt;$r$ 项循环置换（或长为 $r$ 的轮换）&lt;/strong&gt;，记作：
$$\sigma = (j_1\ j_2\ \dots\ j_r)$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;长为 2 的轮换称为&lt;strong&gt;对换（Transposition）&lt;/strong&gt;，记作 $(a\ b)$。&lt;/li&gt;
&lt;li&gt;若两个轮换包含变动的数字完全无交集，称它们&lt;strong&gt;互不相交（Disjoint）&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;2.2 不相交轮换的可交换性&lt;/h5&gt;
&lt;h6&gt;定理 6.2&lt;/h6&gt;
&lt;p&gt;若 $\alpha, \beta \in S_n$ 是两个互不相交的循环置换，则它们可以交换次序：
$$\alpha \beta = \beta \alpha$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $\alpha$ 变动的数字集合为 $A$，$\beta$ 变动的数字集合为 $B$。已知 $A \cap B = \emptyset$。
对任意 $x \in {1, 2, \dots, n}$ 逐点讨论：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $x \in A$：因 $A \cap B = \emptyset$，故 $x \notin B$，得 $\beta(x) = x$。
从而 $(\alpha \beta)(x) = \alpha(\beta(x)) = \alpha(x)$。
又因 $\alpha(x) \in A$，故 $\alpha(x) \notin B$，得 $\beta(\alpha(x)) = \alpha(x)$。
因此 $(\alpha \beta)(x) = (\beta \alpha)(x) = \alpha(x)$。&lt;/li&gt;
&lt;li&gt;若 $x \in B$：同理可得 $(\alpha \beta)(x) = (\beta \alpha)(x) = \beta(x)$。&lt;/li&gt;
&lt;li&gt;若 $x \notin A$ 且 $x \notin B$：则 $\alpha(x) = x, \beta(x) = x$，显然 $(\alpha \beta)(x) = (\beta \alpha)(x) = x$。
综上，对所有元素均有 $(\alpha \beta)(x) = (\beta \alpha)(x)$，故 $\alpha \beta = \beta \alpha$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;2.3 不相交轮换分解定理与置换的阶&lt;/h5&gt;
&lt;h6&gt;定理 6.3（不相交轮换分解定理）&lt;/h6&gt;
&lt;p&gt;任何一个有限置换 $\sigma \in S_n$ 都可以唯一地表示为若干个互不相交且长度均 $\ge 2$ 的循环置换之积（在不计因式乘法先后次序的意义下）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;存在性&lt;/strong&gt;：对置换 $\sigma$ 实际变动的元素个数 $t = |{x \mid \sigma(x) \ne x}|$ 施加数学归纳法。
&lt;ul&gt;
&lt;li&gt;当 $t = 0$ 时，$\sigma = I$ 为恒等置换（空乘积），命题成立。&lt;/li&gt;
&lt;li&gt;假设变动元素个数 $&amp;lt; s$（$s \ge 1$）的所有置换均能分解为互不相交循环之积。&lt;/li&gt;
&lt;li&gt;考虑变动元素个数为 $s$ 的置换 $\sigma$。取变动元素 $j_1$，考察轨道序列 $j_1, \sigma(j_1), \sigma^2(j_1), \dots$。因集合有限，该序列必有重复项。设第一个满足 $\sigma^r(j_1) \in {j_1, \sigma(j_1), \dots, \sigma^{r-1}(j_1)}$ 的正整数为 $r$。&lt;/li&gt;
&lt;li&gt;若 $\sigma^r(j_1) = \sigma^i(j_1)$（$0 &amp;lt; i &amp;lt; r$），由单射性两边作用 $\sigma^{-1}$ 得 $\sigma^{r-1}(j_1) = \sigma^{i-1}(j_1)$，与 $r$ 的最小性矛盾。因此必有 $\sigma^r(j_1) = j_1$。&lt;/li&gt;
&lt;li&gt;定义循环 $\tau_1 = (j_1\ \sigma(j_1)\ \dots\ \sigma^{r-1}(j_1))$。令 $\sigma_1 = \sigma \tau_1^{-1}$，则 $\sigma_1$ 在 ${j_1, \dots, \sigma^{r-1}(j_1)}$ 上恒等，实际变动元素个数为 $s - r &amp;lt; s$。&lt;/li&gt;
&lt;li&gt;由归纳假设，$\sigma_1$ 可分解为与 $\tau_1$ 均不相交的循环之积 $\tau_2 \cdots \tau_k$。故 $\sigma = \tau_1 \tau_2 \cdots \tau_k$。存在性得证。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;唯一性&lt;/strong&gt;：设 $\sigma = \tau_1 \cdots \tau_k = \rho_1 \cdots \rho_m$ 为两组互不相交循环之积（每项长 $\ge 2$）。
任取变动元素 $x$。在第一组分解中，$x$ 恰好属于唯一的循环（不妨设为 $\tau_1$），且对所有整数 $d$ 有 $\sigma^d(x) = \tau_1^d(x)$。
在第二组分解中，$x$ 也必属于唯一的循环（不妨设为 $\rho_1$），同理对所有整数 $d$ 有 $\sigma^d(x) = \rho_1^d(x)$。
因此 $\tau_1$ 与 $\rho_1$ 的轨道集合都是 ${\sigma^d(x) \mid d \ge 0}$，且其在循环中的轮换作用完全由 $\sigma$ 在该轨道上的映射确定。故 $\tau_1$ 与 $\rho_1$ 作为置换完全相等（至多循环内部起点写法不同）。
两边消去 $\tau_1 = \rho_1$ 并对变动元素集合重复上述论证，最终可得 $k = m$ 且两组循环因子集合完全一致。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h6&gt;定理 6.4（置换求阶公式）&lt;/h6&gt;
&lt;p&gt;设置换 $\sigma$ 分解为互不相交循环之积 $\sigma = \tau_1 \tau_2 \cdots \tau_k$，其中各循环的长度分别为 $r_1, r_2, \dots, r_k$。则置换 $\sigma$ 的阶为：
$$\operatorname{ord}(\sigma) = \operatorname{lcm}(r_1, r_2, \dots, r_k)$$&lt;/p&gt;
&lt;p&gt;约定空列表的 LCM 为 1，对应恒等置换的阶。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
因各循环 $\tau_i$ 互不相交，由定理 6.2 它们两两可交换。
因此对任意正整数 $m$：$\sigma^m = \tau_1^m \tau_2^m \cdots \tau_k^m$。
又因各循环作用的变动集合互不相交，$\sigma^m = I \iff \forall i \in {1, \dots, k}, \tau_i^m = I$。
单个长为 $r_i$ 的循环其阶等于长度 $r_i$，即 $\operatorname{ord}(\tau_i) = r_i$。
由阶的整除性质，$\tau_i^m = I \iff r_i \mid m$。
使得所有 $r_i \mid m$ 成立的最小正整数 $m$ 即为最小公倍数 $\operatorname{lcm}(r_1, \dots, r_k)$。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;3. 对换、奇偶置换与交代群 $A_n$&lt;/h4&gt;
&lt;h5&gt;3.1 任意置换的对换分解&lt;/h5&gt;
&lt;h6&gt;定理 6.5&lt;/h6&gt;
&lt;p&gt;当 $n \ge 2$ 时，任何置换都可以表示为有限个对换的乘积。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
由定理 6.3，只需证明任意轮换均能分解为对换之积即可。
直接验证公式：
$$(j_1\ j_2\ \dots\ j_r) = (j_1\ j_r)(j_1\ j_{r-1}) \cdots (j_1\ j_3)(j_1\ j_2)$$
从右向左依次复合追踪各元素：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$j_1 \mapsto j_2$（最右侧对换将 $j_1$ 变到 $j_2$，其余对换均不动 $j_2$）；&lt;/li&gt;
&lt;li&gt;$j_k \mapsto j_1 \mapsto j_{k+1}$（第 $k-1$ 个对换将 $j_k$ 变到 $j_1$，紧接着第 $k$ 个对换将 $j_1$ 变到 $j_{k+1}$）；&lt;/li&gt;
&lt;li&gt;$j_r \mapsto j_1$（最左侧对换将 $j_r$ 变到 $j_1$）。
映射结果与 $(j_1\ j_2\ \dots\ j_r)$ 完全相同。一个长为 $r$ 的循环可分解为 $r - 1$ 个对换。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h5&gt;3.2 对换个数奇偶性不变量定理&lt;/h5&gt;
&lt;p&gt;置换分解为对换的乘积方式并不唯一，但分解所得对换个数的奇偶性是客观不变量。&lt;/p&gt;
&lt;h6&gt;定理 6.6（对换奇偶性不变量定理）&lt;/h6&gt;
&lt;p&gt;设置换 $\sigma \in S_n$。若 $\sigma$ 既能表示为 $k$ 个对换之积，又能表示为 $m$ 个对换之积，则 $k \equiv m \pmod 2$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
考虑 $n$ 元多项式（差分多项式）：
$$\Delta(x_1, x_2, \dots, x_n) = \prod_{1 \le i &amp;lt; j \le n} (x_j - x_i)$$
对任意置换 $\sigma \in S_n$，定义其对多项式的变量置换作用为：
$$\sigma(\Delta) = \prod_{1 \le i &amp;lt; j \le n} (x_{\sigma(j)} - x_{\sigma(i)})$$
因 $\sigma$ 为双射，${ {\sigma(i), \sigma(j)} \mid 1 \le i &amp;lt; j \le n }$ 遍历了全集合的所有两元子集。故乘积中的每一个因子 $x_{\sigma(j)} - x_{\sigma(i)}$ 在绝对值上对应原本的某个因子 $x_q - x_p$（$p &amp;lt; q$），仅差符号。
因此必存在常数 $c_\sigma \in {1, -1}$，使得 $\sigma(\Delta) = c_\sigma \Delta$。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性质&lt;/strong&gt;：对任意 $\sigma, \tau \in S_n$：
$$(\sigma \tau)(\Delta) = \sigma(\tau(\Delta)) = \sigma(c_\tau \Delta) = c_\tau \sigma(\Delta) = c_\tau c_\sigma \Delta = (c_\sigma c_\tau) \Delta$$
因此 $c_{\sigma \tau} = c_\sigma c_\tau$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;计算单个对换的符号常数&lt;/strong&gt;：
考虑任意对换 $\rho = (s\ t)$（设 $1 \le s &amp;lt; t \le n$）。考察乘积中各因式 $(x_j - x_i)$（$i &amp;lt; j$）在 $\rho$ 作用下的符号变化：
&lt;ul&gt;
&lt;li&gt;若 ${i, j} \cap {s, t} = \emptyset$，因子不变；&lt;/li&gt;
&lt;li&gt;对因子 $(x_t - x_s)$，作用后变为 $x_s - x_t = -(x_t - x_s)$，符号反转一次；&lt;/li&gt;
&lt;li&gt;对满足 $s &amp;lt; k &amp;lt; t$ 的每个 $k$：
因子 $x_k - x_s$ 变为 $x_k - x_t = -(x_t - x_k)$；
因子 $x_t - x_k$ 变为 $x_s - x_k = -(x_k - x_s)$；
这两个因子均反号，其乘积不变号；这样的中间元素共有 $t - s - 1$ 个，产生 $2(t - s - 1)$ 次变号；&lt;/li&gt;
&lt;li&gt;对 $k &amp;lt; s$ 或 $k &amp;gt; t$ 的元素，同样成对保持符号不变。
综上，受对换 $\rho$ 作用反号的因子总数为 $1 + 2(t - s - 1)$，恒为奇数。
因此对任意对换 $\rho$，均有 $c_\rho = -1$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;完成证明&lt;/strong&gt;：
若 $\sigma = \tau_1 \tau_2 \cdots \tau_k = \rho_1 \rho_2 \cdots \rho_m$（各 $\tau_i, \rho_j$ 均为对换），则：
$$c_\sigma = (-1)^k = (-1)^m$$
从而 $(-1)^k = (-1)^m \implies k \equiv m \pmod 2$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;3.3 奇偶置换与交代群 $A_n$&lt;/h5&gt;
&lt;h6&gt;定义 6.7&lt;/h6&gt;
&lt;ul&gt;
&lt;li&gt;能表示为&lt;strong&gt;偶数个&lt;/strong&gt;对换之积的置换称为&lt;strong&gt;偶置换&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;能表示为&lt;strong&gt;奇数个&lt;/strong&gt;对换之积的置换称为&lt;strong&gt;奇置换&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;由定理 6.5，长为 $r$ 的循环可分解为 $r - 1$ 个对换。因此：长度为奇数的循环是偶置换，长度为偶数的循环是奇置换。&lt;/li&gt;
&lt;/ul&gt;
&lt;h6&gt;定理 6.8（交代群的子群性质与阶数）&lt;/h6&gt;
&lt;p&gt;$S_n$ 中全体偶置换构成的集合关于置换乘法构成一个群，称为 &lt;strong&gt;$n$ 次交代群（Alternating Group）&lt;/strong&gt;，记作 $A_n$。
当 $n \ge 2$ 时，其阶数为：
$$|A_n| = \frac{n!}{2}$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;子群性质&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;单位元 $I$ 是零个对换的乘积（空乘积），故 $I \in A_n$。&lt;/li&gt;
&lt;li&gt;设 $\sigma$ 含偶数 $2k$ 个对换，$\tau$ 含偶数 $2m$ 个对换，则 $\sigma\tau$ 含 $2k + 2m$ 个对换，仍为偶数，故封闭。&lt;/li&gt;
&lt;li&gt;$\sigma^{-1} = (\tau_1 \cdots \tau_{2k})^{-1} = \tau_{2k} \cdots \tau_1$ 包含 $2k$ 个对换，故 $\sigma^{-1} \in A_n$。因此 $A_n \le S_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;阶数证明&lt;/strong&gt;：
设 $S_n$ 中全体奇置换构成的集合为 $B_n$。固定对换 $\rho = (1\ 2)$。
定义映射 $f: A_n \to B_n, f(\sigma) = \rho \sigma$。
&lt;ul&gt;
&lt;li&gt;偶置换左乘一个对换变为奇置换，映射良定。&lt;/li&gt;
&lt;li&gt;单射性：若 $\rho \sigma_1 = \rho \sigma_2$，左乘 $\rho^{-1}$ 即得 $\sigma_1 = \sigma_2$。&lt;/li&gt;
&lt;li&gt;满射性：对任意 $\mu \in B_n$，$\rho \mu$ 为偶置换（$\rho \mu \in A_n$），且 $f(\rho \mu) = \rho^2 \mu = \mu$。
故 $f$ 是双射，从而 $|A_n| = |B_n|$。
又因 $S_n = A_n \cup B_n$ 且 $A_n \cap B_n = \emptyset$，故 $|A_n| + |B_n| = n! \implies |A_n| = \frac{n!}{2}$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;4. 3-轮换生成交代群定理&lt;/h4&gt;
&lt;h6&gt;定理 6.9&lt;/h6&gt;
&lt;p&gt;当 $n \ge 3$ 时，$n$ 次交代群 $A_n$ 是由全体 3-轮换生成的：
$$A_n = \langle (a\ b\ c) \mid a, b, c \in {1, 2, \dots, n} \rangle$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
任取 $\sigma \in A_n$。由偶置换定义，$\sigma$ 可以分解为偶数个对换的乘积：
$$\sigma = (\tau_1 \tau_2)(\tau_3 \tau_4) \cdots (\tau_{2k-1} \tau_{2k})$$
只需证明：&lt;strong&gt;任意两个对换的乘积 $\tau \rho$ 均可表示为 3-轮换或其乘积&lt;/strong&gt;。
设 $\tau = (a\ b), \rho = (c\ d)$。按涉及的互异元素个数分类讨论：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;重叠 2 个元素&lt;/strong&gt;（对换相同）：
$$(a\ b)(a\ b) = I = (a\ b\ c)(a\ c\ b)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;重叠 1 个元素&lt;/strong&gt;（不妨设公共元素为 $a$）：
从右向左复合验证：
$$(a\ b)(a\ c) = (a\ c\ b)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;重叠 0 个元素&lt;/strong&gt;（4 个元素 $a, b, c, d$ 互不相同）：
在中间插入 $(b\ c)(b\ c) = I$：
$$(a\ b)(c\ d) = (a\ b) \cdot [(b\ c)(b\ c)] \cdot (c\ d) = [(a\ b)(b\ c)] \cdot [(b\ c)(c\ d)]$$
利用情况 2 的结论：$[(a\ b)(b\ c)] = (a\ b\ c)$，$[(b\ c)(c\ d)] = (b\ c\ d)$。
因此：
$$(a\ b)(c\ d) = (a\ b\ c)(b\ c\ d)$$
为两个 3-轮换之积。
综合上述三种情形，任意两个对换之积均可表示为 3-轮换之积，故全体 3-轮换生成 $A_n$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;5. 置换的共轭与循环型&lt;/h4&gt;
&lt;h5&gt;5.1 置换共轭的作用形式&lt;/h5&gt;
&lt;h6&gt;定理 6.10（置换共轭公式）&lt;/h6&gt;
&lt;p&gt;设 $\sigma = (i_1\ i_2\ \dots\ i_r)$ 是 $S_n$ 中的一个 $r$-循环，$\tau \in S_n$ 是任意置换。则共轭置换 $\tau \sigma \tau^{-1}$ 仍然是长为 $r$ 的循环，且形式为：
$$\tau \sigma \tau^{-1} = (\tau(i_1)\ \tau(i_2)\ \dots\ \tau(i_r))$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
对任意 $x \in {1, \dots, n}$ 计算 $(\tau \sigma \tau^{-1})(x)$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $x = \tau(i_k)$（$1 \le k \le r$）：
&lt;ul&gt;
&lt;li&gt;第一步：$\tau^{-1}(x) = i_k$；&lt;/li&gt;
&lt;li&gt;第二步：$\sigma(i_k) = i_{k+1}$（约定 $k=r$ 时下一项为 $i_1$）；&lt;/li&gt;
&lt;li&gt;第三步：$\tau(i_{k+1})$。
连起来得到 $(\tau \sigma \tau^{-1})(\tau(i_k)) = \tau(i_{k+1})$。这与循环 $(\tau(i_1)\ \dots\ \tau(i_r))$ 在元素 $\tau(i_k)$ 上的映射一致。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;若 $x \notin {\tau(i_1), \dots, \tau(i_r)}$：
则 $\tau^{-1}(x) \notin {i_1, \dots, i_r}$。
由定义 $\sigma(\tau^{-1}(x)) = \tau^{-1}(x)$。
再由左侧 $\tau$ 作用得 $\tau(\tau^{-1}(x)) = x$。即该元素保持不动。
综合两类情形，公式成立。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;5.2 循环型与共轭类分类定理&lt;/h5&gt;
&lt;p&gt;置换的不相交循环长度序列（包含长为 1 的不动点循环）称为该置换的&lt;strong&gt;循环型（Cycle Type）&lt;/strong&gt;。&lt;/p&gt;
&lt;h6&gt;定理 6.11（共轭类与循环型充要条件）&lt;/h6&gt;
&lt;p&gt;在对称群 $S_n$ 中，两个置换 $\sigma, \sigma&apos;$ 共轭当且仅当它们具有相同的循环型。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;必要性&lt;/strong&gt;：设存在 $\tau \in S_n$ 使得 $\sigma&apos; = \tau \sigma \tau^{-1}$。
将 $\sigma$ 写为不相交循环之积 $\sigma = \pi_1 \pi_2 \cdots \pi_k$。
由定理 6.10，$\sigma&apos; = \tau \pi_1 \tau^{-1} \cdot \tau \pi_2 \tau^{-1} \cdots \tau \pi_k \tau^{-1}$。
因 $\tau$ 是双射，每个循环 $\tau \pi_j \tau^{-1}$ 的长度与 $\pi_j$ 完全相同，且变动元素集合两两不相交。
故 $\sigma&apos;$ 与 $\sigma$ 具有完全相同的循环型。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性&lt;/strong&gt;：设 $\sigma$ 与 $\sigma&apos;$ 具有相同的循环型。
将两者的不相交循环分解（包括长度为 1 的不动点）按循环长度从大到小依次写出：
$$\sigma = (a_{1,1}\ \dots\ a_{1, r_1})(a_{2,1}\ \dots\ a_{2, r_2}) \cdots (a_{m,1}\ \dots\ a_{m, r_m})$$
$$\sigma&apos; = (b_{1,1}\ \dots\ b_{1, r_1})(b_{2,1}\ \dots\ b_{2, r_2}) \cdots (b_{m,1}\ \dots\ b_{m, r_m})$$
其中 $\sum_{i=1}^m r_i = n$，且 ${a_{i,j}}$ 与 ${b_{i,j}}$ 分别构成了集合 ${1, 2, \dots, n}$ 的完整排列。
定义映射 $\tau: {1, \dots, n} \to {1, \dots, n}$ 为：
$$\tau(a_{i, j}) = b_{i, j} \quad (1 \le i \le m, 1 \le j \le r_i)$$
因 $\tau$ 将全集的一个全排列映为另一个全排列，故 $\tau$ 是双射，$\tau \in S_n$。
由定理 6.10：
$$\tau \sigma \tau^{-1} = (\tau(a_{1,1})\ \dots\ \tau(a_{1, r_1})) \cdots (\tau(a_{m,1})\ \dots\ \tau(a_{m, r_m})) = \sigma&apos;$$
故 $\sigma$ 与 $\sigma&apos;$ 在 $S_n$ 中共轭。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;6. 【选读】单群与 $A_5$ 的单群性&lt;/h4&gt;
&lt;h5&gt;6.1 单群（Simple Group）的定义&lt;/h5&gt;
&lt;p&gt;如果非平凡群 $G\ne{e}$ 除了平凡子群 ${e}$ 和其自身 $G$ 之外，&lt;strong&gt;不存在任何其他正规子群&lt;/strong&gt;，则称群 $G$ 为&lt;strong&gt;单群（Simple Group）&lt;/strong&gt;。&lt;/p&gt;
&lt;h5&gt;6.2 交代群 $A_5$ 的单群性（依赖群作用与共轭类划分）&lt;/h5&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;依赖声明&lt;/strong&gt;：本小节引用 $A_5$ 的完整共轭类分解 $1, 15, 20, 12, 12$（包括 3-轮换、双对换各自形成单个 $A_5$ 共轭类，以及 5-轮换分裂）作为外部结论。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h6&gt;结论 6.12&lt;/h6&gt;
&lt;p&gt;5 次交代群 $A_5$（阶数为 60）是一个单群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;推导过程：&lt;/strong&gt;
设 $N \triangleleft A_5$ 为正规子群。正规子群对共轭运算封闭，因此 $N$ 必定是由 $A_5$ 内部若干个完整的共轭类构成的并集，且必须包含单位元类。
$A_5$ 中 60 个元素划分为 5 个共轭类：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;单位元类 $C_1$：大小为 $1$；&lt;/li&gt;
&lt;li&gt;双对换类 $C_{2,2}$（形如 $(a\ b)(c\ d)$）：大小为 $\frac{\binom{5}{4} \times 3}{1} = 15$；&lt;/li&gt;
&lt;li&gt;3-轮换类 $C_3$（形如 $(a\ b\ c)$）：大小为 $\binom{5}{3} \times 2 = 20$；&lt;/li&gt;
&lt;li&gt;5-轮换类在 $A_5$ 中分裂为两个类 $C_5&apos;, C_5&apos;&apos;$：大小各为 $12$。
总计：$1 + 15 + 20 + 12 + 12 = 60$。
若存在正规子群 $N$，其阶数 $|N|$ 必须满足以下两个条件：&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;$|N| = 1 + 15 a + 20 b + 12 c + 12 d$（其中 $a, b, c, d \in {0, 1}$）；&lt;/li&gt;
&lt;li&gt;由 Lagrange 定理，$|N| \mid 60$。
逐一检查所有非空选择组合的和：&lt;/li&gt;
&lt;li&gt;取 1 个非单位元类：$1+12=13, 1+15=16, 1+20=21$，均不能整除 60；&lt;/li&gt;
&lt;li&gt;取 2 个非单位元类：$1+12+12=25, 1+12+15=28, 1+12+20=33, 1+15+20=36$，均不能整除 60；&lt;/li&gt;
&lt;li&gt;取 3 个非单位元类：$1+12+12+15=40, 1+12+12+20=45, 1+12+15+20=48$，均不能整除 60；&lt;/li&gt;
&lt;li&gt;取 4 个非单位元类（全选）：$1+12+12+15+20=60$，对应全群 $N = A_5$；&lt;/li&gt;
&lt;li&gt;不取非单位元类：$|N|=1$，对应平凡子群 $N={e}$。
因此 $A_5$ 不存在非平凡正规子群，$A_5$ 必为单群。
（注：更一般的群论结果表明当 $n \ge 5$ 时 $A_n$ 均为单群，该性质在伽罗瓦理论中与代数方程的可解性相关，属于后续群论内容。）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;7. 自同构群与内自同构群&lt;/h4&gt;
&lt;h5&gt;7.1 内自同构的严格定义与验证&lt;/h5&gt;
&lt;h6&gt;定理 6.13&lt;/h6&gt;
&lt;p&gt;设 $G$ 是群。对固定元素 $g \in G$，定义映射：
$$\sigma_g: G \to G, \quad \sigma_g(x) = g x g^{-1} \quad (\forall x \in G)$$
则 $\sigma_g$ 是群 $G$ 的一个自同构（$\sigma_g \in \operatorname{Aut}(G)$），称为由 $g$ 诱导的&lt;strong&gt;内自同构（Inner Automorphism）&lt;/strong&gt;。
全体内自同构构成的集合记作 $\operatorname{Inn}(G) = {\sigma_g \mid g \in G}$，它是自同构群 $\operatorname{Aut}(G)$ 的子群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：
$$\sigma_g(xy) = g(xy)g^{-1} = g x (g^{-1} g) y g^{-1} = (g x g^{-1})(g y g^{-1}) = \sigma_g(x)\sigma_g(y)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射&lt;/strong&gt;：若 $\sigma_g(x) = \sigma_g(y) \implies g x g^{-1} = g y g^{-1}$。两边左乘 $g^{-1}$、右乘 $g$，得 $x = y$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射&lt;/strong&gt;：对任意 $y \in G$，取 $x = g^{-1} y g \in G$，则 $\sigma_g(x) = g(g^{-1}yg)g^{-1} = y$。
故 $\sigma_g$ 是双射同态，$\sigma_g \in \operatorname{Aut}(G)$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;7.2 内自同构群与群中心的商群同构&lt;/h5&gt;
&lt;h6&gt;定理 6.14&lt;/h6&gt;
&lt;p&gt;设 $G$ 是群，$Z(G)$ 是群的中心。则：
$$G/Z(G) \cong \operatorname{Inn}(G)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
构造映射：
$$\Psi: G \to \operatorname{Inn}(G), \quad \Psi(g) = \sigma_g$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：对任意 $g, h \in G$ 及 $x \in G$：
$$\sigma_{gh}(x) = (gh)x(gh)^{-1} = g(hxh^{-1})g^{-1} = \sigma_g(\sigma_h(x)) = (\sigma_g \circ \sigma_h)(x)$$
由映射相等的定义，$\sigma_{gh} = \sigma_g \circ \sigma_h$，即 $\Psi(gh) = \Psi(g)\Psi(h)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：由 $\operatorname{Inn}(G)$ 的定义，每个内自同构均形如 $\sigma_g = \Psi(g)$，故 $\Psi$ 是满同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求解同态核 $\operatorname{Ker}\Psi$&lt;/strong&gt;：
$\operatorname{Aut}(G)$ 的单位元是恒等变换 $I_G$。
$$\operatorname{Ker}\Psi = {g \in G \mid \Psi(g) = I_G} = {g \in G \mid \sigma_g = I_G}$$
$$\sigma_g = I_G \iff \forall x \in G, gxg^{-1} = x \iff \forall x \in G, gx = xg$$
与群中每个元素均可交换的元素集合正是群中心 $Z(G)$。因此：
$$\operatorname{Ker}\Psi = Z(G)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;应用第一同构定理&lt;/strong&gt;：
由定理 5.1（第一同构定理），自然诱导同构：
$$G/\operatorname{Ker}\Psi \cong \operatorname{Im}\Psi \implies G/Z(G) \cong \operatorname{Inn}(G) \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;8. 凯莱定理（Cayley&apos;s Theorem）&lt;/h4&gt;
&lt;h5&gt;8.1 严格表述&lt;/h5&gt;
&lt;h6&gt;定理 6.15（Cayley 定理）&lt;/h6&gt;
&lt;p&gt;任何群 $G$ 都与集合 $G$ 上的一个变换群同构。
特别地，任何 $n$ 阶有限群都同构于 $n$ 次对称群 $S_n$ 的某个子群（即同构于一个置换群）。&lt;/p&gt;
&lt;h5&gt;8.2 形式化证明&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $G$ 是群，$E(G)$ 是集合 $G$ 到自身的全体双射构成的群。
对任意 $a \in G$，定义左乘变换：
$$L_a: G \to G, \quad L_a(x) = ax \quad (\forall x \in G)$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;验证 $L_a \in E(G)$（$L_a$ 是双射）&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;单射：若 $L_a(x_1) = L_a(x_2) \implies ax_1 = ax_2 \implies x_1 = x_2$（群消去律）。&lt;/li&gt;
&lt;li&gt;满射：对任意 $y \in G$，取 $x = a^{-1}y \in G$，则 $L_a(x) = a(a^{-1}y) = y$。
故 $L_a$ 为双射，$L_a \in E(G)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;构造映射&lt;/strong&gt;：
定义 $\Phi: G \to E(G)$ 为 $\Phi(a) = L_a$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;验证 $\Phi$ 是群同态&lt;/strong&gt;：
任取 $a, b \in G$。对任意 $x \in G$：
$$(L_a \circ L_b)(x) = L_a(L_b(x)) = L_a(bx) = a(bx) = (ab)x = L_{ab}(x)$$
因此 $L_a \circ L_b = L_{ab}$，即 $\Phi(a) \circ \Phi(b) = \Phi(ab)$，$\Phi$ 为群同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;验证 $\Phi$ 是单同态&lt;/strong&gt;：
考察同态核：
$$\operatorname{Ker}\Phi = {a \in G \mid \Phi(a) = I_G} = {a \in G \mid L_a = I_G}$$
若 $L_a = I_G$，则对所有 $x \in G$ 均有 $ax = x$。
特别取 $x = e$，得 $ae = e \implies a = e$。
故 $\operatorname{Ker}\Phi = {e}$，由定理 4.7，$\Phi$ 为单同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;得出同构结论&lt;/strong&gt;：
$\Phi$ 在其同态像 $\bar{G} = \operatorname{Im}\Phi = {L_a \mid a \in G} \le E(G)$ 上构成双射同态。
因此：
$$G \cong \bar{G} \le E(G) \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h5&gt;8.3 左乘与右乘的区别&lt;/h5&gt;
&lt;p&gt;若定义右乘变换 $R_a(x) = xa$，计算复合映射：
$$(R_a \circ R_b)(x) = R_a(R_b(x)) = R_a(xb) = (xb)a = x(ba) = R_{ba}(x)$$
若群为非交换群，存在 $ab \ne ba$，则 $R_a \circ R_b = R_{ba} \ne R_{ab}$。该映射反转了运算次序，构成了反同态。
若定义带逆元的右侧作用 $R&apos;_a(x) = x a^{-1}$，则 $(R&apos;_a \circ R&apos;&lt;em&gt;b)(x) = (x b^{-1}) a^{-1} = x (b^{-1} a^{-1}) = x (ab)^{-1} = R&apos;&lt;/em&gt;{ab}(x)$，同样可构成群同态。&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;9. 核心易错点&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;置换复合次序&lt;/strong&gt;：代数计算约定为 $(\sigma\tau)(x) = \sigma(\tau(x))$ 从右向左复合计算，避免按矩阵书写顺序从左向右读取。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;长循环分解为对换&lt;/strong&gt;：$r$-循环 $(j_1\ j_2\ \dots\ j_r)$ 分解为 $r-1$ 个对换 $(j_1\ j_r)(j_1\ j_{r-1}) \cdots (j_1\ j_2)$，不能拆分成独立的两个非重叠对换。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;借桥分解的元素对应&lt;/strong&gt;：在将两个不相交对换 $(a\ b)(c\ d)$ 改写为 3-轮换乘积时，借助恒等式 $(a\ b)(c\ d) = (a\ b\ c)(b\ c\ d)$，需注意元素排列顺序。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单群的同态像&lt;/strong&gt;：单群没有非平凡正规子群，因此任何从单群出发的群同态，其核要么为 ${e}$（此时为单同态），要么为全群（此时像为平凡群 ${e&apos;}$）。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;10. 前后知识连接&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：群公理（&lt;code&gt;01-群与子群.md&lt;/code&gt;）、Lagrange 定理与商群（&lt;code&gt;03-陪集-Lagrange-正规子群.md&lt;/code&gt;）、第一同构定理（&lt;code&gt;05-三大同构定理.md&lt;/code&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;Cayley 定理证明了置换群可作为有限群的具体模型。&lt;/li&gt;
&lt;li&gt;循环分解与置换求阶是算法竞赛中置换环分析、快速幂及 Burnside/Pólya 计数（&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;）的基础。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-12-9&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;12.9 易错点与证明套路&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：定义、定理、证明与例题。&lt;/p&gt;
&lt;h3&gt;90-易错点与证明套路&lt;/h3&gt;
&lt;h4&gt;1. 经典概念易错点复盘&lt;/h4&gt;
&lt;h5&gt;易错点 1：置换复合运算的读取方向&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：计算 $\sigma\tau$ 时，先看 $\sigma$ 把数字变到哪里，再看 $\tau$ 把结果变到哪里（从左往右计算）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：置换乘法本质是&lt;strong&gt;函数的复合&lt;/strong&gt;，公式定义为：
$$(\sigma\tau)(x) = \sigma(\tau(x))$$
右侧置换 $\tau$ 先作用，左侧置换 $\sigma$ 后作用。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 2：循环记号与对换拆分的混淆&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：看到长为 4 的轮换 $(1\ 3\ 5\ 2)$，错误拆成两个对换 $(1\ 3)(5\ 2)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;$(1\ 3)(5\ 2)$ 是两个互不相交的 2-循环之积，表示 1 与 3 互换、5 与 2 互换；&lt;/li&gt;
&lt;li&gt;$(1\ 3\ 5\ 2)$ 是长为 4 的单一大轮换，拆成对换必须用标准公式：
$$(j_1\ j_2\ \dots\ j_r) = (j_1\ j_r)(j_1\ j_{r-1})\cdots(j_1\ j_2)$$
长为 4 的循环拆成对换需要 $4 - 1 = 3$ 个对换：$(1\ 2)(1\ 5)(1\ 3)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 3：循环长度与奇偶置换的对应关系&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：误以为“3-循环是奇置换，4-循环是偶置换”。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;长为 $r$ 的循环可分解为 $r-1$ 个对换；&lt;/li&gt;
&lt;li&gt;3-循环分解为 $3-1 = 2$ 个对换，属于&lt;strong&gt;偶置换&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;4-循环分解为 $4-1 = 3$ 个对换，属于&lt;strong&gt;奇置换&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;2-循环（对换）分解为 $2-1 = 1$ 个对换，属于&lt;strong&gt;奇置换&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 4：不相交对换改写为 3-轮换时的元素对齐&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：拆分两个无交集的对换 $(1\ 3)(2\ 4)$ 时，顺序写反导致映射不一致。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;标准改写公式&lt;/strong&gt;：
$$(a\ b)(c\ d) = [(a\ b)(b\ c)] \cdot [(b\ c)(c\ d)] = (a\ b\ c)(b\ c\ d)$$
插入中间项 $(b\ c)(b\ c) = I$ 后，从右向左复合需确保公共元素顺序对应。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 5：素数阶群与循环群元素阶的表述&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：认为“素数阶群中每个元素的阶都与群阶互质”。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;在有限群中，每个元素的阶必须是群阶的因数（Lagrange 定理推论）；&lt;/li&gt;
&lt;li&gt;若群阶为素数 $p$，其正因数只有 $1$ 和 $p$；&lt;/li&gt;
&lt;li&gt;除了单位元（阶为 1）外，其余所有非单位元的阶均等于 $p$，从而每个非单位元都能生成该群。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 6：群同构时单位元的对应&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：复数乘法群 $U_4 = {1, i, -1, -i}$ 同构于 $(\mathbb{Z}_4, +)$ 时，误认为乘法单位元 $1$ 对应加法群里的元素 $1$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：同构映射必须保持单位元性质（$f(e) = e&apos;$）。
&lt;ul&gt;
&lt;li&gt;乘法群 $U_4$ 的单位元是复数 $1$；&lt;/li&gt;
&lt;li&gt;加法群 $(\mathbb{Z}_4, +)$ 的单位元是剩余类 $[0]$；&lt;/li&gt;
&lt;li&gt;故必须有 $f(1) = [0]$，生成元 $i$ 对应生成元 $[1]$（或 $[3]$）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 7：商群乘法良定性的验证&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：定义商群乘法 $(aN)(bN) = (ab)N$ 时，认为该运算显然封闭且无需验证良定性。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：陪集由代表元给出，若选择不同代表元 $a_1 \in aN, b_1 \in bN$，乘积代表元 $a_1 b_1$ 是否仍落在 $(ab)N$ 中，依赖于正规性 $N \triangleleft G$。若 $N$ 不是正规子群，该二元运算在陪集集合上不良定。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 8：Lagrange 定理逆命题不成立&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：看到群阶能被 $d$ 整除，就断定群内必有 $d$ 阶子群。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：Lagrange 定理仅给出子群阶必须整除群阶的必要条件。典型反例为 12 阶的交代群 $A_4$，它没有 6 阶子群。只有在有限循环群中，群阶的每个正因数才对应唯一的子群。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 9：右乘变换诱导同构的反同态问题&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：定义右乘映射 $R_a(x) = xa$，并直接断言 $a \mapsto R_a$ 给出群同构。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：在非交换群中，$(R_a \circ R_b)(x) = xba = R_{ba}(x) \ne R_{ab}(x)$，乘法次序被颠倒，构成反同态。必须使用左乘 $L_a(x) = ax$，或定义带逆元的右乘 $R&apos;_a(x) = x a^{-1}$ 才能构成同态。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h5&gt;易错点 10：子群链指数公式（塔式法则）不需正规性假设&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：误以为 $[G:K] = [G:H][H:K]$ 必须假设 $H$ 或 $K$ 为正规子群。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：塔式法则仅需子群包含关系 $K \le H \le G$，其证明直接来自陪集的细分与双射配对，不依赖正规性。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 核心证明推导模板&lt;/h4&gt;
&lt;h5&gt;模板 1：子群一步判定法&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明非空子集 $H \subseteq G$ 是群 $G$ 的子群（$H \le G$）。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. [非空性]：指出单位元 e ∈ H，说明 H ≠ ∅。
2. [任取元]：任取 a, b ∈ H。
3. [算复合]：计算乘积 ab⁻¹（加法群中为 a - b）。
4. [落回集]：利用 H 的定义条件或已知性质，推导出 ab⁻¹ ∈ H。
   根据子群判定定理，得出 H ≤ G。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h5&gt;模板 2：第一同构定理构建商群同构&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明商群 $G/N \cong G&apos;$。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. [构造映射]：构造从群 G 到目标群 G&apos; 的映射 f: G → G&apos;。
2. [验证满同态]：
   - 证明同态性：f(ab) = f(a)f(b)；
   - 证明满射性：对任意 y ∈ G&apos;，证明存在 x ∈ G 使得 f(x) = y。
3. [求解同态核]：
   Ker(f) = {x ∈ G | f(x) = e&apos;}。
   根据同态核定义解方程，证明 Ker(f) = N。
4. [应用定理]：
   由第一同构定理，得出 N ◁ G 且 G/N ≅ G&apos;。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h5&gt;模板 3：单同态判定（通过同态核）&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明群同态 $f: G \to G&apos;$ 是单同态。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 写出同态核定义：Ker(f) = {x ∈ G | f(x) = e&apos;}。
2. 任取 x ∈ Ker(f)，由 f(x) = e&apos; 出发，结合群性质推出 x = e。
3. 说明 Ker(f) ⊆ {e}，从而 Ker(f) = {e}。
4. 由单同态判据（定理 4.7），得出 f 为单同态。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h5&gt;模板 4：循环群子群证明（最小步长与带余除法）&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明循环群的子群必为循环群。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 设 G = ⟨a⟩。若 H = {e}，则 H = ⟨e⟩，结论成立。
2. 若 H ≠ {e}，取集合 {k ∈ ℤ⁺ | aᵏ ∈ H} 中的最小正整数，记为 m。
3. 任取 aˢ ∈ H，由带余除法：s = qm + r，其中 0 ≤ r &amp;lt; m。
4. 变形得 a^r = a^s (a^m)^(-q)。由子群运算封闭性，aʳ ∈ H。
5. 若 r &amp;gt; 0，与 m 的最小性矛盾，故必有 r = 0，从而 s = qm。
6. 结论：H = ⟨aᵐ⟩ 为循环群。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h5&gt;模板 5：指数为 2 的子群必正规&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明 $[G : H] = 2 \implies H \triangleleft G$。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 任取 g ∈ G。若 g ∈ H，由子群封闭性 gH = H = Hg。
2. 若 g ∉ H：
   - 因 [G : H] = 2，左陪集只有两个：H 和 gH，它们构成全群划分，故 gH = G \ H；
   - 同理，右陪集也只有两个：H 和 Hg，故 Hg = G \ H；
3. 对比两式得到 gH = Hg。
4. 综合两类情况，对所有 g ∈ G 均有 gH = Hg，故 H ◁ G。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h5&gt;模板 6：有限子群封闭性判定（抽屉原理构造逆元）&lt;/h5&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明有限群 $G$ 的非空子集 $H \subseteq G$ 仅需运算封闭即可构成子群。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 任取 a ∈ H。考察元素幂序列 a, a², a³, ...。
2. 由乘法封闭性，该序列中所有元素均属于 H。
3. 因 H 为有限集合，由抽屉原理，必存在正整数 i &amp;gt; j ≥ 1 使得 aⁱ = aʲ。
4. 两边消去 aʲ，得 aⁱ⁻ʲ = e ∈ H（其中 i - j ≥ 1）。
5. 若 i - j = 1，则 a = e，a⁻¹ = e ∈ H；
   若 i - j &amp;gt; 1，则 a⁻¹ = aⁱ⁻ʲ⁻¹ ∈ H（因 i - j - 1 ≥ 1 为正整数）。
6. 由逆元封闭性与运算封闭性，H ≤ G。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&amp;lt;a id=&quot;chapter-13&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h1&gt;附录 个人易错点&lt;/h1&gt;
&lt;p&gt;&amp;lt;a id=&quot;section-13-1&quot;&amp;gt;&amp;lt;/a&amp;gt;&lt;/p&gt;
&lt;h2&gt;13.1 个人易错点与三个月复盘&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;说明与应用场景&lt;/strong&gt;：实际错误、理解卡点、最小反例与提交检查。&lt;/p&gt;
&lt;h3&gt;算法竞赛个人易错点&lt;/h3&gt;
&lt;p&gt;这份清单以“发现性质 → 定义状态 → 证明正确 → 检查实现”为顺序。目标是每个问题都有一个可以立刻执行的动作，而不是泛泛地提醒仔细。&lt;/p&gt;
&lt;h4&gt;证据范围&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;对话摘要&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/2026-07%E8%87%B310-%E7%AE%97%E6%B3%95%E4%B8%89%E4%B8%AA%E6%9C%88%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/&quot;&gt;2026-07至10 算法三个月回顾（用户提供）&lt;/a&gt; 与 &lt;a href=&quot;/posts/obsidian/2026-10-%E7%AE%97%E6%B3%95%E5%AF%B9%E8%AF%9D%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/&quot;&gt;2026-10 算法对话回顾（用户提供）&lt;/a&gt;。名义范围 2026-07-25 至 10-25，主要记录集中在 8 月中下旬后；没有独立读取原始网页会话，不把摘要中的追问算成错误次数。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;本地核对&lt;/strong&gt;：读取 &lt;code&gt;/home/sanzenin/test/algo&lt;/code&gt; 的代码及相关讲解；当前版本可能已经修复当时错误。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;实现复现&lt;/strong&gt;：对明确的整数移位问题运行 UBSan。其余条件性风险会写明输入前提，不能等同于原题 WA。&lt;/li&gt;
&lt;li&gt;优先级是复习建议，不是统计错误率；本次没有批量修改你的题目解答。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;归因&lt;/strong&gt;：Hydra 首版 WA 来自先前助手代码，不算用户代码错误；只作为历史信息不足的模型反例。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;1. 动态过程：太早进入算法，漏掉不变量&lt;/h4&gt;
&lt;p&gt;对话摘要中的最高位递归和 Slot Machine，都属于“自然模型复杂，换个状态很短”。&lt;/p&gt;
&lt;p&gt;开写前花两分钟做这三件事：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;手动操作三个状态，写出共同保留的对象。&lt;/li&gt;
&lt;li&gt;把“历史”改写成已保留集合、极值、差值、计数或顺序统计量。&lt;/li&gt;
&lt;li&gt;检查只给这个压缩状态，是否能恢复下一次操作。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;例&lt;/strong&gt;：Slot Machine 在“先删最大、再补新数”的规则下，状态是历史最小 $n-1$ 个数加最新值。原理和最终样本数见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#16-%E9%A1%BA%E5%BA%8F%E7%BB%9F%E8%AE%A1%E9%87%8F-%E5%85%88%E5%8C%BA%E5%88%86%E8%BF%9E%E7%BB%AD%E4%B8%8E%E7%A6%BB%E6%95%A3&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;停止条件&lt;/strong&gt;：找不到性质时再进入 DP / 搜索；不要因为“像按位题”就默认每位独立。若某操作重置了连续计数，逐位状态必须体现重置，或按最高位分段处理。&lt;/p&gt;
&lt;h4&gt;2. DP：同时检查“少存了什么”和“多存了什么”&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;充分性判据&lt;/strong&gt;：同一状态的任意两段历史，未来允许的决策和最优剩余代价是否相同？相同才能合并。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;冗余性判据&lt;/strong&gt;：某个维度能否由其他维度唯一算出？能就不必存。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;本人近期场景&lt;/th&gt;
&lt;th&gt;判断&lt;/th&gt;
&lt;th&gt;立刻执行&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;状压分组 &lt;code&gt;dp[mask][rem]&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;rem=sum[mask]%T&lt;/code&gt; 可恢复&lt;/td&gt;
&lt;td&gt;删余数维，单独检查 T&amp;gt;0、空集与答案换算&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cryptarithm 当前块位置&lt;/td&gt;
&lt;td&gt;对话里提出的是合理质疑&lt;/td&gt;
&lt;td&gt;看状态定义是否含最后选到的位置&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;括号树&lt;/td&gt;
&lt;td&gt;深度、已处理兄弟和祖先前缀是不同量&lt;/td&gt;
&lt;td&gt;画含两棵子树的括号森林再标状态&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;树形 DP&lt;/td&gt;
&lt;td&gt;同一节点不同父边约束可能影响未来&lt;/td&gt;
&lt;td&gt;明确树根、状态参数和转移依赖&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;可直接查看 &lt;a href=&quot;/home/sanzenin/test/algo/Cryptarithm_%E9%80%9A%E4%BF%97%E8%AE%B2%E8%A7%A3.md:66&quot;&gt;本地 Cryptarithm 讲解&lt;/a&gt;。其中 $f_j(i)$ 已定义为“当前副本最后选在位置 $i$”，&lt;strong&gt;没有缺少这个位置&lt;/strong&gt;。副本数已计入费用，不必再存。预收整份删除费 $W=x+nz$ 后，每保留一项退还 $z$，转移为&lt;/p&gt;
&lt;p&gt;$$f_j(i)=\min(\min_{t&amp;lt;i}f_{j-1}(t),\min_tf_{j-1}(t)+W)+y|a_i-b_j|-z.$$&lt;/p&gt;
&lt;p&gt;不要把你对状态的追问误写成“你提交了状态不足的错误解”。&lt;/p&gt;
&lt;h4&gt;3. 概率：先用一句中文说清事件&lt;/h4&gt;
&lt;p&gt;对话摘要明确记录过把 $\frac1m(k/m)^{n-1}$ 当成最大值恰为 $k$ 的概率。&lt;/p&gt;
&lt;p&gt;这其实固定了一个样本等于 $k$，其他样本不超过 $k$。正确事件应为“所有样本不超过 $k$，但不全小于 $k$”：&lt;/p&gt;
&lt;p&gt;$$P(\max X_i=k)=(k/m)^n-((k-1)/m)^n.$$&lt;/p&gt;
&lt;p&gt;固定反例 &lt;code&gt;n=2,m=2&lt;/code&gt;：四种结果，最大值为 2 的有三种，概率 $3/4$。若你的式子算不出它，先修事件再写代码。&lt;/p&gt;
&lt;p&gt;连续顺序统计的分母为“参与排序样本数 + 1”。Slot Machine 最新样本被单独保留时，不参与旧历史最小值的排序；本地 &lt;code&gt;nowcoder_2026_summer/10/e.cpp:17&lt;/code&gt; 分母为 $n+k$，要从 $n+k-1$ 个旧样本解释，不能死背。&lt;/p&gt;
&lt;h4&gt;4. SOS：先画包含方向，费用另算&lt;/h4&gt;
&lt;p&gt;对话摘要中的 Retest Queue 涉及超集方向、拒绝费用；没有完整题面，不能补造它的费用公式。&lt;/p&gt;
&lt;p&gt;通用检查用两位掩码：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;01&lt;/code&gt; 的子集是 &lt;code&gt;00,01&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;01&lt;/code&gt; 的超集是 &lt;code&gt;01,11&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;所有“包含我要求的特征”的候选，应查询超集。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;x &amp;amp; y == 0&lt;/code&gt; 应查询固定位宽补集的子集，不是超集。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;写注释 &lt;code&gt;dp[S] = ...&lt;/code&gt; 后再写循环。费用必须按接受/拒绝事件分别列式，不能因为 SOS 统计了人数就默认这些人都支付同样费用。&lt;/p&gt;
&lt;h4&gt;5. 计数：先固定见证对象&lt;/h4&gt;
&lt;p&gt;对话摘要中 Matrix Game 的 $k^a$ 漏了“相同取值属于同一组行”的要求。&lt;/p&gt;
&lt;p&gt;以后每个乘法因子旁写含义：“先选哪组行”“再选颜色”“后选列”。如果两个因子都在重新挑行组，它们通常不能直接相乘。鸽巢前把鸽子和巢写成具体元组。&lt;/p&gt;
&lt;p&gt;最小验证：取 2–3 行、2–3 列，枚举矩阵或选择对象，检查“同一行组”是不是被多个局部选择偷换。&lt;/p&gt;
&lt;h4&gt;6. 贪心 / 博弈：可行不等于最优&lt;/h4&gt;
&lt;p&gt;循环排列奇偶策略等问题在摘要中属于证明理解，不直接记为错误。&lt;/p&gt;
&lt;p&gt;用两段式证明：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;能保证&lt;/strong&gt;：给出一个合法策略，说明不变量如何持续。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;不能更好&lt;/strong&gt;：给出对手反制、下界或交换论证，封住更优结果。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;若证明“只考虑这几种情况”，必须说明任意其他方案如何归约到它们。小规模 Minimax 可帮助发现策略，但打表一致不能代替证明；有循环的博弈还需定义终止和和局。&lt;/p&gt;
&lt;h4&gt;7. 位操作：类型由左操作数决定&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;本地确定问题&lt;/strong&gt;：&lt;a href=&quot;/home/sanzenin/test/algo/cf/cf1077/d.cpp:71&quot;&gt;cf/cf1077/d.cpp&lt;/a&gt; 循环包括 &lt;code&gt;i=32&lt;/code&gt;，重建时使用 &lt;code&gt;(bit_p &amp;lt;&amp;lt; i)&lt;/code&gt;、&lt;code&gt;(bit_q &amp;lt;&amp;lt; i)&lt;/code&gt;；&lt;code&gt;bit_p&lt;/code&gt; 是 &lt;code&gt;int&lt;/code&gt;。即使赋给 &lt;code&gt;long long&lt;/code&gt;，右侧也已按 32 位移位。UBSan 对输入 &lt;code&gt;1\n1 1\n&lt;/code&gt; 可复现“shift exponent 32 ... 32-bit type int”。&lt;/p&gt;
&lt;p&gt;修正形式：&lt;code&gt;(1ULL * bit_p &amp;lt;&amp;lt; i)&lt;/code&gt;，并保证 &lt;code&gt;0&amp;lt;=i&amp;lt;64&lt;/code&gt;。若结果必须为有符号数，还需保证最高位不会越过可表示范围。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// GNU C++17；只对非零 unsigned long long x 调用
int low = __builtin_ctzll(x);       // 最低 1 的位号
int high = 63 - __builtin_clzll(x); // 最高 1 的位号
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;0 要先特判；&lt;code&gt;1 &amp;lt;&amp;lt; k&lt;/code&gt; 的位宽仍是 int，&lt;code&gt;1ULL &amp;lt;&amp;lt; k&lt;/code&gt; 才是无符号 64 位。&lt;/p&gt;
&lt;h4&gt;8. 128 位：把强制转换移到第一个危险运算前&lt;/h4&gt;
&lt;p&gt;摘要记录过中间乘法先溢出的问题。本地 &lt;a href=&quot;/home/sanzenin/test/algo/reginonals/26xian/h.cpp:46&quot;&gt;26xian/h.cpp&lt;/a&gt; 也保留了条件性风险：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cur += (__int128)(pos - last) * (x - y * cnt);
// y*cnt 与 pos-last 都先以 long long 计算。
// 如果参数上界允许超过 long long，改为：
cur += ((__int128)pos - last) * ((__int128)x - (__int128)y * cnt);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是否触发依赖原题上界，本次未把它宣判为原题 WA。&lt;code&gt;sum&lt;/code&gt;、累加量和最终 &lt;code&gt;(long long)ans&lt;/code&gt; 也要核对范围。打印 128 位使用配套 &lt;code&gt;to_string128&lt;/code&gt;，不要为了输出强行缩回 64 位。&lt;/p&gt;
&lt;h4&gt;9. 扫描线：每次只推进一个明确动作&lt;/h4&gt;
&lt;p&gt;摘要记录过 &lt;code&gt;i++, cnt += events[i].second&lt;/code&gt; 先跳索引的错误。当前 &lt;code&gt;26xian/h.cpp&lt;/code&gt; 已使用先读再递增，不能记为仍未修复。&lt;/p&gt;
&lt;p&gt;推荐固定写法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while (i &amp;lt; events.size() &amp;amp;&amp;amp; events[i].first == pos) {
    cnt += events[i].second;
    ++i;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;顺序固定为“用旧斜率走到 pos → 记录值 → 合并 pos 的全部事件”。测试同坐标两个开始事件、开始与结束重合、零长度区间。没有证明单峰时，不把断点扫描随意替换成三分。&lt;/p&gt;
&lt;h4&gt;10. DFS、左偏树、括号树：结构检查不能只靠样例&lt;/h4&gt;
&lt;p&gt;摘要中的结构错误建立以下固定检查：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;对象&lt;/th&gt;
&lt;th&gt;不变量&lt;/th&gt;
&lt;th&gt;极小数据&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;DFS&lt;/td&gt;
&lt;td&gt;从根调用；无向边跳父亲；孩子先算完再合并&lt;/td&gt;
&lt;td&gt;单点、长度 3 的链、星形树&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DP&lt;/td&gt;
&lt;td&gt;叶子值正确，不可达不会被普通 0 混入&lt;/td&gt;
&lt;td&gt;不能选择任何对象的状态&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;左偏树&lt;/td&gt;
&lt;td&gt;堆序；左 dist &amp;gt;= 右 dist；dist=右 dist+1&lt;/td&gt;
&lt;td&gt;空堆合并、单点 pop、重复键&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;空堆&lt;/td&gt;
&lt;td&gt;&lt;code&gt;dist[0]=0&lt;/code&gt;、新叶子 dist=1（或统一另一套约定）&lt;/td&gt;
&lt;td&gt;merge(0,0)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;括号树&lt;/td&gt;
&lt;td&gt;0 仅作为虚拟根，真实点从 1 起&lt;/td&gt;
&lt;td&gt;&lt;code&gt;()&lt;/code&gt;、&lt;code&gt;()()&lt;/code&gt;、&lt;code&gt;(())&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;反对角线&lt;/td&gt;
&lt;td&gt;$i+j=d$ 时 max(1,d-m)&amp;lt;=i&amp;lt;=min(n,d-1)&lt;/td&gt;
&lt;td&gt;1x1、1xm、nx1、2x3&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;如果同时处理相邻对角线的并集，范围可能要包含哨兵 0，必须注明；不能用一个看似宽松的区间默默访问真实数组以外的位置。&lt;/p&gt;
&lt;p&gt;本地 &lt;code&gt;nowcoder_2026_summer/3/j.cpp&lt;/code&gt; 对新节点设置 &lt;code&gt;dist=1&lt;/code&gt;，空点默认 0；它体现了正确的一套约定。&lt;/p&gt;
&lt;h4&gt;11. 递归必须有严格下降的量&lt;/h4&gt;
&lt;p&gt;摘要记录最高位递归在 $n=2,3$ 可能不缩小。本地 &lt;code&gt;cf/cf1129/d1.cpp&lt;/code&gt; 目前只有小值分支和未完成的主体，不是可直接用的模板，也不能从它推断完整递推正确。&lt;/p&gt;
&lt;p&gt;对每条递归边写出 $measure(next)&amp;lt;measure(cur)$；可用 n、剩余位数、未处理节点数或字典序二元组。把 0、1、2、3 逐个代入，若出现自己调自己，增加基例或改递推。&lt;/p&gt;
&lt;h4&gt;12. 状态规模与内存是实现的一部分&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/home/sanzenin/test/algo/nowcoder_2026_summer/8/m.cpp:26&quot;&gt;nowcoder/8/m.cpp&lt;/a&gt; 分配约一百万个 &lt;code&gt;vector&amp;lt;int&amp;gt;(28)&lt;/code&gt;：仅 int 负载约 106.8 MiB，另有约 22.9 MiB 的 vector 对象（典型 64 位实现）和一百万次堆分配开销。更适合连续 &lt;code&gt;vector&amp;lt;array&amp;lt;int,26&amp;gt;&amp;gt;&lt;/code&gt; 或按实际 Trie 节点数分配。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/home/sanzenin/test/algo/cf/1523D.cpp:38&quot;&gt;cf/1523D.cpp&lt;/a&gt; 抽样 20 次；若一次命中支持最优答案的样本概率至少 1/2，且各次独立，理论漏掉概率至多 $2^{-20}$。仍需证明行内压缩位数小，否则 $2^{siz}$ 无法承受。&lt;/li&gt;
&lt;li&gt;$2^{22}$ 个 &lt;code&gt;int&lt;/code&gt; 约 16 MiB，&lt;code&gt;long long&lt;/code&gt; 约 32 MiB；有多份数组时按峰值相加。时间按轮数乘 $B2^B$，不能只看一次 SOS。&lt;/li&gt;
&lt;li&gt;哈希/随机化要注明正确性概率；&lt;code&gt;TODO&lt;/code&gt;、空 solve、未完成函数不能仅凭能编译就收入可用模板。本地 &lt;code&gt;cf/453A.cpp&lt;/code&gt; 是空壳，应使用已推导的公式而非复制这个文件。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;三个月新增：相同模式在不同题型中的表现&lt;/h4&gt;
&lt;h5&gt;重复键不是可以随意丢弃的历史&lt;/h5&gt;
&lt;p&gt;摘要中树上碰撞的 &lt;code&gt;rev[x][dep[x]+s]=i&lt;/code&gt; 覆盖前一人。最小反例：一个节点、两个人同在时刻 0 出生，应该立即碰撞。&lt;/p&gt;
&lt;p&gt;插入映射前先问：&lt;strong&gt;同 key 的两个对象是否等价，还是它们相遇就是事件？&lt;/strong&gt; 对应处理可为计数、保存全部 ID、插入失败即触发；不是一律把 map 改 multimap。比如只维护最小费用时，同 key 取 min 就合理。&lt;/p&gt;
&lt;h5&gt;树上差分：先确定恢复的是边还是根路径&lt;/h5&gt;
&lt;p&gt;两端点 XOR 标记 &lt;code&gt;d[u]^=1,d[v]^=1&lt;/code&gt; 后，恢复边覆盖奇偶要子传父。对子树边 $(parent[v],v)$，删边形成的割中，每条路径跨割当且仅当一个端点在子树内，因此子树 XOR 就是边覆盖奇偶。&lt;/p&gt;
&lt;p&gt;父传子通常恢复已定义的根到点前缀；它不能替代端点标记的子树汇总。调用 &lt;code&gt;cp::tree_path_xor_edges&lt;/code&gt; 可得到按输入边顺序的覆盖奇偶，采用迭代遍历避免深链递归。&lt;/p&gt;
&lt;h5&gt;回滚与清理是算法的一部分&lt;/h5&gt;
&lt;p&gt;DSU on Tree 的 &lt;code&gt;keep=false&lt;/code&gt; 分支，对自己临时加入的状态必须清理，即使已经找到答案。虚树的邻接边、访问标记、多测答案集合也都要明确归属。&lt;/p&gt;
&lt;p&gt;固定写法是先保存 &lt;code&gt;found&lt;/code&gt;，继续执行必要清理，再返回。也可让每次 check 拥有独立局部容器，或用作用域恢复器。&lt;strong&gt;不能把 keep=true 的保留状态一并清空&lt;/strong&gt;，应逐项说明哪些状态归本层所有。&lt;/p&gt;
&lt;p&gt;测试：连续调用同一 check 两次应得相同结果；交换兄弟处理顺序应不改变答案；两组测试用例交换顺序后输出只交换、不变化。&lt;/p&gt;
&lt;h5&gt;数值域、位置域、压缩编号分清&lt;/h5&gt;
&lt;p&gt;约数扫描线摘要中的 &lt;code&gt;divisors[i]&lt;/code&gt;/&lt;code&gt;divisors[a[i]]&lt;/code&gt;、扫 &lt;code&gt;ma&lt;/code&gt;/扫 &lt;code&gt;n&lt;/code&gt;，与 MEX 中 &lt;code&gt;j*i&lt;/code&gt;/&lt;code&gt;j*x&lt;/code&gt;、&lt;code&gt;pre&lt;/code&gt;/&lt;code&gt;dp&lt;/code&gt; 混用，根源都是变量含义漂移。&lt;/p&gt;
&lt;p&gt;对每个数组写一句 &lt;code&gt;数组[谁] = 什么&lt;/code&gt;：&lt;code&gt;divisors[value]&lt;/code&gt;、&lt;code&gt;last[valueId]&lt;/code&gt;、&lt;code&gt;dp[prefixLength]&lt;/code&gt;、&lt;code&gt;events[position]&lt;/code&gt;。把 idx、value、rank 分开命名，离散编号只能用于比较/索引，原始距离不能用编号差代替。&lt;/p&gt;
&lt;p&gt;差值 DP 封装 &lt;code&gt;idx(d)=d+offset&lt;/code&gt;，包括初始化 &lt;code&gt;idx(0)&lt;/code&gt;；切勿只给转移加 offset。&lt;/p&gt;
&lt;h5&gt;二分必须证明边界与整个检查复杂度&lt;/h5&gt;
&lt;p&gt;Gas Station 的“容量至少最大边权”仅在&lt;strong&gt;不能在边内部增设站、完整走边需要足够油量&lt;/strong&gt;的模型下成立；若允许边内加站，结论要重证。题名不能代替题意。&lt;/p&gt;
&lt;p&gt;开区间二分先写 &lt;code&gt;check(lo)=false,check(hi)=true&lt;/code&gt;（或相反），推导上界或在有可行性保证时扩大上界；无解和乘二溢出单独处理。复杂度按 &lt;code&gt;轮数 × check&lt;/code&gt; 算，嵌套 LCA 再乘 $\log n$；不要把判定扫描误认为一次总共只扫一遍。&lt;/p&gt;
&lt;h5&gt;最短路边内部必须比较两个入口&lt;/h5&gt;
&lt;p&gt;CF144D 边 $(u,v,w)$ 上、距 u 为 x 的点：&lt;/p&gt;
&lt;p&gt;$$D(x)=\min(dis[u]+x,dis[v]+w-x).$$&lt;/p&gt;
&lt;p&gt;候选 $x=L-dis[u]$ 必须满足 $0&amp;lt;x&amp;lt;w$，以及另一方向 $dis[v]+w-x\ge L$。等号表示从两端得到同一个候选，要去重。最小反例：只有一条长度 10 的边，却有另一条路让 &lt;code&gt;dis[u]=dis[v]=0&lt;/code&gt;；从 u 看 x=7 是 L=7，但实际最短距离是 3。（可用两端与源点各连零权边实现；若原题边权要求正，可统一把两端距离改为 1、目标改为 8。）&lt;/p&gt;
&lt;p&gt;本地 &lt;code&gt;cf/144D.cpp&lt;/code&gt; 当前已比较另一端，等号用顶点编号约束去重；摘要中的错误不应写成当前版本仍存在。&lt;/p&gt;
&lt;h5&gt;概率必须覆盖全部类别&lt;/h5&gt;
&lt;p&gt;Erratic Lights 的“方案数漏除总方案数”和 CF1418E 的“漏弱怪贡献”是两类错误。前者核对样本空间权重；后者把对象分类后逐类写指示变量。&lt;/p&gt;
&lt;p&gt;强怪被挡不代表弱怪永远不造成伤害：盾牌破后遇到弱怪仍可能贡献。强怪数量恰等于耐久时，是检测“强怪贡献为 0、弱怪仍可能非零”的有效边界。公式与假设见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#22-%E5%88%86%E7%B1%BB%E6%9C%9F%E6%9C%9B-%E4%B8%8D%E8%A6%81%E6%BC%8F%E6%8E%89%E8%A2%AB%E7%8A%B6%E6%80%81%E6%94%B9%E5%8F%98%E7%9A%84%E5%8F%A6%E4%B8%80%E7%B1%BB&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;h5&gt;BFS、容器与几何的固定动作&lt;/h5&gt;
&lt;ul&gt;
&lt;li&gt;BFS 每次取队首后立即 pop；visited/距离在入队时更新，避免重复入队。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;erase(first,last)&lt;/code&gt; 使用半开区间；空范围是 first==last，别把结尾迭代器解引用。&lt;/li&gt;
&lt;li&gt;先明确输出是否需要操作数，再输出完整操作序列；回放操作验证最终状态与每步合法性。&lt;/li&gt;
&lt;li&gt;反三角函数前检查几何是否有解，再对理论在 [-1,1] 的值 clamp；不能靠 clamp 掩盖本来无交点的情况。&lt;/li&gt;
&lt;li&gt;构造图的父边来自指定遍历树，验证源点可达及构造后算法产生的顺序；输入顺序不天然等于遍历顺序。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;三个月二刷清单&lt;/h4&gt;
&lt;p&gt;这些题名来自用户提供的回顾；没有完整题面/官方编号的条目暂不补造链接。每题完成的标准是恢复性质、证明和代码，而不是读完题解。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;[ ] 树上碰撞：两个相同键触发事件，不被覆盖。&lt;/li&gt;
&lt;li&gt;[ ] Gas Station：解释站点位置限制、可行上下界、深链。&lt;/li&gt;
&lt;li&gt;[ ] Erratic Lights：每项权重说明概率空间、全部下标合法。&lt;/li&gt;
&lt;li&gt;[ ] Canal Crossing：用割解释子传父，手算三点链。&lt;/li&gt;
&lt;li&gt;[ ] RGB 分段：两个前缀差推偏序，query在insert前。&lt;/li&gt;
&lt;li&gt;[ ] MEX 区间计数：变量含义不漂移、空区间、重叠约束、小规模暴力。&lt;/li&gt;
&lt;li&gt;[ ] DSU on Tree + XOR：keep=false清理、重复check、兄弟顺序无关。&lt;/li&gt;
&lt;li&gt;[ ] CF1418E：强怪和弱怪两类贡献、强怪数等于耐久。&lt;/li&gt;
&lt;li&gt;[ ] CF144D：两个入口、边端点、相等候选去重。&lt;/li&gt;
&lt;li&gt;[ ] Cryptarithm：说清最后位置、开新副本、P更新时机。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;提交前九项检查&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;[ ] 写出一个可验证的不变量 / 单调性 / 结构化简。&lt;/li&gt;
&lt;li&gt;[ ] DP 状态足以决定未来，没有可推导的多余维度。&lt;/li&gt;
&lt;li&gt;[ ] 贪心或博弈有“能保证”和“不能更好”两部分。&lt;/li&gt;
&lt;li&gt;[ ] 概率事件、计数见证、子集 / 超集方向写成一句中文。&lt;/li&gt;
&lt;li&gt;[ ] DFS 有入口，父亲与叶子处理一致，深链考虑递归栈。&lt;/li&gt;
&lt;li&gt;[ ] 每个递归分支严格缩小，0、1、2、3 都能终止。&lt;/li&gt;
&lt;li&gt;[ ] 空集、虚拟点、闭区间、同坐标事件合法。&lt;/li&gt;
&lt;li&gt;[ ] 乘法、减法、移位先确定类型；模减法规范化；分母可逆。&lt;/li&gt;
&lt;li&gt;[ ] 手算重复值与边界；需要时用不同思路的暴力对拍。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;一轮复盘怎么用&lt;/h4&gt;
&lt;p&gt;每道题只记四行：&lt;strong&gt;题面触发器 → 我漏掉的性质 → 最小反例 → 下次固定动作&lt;/strong&gt;。没有出错、只是认真追问证明的题，记录为“证明待巩固”。&lt;/p&gt;
&lt;p&gt;优先补：最大值概率、SOS 方向、mask 删维、最高位递归收缩、同坐标事件。每题写五行状态 / 证明，比重复复制模板更有针对性。&lt;/p&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%BB%8F%E5%85%B8trick/&quot;&gt;经典Trick&lt;/a&gt;。&lt;/p&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>算法竞赛 Classic Tricks 复习笔记</title><link>https://sanzenin.top/posts/obsidian/%E7%BB%8F%E5%85%B8trick/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%BB%8F%E5%85%B8trick/</guid><description>- 区间/长度要拆成若干段，每段长度只能取 2 或 3。 - 构造题中需要证明所有 都可写成 ，其中 。 - 原题出现“2 和 3 的倍数组合”时，先把它化成非负整数解问题。 对任意整数 ，都存在 使 若 为偶数，取 ；若 为奇数，则 ，先取一个 3，剩下 为偶数。 - 边权值域很小（如 ， ），但边数很多（ 很大）。</description><pubDate>Mon, 16 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛 Classic Tricks 复习笔记&lt;/h1&gt;
&lt;hr /&gt;
&lt;h2&gt;A. 任意 $n\ge2$ 都能由 2 和 3 凑出&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;区间/长度要拆成若干段，每段长度只能取 2 或 3。&lt;/li&gt;
&lt;li&gt;构造题中需要证明所有 $n\ge2$ 都可写成 $2x+3y$，其中 $x,y\ge0$。&lt;/li&gt;
&lt;li&gt;原题出现“2 和 3 的倍数组合”时，先把它化成非负整数解问题。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;核心结论&lt;/h3&gt;
&lt;p&gt;对任意整数 $n\ge2$，都存在 $x,y\ge0$ 使&lt;/p&gt;
&lt;p&gt;$$
n=2x+3y.
$$&lt;/p&gt;
&lt;p&gt;若 $n$ 为偶数，取 $x=n/2,y=0$；若 $n$ 为奇数，则 $n\ge3$，先取一个 3，剩下 $n-3$ 为偶数。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;B. Kruskal 瓶颈在排序时不如直接枚举值域&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;边权值域很小（如 $[0,W]$，$W \le 10^6$），但边数很多（$m$ 很大）。&lt;/li&gt;
&lt;li&gt;图由隐式规则生成，值域有限但边数是 $O(n^2)$ 级别。&lt;/li&gt;
&lt;li&gt;需要最小生成树，且排序成本 $O(m\log m)$ 超过 $O(n + W)$ 枚举。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;核心观察&lt;/h3&gt;
&lt;p&gt;Kruskal 真正要求的是“按边权从小到大处理”，不一定非要比较排序。若边权值域 $W$ 很小，并且能把显式边按权值桶化，或能直接生成某个权值的候选边，就可以从小到大枚举权值并做并查集合并。&lt;/p&gt;
&lt;p&gt;显式边桶化时，排序部分可由 $O(m\log m)$ 降到 $O(m+W)$；若图是隐式生成的，还必须把“生成当前权值的候选边”的复杂度一起算进去，不能仅凭值域小就自动省掉 $O(n^2)$ 条边。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;C. 固定 K 的乘除 → 考虑 K 进制&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;问题中存在某个固定常数 $K$，元素需要乘以 $K$ 或除以 $K$。&lt;/li&gt;
&lt;li&gt;操作反复作用在同一数上，或需要统计&quot;乘了多少次 $K$&quot;。&lt;/li&gt;
&lt;li&gt;权重/贡献与 $K$ 的幂次有关，或题目本质是&quot;进位/借位&quot;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;核心观察&lt;/h3&gt;
&lt;p&gt;若有固定的 $K$，则“乘 $K$”对应 $K$ 进制左移一位；当当前数能被 $K$ 整除时，“除 $K$”对应右移一位。若题目使用整数除法，还要单独处理被舍去的最低位。&lt;/p&gt;
&lt;p&gt;因此看到反复乘/除固定 $K$，可以把数拆成 $K$ 进制各位，检查操作是否变成移位、进位或按位独立处理。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;D. BFS 遍历所有状态求最值&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;状态空间有限，且每次转移代价均为 $1$（或均匀），问最短步数/最大/最小值。&lt;/li&gt;
&lt;li&gt;问题看似需要 DP 或搜索，但状态之间无拓扑序或转移顺序不固定。&lt;/li&gt;
&lt;li&gt;需要求&quot;从所有合法起点出发能到达哪些状态的最小距离&quot;，多源 BFS。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;核心观察&lt;/h3&gt;
&lt;p&gt;这里的重点不是“BFS 能直接求任意最值”，而是：&lt;strong&gt;BFS 也可以只是一个状态枚举器&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;当状态空间有限，并且每个状态只需被处理一次时，可以从初始状态 BFS，把所有可达状态遍历出来；若目标是“所有可达状态自身的最大/最小属性”，遍历时直接统计即可。多源 BFS 则可同时从所有起点出发，得到到最近起点的最短距离。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning]
BFS 本身不能求一般图最长路，也不能自动保证任意“最大值 DP”正确。若答案依赖路径历史而非状态本身，需要额外的 DAG/DP 性质或重新设计状态。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;E. 两物性价比与数量上界&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;有两类物品，各有价值 $v_i$ 与价格 $p_i$（$i=1,2$），要以最低总价达到总价值 $\ge V$。&lt;/li&gt;
&lt;li&gt;背包类题目中物品只有两种，或可以把所有物品归类成&quot;性价比高&quot;与&quot;性价比低&quot;两组。&lt;/li&gt;
&lt;li&gt;需要证明最优解中某类物品的数量有上界。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;核心结论&lt;/h3&gt;
&lt;p&gt;设两类物品价值/价格分别为 $(v_1,p_1)$、$(v_2,p_2)$，且物品 1 的单位价值成本不高于物品 2：&lt;/p&gt;
&lt;p&gt;$$
\frac{p_1}{v_1}\le\frac{p_2}{v_2}.
$$&lt;/p&gt;
&lt;p&gt;令 $g=\gcd(v_1,v_2)$。若物品 2 买了至少 $v_1/g$ 个，可以把其中 $v_1/g$ 个物品 2 替换成 $v_2/g$ 个物品 1：两边提供的价值完全相同，而替换后的总价不会更高。因此一定存在一个最优解满足&lt;/p&gt;
&lt;p&gt;$$
0\le x_2&amp;lt;\frac{v_1}{g}.
$$&lt;/p&gt;
&lt;p&gt;所以可以枚举性价比较低的物品数量，再用高性价比物品补足目标价值。原文“性价比低的数量不会买超过性价比更高的价值”记录的就是这种交换上界思想；具体上界必须由题目参数证明，不能凭性价比直接猜。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;F. 序列中移动元素 → 观察 $a_i \pm i$&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;序列中可以将某个元素向左或向右移动若干步，移动代价与移动距离（下标差）有关。&lt;/li&gt;
&lt;li&gt;要把一组元素移动到某些目标位置，使总移动距离最小。&lt;/li&gt;
&lt;li&gt;元素相对顺序不变（或只考虑某个元素），操作等价于调整下标。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;核心观察&lt;/h3&gt;
&lt;p&gt;当表达式里同时出现“值 $a_i$”和位置差 $|i-j|$ 时，先按左右关系拆绝对值。例如&lt;/p&gt;
&lt;p&gt;$$
a_i+|i-j|=
\begin{cases}
(a_i-i)+j,&amp;amp;i\le j,\
(a_i+i)-j,&amp;amp;i&amp;gt;j.
\end{cases}
$$&lt;/p&gt;
&lt;p&gt;于是所有与 $i$ 有关的部分只剩 $a_i-i$ 或 $a_i+i$。这经常能把“值 + 移动距离”拆成前缀/后缀最值问题。&lt;/p&gt;
&lt;p&gt;常见触发式：$a_i\pm|i-j|$、$|a_i-a_j|+|i-j|$、需要同时比较数值与位置的最值式。原文只记录了“观察 $a_i\pm i$”这个触发器；具体操作是否真的形成不变量，必须针对题目另证。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;G. 二进制位运算律速查&lt;/h2&gt;
&lt;p&gt;位运算逐位独立，因此很多恒等式只需在单个 bit 的 $0/1$ 情况下验证。&lt;/p&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;题目涉及位掩码、子集枚举、按位统计。&lt;/li&gt;
&lt;li&gt;需要把 XOR/AND/OR 的前缀和或区间查询转化成等价形式。&lt;/li&gt;
&lt;li&gt;推导某个位运算组合是否满足分配律，或需要把补集写成 XOR。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;G-1. XOR（异或）&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;交换律：$a\oplus b=b\oplus a$&lt;/li&gt;
&lt;li&gt;结合律：$(a\oplus b)\oplus c=a\oplus(b\oplus c)$&lt;/li&gt;
&lt;li&gt;单位元：$a\oplus0=a$&lt;/li&gt;
&lt;li&gt;自反：$a\oplus a=0$&lt;/li&gt;
&lt;li&gt;消去：$a\oplus b\oplus b=a$&lt;/li&gt;
&lt;li&gt;因而前缀异或可直接还原区间：$a_l\oplus\cdots\oplus a_r=pre_r\oplus pre_{l-1}$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;G-2. AND / OR&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;交换律：$a\mathbin{&amp;amp;}b=b\mathbin{&amp;amp;}a$，$a|b=b|a$&lt;/li&gt;
&lt;li&gt;结合律：$(a\mathbin{&amp;amp;}b)\mathbin{&amp;amp;}c=a\mathbin{&amp;amp;}(b\mathbin{&amp;amp;}c)$，OR 同理&lt;/li&gt;
&lt;li&gt;幂等：$a\mathbin{&amp;amp;}a=a$，$a|a=a$&lt;/li&gt;
&lt;li&gt;零元/单位元：$a\mathbin{&amp;amp;}0=0$，$a|0=a$&lt;/li&gt;
&lt;li&gt;吸收律：$a|(a\mathbin{&amp;amp;}b)=a$，$a\mathbin{&amp;amp;}(a|b)=a$&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;AND 与 OR 互相满足分配律：&lt;/p&gt;
&lt;p&gt;$$
a\mathbin{&amp;amp;}(b|c)=(a\mathbin{&amp;amp;}b)|(a\mathbin{&amp;amp;}c),
$$&lt;/p&gt;
&lt;p&gt;$$
a|(b\mathbin{&amp;amp;}c)=(a|b)\mathbin{&amp;amp;}(a|c).
$$&lt;/p&gt;
&lt;p&gt;固定掩码的 AND 对 XOR 也满足分配律：&lt;/p&gt;
&lt;p&gt;$$
(a\oplus b)\mathbin{&amp;amp;}m
=(a\mathbin{&amp;amp;}m)\oplus(b\mathbin{&amp;amp;}m),
$$&lt;/p&gt;
&lt;p&gt;因此&lt;/p&gt;
&lt;p&gt;$$
\left(\bigoplus_{i\in S}a_i\right)\mathbin{&amp;amp;}m
=\bigoplus_{i\in S}(a_i\mathbin{&amp;amp;}m).
$$&lt;/p&gt;
&lt;p&gt;直观上，$m$ 只是逐位过滤器：$m_i=0$ 时该位统一清零，$m_i=1$ 时原样保留 XOR。&lt;/p&gt;
&lt;h3&gt;G-3. NOT 与德摩根律&lt;/h3&gt;
&lt;p&gt;在固定 $B$ 位范围、$MASK=2^B-1$ 时，可把补集写成 $\overline a=a\oplus MASK$。&lt;/p&gt;
&lt;p&gt;$$
\overline{a\mathbin{&amp;amp;}b}=\overline a|\overline b,
\qquad
\overline{a|b}=\overline a\mathbin{&amp;amp;}\overline b.
$$&lt;/p&gt;
&lt;p&gt;C++ 的 &lt;code&gt;~a&lt;/code&gt; 会翻转整数类型的全部位；只关心低 $B$ 位时记得再 &lt;code&gt;&amp;amp; MASK&lt;/code&gt;。&lt;/p&gt;
&lt;h3&gt;G-4. 竞赛常用恒等式&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;判第 $k$ 位：&lt;code&gt;(x &amp;gt;&amp;gt; k) &amp;amp; 1&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;置第 $k$ 位：&lt;code&gt;x |= 1LL &amp;lt;&amp;lt; k&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;清第 $k$ 位：&lt;code&gt;x &amp;amp;= ~(1LL &amp;lt;&amp;lt; k)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;翻转第 $k$ 位：&lt;code&gt;x ^= 1LL &amp;lt;&amp;lt; k&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;最低位的 $1$：&lt;code&gt;lowbit(x) = x &amp;amp; -x&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;删除最低位的 $1$：&lt;code&gt;x &amp;amp;= x - 1&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;判断 $x$ 是否为 $2$ 的幂：&lt;code&gt;x &amp;gt; 0 &amp;amp;&amp;amp; (x &amp;amp; (x - 1)) == 0&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;低 $k$ 位掩码：&lt;code&gt;(1LL &amp;lt;&amp;lt; k) - 1&lt;/code&gt;（注意 $k$ 不能等于类型位宽）&lt;/li&gt;
&lt;li&gt;枚举非空子掩码：&lt;code&gt;for (int s = mask; s; s = (s - 1) &amp;amp; mask)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;G-5. 常见转化&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;XOR 前缀和：$xor(l,r)=pre_r\oplus pre_{l-1}$。&lt;/li&gt;
&lt;li&gt;只关心掩码 $m$ 中的位：可以先做 &lt;code&gt;a[i] &amp;amp; m&lt;/code&gt; 再 XOR，因为 AND 对 XOR 线性。&lt;/li&gt;
&lt;li&gt;要求 &lt;code&gt;mask&lt;/code&gt; 的所有 $1$ 都包含在 $x$ 中：&lt;code&gt;(x &amp;amp; mask) == mask&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;要求 $x$ 的所有 $1$ 都属于 &lt;code&gt;mask&lt;/code&gt;：&lt;code&gt;(x &amp;amp; mask) == x&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning] 不要错误推广
OR 不对 XOR 满足类似分配律。例：$a=0,b=0,m=1$，$(a|m)\oplus(b|m)=0$，但 $(a\oplus b)|m=1$。
移位等价于乘除 $2^k$ 只应在无溢出、且右移对象非负等条件下使用。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;H. 质数与质因子：$10^8$ 值域结论&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;题目值域不超过 $10^8$，需要判素、分解质因子、或枚举约数。&lt;/li&gt;
&lt;li&gt;需要对某个 $n$ 的所有互质计数（容斥），或枚举无平方因子约数。&lt;/li&gt;
&lt;li&gt;出现 &lt;code&gt;gcd&lt;/code&gt; 边权，怀疑可用中间质数构造权值为 $1$ 的边。&lt;/li&gt;
&lt;li&gt;题目要求枚举 $n$ 附近的质数，或判断&quot;所有质因子都大于 $10^4$&quot;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;H-1. 判定与筛法的边界&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;若 $n\le 10^8$ 为合数，则它一定有一个不超过 $\sqrt n\le10^4$ 的质因子。因此单次试除只需检查到 $10^4$。&lt;/li&gt;
&lt;li&gt;$10^4$ 以内共有 $1229$ 个质数。先筛出这些质数后，单次分解 $n\le10^8$ 最多试除 $1229$ 次，而不必枚举所有整数。&lt;/li&gt;
&lt;li&gt;$10^8$ 以内共有 $5,761,455$ 个质数，最大质数是 $99,999,989$。&lt;/li&gt;
&lt;li&gt;若要回答大量区间质数问题，埃氏筛的时间复杂度为 $O(N\log\log N)$，普通 &lt;code&gt;bool/uint8_t&lt;/code&gt; 标记约占 $N$ 字节；只存奇数可把空间减半。&lt;/li&gt;
&lt;li&gt;单个 $32$ 位整数的判素也可使用确定性 Miller--Rabin；但在 $10^8$ 内，试除或预筛通常更短且常数稳定。参见 &lt;a href=&quot;/posts/obsidian/miller-rabin%E7%AE%97%E6%B3%95/&quot;&gt;Miller Rabin算法&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E6%AC%A7%E6%8B%89%E7%AD%9B%E6%B3%95-%E7%BA%BF%E6%80%A7%E7%AD%9B/&quot;&gt;欧拉筛法(线性筛)&lt;/a&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!tip] 平方根写法
用 &lt;code&gt;1LL * p * p &amp;lt;= n&lt;/code&gt;，避免 &lt;code&gt;p * p&lt;/code&gt; 在更大值域中发生 &lt;code&gt;int&lt;/code&gt; 溢出。分解结束后若 &lt;code&gt;n &amp;gt; 1&lt;/code&gt;，剩余部分本身就是一个质因子。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;H-2. 不同质因子个数很少&lt;/h3&gt;
&lt;p&gt;令 $\omega(n)$ 表示 $n$ 的不同质因子个数。为了在固定值域内让 $\omega(n)$ 最大，应依次乘最小的不同质数：&lt;/p&gt;
&lt;p&gt;$$
2\cdot3\cdot5\cdot7\cdot11\cdot13\cdot17\cdot19
=9,699,690\le10^8,
$$&lt;/p&gt;
&lt;p&gt;但&lt;/p&gt;
&lt;p&gt;$$
9,699,690\cdot23=223,092,870&amp;gt;10^8.
$$&lt;/p&gt;
&lt;p&gt;因此&lt;/p&gt;
&lt;p&gt;$$
n\le10^8\Longrightarrow \omega(n)\le8.
$$&lt;/p&gt;
&lt;p&gt;直接推论：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;枚举不同质因子的所有子集至多 $2^8=256$ 个状态；&lt;/li&gt;
&lt;li&gt;用容斥统计区间内与 $n$ 互质的数，复杂度可视为常数；&lt;/li&gt;
&lt;li&gt;若只需要无平方因子约数、莫比乌斯式容斥项，同样最多枚举 $256$ 项。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;对 $n$ 的不同质因子集合 $P$，$[1,x]$ 内与 $n$ 互质的数可写为&lt;/p&gt;
&lt;p&gt;$$
C(x)=\sum_{S\subseteq P}(-1)^{|S|}
\left\lfloor\frac{x}{\prod_{p\in S}p}\right\rfloor.
$$&lt;/p&gt;
&lt;p&gt;区间 $[l,r]$ 的答案为 $C(r)-C(l-1)$。&lt;/p&gt;
&lt;h3&gt;H-3. 质因子总数、因子个数与枚举规模&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;令 $\Omega(n)$ 计重数。由于 $2^{26}=67,108,864\le10^8&amp;lt;2^{27}$，故 $\Omega(n)\le26$。&lt;/li&gt;
&lt;li&gt;$10^8$ 内约数个数的最大值为 $768$，例如 $73,513,440$ 达到该值。因此对单个数直接枚举全部约数通常足够快。&lt;/li&gt;
&lt;li&gt;枚举因数对只需循环到 $\sqrt n\le10^4$；发现 $d\mid n$ 时同时处理 $d$ 与 $n/d$，平方数需避免重复。&lt;/li&gt;
&lt;li&gt;质因数分解后，约数个数为 $\tau(n)=\prod_i(e_i+1)$，欧拉函数为 $\varphi(n)=n\prod_i(1-1/p_i)$。两者都只依赖分解结果，适合一次分解后集中计算。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;H-4. 质数间隔可把&quot;大值域&quot;压成&quot;小尾段&quot;&lt;/h3&gt;
&lt;p&gt;在明确值域上界时，相邻质数间隔可作为竞赛中的小常数，但必须区分&quot;严格结论&quot;和&quot;拍脑袋常数&quot;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在 $10^7$ 内，相邻质数的最大间隔为 $154$；在 $10^8$ 内最大间隔为 $220$。&lt;/li&gt;
&lt;li&gt;因而在 $x\le10^8$ 时，向前或向后寻找附近质数，保守扫描约 $220$ 个连续整数即可覆盖内部完整质数间隔；靠近值域端点时仍需显式处理边界。&lt;/li&gt;
&lt;li&gt;这适合把区间拆成&quot;大段统一计数 + 质数附近小尾段 DP/暴力&quot;。例如边权为 $\gcd(u,v)$ 时，夹在两点之间且不整除端点的质数能提供两条权值为 $1$ 的边，从而把最短路封顶为 $2$。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning] 使用条件
&quot;中间有质数&quot;不自动推出两条边的 &lt;code&gt;gcd&lt;/code&gt; 都是 $1$。若质数 $p$ 小于端点 $v$，仍可能有 $p\mid v$。证明中应排除该情形、另选质数，或把同一小质数间隔交给暴力/DP。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;H-5. 常见建模触发器&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;题目出现&quot;与固定 $n$ 互质的区间计数&quot;：分解 $n$ 的不同质因子，做至多 $256$ 项容斥。&lt;/li&gt;
&lt;li&gt;题目出现&quot;寻找 $x$ 附近的质数&quot;且 $x\le10^8$：试除判素配合小范围扫描通常已经足够。&lt;/li&gt;
&lt;li&gt;题目出现&quot;所有质因子都大于 $10^4$&quot;且数不超过 $10^8$：该数只能是 $1$ 或质数，不可能含两个大于 $10^4$ 的质因子。&lt;/li&gt;
&lt;li&gt;题目出现 &lt;code&gt;gcd&lt;/code&gt; 边权且允许向更大的整数跳转：尝试用中间质数制造权值 $1$ 的边，再单独处理质数间隔内的短尾部。&lt;/li&gt;
&lt;li&gt;题目要求枚举 $n$ 的无平方因子约数：只枚举不同质因子子集，不必生成全部约数。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;I. 自由构造模数：同余 → 整除取差&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;题目要求&lt;strong&gt;输出一个模数&lt;/strong&gt; $m$，使得某个关系 $a \equiv b \pmod{m}$ 成立。&lt;/li&gt;
&lt;li&gt;题目允许&quot;任意合法解均可&quot;，模数不是固定输入。&lt;/li&gt;
&lt;li&gt;看到&quot;输出一个数使得……在模该数意义下……&quot;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;I-1. 触发器&lt;/h3&gt;
&lt;p&gt;题目要求构造某个模数 $m$，并满足：&lt;/p&gt;
&lt;p&gt;$$
a\equiv b\pmod m
$$&lt;/p&gt;
&lt;p&gt;或者：&lt;/p&gt;
&lt;p&gt;$$
f(x)\equiv y\pmod m
$$&lt;/p&gt;
&lt;p&gt;且 $m$ 不是输入固定的，而是允许自己输出。&lt;/p&gt;
&lt;p&gt;这时不要急着做同余方程或二次剩余判定，先把同余翻译成整除：&lt;/p&gt;
&lt;p&gt;$$
a\equiv b\pmod m
\Longleftrightarrow
m\mid a-b
$$&lt;/p&gt;
&lt;p&gt;既然 $m$ 可以自己选，若 $a\ne b$，最直接可以取&lt;/p&gt;
&lt;p&gt;$$
m=|a-b|,
$$&lt;/p&gt;
&lt;p&gt;或者取 $|a-b|$ 的某个正因子。若 $a=b$，这条同余对任意合法正模数都成立，再按题目的范围条件选 $m$ 即可。&lt;/p&gt;
&lt;h3&gt;I-2. 核心想法&lt;/h3&gt;
&lt;p&gt;如果模数由我们构造，那么我们可以反过来制造一个&quot;必然成立&quot;的模关系。&lt;/p&gt;
&lt;p&gt;常见模板：&lt;/p&gt;
&lt;p&gt;$$
f(x)\equiv y\pmod m
$$&lt;/p&gt;
&lt;p&gt;等价于：&lt;/p&gt;
&lt;p&gt;$$
m\mid f(x)-y
$$&lt;/p&gt;
&lt;p&gt;若 $f(x)\ne y$，可令&lt;/p&gt;
&lt;p&gt;$$
m=|f(x)-y|.
$$&lt;/p&gt;
&lt;p&gt;这条同余就直接成立；若 $f(x)=y$，任意合法正模数都满足它。之后仍要检查题目对 $m$ 的范围、大小、互异性等额外限制。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!tip] 赛时提醒
看到&quot;输出一个模数 / 输出一个数作为模数 / 任意合法解均可&quot;，优先把同余改写成整除。自由变量不要拿来猜，拿来消掉约束。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%B4%A2%E5%BC%95/&quot;&gt;抽象代数&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/miller-rabin%E7%AE%97%E6%B3%95/&quot;&gt;Miller Rabin算法&lt;/a&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;J. LogTrick：固定端点压缩区间运算状态&lt;/h2&gt;
&lt;p&gt;适用：区间运算满足结合律，并且固定一端后，累计值只会沿某个方向收缩/扩张。典型是 $\gcd$、LCM、按位 AND、按位 OR。&lt;/p&gt;
&lt;p&gt;固定右端点 $r$，看所有&lt;/p&gt;
&lt;p&gt;$$
f(l,r)=a_l\circ a_{l+1}\circ\cdots\circ a_r,\qquad l=r,r-1,\dots,1.
$$&lt;/p&gt;
&lt;p&gt;虽然左端点有 $O(n)$ 个，但不同的 $f(l,r)$ 往往只有 $O(\log V)$ 个，因此可以把连续产生同一结果的一批左端点合并成一个状态。&lt;/p&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;看到&quot;所有子数组的 GCD / AND / OR / 有界 LCM&quot;。&lt;/li&gt;
&lt;li&gt;固定右端点后，区间值只会变小（GCD、AND）或变大（LCM、OR）。&lt;/li&gt;
&lt;li&gt;要统计满足某个区间运算结果等于 $K$ 的子数组个数。&lt;/li&gt;
&lt;li&gt;$n$ 很大，显然不能枚举 $O(n^2)$ 个区间，但值域只有 30/60 位。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;J-1. 为什么状态数是对数级&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;GCD&lt;/strong&gt;：若新值变小，则它是旧值的真因数，因此至少减半：&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
g_{\text{new}}\mid g_{\text{old}},\quad g_{\text{new}}&amp;lt;g_{\text{old}}
\Longrightarrow
g_{\text{new}}\le \frac{g_{\text{old}}}{2}.
$$&lt;/p&gt;
&lt;p&gt;所以从 $V$ 开始最多严格变化 $O(\log V)$ 次。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;LCM&lt;/strong&gt;：若新值变大，则旧值整除新值，因此至少翻倍：&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
L_{\text{old}}\mid L_{\text{new}},\quad L_{\text{new}}&amp;gt;L_{\text{old}}
\Longrightarrow
L_{\text{new}}\ge 2L_{\text{old}}.
$$&lt;/p&gt;
&lt;p&gt;实际使用时通常设上界 $U$ 或要求最终整除目标 $K$。超过上界后直接截断，否则状态数也是 $O(\log U)$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;AND&lt;/strong&gt;：向区间里加入元素后，二进制位只会 $1\to0$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;OR&lt;/strong&gt;：向区间里加入元素后，二进制位只会 $0\to1$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;若有效位数为 $B$，每次值改变至少翻转一个尚未翻转过的 bit，因此不同值最多 $B+1$ 个。&lt;/p&gt;
&lt;h3&gt;J-2. 最稳的 Rolling Vector 写法&lt;/h3&gt;
&lt;p&gt;不要纠结&quot;最远左端点&quot;方向，直接维护 $(value,count)$：表示以当前 $r$ 结尾时，有多少个左端点得到这个 value。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;pair&amp;lt;long long, long long&amp;gt;&amp;gt; cur;

for (int r = 0; r &amp;lt; n; ++r) {
    vector&amp;lt;pair&amp;lt;long long, long long&amp;gt;&amp;gt; nxt;
    nxt.push_back({a[r], 1});          // 区间 [r,r]

    for (auto [v, cnt] : cur) {
        long long nv = std::gcd(v, a[r]); // 可换成 &amp;amp;, |, lcm
        if (!nxt.empty() &amp;amp;&amp;amp; nxt.back().first == nv)
            nxt.back().second += cnt;
        else
            nxt.push_back({nv, cnt});
    }

    cur.swap(nxt);

    // cur 中就是所有以 r 结尾的不同区间值
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么只需要合并相邻相同值：上一轮状态已经按左端点远近排好，加入同一个 $a_r$ 后，GCD / AND / OR / 有界 LCM 的变化仍保持单调，因此相同结果会连续出现。&lt;/p&gt;
&lt;p&gt;总状态数每轮只有 $O(\log V)$，所以总复杂度通常是&lt;/p&gt;
&lt;p&gt;$$
O(n\log V).
$$&lt;/p&gt;
&lt;p&gt;GCD 还要乘上一次 $\gcd$ 的常数/对数代价，但竞赛里通常很小。&lt;/p&gt;
&lt;h3&gt;J-3. 常见用途&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;统计所有子数组能得到多少种不同 GCD / AND / OR：每个 $r$ 枚举 &lt;code&gt;cur&lt;/code&gt;，扔进全局 set。&lt;/li&gt;
&lt;li&gt;统计满足 $f(l,r)=K$ 的子数组个数：若某状态 $(K,cnt)$，答案直接加 $cnt$。&lt;/li&gt;
&lt;li&gt;求区间运算结果最接近 $K$：每轮只检查 $O(\log V)$ 个状态。&lt;/li&gt;
&lt;li&gt;最短区间 LCM $=K$：先把不是 $K$ 因子的元素当断点；更新 LCM 后若不再整除 $K$，该状态直接删除。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;J-4. LCM 溢出保护&lt;/h3&gt;
&lt;p&gt;计算&lt;/p&gt;
&lt;p&gt;$$
\operatorname{lcm}(a,b)=\frac{a}{\gcd(a,b)}\cdot b
$$&lt;/p&gt;
&lt;p&gt;必须先除后乘。若只关心不超过上界 $U$，设&lt;/p&gt;
&lt;p&gt;$$
x=\frac{a}{\gcd(a,b)}.
$$&lt;/p&gt;
&lt;p&gt;乘之前判断&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;if (x &amp;gt; U / b) {
    // lcm &amp;gt; U，直接截断
} else {
    long long l = x * b;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;J-5. ST 表 + 二分跳跃&lt;/h3&gt;
&lt;p&gt;另一种写法是先用 ST 表支持静态区间 GCD / AND / OR 查询。&lt;/p&gt;
&lt;p&gt;固定左端点 $l$，当前区间值为 $v$。由于结果沿右端点单调变化，可以二分找到满足&lt;/p&gt;
&lt;p&gt;$$
f(l,x)=v
$$&lt;/p&gt;
&lt;p&gt;的最远位置 $x$，然后从 $x+1$ 开始处理下一个不同值。&lt;/p&gt;
&lt;p&gt;若区间查询 $O(1)$，枚举一个固定端点的全部不同状态约为&lt;/p&gt;
&lt;p&gt;$$
O(\log V\log n).
$$&lt;/p&gt;
&lt;p&gt;这种写法适合需要直接找&quot;下一次值变化位置&quot;或配合离线区间查询的题；单纯扫全部子数组时通常 Rolling Vector 更短。&lt;/p&gt;
&lt;h3&gt;J-6. 赛时触发器&lt;/h3&gt;
&lt;p&gt;看到下面这些特征就想 LogTrick：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&quot;所有子数组的 GCD / AND / OR&quot;&lt;/li&gt;
&lt;li&gt;&quot;固定右端点后，区间值只会变小/变大&quot;&lt;/li&gt;
&lt;li&gt;&quot;要求统计某个区间运算结果等于 $K$&quot;&lt;/li&gt;
&lt;li&gt;&quot;$n$ 很大，显然不能枚举 $O(n^2)$ 个区间，但值域只有 30/60 位&quot;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;一句话：&lt;strong&gt;固定一个端点，把连续产生同一运算结果的左端点压成一个状态；状态数靠因数链或 bit 单调性压到 $O(\log V)$。&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;K. 网格图 Hamilton 路径 / 回路：先看黑白染色&lt;/h2&gt;
&lt;h3&gt;使用场景&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;二维网格要求“一笔走完所有格子”、每格恰好经过一次。&lt;/li&gt;
&lt;li&gt;判断某两个指定端点之间能否存在 Hamilton 路径。&lt;/li&gt;
&lt;li&gt;网格删点、加边、加障碍后，需要先做快速无解判定。&lt;/li&gt;
&lt;li&gt;构造 Hamilton 回路/路径前，先检查奇偶性和黑白点数量。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;K-1. 网格天然是二分图&lt;/h3&gt;
&lt;p&gt;对格点 $(x,y)$ 按&lt;/p&gt;
&lt;p&gt;$$
c(x,y)=(x+y)\bmod 2
$$&lt;/p&gt;
&lt;p&gt;黑白染色。任意网格边都使 $x+y$ 的奇偶性翻转，因此每条边一定连接异色点。&lt;/p&gt;
&lt;p&gt;所以任何路径颜色都严格交替：&lt;/p&gt;
&lt;p&gt;$$
B\to W\to B\to W\to\cdots
$$&lt;/p&gt;
&lt;p&gt;这给 Hamilton 问题提供了最便宜也最常用的必要条件。&lt;/p&gt;
&lt;h3&gt;K-2. 黑白点数量&lt;/h3&gt;
&lt;p&gt;设 $(1,1)$ 为黑点。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $nm$ 为偶数：&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
|V_B|=|V_W|=\frac{nm}{2}.
$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $nm$ 为奇数：&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;$$
|V_B|=\frac{nm+1}{2},\qquad
|V_W|=\frac{nm-1}{2}.
$$&lt;/p&gt;
&lt;p&gt;即黑点恰好多一个。&lt;/p&gt;
&lt;h3&gt;K-3. Hamilton 回路&lt;/h3&gt;
&lt;p&gt;二分图中的任意环长度必为偶数，所以 Hamilton 回路必须满足&lt;/p&gt;
&lt;p&gt;$$
|V_B|=|V_W|.
$$&lt;/p&gt;
&lt;p&gt;对于完整矩形网格 $P_n\times P_m$：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;存在 Hamilton 回路 $\Longleftrightarrow n,m\ge2$ 且 $nm$ 为偶数。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;必要性来自二分图黑白平衡以及单行/单列无法成环；充分性可用标准蛇形构造。&lt;/p&gt;
&lt;p&gt;若其中一维为偶数，例如 $n$ 为偶数，可以保留第一列作为“回边通道”，其余部分蛇形扫描，最后沿边界回到起点。&lt;/p&gt;
&lt;p&gt;赛时记忆：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;矩形完整网格要成 Hamilton 环：不能是一条链，并且总格子数必须是偶数。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;K-4. Hamilton 路径的端点颜色&lt;/h3&gt;
&lt;p&gt;Hamilton 路径经过 $nm$ 个点，有 $nm-1$ 条边。&lt;/p&gt;
&lt;h4&gt;$nm$ 为偶数&lt;/h4&gt;
&lt;p&gt;路径长度为奇数，首尾颜色必须不同：&lt;/p&gt;
&lt;p&gt;$$
c(s)\ne c(t).
$$&lt;/p&gt;
&lt;p&gt;也就是一个黑点、一个白点。&lt;/p&gt;
&lt;h4&gt;$nm$ 为奇数&lt;/h4&gt;
&lt;p&gt;路径长度为偶数，首尾颜色相同；同时因为黑点比白点多一个，所以若 $(1,1)$ 为黑点，则必须&lt;/p&gt;
&lt;p&gt;$$
c(s)=c(t)=0.
$$&lt;/p&gt;
&lt;p&gt;即两个端点都必须取多数色。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning] 颜色条件通常只是必要条件
对“指定任意两个端点”的矩形网格 Hamilton 路径，除了颜色相容，还可能受到窄网格、边界位置、割结构等限制。竞赛中除非已经有对应定理或构造证明，否则不要直接把“颜色满足”当成充分条件。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;所谓 &lt;strong&gt;Hamilton-laceable&lt;/strong&gt;，强调的是二分图中颜色相容的两端点之间总能找到 Hamilton 路径。矩形网格的精确端点可行性有额外边界条件，做题时更实用的是：&lt;strong&gt;先用染色秒掉不可能，再针对剩余情况构造或 DP。&lt;/strong&gt;&lt;/p&gt;
&lt;h3&gt;K-5. 删点 / 加边时的快速判定&lt;/h3&gt;
&lt;h4&gt;删点后想成 Hamilton 回路&lt;/h4&gt;
&lt;p&gt;先统计剩余黑白点：&lt;/p&gt;
&lt;p&gt;$$
|V&apos;_B|\ne|V&apos;_W|
\Longrightarrow
\text{一定无解}.
$$&lt;/p&gt;
&lt;p&gt;但&lt;/p&gt;
&lt;p&gt;$$
|V&apos;_B|=|V&apos;_W|
$$&lt;/p&gt;
&lt;p&gt;只是必要条件，不保证一定存在回路；障碍可能造成割点、死角或局部不可连通。&lt;/p&gt;
&lt;p&gt;带障碍、规模较小的网格 Hamilton 回路通常考虑：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;轮廓线 DP / 插头 DP；&lt;/li&gt;
&lt;li&gt;状压 DP；&lt;/li&gt;
&lt;li&gt;根据题目特殊形状做构造。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;完美匹配、最大流可以提供额外必要条件或辅助建模，但&lt;strong&gt;一般不能单独判定 Hamilton 回路存在性&lt;/strong&gt;。&lt;/p&gt;
&lt;h4&gt;奇数网格额外加一条边&lt;/h4&gt;
&lt;p&gt;原图黑点比白点多 $1$。若想形成经过全部点的 Hamilton 回路，回路中必须“补偿”一次颜色交替被打破。&lt;/p&gt;
&lt;p&gt;因此新增边若仍然是黑白边，整体仍保持二分图，奇数个顶点不可能形成 Hamilton 环。&lt;/p&gt;
&lt;p&gt;若有希望，新增边必须是同色边；在 $(1,1)$ 为黑色的标准染色下，尤其要关注&lt;strong&gt;黑—黑边&lt;/strong&gt;。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning]
“存在一条黑—黑新增边”仍然只是必要方向，不自动保证整张图能构造成 Hamilton 回路。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;K-6. 赛时触发器&lt;/h3&gt;
&lt;p&gt;看到网格“一笔走完 / 每格恰一次 / 回到起点”，先做三件事：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;染色：$c(x,y)=(x+y)\bmod2$。&lt;/li&gt;
&lt;li&gt;数黑白点：回路要求相等；路径看端点颜色。&lt;/li&gt;
&lt;li&gt;再检查结构：边界、障碍、割点、窄网格，最后才进入构造或插头 DP。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;一句话：&lt;strong&gt;网格 Hamilton 问题先别急着搜路径，先用二分图黑白计数把不可能情况砍掉。&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;L. 概率与期望&lt;/h2&gt;
&lt;h3&gt;L-1. 概率计算&lt;/h3&gt;
&lt;p&gt;独立事件的交集概率相乘，互斥事件的并集概率相加。&lt;/p&gt;
&lt;p&gt;$$
P(A\cap B)=P(A)P(B\mid A).
$$&lt;/p&gt;
&lt;p&gt;只有独立时才能把 $P(B\mid A)$ 换成 $P(B)$。不放回抽样通常不独立。&lt;/p&gt;
&lt;p&gt;至少发生一次，先算一次都不发生。各次独立、发生概率为 $p_i$ 时：&lt;/p&gt;
&lt;p&gt;$$
P(\text{至少一次})=1-\prod_i(1-p_i).
$$&lt;/p&gt;
&lt;p&gt;事件不独立时，可用容斥：&lt;/p&gt;
&lt;p&gt;$$
P\left(\bigcup_{i=1}^n A_i\right)
=\sum_{\varnothing\ne S\subseteq[n]}(-1)^{|S|+1}
P\left(\bigcap_{i\in S}A_i\right).
$$&lt;/p&gt;
&lt;h3&gt;L-2. 期望的性质&lt;/h3&gt;
&lt;p&gt;离散变量按概率求和，有密度的连续变量按密度积分：&lt;/p&gt;
&lt;p&gt;$$
E[g(X)]=\sum_x g(x)P(X=x),\qquad
E[g(X)]=\int g(x)f_X(x),dx.
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;线性性不要求独立。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;$$
E\left[c+\sum_i w_iX_i\right]=c+\sum_iw_iE[X_i].
$$&lt;/p&gt;
&lt;p&gt;例如相邻差共享元素，仍然可以拆开算：&lt;/p&gt;
&lt;p&gt;$$
E\left[\sum_{i=2}^n|a_i-a_{i-1}|\right]
=\sum_{i=2}^nE[|a_i-a_{i-1}|].
$$&lt;/p&gt;
&lt;p&gt;若 $X,Y$ 独立，则 $E[XY]=E[X]E[Y]$。但下面这些式子一般不成立：&lt;/p&gt;
&lt;p&gt;$$
E[X^2]=E[X]^2,\qquad E[|X|]=|E[X]|,\qquad
E[X/Y]=E[X]/E[Y].
$$&lt;/p&gt;
&lt;p&gt;按第一步结果分类，就是全期望公式。设 $B_i$ 是互斥且覆盖所有情况的事件：&lt;/p&gt;
&lt;p&gt;$$
E[X]=\sum_iP(B_i)E[X\mid B_i].
$$&lt;/p&gt;
&lt;p&gt;期望 DP 的转移由此得到。&lt;/p&gt;
&lt;h3&gt;L-3. 指示变量与贡献法&lt;/h3&gt;
&lt;p&gt;设 $I_i$ 表示第 $i$ 个对象是否贡献，贡献为 $1$，否则为 $0$。那么&lt;/p&gt;
&lt;p&gt;$$
E[I_i]=P(I_i=1),\qquad
E\left[\sum_i I_i\right]=\sum_iP(I_i=1).
$$&lt;/p&gt;
&lt;p&gt;求数量的期望，往往只需要算单个对象被计入的概率。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;问题&lt;/th&gt;
&lt;th&gt;单个贡献的概率&lt;/th&gt;
&lt;th&gt;期望&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;$n$ 个互异元素的均匀随机排列，逆序对数&lt;/td&gt;
&lt;td&gt;每对下标为 $1/2$&lt;/td&gt;
&lt;td&gt;$n(n-1)/4$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同上，前缀最大值个数&lt;/td&gt;
&lt;td&gt;第 $i$ 位为 $1/i$&lt;/td&gt;
&lt;td&gt;$H_n$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$m$ 个球独立均匀放入 $n$ 个盒子，非空盒子数&lt;/td&gt;
&lt;td&gt;每盒为 $1-(1-1/n)^m$&lt;/td&gt;
&lt;td&gt;$n[1-(1-1/n)^m]$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;这里 $H_n=\sum_{i=1}^n1/i$，$H_0=0$。&lt;/p&gt;
&lt;p&gt;覆盖长度也可以按位置拆：整数位置求 $\sum_xP(x\text{ 被覆盖})$，连续区间求 $\int P(x\text{ 被覆盖}),dx$。&lt;/p&gt;
&lt;h3&gt;L-4. 尾和公式与最值&lt;/h3&gt;
&lt;p&gt;非负整数变量：&lt;/p&gt;
&lt;p&gt;$$
E[X]=\sum_{k=1}^{\infty}P(X\ge k),\qquad
E[X^2]=\sum_{k=1}^{\infty}(2k-1)P(X\ge k).
$$&lt;/p&gt;
&lt;p&gt;证明只需把每个取值拆开：$x=\sum_{k=1}^x1$，$x^2=\sum_{k=1}^x(2k-1)$。&lt;/p&gt;
&lt;p&gt;非负连续变量：&lt;/p&gt;
&lt;p&gt;$$
E[X]=\int_0^{\infty}P(X&amp;gt;t),dt.
$$&lt;/p&gt;
&lt;p&gt;最值先求阈值概率。若 $X_i$ 独立，$F_i(t)=P(X_i\le t)$，则&lt;/p&gt;
&lt;p&gt;$$
P(\max_iX_i\le t)=\prod_iF_i(t),\qquad
P(\min_iX_i&amp;gt;t)=\prod_i(1-F_i(t)).
$$&lt;/p&gt;
&lt;p&gt;求“最长长度、最大值、还能进行多少步”的期望时，可以先枚举阈值，算达到这个阈值的概率。&lt;/p&gt;
&lt;h3&gt;L-5. 成功次数与等待时间&lt;/h3&gt;
&lt;h4&gt;成功次数&lt;/h4&gt;
&lt;p&gt;$n$ 次独立试验，每次成功率都是 $p$，恰好成功 $k$ 次：&lt;/p&gt;
&lt;p&gt;$$
P(X=k)=\binom nkp^k(1-p)^{n-k},\qquad E[X]=np.
$$&lt;/p&gt;
&lt;p&gt;成功率不同为 $p_i$ 时，$E[X]=\sum_i p_i$。恰好成功 $k$ 次的概率用 DP：&lt;/p&gt;
&lt;p&gt;$$
dp[i][k]=dp[i-1]&lt;a href=&quot;1-p_i&quot;&gt;k&lt;/a&gt;+dp[i-1][k-1]p_i,
\qquad dp[0][0]=1.
$$&lt;/p&gt;
&lt;p&gt;从 $N$ 个物品中均匀不放回取 $m$ 个，其中 $K$ 个是目标物品：&lt;/p&gt;
&lt;p&gt;$$
P(X=k)=\frac{\binom Kk\binom{N-K}{m-k}}{\binom Nm},\qquad
E[X]=\frac{mK}{N}.
$$&lt;/p&gt;
&lt;p&gt;不合法的组合数按 $0$ 处理。&lt;/p&gt;
&lt;h4&gt;首次成功&lt;/h4&gt;
&lt;p&gt;每次独立成功率为 $p&amp;gt;0$，$T$ 包含成功那次：&lt;/p&gt;
&lt;p&gt;$$
P(T=k)=(1-p)^{k-1}p,\qquad E[T]=\frac1p.
$$&lt;/p&gt;
&lt;p&gt;也可以写 $E=1+(1-p)E$，移项得 $E=1/p$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;只数成功前的失败次数：$(1-p)/p$。&lt;/li&gt;
&lt;li&gt;等到累计 $k$ 次成功：$k/p$。&lt;/li&gt;
&lt;li&gt;等到连续 $k$ 次成功：$\sum_{j=1}^k p^{-j}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;连续成功的式子可由状态方程推出。$E_j$ 表示当前连续成功 $j$ 次，到结束还需的步数：&lt;/p&gt;
&lt;p&gt;$$
E_j=1+pE_{j+1}+(1-p)E_0\quad(0\le j&amp;lt;k),\qquad E_k=0.
$$&lt;/p&gt;
&lt;h4&gt;分阶段&lt;/h4&gt;
&lt;p&gt;在阶段 $i$，每次独立以概率 $p_i&amp;gt;0$ 进入下一阶段，失败仍停在原阶段。总期望为&lt;/p&gt;
&lt;p&gt;$$
\sum_i\frac1{p_i}.
$$&lt;/p&gt;
&lt;p&gt;每次独立均匀抽取 $n$ 种物品之一，已经有 $k$ 种时，抽到新种类的概率为 $(n-k)/n$。集齐全部的期望为&lt;/p&gt;
&lt;p&gt;$$
E[T]=\sum_{k=0}^{n-1}\frac n{n-k}=nH_n.
$$&lt;/p&gt;
&lt;p&gt;只需集齐任意 $m$ 种，则为 $n(H_n-H_{n-m})$。各种物品概率不相等时，不能套这个式子。&lt;/p&gt;
&lt;h3&gt;L-6. 均匀分布&lt;/h3&gt;
&lt;p&gt;设 $L=r-l$，$m=r-l+1$。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;连续 $U[l,r]$，$L&amp;gt;0$&lt;/th&gt;
&lt;th&gt;整数 $l,l+1,\dots,r$ 等概率&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;密度 / 单点概率&lt;/td&gt;
&lt;td&gt;区间内密度 $1/L$，单点概率为 $0$&lt;/td&gt;
&lt;td&gt;每个整数概率 $1/m$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$E[X]$&lt;/td&gt;
&lt;td&gt;$(l+r)/2$&lt;/td&gt;
&lt;td&gt;$(l+r)/2$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\operatorname{Var}(X)$&lt;/td&gt;
&lt;td&gt;$L^2/12$&lt;/td&gt;
&lt;td&gt;$(m^2-1)/12$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$E[X^2]$&lt;/td&gt;
&lt;td&gt;$(l^2+lr+r^2)/3$&lt;/td&gt;
&lt;td&gt;$((l+r)/2)^2+(m^2-1)/12$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;连续分布除以 $r-l$，整数分布除以 $r-l+1$。$l=r$ 时是常数，期望为 $l$、方差为 $0$。&lt;/p&gt;
&lt;p&gt;连续均匀变量的分布函数：&lt;/p&gt;
&lt;p&gt;$$
F_X(t)=\begin{cases}
0,&amp;amp;t&amp;lt;l,\
(t-l)/L,&amp;amp;l\le t\le r,\
1,&amp;amp;t&amp;gt;r.
\end{cases}
$$&lt;/p&gt;
&lt;p&gt;区间概率等于交集长度除以 $L$；整数分布则数交集中的整数个数，再除以 $m$。&lt;/p&gt;
&lt;p&gt;令 $X=l+LU$，$U\sim U[0,1]$，可以把一般区间化到 $[0,1]$。对整数 $k\ge0$：&lt;/p&gt;
&lt;p&gt;$$
E[U^k]=\frac1{k+1},\qquad
E[X^k]=\frac{r^{k+1}-l^{k+1}}{(k+1)(r-l)}.
$$&lt;/p&gt;
&lt;h4&gt;连续抽样：第 $k$ 小、最值和间隔&lt;/h4&gt;
&lt;p&gt;在 $[l,r]$ 中独立均匀取 $n$ 个点，排序后记为 $X_{(1)},\dots,X_{(n)}$：&lt;/p&gt;
&lt;p&gt;$$
E[X_{(k)}]=l+\frac{kL}{n+1},
$$&lt;/p&gt;
&lt;p&gt;$$
E[\min X_i]=l+\frac L{n+1},\qquad
E[\max X_i]=r-\frac L{n+1},
$$&lt;/p&gt;
&lt;p&gt;$$
E[\max X_i-\min X_i]=\frac{n-1}{n+1}L.
$$&lt;/p&gt;
&lt;p&gt;加上两个端点后，共有 $n+1$ 个间隔。各间隔同分布、总长为 $L$，所以每个间隔的期望都是 $L/(n+1)$。第 $k$ 小距左端点的长度是前 $k$ 个间隔之和。&lt;/p&gt;
&lt;h4&gt;整数抽样：有放回&lt;/h4&gt;
&lt;p&gt;$n$ 次独立均匀取整数 $l,\dots,r$，允许重复：&lt;/p&gt;
&lt;p&gt;$$
E[\max X_i]=l+\sum_{j=1}^{m-1}\left(1-\left(\frac jm\right)^n\right),
$$&lt;/p&gt;
&lt;p&gt;$$
E[\min X_i]=l+\sum_{j=1}^{m-1}\left(\frac{m-j}{m}\right)^n.
$$&lt;/p&gt;
&lt;p&gt;由尾和公式得到，$m=1$ 时空和为 $0$。&lt;/p&gt;
&lt;h4&gt;整数抽样：不放回&lt;/h4&gt;
&lt;p&gt;从 $1,\dots,N$ 中均匀选出 $m$ 个不同数，排序后为 $S_1&amp;lt;\cdots&amp;lt;S_m$：&lt;/p&gt;
&lt;p&gt;$$
E[S_k]=\frac{k(N+1)}{m+1}.
$$&lt;/p&gt;
&lt;p&gt;选中元素前后及之间共有 $m+1$ 个空隙，未选中元素共 $N-m$ 个。每个空隙中未选中元素数的期望为 $(N-m)/(m+1)$，于是 $E[S_k]=k+k(N-m)/(m+1)$。&lt;/p&gt;
&lt;h3&gt;L-7. 均匀分布的距离&lt;/h3&gt;
&lt;h4&gt;点到区间&lt;/h4&gt;
&lt;p&gt;$X\sim U[l,r]$，$L=r-l&amp;gt;0$，固定点为 $p$：&lt;/p&gt;
&lt;p&gt;$$
E[|X-p|]=\frac{(r-p)|r-p|-(l-p)|l-p|}{2L}.
$$&lt;/p&gt;
&lt;p&gt;分段写法：&lt;/p&gt;
&lt;p&gt;$$
E[|X-p|]=\begin{cases}
(l+r)/2-p,&amp;amp;p\le l,\
\big((p-l)^2+(r-p)^2\big)/(2L),&amp;amp;l&amp;lt;p&amp;lt;r,\
p-(l+r)/2,&amp;amp;p\ge r.
\end{cases}
$$&lt;/p&gt;
&lt;h4&gt;两个区间&lt;/h4&gt;
&lt;p&gt;$X\sim U[a,b]$、$Y\sim U[c,d]$ 独立，$A=b-a&amp;gt;0$、$B=d-c&amp;gt;0$：&lt;/p&gt;
&lt;p&gt;$$
\boxed{E[|X-Y|]
=\frac{|b-c|^3+|a-d|^3-|a-c|^3-|b-d|^3}{6AB}}.
$$&lt;/p&gt;
&lt;p&gt;推导：联合密度为 $1/(AB)$，而&lt;/p&gt;
&lt;p&gt;$$
\int_c^d|x-y|,dy
=\frac{(x-c)|x-c|-(x-d)|x-d|}{2},
$$&lt;/p&gt;
&lt;p&gt;$$
\int_a^b\int_c^d|x-y|,dy,dx
=\left[\frac{|x-c|^3-|x-d|^3}{6}\right]_a^b.
$$&lt;/p&gt;
&lt;p&gt;区间相离、相交、包含都适用。一个区间退化为点时用“点到区间”；两个都是点时直接取绝对差。&lt;/p&gt;
&lt;p&gt;若 $b\le c$，直接算 $E[Y]-E[X]=(c+d-a-b)/2$。&lt;/p&gt;
&lt;h4&gt;同一区间&lt;/h4&gt;
&lt;p&gt;$X,Y$ 独立同分布：&lt;/p&gt;
&lt;p&gt;| | $E[|X-Y|]$ | $E[(X-Y)^2]$ |
| --- | --- | --- |
| 连续区间，长度 $L$ | $L/3$ | $L^2/6$ |
| 整数区间，共 $m$ 个数 | $(m^2-1)/(3m)$ | $(m^2-1)/6$ |&lt;/p&gt;
&lt;p&gt;整数绝对差按距离枚举：距离 $k&amp;gt;0$ 的有序数对有 $2(m-k)$ 对，所以&lt;/p&gt;
&lt;p&gt;$$
E[|X-Y|]=\frac2{m^2}\sum_{k=1}^{m-1}k(m-k)=\frac{m^2-1}{3m}.
$$&lt;/p&gt;
&lt;p&gt;同一连续区间中，距离不超过 $t$ 的概率为&lt;/p&gt;
&lt;p&gt;$$
P(|X-Y|\le t)=\frac{2t}{L}-\frac{t^2}{L^2},\qquad 0\le t\le L.
$$&lt;/p&gt;
&lt;p&gt;可在边长为 $L$ 的正方形中，减掉 $|x-y|&amp;gt;t$ 对应的两个三角形来推。&lt;/p&gt;
&lt;h4&gt;两个数的大小关系&lt;/h4&gt;
&lt;p&gt;仍设两个区间非退化且独立，记 $z_+=\max(z,0)$：&lt;/p&gt;
&lt;p&gt;$$
P(X\le Y)=\frac{(d-a)&lt;em&gt;+^2-(d-b)&lt;/em&gt;+^2-(c-a)&lt;em&gt;+^2+(c-b)&lt;/em&gt;+^2}{2AB}.
$$&lt;/p&gt;
&lt;p&gt;由 $P(X\le Y)=\frac1B\int_c^dF_X(y),dy$ 积分得到。&lt;/p&gt;
&lt;p&gt;这里 $P(X=Y)=0$。整数分布则需要另算相等概率，不能混用 $&amp;lt;$ 和 $\le$。&lt;/p&gt;
&lt;h3&gt;L-8. 二阶矩与方差&lt;/h3&gt;
&lt;p&gt;$$
\operatorname{Var}(X)=E[X^2]-E[X]^2.
$$&lt;/p&gt;
&lt;p&gt;计算总贡献平方时，展开成单项和成对贡献：&lt;/p&gt;
&lt;p&gt;$$
E\left[\left(\sum_iX_i\right)^2\right]
=\sum_iE[X_i^2]+2\sum_{i&amp;lt;j}E[X_iX_j].
$$&lt;/p&gt;
&lt;p&gt;对指示变量，$I_i^2=I_i$，$E[I_iI_j]=P(I_i=I_j=1)$。因此计数的方差通常需要算“两件事同时发生”的概率。&lt;/p&gt;
&lt;p&gt;独立时：&lt;/p&gt;
&lt;p&gt;$$
\operatorname{Var}\left(\sum_iX_i\right)=\sum_i\operatorname{Var}(X_i).
$$&lt;/p&gt;
&lt;p&gt;独立试验的成功次数，方差为 $\sum_i p_i(1-p_i)$。&lt;/p&gt;
&lt;p&gt;两个独立变量的平方差：&lt;/p&gt;
&lt;p&gt;$$
E[(X-Y)^2]=\operatorname{Var}(X)+\operatorname{Var}(Y)+(E[X]-E[Y])^2.
$$&lt;/p&gt;
&lt;h3&gt;L-9. 期望 DP&lt;/h3&gt;
&lt;h4&gt;正推&lt;/h4&gt;
&lt;p&gt;按步数分层或在 DAG 上，维护：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$P_s$：到达状态 $s$ 的概率。&lt;/li&gt;
&lt;li&gt;$F_s$：到达状态 $s$ 的所有情况中，累计得分乘概率的和。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;边 $s\to t$ 的转移概率为 $p$，新增得分为 $w$：&lt;/p&gt;
&lt;p&gt;$$
P_t\mathrel{+}=pP_s,\qquad
F_t\mathrel{+}=p(F_s+wP_s).
$$&lt;/p&gt;
&lt;p&gt;初始状态 $P=1,F=0$，答案为所有终止状态的 $F$ 之和。$F_s$ 已经包含到达概率，新增得分仍需乘 $P_s$。&lt;/p&gt;
&lt;h4&gt;倒推&lt;/h4&gt;
&lt;p&gt;$E_s$ 表示从状态 $s$ 出发，到结束还需要的期望代价。转移概率为 $p_{st}$、单步代价为 $w_{st}$：&lt;/p&gt;
&lt;p&gt;$$
E_s=\sum_t p_{st}(w_{st}+E_t).
$$&lt;/p&gt;
&lt;p&gt;没有终点奖励时 $E_{\mathrm{end}}=0$。每步代价都是 $1$ 时：&lt;/p&gt;
&lt;p&gt;$$
E_s=1+\sum_t p_{st}E_t.
$$&lt;/p&gt;
&lt;p&gt;自环概率为 $q&amp;lt;1$，移项：&lt;/p&gt;
&lt;p&gt;$$
E_s=\frac{1+\sum_{t\ne s}p_{st}E_t}{1-q}.
$$&lt;/p&gt;
&lt;p&gt;有一般环依赖时写线性方程组，不能直接记忆化递归。先检查是否可能进入无法到达终点的状态；若能以正概率进入，结束步数的期望为无穷大。&lt;/p&gt;
&lt;p&gt;状态需包含决定后续转移的全部信息。例如连续成功题要记当前连击长度，不能只记已经进行多少次。&lt;/p&gt;
&lt;h4&gt;二阶矩转移&lt;/h4&gt;
&lt;p&gt;$Q_s$ 表示从 $s$ 出发，剩余总代价平方的期望。边代价 $w_{st}$ 固定时：&lt;/p&gt;
&lt;p&gt;$$
Q_s=\sum_t p_{st}(w_{st}^2+2w_{st}E_t+Q_t).
$$&lt;/p&gt;
&lt;p&gt;先求 $E_s$，再求 $Q_s$，方差为 $Q_s-E_s^2$。&lt;/p&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E6%9C%9F%E6%9C%9Bdp/&quot;&gt;期望DP&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;L-10. 取模&lt;/h3&gt;
&lt;p&gt;有理数 $P/Q$ 的模表示为 $P\cdot Q^{-1}$。模数 $M$ 为质数且 $Q\not\equiv0\pmod M$ 时：&lt;/p&gt;
&lt;p&gt;$$
Q^{-1}\equiv Q^{M-2}\pmod M.
$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;百分比转为 $p\cdot100^{-1}$，固定分母的逆元只算一次。&lt;/li&gt;
&lt;li&gt;比较大小、取绝对值、取 $z_+$，都在取模前做。&lt;/li&gt;
&lt;li&gt;连乘逐步取模，三次方不要直接在原整数上计算。&lt;/li&gt;
&lt;li&gt;自环移项的 $1-q$ 也要检查是否可逆。实数意义下非零，不代表模意义下非零。&lt;/li&gt;
&lt;li&gt;大量非零分母可用前缀积和倒推批量求逆，只求一次总乘积的逆元，复杂度 $O(n+\log M)$。&lt;/li&gt;
&lt;li&gt;分母模 $M$ 为 $0$ 时不能硬求逆。先在有理数层面约分，最终分母仍与 $M$ 不互质，则这种模表示不存在。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;M. 切比雪夫距离与曼哈顿距离&lt;/h2&gt;
&lt;p&gt;设 $P=(x_1,y_1),Q=(x_2,y_2)$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;曼哈顿距离&lt;/strong&gt;：$d_1(P,Q)=|x_1-x_2|+|y_1-y_2|$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;切比雪夫距离&lt;/strong&gt;：$d_\infty(P,Q)=\max(|x_1-x_2|,|y_1-y_2|)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;将每个点变换为 $T(x,y)=(x+y,x-y)$，则：&lt;/p&gt;
&lt;p&gt;$$
\boxed{d_1(P,Q)=d_\infty(T(P),T(Q))}
$$&lt;/p&gt;
&lt;p&gt;$$
\boxed{d_\infty(P,Q)=\frac12d_1(T(P),T(Q))}
$$&lt;/p&gt;
&lt;p&gt;即：&lt;strong&gt;原曼哈顿 = 新切比雪夫；原切比雪夫 = 新曼哈顿的一半。&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;N. 离散介值性质与非单调二分&lt;/h2&gt;
&lt;h3&gt;N-1. 使用场景&lt;/h3&gt;
&lt;p&gt;固定长度的窗口每次右移一格，只移出左端点、加入右侧新点。若每个位置的贡献为 0 或 1，窗口统计量每次只能变化 $-1,0,1$。&lt;/p&gt;
&lt;p&gt;当题目要求找到 $f(s)=k$ 的某个位置时，可以检查相邻位置的差值是否至多为 1。此时即使 $f$ 不单调，只要找到函数值位于 $k$ 两侧的两个端点，也能二分出一个解。&lt;/p&gt;
&lt;h3&gt;N-2. 离散介值性质&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;命题&lt;/strong&gt;：设整数区间 $[L, R]$ 上的整数值函数 $f: \mathbb{Z}\cap[L, R]\to\mathbb{Z}$ 满足对任意整数 $x\in[L, R-1]$ 均有 $|f(x+1) - f(x)| \le 1$。
对任意整数 $k$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $f(L) &amp;gt; k \ge f(R)$ 且 $L &amp;lt; R$，则必存在整数 $s \in (L, R]$ 满足 $f(s) = k$。&lt;/li&gt;
&lt;li&gt;（反向跨越版本）若 $f(L) &amp;lt; k \le f(R)$ 且 $L &amp;lt; R$，则同样必存在整数 $s \in (L, R]$ 满足 $f(s) = k$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;证明&lt;/strong&gt;（以 $f(L) &amp;gt; k \ge f(R)$ 为例）：
考虑集合 $S = {x \in [L, R] \mid f(x) \le k}$。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;因为 $R \in S$，故 $S$ 是有限非空整数集，必存在最小元素 $s = \min S$。&lt;/li&gt;
&lt;li&gt;因为 $f(L) &amp;gt; k$，故 $L \notin S$，由此可知 $s &amp;gt; L$。&lt;/li&gt;
&lt;li&gt;由 $s$ 的最小性，其前驱位置 $s - 1 \notin S$，即 $f(s-1) &amp;gt; k$。由于函数值为整数，这意味着 $f(s-1) \ge k + 1$。&lt;/li&gt;
&lt;li&gt;根据单步差分约束，每步至多下降 1：$f(s) \ge f(s-1) - 1 \ge k$。&lt;/li&gt;
&lt;li&gt;结合 $s \in S$ 的定义 $f(s) \le k$，两式夹逼立得 $f(s) = k$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;N-3. 非单调二分&lt;/h3&gt;
&lt;p&gt;这里不要求 $f$ 单调，也不要求判定式 $f(s)&amp;gt;k$ 构成一个连续前缀。&lt;/p&gt;
&lt;p&gt;算法维护当前搜索区间 $[L, R]$，其循环不变式始终为：&lt;/p&gt;
&lt;p&gt;$$
f(L) &amp;gt; k \quad \text{且} \quad f(R) \le k
$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;取 $\mathrm{mid} = \lfloor(L + R) / 2\rfloor$。&lt;/li&gt;
&lt;li&gt;若 $f(\mathrm{mid}) &amp;gt; k$，更新 $L \leftarrow \mathrm{mid}$；否则更新 $R \leftarrow \mathrm{mid}$。&lt;/li&gt;
&lt;li&gt;循环终止条件为 $L + 1 = R$（区间长度缩减为 1，两端点为相邻整数）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;相邻端点收敛正确性&lt;/strong&gt;：终止时由不变式可知 $f(L) \ge k + 1$ 且 $f(R) \le k$。又由单步变化约束 $|f(R) - f(L)| \le 1$，两端至多相差 1，因此两个不等式必然同时取等，推导出 $f(L) = k + 1$ 且 $f(R) = k$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;被丢弃的半边可能也有解，但保留下来的两端始终分别满足 $f(L)&amp;gt;k$ 与 $f(R)\le k$。二分只利用这两个端点的跨越关系，直到它们相邻；并不是在求单调分界点。&lt;/p&gt;
&lt;h3&gt;N-4. 实例：CF Target Infection&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;题意抽象&lt;/strong&gt;：数轴上给定若干互不相交的闭区间 $[l_i, r_i]$（均为感染点，其余为 0）。给定检测窗口长度 $m$ 与目标感染数 $k$，求是否存在窗口 $[s, s + m - 1]$ 使得其中的感染点数恰好为 $k$。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;单步变化性质&lt;/strong&gt;：
设 $a(x) \in {0, 1}$ 为坐标 $x$ 是否被感染的示性函数。窗口以 $s$ 为左端点，包含感染点数为 $f(s)$，则平移一步的变化为：
$$
f(s+1) - f(s) = a(s+m) - a(s) \in {-1, 0, 1}
$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;全局最大值必可在某个 $l_i$ 处取到&lt;/strong&gt;：
设某个窗口 $[s^&lt;em&gt;, s^&lt;/em&gt; + m - 1]$ 取得全局感染点数最大值：
&lt;ul&gt;
&lt;li&gt;若 $s^&lt;em&gt;$ 为非感染点且右侧还有感染区间，向右平移至下一个区间左端点 $l_i$。平移时左端移出的全是 0，右端移入点数非负，$f$ 不减。若 $s^&lt;/em&gt;&amp;gt;r_n$，则 $f(s^*)=0$，而 $f(l_n)\ge1$，因此这不可能是最大值点；&lt;/li&gt;
&lt;li&gt;若 $s^&lt;em&gt;$ 落在某个感染区间内部且 $s^&lt;/em&gt; &amp;gt; l_i$，向左平移窗口至 $l_i$。平移期间左端移入的全是 1，右端移出点数至多等于移入点数，$f$ 不减。&lt;/li&gt;
&lt;li&gt;故枚举所有区间的左端点 $l_i$，必能覆盖到至少一个全局最大值。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;算法流程与边界处理&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;遍历所有 $l_i$ 计算 $f(l_i)$：
&lt;ul&gt;
&lt;li&gt;若中途直接命中 $f(l_i) = k$，直接输出 $l_i$ 即可（包含 $k = 0$ 时若恰好有 $f(l_i) = 0$）；&lt;/li&gt;
&lt;li&gt;若存在 $f(l_i) &amp;gt; k$，记录任意一个满足条件的端点作为二分左端点 $L$；&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;若所有 $l_i$ 均满足 $f(l_i) &amp;lt; k$，由于最大值亦严格小于 $k$，问题直接无解；&lt;/li&gt;
&lt;li&gt;确定 $L$ 后，取右端点 $R = r_n + 1$。因为窗口完全落在所有感染区间右侧，窗口内感染数为 $f(R) = 0$。对于任意非负目标 $k \ge 0$，均满足 $f(R) = 0 \le k$；特别地若 $k = 0$，此处可直接确定有解；&lt;/li&gt;
&lt;li&gt;此时满足 $L &amp;lt; R$ 且 $f(L) &amp;gt; k \ge f(R)$，直接调用非单调二分，返回收敛时的 $R$ 即可。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$O(\log n)$ 快速求 $f(s)$&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;令 $F(x)$ 为坐标 $\le x$ 的感染点总数，则 $f(s) = F(s + m - 1) - F(s - 1)$。&lt;/li&gt;
&lt;li&gt;区间互不相交，维护各区间长度的前缀和。用 &lt;code&gt;std::upper_bound&lt;/code&gt; 找到最后一个满足 $l_j\le x$ 的区间，再计算 $pre[j-1]+\min(x,r_j)-l_j+1$；没有这样的区间时取 0。即使 $x$ 位于两个区间的空隙中，公式也成立。单次计算为 $O(\log n)$。&lt;/li&gt;
&lt;li&gt;坐标与前缀长度可能达到 $10^{15}$，相关计算需统一使用 &lt;code&gt;long long&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;N-5. C++17 核心模板&lt;/h3&gt;
&lt;p&gt;以下代码放在 &lt;code&gt;solve()&lt;/code&gt; 内；&lt;code&gt;f(s)&lt;/code&gt; 已实现，区间数组 &lt;code&gt;l,r&lt;/code&gt; 使用 1-based 下标，&lt;code&gt;n,k&lt;/code&gt; 和坐标均为整数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto find_s = [&amp;amp;]() -&amp;gt; ll {
    if (k == 0) return r[n] + 1;

    ll L = -1;
    for (int i = 1; i &amp;lt;= n; ++i) {
        ll val = f(l[i]);
        if (val == k) return l[i];
        if (val &amp;gt; k) {
            L = l[i];
            break;
        }
    }
    if (L == -1) return -1; // 最大感染数小于 k

    ll R = r[n] + 1;        // f(L) &amp;gt; k，f(R) = 0 &amp;lt;= k
    while (L + 1 &amp;lt; R) {
        ll mid = L + (R - L) / 2;
        if (f(mid) &amp;gt; k) L = mid;
        else R = mid;
    }
    return R; // 相邻时必有 f(R) == k
};

cout &amp;lt;&amp;lt; find_s() &amp;lt;&amp;lt; &apos;\n&apos;;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;局限：若每步可跳过整数目标（如 $2\to0$ 找 1），结论不成立；两端未跨越 $k$ 时也不适用。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;O. SOS：先把集合包含方向写出来&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：候选满足“至少含有这些位”、与 x 按位不相交、某些位全部为1。&lt;/p&gt;
&lt;p&gt;子集和从缺一位传给有这一位，超集和从有这一位传给缺这一位。用 &lt;code&gt;01&lt;/code&gt; 检查：子集是 &lt;code&gt;00,01&lt;/code&gt;，超集是 &lt;code&gt;01,11&lt;/code&gt;。&lt;code&gt;x&amp;amp;y==0&lt;/code&gt; 则 y 是 &lt;code&gt;FULL^x&lt;/code&gt; 的子集，调用 &lt;code&gt;cp::subset_witness(a,B)&lt;/code&gt; 后查补集即可。&lt;/p&gt;
&lt;p&gt;求非空子集 AND=0：超集统计 c[S]，容斥加减 &lt;code&gt;2^c[S]-1&lt;/code&gt;，符号由 popcount(S) 的奇偶决定。预处理2的幂，避免每个mask重复快速幂。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;cf/165E.cpp&lt;/code&gt;、&lt;code&gt;cf/449D.cpp&lt;/code&gt;。完整公式见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#5-%E9%9B%86%E5%90%88%E5%85%B3%E7%B3%BB-sos-%E6%96%B9%E5%90%91%E4%B8%8E%E5%AE%B9%E6%96%A5&quot;&gt;算法竞赛数学套路&lt;/a&gt;，自包含代码见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;P. 乘积为完全平方：质因子指数奇偶 + 前缀相等&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：区间乘积巨大，但只关心它是否为平方。&lt;/p&gt;
&lt;p&gt;不乘出乘积，而存质因子指数模2。区间乘积为平方 iff 两端前缀向量相同。用质数集合对称差维护，或质数种类小时压成bit。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;12&lt;/code&gt; 和 &lt;code&gt;3&lt;/code&gt; 相乘为平方，指数2必须抵消；不能只记出现的质数，也不能将质数本身数值随意XOR来替代坐标向量。0与负数额外处理。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;cf/cf1125/f.cpp&lt;/code&gt;。完全k次幂改成指数模k，查询互补向量。&lt;/p&gt;
&lt;h2&gt;Q. 严格多数的坏事件互斥&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：每个选择只属一个类别，禁止某类数量超过所选总数的一半。&lt;/p&gt;
&lt;p&gt;两类不能同时严格过半，故“总方案数 - 每类坏方案数之和”即可。固定类别j，用差值 &lt;code&gt;选j个数-选其他个数&lt;/code&gt; 做DP，最后减去差值&amp;gt;0的状态。&lt;/p&gt;
&lt;p&gt;若变为“大于等于一半”，两类各占一半可以同时发生，就不能直接减。空方案是否允许必须独立处理。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;luogu/P5664.cpp&lt;/code&gt;，转移与模减法见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#6-%E4%B8%A5%E6%A0%BC%E5%A4%9A%E6%95%B0-%E5%9D%8F%E4%BA%8B%E4%BB%B6%E5%8F%AF%E8%83%BD%E4%BA%92%E6%96%A5&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;R. mask 已决定的余数，不再增加状态维&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：已选元素集合固定，所有组目标和为T。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;rem=sum[mask]%T&lt;/code&gt; 唯一，删除余数维。但“余数为0”是否完成一个合法组依赖题意；装桶需检查不超过T，计数倍数边界是另一种模型。&lt;code&gt;dp[0]&lt;/code&gt; 根据“已完成非空组数”初始化为0。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;atcoder/atcoder480/f.cpp&lt;/code&gt;。用充分性与可恢复性同时审查状态：未来不同则不能合并，量已唯一决定则不必存。&lt;/p&gt;
&lt;h2&gt;S. 离线缓存：下一次最晚使用者优先淘汰&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：已知完整访问序列，容量有限、载入代价相同，求最少缺失。&lt;/p&gt;
&lt;p&gt;从后往前计算每次访问的下一次位置；标准单项请求模型中，满缓存缺失时淘汰下次使用最远的已有对象，永不再用视为无穷。交换论证：若另一方案淘汰更早要用者，交换这两个淘汰对象，在更早的那次访问前不会更差。&lt;/p&gt;
&lt;p&gt;本地 &lt;code&gt;nowcoder_2026_summer/8/m.cpp&lt;/code&gt; 将Trie前缀映射为访问对象，并用PBDS修改下一次位置。&lt;strong&gt;整批前缀需要共存的规则和逐个请求不同&lt;/strong&gt;，不能把通用单项模板原封不动套到整批模型。是否能提前丢弃、当前批次容量如何约束，均要查原题。&lt;/p&gt;
&lt;p&gt;自包含单项版本 &lt;code&gt;cp::offline_cache_misses&lt;/code&gt; 使用惰性堆，复杂度O(n log n)、空间O(n)，不是O(n log capacity)。容量0单独返回访问数。&lt;/p&gt;
&lt;h2&gt;T. min/max 组成代价：断点与斜率&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：参数t变化，代价为线性项加若干截断区间贡献。&lt;/p&gt;
&lt;p&gt;先标出改变表达式的断点，如l_i,r_i。相邻断点间函数线性，最值在端点或整段取得；不需要先证明整个函数单峰。&lt;/p&gt;
&lt;p&gt;同坐标事件一起处理：旧斜率推值到pos → 更新答案 → 合并pos事件。&lt;code&gt;cp::clipped_cost_min&lt;/code&gt; 对指定的截断模型返回最优值与t；通用推导见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#19-%E5%88%86%E6%AE%B5%E7%BA%BF%E6%80%A7%E5%87%BD%E6%95%B0-%E6%89%AB%E6%96%AD%E7%82%B9-%E4%B8%8D%E7%8C%9C%E5%8D%95%E5%B3%B0&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;reginonals/26xian/h.cpp&lt;/code&gt;。128位必须保护括号内乘法。&lt;/p&gt;
&lt;h2&gt;U. 同步加减的数对：先压缩差值&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：两数一起加减，或者同时除某个公因子。&lt;/p&gt;
&lt;p&gt;一起加减保持差d；共同因子整除d；同除p使差变d/p。因此可先分解初始差，递归只选择其质因子，再记忆化当前(a,d)。向上和向下凑倍数是否都允许，必须服从原题。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;reginonals/21nanjing/j.cpp&lt;/code&gt;。d=0、1及数值是否要求正数需单独分析，不能盲抄非零差的分解过程。&lt;/p&gt;
&lt;h2&gt;V. 乘法统计：转到原根指数域做循环卷积&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：模素数p，非零乘积的余数分布，或重复独立乘法。&lt;/p&gt;
&lt;p&gt;非零值=g^e后，乘法变指数相加mod(p-1)，由线性卷积再按p-1折叠。0单独处理；1对应指数0；多项式快速幂单位元为[1,0,...]。&lt;/p&gt;
&lt;p&gt;代码证据：&lt;code&gt;reginonals/23xian/f.cpp&lt;/code&gt;。原根、NTT长度、计数模数是三个不同参数；不能把乘法值域素数p直接当NTT模数。见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#13-%E6%A8%A1%E7%B4%A0%E6%95%B0%E7%9A%84%E4%B9%98%E6%B3%95-%E6%8C%87%E6%95%B0%E5%8A%A0%E6%B3%95&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;W. 区间颜色比较：先变前缀差，再看二维偏序&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：同一区间内多种字符数量之间有若干不等式。&lt;/p&gt;
&lt;p&gt;R&amp;gt;=G与R&amp;gt;=B变为两个前缀差X,Y，合法(j,i]等价于X_j&amp;lt;=X_i,Y_j&amp;lt;=Y_i。若答案是所选不交区间总长度，再将i-j拆成i+(-j)，查询历史点的dp[j]-j最大值。&lt;/p&gt;
&lt;p&gt;不要因“二维”就直接选树套树；先说明第三个时间约束j&amp;lt;i由处理顺序保证，查询在插入前。&lt;code&gt;cp::Fenwick2DMax&lt;/code&gt; 预收坐标，后续在线chmax与前缀最大值查询。&lt;/p&gt;
&lt;p&gt;来源：用户提供的9月RGB回顾，未凭题名补造完整题面。见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#23-%E5%8C%BA%E9%97%B4%E6%95%B0%E9%87%8F%E6%AF%94%E8%BE%83-%E5%89%8D%E7%BC%80%E5%B7%AE-%E5%A4%9A%E7%BB%B4%E5%81%8F%E5%BA%8F&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;X. 树上路径差分：用割决定传播方向&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：批量路径对每条树边的覆盖次数或奇偶。&lt;/p&gt;
&lt;p&gt;端点XOR后，边的答案是子树标记XOR，必须从子到父恢复。理由：路径跨越子树割当且仅当一端在子树里。&lt;/p&gt;
&lt;p&gt;若改求普通次数，需要端点+1、LCA-2；点覆盖次数又是另一套LCA修正。根到点前缀的父传子不能替代这一步。&lt;/p&gt;
&lt;p&gt;来源：用户提供的Canal Crossing回顾。迭代代码 &lt;code&gt;cp::tree_path_xor_edges&lt;/code&gt; 不依赖LCA，适用于边覆盖奇偶。&lt;/p&gt;
&lt;h2&gt;Y. 算法退出前，先完成状态恢复&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：DSU on Tree、回溯、虚树多询问、二分check临时统计。&lt;/p&gt;
&lt;p&gt;提前找到答案只允许跳过不再需要的搜索，不能跳过本层负责的回滚。保存found，完成清理后返回，或用局部容器/作用域恢复。keep=false需恢复，keep=true按协议保留，二者不能混淆。&lt;/p&gt;
&lt;p&gt;固定验证：同一个check调用两次结果相同、用例次序交换不影响各自答案、兄弟处理顺序不改变结果。来源：用户提供的10月DSU on Tree回顾。&lt;/p&gt;
&lt;h2&gt;Z. 同key对象：相遇事件、计数还是等价历史？&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;触发器&lt;/strong&gt;：map中用位置、时间、前缀状态等作为key。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;mp[key]=value&lt;/code&gt;默认丢弃旧对象。先判断同key是否应碰撞、累加、保留全部ID，还是只需保留最小代价。树上碰撞最小反例：一个节点、两个对象同一时刻出现，不能互相覆盖。&lt;/p&gt;
&lt;p&gt;同理，前缀平方状态需要累加频次，最短路状态通常保留最小距离。容器操作应来自状态等价证明，而不是按习惯赋值。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2026-10-25 整理入口&lt;/h2&gt;
&lt;p&gt;新增O–Z来自本地代码核对及用户提供的近三个月对话回顾，未独立读取原网页历史；旧A–N保留。结构证明、输入边界与可运行代码分别见：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B4%E7%90%86%E7%B4%A2%E5%BC%95/&quot;&gt;算法竞赛整理索引&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E5%A2%9E%E8%A1%A5%E6%A0%B8%E5%AF%B9%E8%AE%B0%E5%BD%95/&quot;&gt;算法竞赛增补核对记录&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>虚树</title><link>https://sanzenin.top/posts/obsidian/%E8%99%9A%E6%A0%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E8%99%9A%E6%A0%91/</guid><description>给定一棵以 为根的树，并有多次独立询问；第 次询问给出关键点集合 。 - CF613D：可删除非关键点，使任意两个关键点不连通；求最少删除点数。若存在两关键点在原树上相邻，则无解。 - P2495：边有正权。可删除若干边，使根 不可达任何关键点；求最小删除边权和。 两题中，单次询问的 很小，但 与询问总规模很大。若每次</description><pubDate>Mon, 16 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;虚树&lt;/h1&gt;
&lt;h2&gt;题目重述&lt;/h2&gt;
&lt;p&gt;给定一棵以 $1$ 为根的树，并有多次独立询问；第 $i$ 次询问给出关键点集合 $S_i$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;CF613D&lt;/strong&gt;：可删除非关键点，使任意两个关键点不连通；求最少删除点数。若存在两关键点在原树上相邻，则无解。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;P2495&lt;/strong&gt;：边有正权。可删除若干边，使根 $1$ 不可达任何关键点；求最小删除边权和。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;两题中，单次询问的 $|S_i|$ 很小，但 $n$ 与询问总规模很大。若每次在整棵树上 DP，复杂度会退化为 $O(nq)$。&lt;/p&gt;
&lt;h2&gt;关键观察&lt;/h2&gt;
&lt;h3&gt;虚树仅需保留关键节点与分叉点&lt;/h3&gt;
&lt;p&gt;把关键点按 DFS 序排列，对相邻关键点求 LCA，并将这些 LCA 与根一同加入。得到的点集按 DFS 序建树，称为虚树。&lt;/p&gt;
&lt;p&gt;任意两关键点的路径，其分叉位置必为若干关键点的 LCA；若一个原树节点既不是关键点，也不是这些 LCA，则它只处于某条不发生分叉的祖先链内部。该链上的节点对于不同关键点子树没有独立的组合关系，故可压缩成一条虚边而不改变可行解与最优值。&lt;/p&gt;
&lt;p&gt;排序后只补相邻节点的 LCA 已足够：设 $u,v$ 是 DFS 序相邻的关键点，某个需要保留的分叉点 $x$ 的不同子树中存在关键点；这些子树在 DFS 序中形成连续区间，其边界处必出现一对相邻关键点跨越 $x$，于是 $x=operatorname{LCA}(u,v)$。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/%E8%99%9A%E6%A0%91_%E6%AD%A5%E9%AA%A41_%E5%85%B3%E9%94%AE%E7%82%B9%E4%B8%8ELCA.png&quot; alt=&quot;关键点与 LCA&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;虚树大小是线性的&lt;/h3&gt;
&lt;p&gt;对 $k$ 个关键点，补入的 LCA 不超过 $k-1$ 个；再加入根后，虚树节点数为 $O(k)$。因此一次询问可只在 $O(k)$ 个节点上做 DP。&lt;/p&gt;
&lt;h3&gt;CF613D 的相邻关键点判定&lt;/h3&gt;
&lt;p&gt;若关键点 $u$ 的父亲 $p(u)$ 也是关键点，则原树边 $(p(u),u)$ 的两个端点均不可删，且它们始终连通，故无解。反之，此情形不存在时，虚树 DP 中对每条关键点分支均能在其首个可删位置切断，后述转移可构造可行方案。&lt;/p&gt;
&lt;h2&gt;解析&lt;/h2&gt;
&lt;h3&gt;预处理&lt;/h3&gt;
&lt;p&gt;从根 DFS 得到 $operatorname{dfn}$、深度 $operatorname{dep}$、二进制祖先 $operatorname{fa}$。P2495 还维护&lt;/p&gt;
&lt;p&gt;$$
mn[u]=\min{w(e)\mid e\text{ 在根到 }u\text{ 的路径上}}。
$$&lt;/p&gt;
&lt;p&gt;这是因为若决定从根侧隔离整个 $u$ 的原树子树，在根到 $u$ 的链上任选一条边切断均可，最优代价就是该路径最小边权 $mn[u]$。&lt;/p&gt;
&lt;h3&gt;建树：DFS 序与单调栈&lt;/h3&gt;
&lt;p&gt;将本次关键点按 $operatorname{dfn}$ 排序，栈中维持尚未确定父亲的「根到当前点」祖先链。依次处理新关键点 $v$，令 $l=operatorname{LCA}(	ext{stack.top},v)$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;当栈中倒数第二个节点深度不小于 $operatorname{dep}[l]$ 时，栈顶节点的虚树父亲已经确定；连边并弹栈。&lt;/li&gt;
&lt;li&gt;若 $l$ 不在栈顶，连 $l\to\text{stack.top}$，将栈顶替换为 $l$。&lt;/li&gt;
&lt;li&gt;将 $v$ 入栈。全部处理后，将剩余栈逐个连边弹出。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;栈内节点深度严格递增，每个节点至多入栈、出栈各一次；建树复杂度为 $O(k\log n)$，其中 LCA 查询使用倍增。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/%E8%99%9A%E6%A0%91_%E6%AD%A5%E9%AA%A42_%E5%8D%95%E8%B0%83%E6%A0%88%E8%BF%9E%E8%BE%B9.png&quot; alt=&quot;单调栈连边&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/%E8%99%9A%E6%A0%91_%E6%AD%A5%E9%AA%A43_%E5%AE%8C%E6%88%90%E7%9A%84%E8%99%9A%E6%A0%91.png&quot; alt=&quot;完成的虚树&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;CF613D：最少删除点数&lt;/h3&gt;
&lt;p&gt;令 $cnt[u]$ 表示处理完 $u$ 的虚树子树后，是否仍有一个尚未与上方隔离的关键点分支。后序遍历：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $u$ 是关键点，则不能删 $u$。对每个孩子 $v$，若 $cnt[v]=1$，必须在 $u$ 与该分支之间切断一个点，答案加一，并令该分支归零；最后令 $cnt[u]=1$。&lt;/li&gt;
&lt;li&gt;若 $u$ 不是关键点，合并所有 $cnt[v]$。若合并后至少有两个未隔离分支，则这些分支会经 $u$ 互相连通，删除 $u$ 一次即可同时切断它们，答案加一并令 $cnt[u]=0$；否则保留唯一分支向上。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;第二条转移是最优的：当至少两个分支上行时，任何可行方案都必须切断它们在 $u$ 处的汇合；删 $u$ 花费 $1$ 且一次完成。关键点不能删时，只能分别切断各个仍携带关键点的孩子分支。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/%E8%99%9A%E6%A0%91_%E6%AD%A5%E9%AA%A44_DP%E6%83%85%E5%86%B5%E8%AE%A8%E8%AE%BA.png&quot; alt=&quot;CF613D 与 P2495 的 DP 分支&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;P2495：最小割边代价&lt;/h3&gt;
&lt;p&gt;令 $f[u]$ 为使虚树中 $u$ 的子树不含与 $u$ 连通的关键点的最小代价。若 $u$ 是虚树叶子，必为关键点，$f[u]=mn[u]$。对内部点：&lt;/p&gt;
&lt;p&gt;$$
f[u]=\min\left(mn[u],\sum_{v\in son(u)}f[v]\right).
$$&lt;/p&gt;
&lt;p&gt;第一项是在根到 $u$ 的原树路径上切一条最便宜的边，一次隔离整个子树；第二项是不切上方路径，分别处理每个虚树孩子。二者穷尽了最优解在 $u$ 处「整体切断」与「保留后分治」的两类选择，故取最小值正确。根的 $mn[1]=+infty$，最终答案为 $f[1]$。&lt;/p&gt;
&lt;p&gt;一次询问的排序、建树与 DP 复杂度为 $O(k\log n)$，额外空间为 $O(k)$；树上预处理复杂度为 $O(n\log n)$。&lt;/p&gt;
&lt;h2&gt;代码&lt;/h2&gt;
&lt;h3&gt;CF613D&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
ll n, ans, m, cnt, tol, q;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; adj(n + 5);
    for (int i = 1; i &amp;lt; n; i++) {
        ll a, b;
        cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    vector&amp;lt;int&amp;gt; dep(n + 5, 0);
    vector&amp;lt;int&amp;gt; dfn(n + 5, 0);
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; fa(n + 5, vector&amp;lt;int&amp;gt;(25, 0));
    auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int f, auto &amp;amp;&amp;amp;tim) -&amp;gt; void {
        dfn[x] = ++tim;
        fa[x][0] = f;
        dep[x] = dep[f] + 1;
        for (int i = 1; i &amp;lt;= 20; i++) {
            fa[x][i] = fa[fa[x][i - 1]][i - 1];
        }
        for (auto v : adj[x]) {
            if (v == f)
                continue;
            self(self, v, x, tim);
        }
    };
    dfs(dfs, 1, 0, 0);
    auto lca = [&amp;amp;](ll x, ll y) -&amp;gt; ll {
        if (dep[x] &amp;lt; dep[y])
            swap(x, y);
        for (int i = 20; i &amp;gt;= 0; i--) {
            if (dep[fa[x][i]] &amp;gt;= dep[y])
                x = fa[x][i];
        }
        if (x == y)
            return x;
        for (int i = 20; i &amp;gt;= 0; i--) {
            if (fa[x][i] != fa[y][i])
                x = fa[x][i], y = fa[y][i];
        }
        return fa[x][0];
    };
    vector&amp;lt;ll&amp;gt; h(n + 5, -1);
    vector&amp;lt;ll&amp;gt; cnt(n + 5, 0);
    vector&amp;lt;bool&amp;gt; iscri(n + 5, 0);
    vector&amp;lt;pr&amp;gt; edges;
#define next first
#define to second
    cin &amp;gt;&amp;gt; q;
    while (q--) {
        ll k;
        cin &amp;gt;&amp;gt; k;
        vector&amp;lt;int&amp;gt; cri(k + 5, 0);
        for (int i = 1; i &amp;lt;= k; i++) {
            cin &amp;gt;&amp;gt; cri[i];
            iscri[cri[i]] = 1;
            cnt[cri[i]] = 1;
        }
        sort(cri.begin() + 1, cri.begin() + k + 1, [&amp;amp;](ll a, ll b) { return dfn[a] &amp;lt; dfn[b]; });
        auto build = [&amp;amp;]() {
            auto add = [&amp;amp;](ll a, ll b) {
                auto tmp = h[a];
                h[a] = edges.size();
                edges.push_back({tmp, b});
            };
            edges.clear();
            vector&amp;lt;int&amp;gt; sta;
            sta.push_back(1);
            if (cri[1] != 1)
                sta.push_back(cri[1]);
            for (int i = 2; i &amp;lt;= k; i++) {
                auto l = lca(sta.back(), cri[i]);
                // 递归处理lca下方的链
                while (sta.size() &amp;gt; 1 &amp;amp;&amp;amp; dep[sta[sta.size() - 2]] &amp;gt;= dep[l]) {
                    add(sta[sta.size() - 2], sta.back());
                    sta.pop_back();
                }
                // 如果lca不在栈中
                if (l != sta.back()) {
                    add(l, sta.back());
                    sta.pop_back();
                    sta.push_back(l);
                }
                sta.push_back(cri[i]);
            }
            while (sta.size() &amp;gt; 1) {
                add(sta[sta.size() - 2], sta.back());
                sta.pop_back();
            }
        };
        build();
        int flag = 0;
        for (int i = 1; i &amp;lt;= k; i++) {
            if (iscri[fa[cri[i]][0]]) {
                flag = 1;
                break;
            }
        }
        ll ans = 0;
        auto done = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void {
            for (int i = h[x]; ~i; i = edges[i].next) {
                auto v = edges[i].to;
                self(self, v);
            }
            iscri[x] = 0;
            h[x] = -1;
            cnt[x] = 0;
        };
        if (flag) {
            cout &amp;lt;&amp;lt; -1 &amp;lt;&amp;lt; &apos;\n&apos;;
            done(done, 1);
            continue;
        }
        auto dp = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void {
            if (iscri[x]) {
                for (int i = h[x]; ~i; i = edges[i].next) {
                    auto v = edges[i].to;
                    self(self, v);
                    if (cnt[v]) {
                        ans++;
                        cnt[v] = 0;
                    }
                }
            } else {
                for (int i = h[x]; ~i; i = edges[i].next) {
                    auto v = edges[i].to;
                    self(self, v);
                    cnt[x] += cnt[v];
                    cnt[v] = 0;
                }
                if (cnt[x] &amp;gt; 1)
                    ans++, cnt[x] = 0;
            }
        };
        dp(dp, 1);
        done(done, 1);
        cout &amp;lt;&amp;lt; ans &amp;lt;&amp;lt; &apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;P2495&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 300005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
// vector&amp;lt;vector&amp;lt;pr&amp;gt;&amp;gt;map1;
ll n, ans, m, cnt, s;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    vector&amp;lt;vector&amp;lt;pr&amp;gt;&amp;gt; adj(N);
    vector&amp;lt;ll&amp;gt; dep(N, 0), dfn(N, 0);
    vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt; fa(N, vector&amp;lt;ll&amp;gt;(23, 0));
    vector&amp;lt;ll&amp;gt; mn(N, 1e9);
    auto solve = [&amp;amp;]() {
        cin &amp;gt;&amp;gt; n;
        for (int i = 1; i &amp;lt; n; i++) {
            ll a, b, c;
            cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b &amp;gt;&amp;gt; c;
            adj[a].push_back({b, c});
            adj[b].push_back({a, c});
        }
        auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, ll x, ll f, ll w) -&amp;gt; void {
            dfn[x] = ++cnt;
            fa[x][0] = f;
            mn[x] = min(w, mn[f]);
            dep[x] = dep[f] + 1;
            for (int i = 1; i &amp;lt;= 22; i++) {
                fa[x][i] = fa[fa[x][i - 1]][i - 1];
            }
            for (auto [v, ww] : adj[x]) {
                if (v == f)
                    continue;
                self(self, v, x, ww);
            }
        };
        dfs(dfs, 1, 0, 1e18);
        mn[1] = 1e18;
        auto lca = [&amp;amp;](ll x, ll y) -&amp;gt; ll {
            if (dep[x] &amp;lt; dep[y])
                swap(x, y);
            for (int i = 22; i &amp;gt;= 0; i--) {
                if (dep[fa[x][i]] &amp;gt;= dep[y])
                    x = fa[x][i];
            }
            if (x == y)
                return x;
            for (int i = 22; i &amp;gt;= 0; i--) {
                if (fa[x][i] != fa[y][i])
                    x = fa[x][i], y = fa[y][i];
            }
            return fa[x][0];
        };
        cin &amp;gt;&amp;gt; m;
        for (int i = 1; i &amp;lt;= n; i++)
            adj[i].clear();
        while (m--) {
            ll k;
            cin &amp;gt;&amp;gt; k;
            vector&amp;lt;int&amp;gt; nodes(k + 5);
            for (int i = 1; i &amp;lt;= k; i++) {
                cin &amp;gt;&amp;gt; nodes[i];
            }
            sort(nodes.begin() + 1, nodes.begin() + k + 1,
                 [&amp;amp;](ll a, ll b) { return dfn[a] &amp;lt; dfn[b]; });
            vector&amp;lt;int&amp;gt; sta;
            sta.push_back(1);
            if (nodes[1] != 1)
                sta.push_back(nodes[1]);
            for (int i = 2; i &amp;lt;= k; i++) {
                auto l = lca(nodes[i], sta.back());
                if (l == sta.back())
                    continue;
                while (sta.size() &amp;gt; 1 &amp;amp;&amp;amp; dep[sta[sta.size() - 2]] &amp;gt;= dep[l]) {
                    adj[sta[sta.size() - 2]].push_back({sta.back(), 0});
                    sta.pop_back();
                }
                if (l != sta.back()) {
                    adj[l].push_back({sta.back(), 0});
                    sta.pop_back();
                    sta.push_back(l);
                }
                sta.push_back(nodes[i]);
            }
            while (sta.size() &amp;gt; 1) {
                adj[sta[sta.size() - 2]].push_back({sta.back(), 0});
                sta.pop_back();
            }
            auto dp = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; ll {
                if (!adj[x].size())
                    return mn[x];
                ll sum = 0;
                for (auto [v, _] : adj[x]) {
                    sum += self(self, v);
                }
                adj[x].clear();
                return min(sum, (ll)mn[x]);
            };
            cout &amp;lt;&amp;lt; dp(dp, 1) &amp;lt;&amp;lt; &apos;\n&apos;;
        }
    };
    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>贡献法应用</title><link>https://sanzenin.top/posts/obsidian/%E8%B4%A1%E7%8C%AE%E6%B3%95%E5%BA%94%E7%94%A8/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E8%B4%A1%E7%8C%AE%E6%B3%95%E5%BA%94%E7%94%A8/</guid><description>贡献法适用于答案由大量方案、区间或组合共同构成的情形。直接枚举这些整体对象通常会产生重复计算；更有效的方式是选择一个更小的基本对象，统计它在多少个整体答案中出现，并把“出现次数 单次贡献”累加。 本文的两道题都属于这一类：数组差异题把贡献对象选为排序后的数对或单个元素；函数题把贡献对象选为差分数组中的某个位置。 给定</description><pubDate>Mon, 16 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;贡献法应用&lt;/h1&gt;
&lt;p&gt;贡献法适用于答案由大量方案、区间或组合共同构成的情形。直接枚举这些整体对象通常会产生重复计算；更有效的方式是选择一个更小的基本对象，统计它在多少个整体答案中出现，并把“出现次数 $\times$ 单次贡献”累加。&lt;/p&gt;
&lt;p&gt;本文的两道题都属于这一类：数组差异题把贡献对象选为排序后的数对或单个元素；函数题把贡献对象选为差分数组中的某个位置。&lt;/p&gt;
&lt;h2&gt;问题 E：数组差异&lt;/h2&gt;
&lt;h3&gt;题目重述&lt;/h3&gt;
&lt;p&gt;给定 $n$ 个数，从中选择 $k$ 个数组成新数组。一个数组的差异度定义为其中任意两数差值的绝对值之和。要求所有 $\binom n k$ 种选择方案的差异度总和，并对 $10^9+7$ 取模。&lt;/p&gt;
&lt;h3&gt;关键观察&lt;/h3&gt;
&lt;p&gt;将数组排序为&lt;/p&gt;
&lt;p&gt;$$
s[1]\le s[2]\le \cdots \le s[n].
$$&lt;/p&gt;
&lt;p&gt;排序后任意一对下标 $i&amp;lt;j$ 的差值为 $s[j]-s[i]$。固定这对数后，若一个 $k$ 元选择方案包含它们，则这对数向该方案的差异度贡献 $s[j]-s[i]$。剩余 $k-2$ 个数可从其余 $n-2$ 个位置中选择，因此该数对被计入&lt;/p&gt;
&lt;p&gt;$$
\binom{n-2}{k-2}
$$&lt;/p&gt;
&lt;p&gt;次。&lt;/p&gt;
&lt;p&gt;也可以进一步按单个元素统计。固定 $s[i]$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;它作为较大值时，与前面 $i-1$ 个数形成正贡献；&lt;/li&gt;
&lt;li&gt;它作为较小值时，与后面 $n-i$ 个数形成负贡献。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;因此 $s[i]$ 的系数为 $(i-1)-(n-i)$。&lt;/p&gt;
&lt;h3&gt;解析&lt;/h3&gt;
&lt;p&gt;根据上面的计数，答案为&lt;/p&gt;
&lt;h1&gt;$$
\text{ans}&lt;/h1&gt;
&lt;p&gt;\binom{n-2}{k-2}
\sum_{i=1}^{n}\bigl((i-1)-(n-i)\bigr)s[i].
$$&lt;/p&gt;
&lt;p&gt;组合数通过阶乘和逆元预处理。由于模数 $10^9+7$ 为质数，使用快速幂计算 $x^{p-2}$ 得到乘法逆元。&lt;/p&gt;
&lt;p&gt;时间复杂度为 $O(n\log n)$，瓶颈在排序；空间复杂度为 $O(n)$。&lt;/p&gt;
&lt;h3&gt;代码&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#define ll long long
#define N 200005
using namespace std;
ll ans;
ll n, k;
ll t;
const ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k;
    vector&amp;lt;ll&amp;gt; s(n + 5, 0);
    vector&amp;lt;ll&amp;gt; fact(n + 5, 0);
    vector&amp;lt;ll&amp;gt; fact_inv(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++) {
        cin &amp;gt;&amp;gt; s[i];
    }
    sort(s.begin() + 1, s.begin() + n + 1);
    auto qp = [&amp;amp;](ll x, ll k) {
        ll res = 1;
        while (k) {
            if (k &amp;amp; 1)
                res = (res * x) % mod;
            x = (x * x) % mod;
            k &amp;gt;&amp;gt;= 1;
        }
        return res;
    };
    auto init = [&amp;amp;]() {
        fact[0] = 1;
        fact_inv[0] = 1;
        for (int i = 1; i &amp;lt;= n; i++) {
            fact[i] = (fact[i - 1] * i) % mod;
            fact_inv[i] = (fact_inv[i - 1] * i) % mod;
        }
        fact_inv[n] = qp(fact[n], mod - 2);
        for (int i = n - 1; i &amp;gt;= 1; i--) {
            fact_inv[i] = ((i + 1) * fact_inv[i + 1]) % mod;
        }
    };
    init();
    auto c = [&amp;amp;](ll n, ll m) { return (fact[n] * fact_inv[m] % mod * fact_inv[n - m] % mod); };
    ll res = 0;
    for (int i = 1; i &amp;lt;= n; i++) {
        res = (res + (i - 1 - (n - i)) * s[i]) % mod;
    }
    res = (res * c(n - 2, k - 2)) % mod;
    cout &amp;lt;&amp;lt; res;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;问题 C：函数&lt;/h2&gt;
&lt;h3&gt;题目重述&lt;/h3&gt;
&lt;p&gt;给定长度为 $n$ 的序列 $v[1..n]$ 和 $q$ 次询问。对于每个区间 $[l,r]$，要求所有连续子序列 $v[x..y]$（$l\le x&amp;lt;y\le r$）的 Lipschitz 常数之和。&lt;/p&gt;
&lt;p&gt;序列 $v[x..y]$ 的 Lipschitz 常数定义为满足&lt;/p&gt;
&lt;p&gt;$$
|v[a]-v[b]|\le K|a-b|
$$&lt;/p&gt;
&lt;p&gt;的最小整数 $K$，其中 $x\le a&amp;lt;b\le y$。&lt;/p&gt;
&lt;h3&gt;关键观察&lt;/h3&gt;
&lt;p&gt;令相邻差分为&lt;/p&gt;
&lt;p&gt;$$
d[i]=|v[i+1]-v[i]|.
$$&lt;/p&gt;
&lt;p&gt;对任意 $a&amp;lt;b$，由三角不等式可得&lt;/p&gt;
&lt;p&gt;$$
|v[a]-v[b]|
\le \sum_{i=a}^{b-1}|v[i+1]-v[i]|
\le (b-a)\max_{a\le i&amp;lt;b}d[i].
$$&lt;/p&gt;
&lt;p&gt;因此 $K=\max_{a\le i&amp;lt;b}d[i]$ 一定满足 Lipschitz 条件。&lt;/p&gt;
&lt;p&gt;另一方面，若 $d[p]$ 是区间内的最大相邻差分，取相邻两点 $a=p,b=p+1$，则&lt;/p&gt;
&lt;p&gt;$$
|v[p]-v[p+1]|=d[p]\le K.
$$&lt;/p&gt;
&lt;p&gt;所以任意合法的 $K$ 都不能小于最大相邻差分。两边合并，连续子序列 $v[x..y]$ 的 Lipschitz 常数恰好等于差分区间 $d[x..y-1]$ 的最大值。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/lipschitz_diagram.png&quot; alt=&quot;Lipschitz 常数与相邻差分最大值&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;解析&lt;/h3&gt;
&lt;p&gt;询问 $[l,r]$ 被转化为：求差分数组 $d[l..r-1]$ 的所有非空连续子数组最大值之和。&lt;/p&gt;
&lt;p&gt;对每个差分位置 $i$ 计算其作为最大值的贡献。设：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$\text{left}[i]$ 为 $i$ 左侧最近的、满足 $d[\text{left}[i]]&amp;gt;d[i]$ 的位置；若不存在，则为 $l-1$；&lt;/li&gt;
&lt;li&gt;$\text{right}[i]$ 为 $i$ 右侧最近的、满足 $d[\text{right}[i]]\ge d[i]$ 的位置；若不存在，则为 $r$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;左侧使用严格大于、右侧使用大于等于，是为了处理相等最大值。若一个子数组中最大值出现多次，这种边界定义会固定由其中一个位置承担贡献，避免重复计数。&lt;/p&gt;
&lt;p&gt;当 $d[i]$ 作为某个差分子数组的最大值时，左端点可选&lt;/p&gt;
&lt;p&gt;$$
i-\text{left}[i]
$$&lt;/p&gt;
&lt;p&gt;种，右端点可选&lt;/p&gt;
&lt;p&gt;$$
\text{right}[i]-i
$$&lt;/p&gt;
&lt;p&gt;种。因此 $d[i]$ 的总贡献为&lt;/p&gt;
&lt;p&gt;$$
d[i]\cdot(i-\text{left}[i])\cdot(\text{right}[i]-i).
$$&lt;/p&gt;
&lt;p&gt;每次询问用两遍单调栈求出左右边界，再累加所有位置的贡献。由于 $q\le 100$，按询问逐个线性处理区间即可通过。&lt;/p&gt;
&lt;p&gt;单次询问复杂度为 $O(r-l+1)$，总时间复杂度为 $O(nq)$，空间复杂度为 $O(n)$。&lt;/p&gt;
&lt;h3&gt;代码&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 200005
using namespace std;
ll ans;
ll n, k, m, q;
ll t;
#define pr pair&amp;lt;ll, ll&amp;gt;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; q;
    vector&amp;lt;ll&amp;gt; s(n + 5, 0);
    vector&amp;lt;ll&amp;gt; diff(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++) {
        cin &amp;gt;&amp;gt; s[i];
        diff[i - 1] = abs(s[i] - s[i - 1]);
    }
    vector&amp;lt;int&amp;gt; left(n + 5, 0);
    vector&amp;lt;int&amp;gt; right(n + 5, 0);
    while (q--) {
        ll l, r;
        cin &amp;gt;&amp;gt; l &amp;gt;&amp;gt; r;
        if (l == r) {
            cout &amp;lt;&amp;lt; 0 &amp;lt;&amp;lt; &apos;\n&apos;;
            continue;
        }
        r--;
        stack&amp;lt;int&amp;gt; sta;
        for (int i = l; i &amp;lt;= r; i++) {
            while (sta.size() &amp;amp;&amp;amp; diff[sta.top()] &amp;lt;= diff[i]) {
                sta.pop();
            }
            left[i] = sta.empty() ? l - 1 : sta.top();
            sta.push(i);
        }
        while (sta.size())
            sta.pop();
        for (int i = r; i &amp;gt;= l; i--) {
            while (sta.size() &amp;amp;&amp;amp; diff[sta.top()] &amp;lt; diff[i]) {
                sta.pop();
            }
            right[i] = sta.empty() ? r + 1 : sta.top();
            sta.push(i);
        }
        ll res = 0;
        for (int i = l; i &amp;lt;= r; i++)
            res += diff[i] * (i - left[i]) * (right[i] - i);
        cout &amp;lt;&amp;lt; res &amp;lt;&amp;lt; &apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>欢迎来到 Sanzenin 凪</title><link>https://sanzenin.top/posts/welcome/</link><guid isPermaLink="true">https://sanzenin.top/posts/welcome/</guid><description>这个博客的第一篇文章，说明这里的写作方向、内容范围与更新方式。</description><pubDate>Mon, 16 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;这里是 Sanzenin 凪的个人博客。&lt;/p&gt;
&lt;p&gt;我想把这里做成一个安静的记录空间：写下正在学习的技术，整理读过的书和看过的作品，也保留一些日常里值得记住的片段。文章不会追求固定的更新频率，但每一篇都会尽量完整。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/images/banner.png&quot; alt=&quot;夜色与海面的抽象封面&quot; /&gt;&lt;/p&gt;
&lt;h2&gt;这里会写什么&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;前端开发、工具链与工程实践中的具体问题&lt;/li&gt;
&lt;li&gt;阅读笔记，以及作品带来的想法&lt;/li&gt;
&lt;li&gt;关于生活节奏、审美与长期项目的零散记录&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;为什么写下来&lt;/h2&gt;
&lt;p&gt;很多理解只有在尝试解释的时候才会变得清楚。写作迫使我把模糊的判断整理成可以检验的步骤，也让后来遇到同样问题的人少走一点弯路。&lt;/p&gt;
&lt;p&gt;如果一篇文章只留下了一条有用的命令、一个更准确的概念，或者一次失败尝试的原因，它就已经值得存在。&lt;/p&gt;
&lt;h2&gt;关于技术&lt;/h2&gt;
&lt;p&gt;本站使用 &lt;a href=&quot;https://astro.build/&quot;&gt;Astro&lt;/a&gt; 构建，界面基于 Shirone 主题的 Material 3 Expressive 组件系统。页面以静态内容为主，搜索由 Pagefind 在构建时生成索引。&lt;/p&gt;
&lt;h2&gt;保持联系&lt;/h2&gt;
&lt;p&gt;代码与部分实验会放在 &lt;a href=&quot;https://github.com/wlz6&quot;&gt;GitHub&lt;/a&gt;。如果你想讨论文章里的内容，可以通过那里找到我。&lt;/p&gt;
&lt;p&gt;感谢你读到这里。&lt;/p&gt;
</content:encoded></item><item><title>CUDA 核心概念复习笔记（一）：体系结构、线程分层与内存模型</title><link>https://sanzenin.top/posts/obsidian/01-gpu%E7%A1%AC%E4%BB%B6%E4%B8%8E%E5%86%85%E5%AD%98/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/01-gpu%E7%A1%AC%E4%BB%B6%E4%B8%8E%E5%86%85%E5%AD%98/</guid><description>学习导航：01 GPU硬件与内存 · 02 GPU性能理论 · 03 Reduction逐版代码与解析 [!NOTE] 知识来源说明 本文内容基于现代 GPU 体系结构与通用并行计算通用原理梳理，不针对特定具体硬件型号的定制参数，旨在帮助具备 C++ 背景的开发者建立清晰、严谨的软硬件映射直觉。 对于传统 C++ 开发</description><pubDate>Thu, 12 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;学习导航：&lt;a href=&quot;/posts/obsidian/01-gpu%E7%A1%AC%E4%BB%B6%E4%B8%8E%E5%86%85%E5%AD%98/&quot;&gt;01 GPU硬件与内存&lt;/a&gt; · &lt;a href=&quot;/posts/obsidian/02-gpu%E6%80%A7%E8%83%BD%E7%90%86%E8%AE%BA/&quot;&gt;02 GPU性能理论&lt;/a&gt; · &lt;a href=&quot;/posts/obsidian/03-reduction%E9%80%90%E7%89%88%E4%BB%A3%E7%A0%81%E4%B8%8E%E8%A7%A3%E6%9E%90/&quot;&gt;03 Reduction逐版代码与解析&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h1&gt;CUDA 核心概念复习笔记（一）：体系结构、线程分层与内存模型&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;[!NOTE] 知识来源说明
本文内容基于现代 GPU 体系结构与通用并行计算通用原理梳理，不针对特定具体硬件型号的定制参数，旨在帮助具备 C++ 背景的开发者建立清晰、严谨的软硬件映射直觉。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 硬件视角：GPU 与 SM (Streaming Multiprocessor)&lt;/h2&gt;
&lt;p&gt;对于传统 C++ 开发者而言，CPU 通常由少数几个高主频、配备庞大缓存（L1/L2/L3）以及高度复杂分支预测与乱序执行引擎的核心构成，目标是&lt;strong&gt;最小化单线程延迟（Latency）&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;与此相反，GPU 的设计哲学是&lt;strong&gt;最大化吞吐量（Throughput）&lt;/strong&gt;：将大量的硅片面积让位给算术逻辑单元（ALU），通过成千上万个线程的并发执行，利用硬件级的快速上下文切换来实现&lt;strong&gt;延迟隐藏（Latency Hiding）&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;1.1 GPU 芯片与 SM&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;GPU (Device)&lt;/strong&gt;：完整的片上系统，内部集成了数十至上百个独立计算单元——&lt;strong&gt;SM（流式多处理器，Streaming Multiprocessor）&lt;/strong&gt;，以及跨 SM 共享的片上 L2 缓存、内存控制器和高带宽板载显存（DRAM / Global Memory）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;SM (Streaming Multiprocessor)&lt;/strong&gt;：GPU 的核心计算集群（相当于 CPU 的一个独立多核集群）。每个 SM 都是一个独立的硬件执行环境，拥有独立的控制单元、寄存器堆、共享内存与缓存。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;1.2 SM 内部执行单元构成&lt;/h3&gt;
&lt;p&gt;每个 SM 内部主要包含以下硬件组件：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Warp Scheduler（线程束调度器）&lt;/strong&gt;：负责在每个周期检查就绪的 Warp，并决定将指令发射到哪个执行流水线。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Dispatch Units（指令分发单元）&lt;/strong&gt;：负责将调度器选中的指令分派给具体的硬件执行单元。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;CUDA Cores (ALU / FP32 / INT32)&lt;/strong&gt;：最基础的标量运算单元，负责单精度浮点与整型基础运算。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;DP Units (FP64)&lt;/strong&gt;：双精度浮点运算单元。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;SFU (Special Function Units)&lt;/strong&gt;：特殊函数单元，硬件加速实现 &lt;code&gt;sin&lt;/code&gt;、&lt;code&gt;cos&lt;/code&gt;、&lt;code&gt;sqrt&lt;/code&gt;、&lt;code&gt;log&lt;/code&gt; 等超越函数。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;LD/ST Units (Load/Store)&lt;/strong&gt;：专职负责从各级存储器加载和写回数据的访存通道。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Register File（寄存器堆）&lt;/strong&gt;：SM 内极其高速的片上存储，由该 SM 上驻留的所有活跃线程动态切分共享。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Shared Memory / L1 Cache&lt;/strong&gt;：超低延迟的片上高速 SRAM 存储器。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 软件编程模型 vs 硬件执行模型&lt;/h2&gt;
&lt;p&gt;CUDA 编程的核心难点之一在于理清&lt;strong&gt;软件编写概念&lt;/strong&gt;与&lt;strong&gt;硬件执行实体&lt;/strong&gt;之间的映射关系。&lt;/p&gt;
&lt;h3&gt;2.1 概念层次对比表&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;维度 / 粒度&lt;/th&gt;
&lt;th&gt;软件抽象模型 (Software Model)&lt;/th&gt;
&lt;th&gt;硬件执行实体 (Hardware Architecture)&lt;/th&gt;
&lt;th&gt;映射关系与生命周期&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;应用级&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Grid（网格）&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;GPU Device（完整芯片）&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;一个核函数调用（Kernel Launch）对应一个 Grid，由 GPU 调度执行；使用多少 SM 取决于任务规模和资源限制。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;协同级&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Block（线程块）&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;SM（流式多处理器）&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;一个 Block &lt;strong&gt;仅能分配到某一个 SM&lt;/strong&gt; 上执行；一个 SM 可同时驻留多个 Block。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;调度级&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;em&gt;(无显式语法，系统隐式切分)&lt;/em&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Warp（线程束，32 线程）&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;硬件调度的最小原子单位&lt;/strong&gt;；SM 调度器每次挑选 1 个就绪 Warp 发射指令。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;基本单元&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Thread（线程）&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;CUDA Core / ALU 通道&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;软件逻辑上的最小执行单元，不永久独占某个 CUDA Core。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;束内标识&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;&lt;code&gt;threadIdx.x % 32&lt;/code&gt;&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Lane（通道 ID: 0 ~ 31）&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Warp 内部 32 个物理并行槽位之一。&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;2.2 软硬件关系&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    A[&quot;Kernel 的 Grid&quot;] --&amp;gt; B[&quot;多个 Block&quot;]
    B --&amp;gt; C[&quot;Block 在 SM 上驻留&quot;]
    C --&amp;gt; D[&quot;每个 Block 分为多个 Warp&quot;]
    D --&amp;gt; E[&quot;线程在 Warp 内有 Lane 编号&quot;]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;一个 SM 可同时驻留多个 Block，数量受资源和硬件上限约束。线程不永久绑定某个 CUDA Core。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 硬件执行核心：Warp、Lane 与 256 线程实例剖析&lt;/h2&gt;
&lt;h3&gt;3.1 SIMT (Single Instruction, Multiple Threads) 机制&lt;/h3&gt;
&lt;p&gt;与 CPU 的 SIMD（如 AVX2/AVX-512 中显式操作向量寄存器 &lt;code&gt;__m256&lt;/code&gt;）不同，CUDA 采用 &lt;strong&gt;SIMT&lt;/strong&gt; 模式：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;开发者写代码时仅关注&lt;strong&gt;单标量线程&lt;/strong&gt;（Scalar Thread）的控制流。&lt;/li&gt;
&lt;li&gt;Block 的线程按线性编号每 32 个分为一个 Warp，最后一个 Warp 可以不足 32 个线程。&lt;/li&gt;
&lt;li&gt;Warp 是指令调度的重要单位。现代 GPU 支持线程独立调度状态，不能假定线程始终共用一个 PC，也不能假定内存访问自动同步。&lt;/li&gt;
&lt;li&gt;Lane 是线程在 Warp 中的位置，编号 0 到 31；它不是线程永久独占的 CUDA Core。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3.2 深入拆解：以 256 线程的 Block 为例&lt;/h3&gt;
&lt;p&gt;假定在 Host 端配置一维 Block 启动核函数：&lt;code&gt;dim3 block(256);&lt;/code&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;[!IMPORTANT] 256 线程划分细节&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;线程总数&lt;/strong&gt;：$256$（&lt;code&gt;threadIdx.x&lt;/code&gt; 取值范围 &lt;code&gt;0 ~ 255&lt;/code&gt;）&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Warp 大小&lt;/strong&gt;：通用固定常数 $32$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Warp 数量&lt;/strong&gt;：$256 \div 32 = 8$ 个 Warp（编号 &lt;code&gt;Warp 0&lt;/code&gt; ~ &lt;code&gt;Warp 7&lt;/code&gt;）&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;h4&gt;划分对应明细表&lt;/h4&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Warp 编号&lt;/th&gt;
&lt;th&gt;线程索引范围 (&lt;code&gt;threadIdx.x&lt;/code&gt;)&lt;/th&gt;
&lt;th&gt;硬件 Lane 对应 (&lt;code&gt;Lane 0 ~ 31&lt;/code&gt;)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Warp 0&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$0 \sim 31$&lt;/td&gt;
&lt;td&gt;&lt;code&gt;threadIdx.x = 0&lt;/code&gt; $\to$ Lane 0, ..., &lt;code&gt;threadIdx.x = 31&lt;/code&gt; $\to$ Lane 31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Warp 1&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$32 \sim 63$&lt;/td&gt;
&lt;td&gt;&lt;code&gt;threadIdx.x = 32&lt;/code&gt; $\to$ Lane 0, ..., &lt;code&gt;threadIdx.x = 63&lt;/code&gt; $\to$ Lane 31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Warp 2&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$64 \sim 95$&lt;/td&gt;
&lt;td&gt;&lt;code&gt;threadIdx.x = 64&lt;/code&gt; $\to$ Lane 0, ..., &lt;code&gt;threadIdx.x = 95&lt;/code&gt; $\to$ Lane 31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Warp 3&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$96 \sim 127$&lt;/td&gt;
&lt;td&gt;&lt;code&gt;threadIdx.x = 96&lt;/code&gt; $\to$ Lane 0, ..., &lt;code&gt;threadIdx.x = 127&lt;/code&gt; $\to$ Lane 31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Warp 4&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$128 \sim 159$&lt;/td&gt;
&lt;td&gt;&lt;code&gt;threadIdx.x = 128&lt;/code&gt; $\to$ Lane 0, ..., &lt;code&gt;threadIdx.x = 159&lt;/code&gt; $\to$ Lane 31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Warp 5&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$160 \sim 191$&lt;/td&gt;
&lt;td&gt;&lt;code&gt;threadIdx.x = 160&lt;/code&gt; $\to$ Lane 0, ..., &lt;code&gt;threadIdx.x = 191&lt;/code&gt; $\to$ Lane 31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Warp 6&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$192 \sim 223$&lt;/td&gt;
&lt;td&gt;&lt;code&gt;threadIdx.x = 192&lt;/code&gt; $\to$ Lane 0, ..., &lt;code&gt;threadIdx.x = 223&lt;/code&gt; $\to$ Lane 31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Warp 7&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$224 \sim 255$&lt;/td&gt;
&lt;td&gt;&lt;code&gt;threadIdx.x = 224&lt;/code&gt; $\to$ Lane 0, ..., &lt;code&gt;threadIdx.x = 255&lt;/code&gt; $\to$ Lane 31&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h4&gt;计算公式&lt;/h4&gt;
&lt;p&gt;对于任一线程 &lt;code&gt;threadIdx.x&lt;/code&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;所属 Warp 索引：&lt;code&gt;warp_id = threadIdx.x / 32;&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;所处 Lane 槽位：&lt;code&gt;lane_id = threadIdx.x % 32;&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;关键推论：分支分化（Warp Divergence）&lt;/h4&gt;
&lt;p&gt;若在代码中出现条件分支：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// 示例：假设在 256 线程的 Block 中
if (threadIdx.x % 2 == 0) {
    do_path_A();
} else {
    do_path_B();
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;当一个 Warp 内的线程走不同分支时：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;在每个 Warp（如 &lt;code&gt;Warp 0&lt;/code&gt;）中，偶数 Lane 执行 &lt;code&gt;do_path_A()&lt;/code&gt; 时，奇数 Lane 必须硬件挂起（屏蔽执行）。&lt;/li&gt;
&lt;li&gt;随后切换执行 &lt;code&gt;do_path_B()&lt;/code&gt;，奇数 Lane 激活，偶数 Lane 挂起。&lt;/li&gt;
&lt;li&gt;两条路径可能由不同活动线程分别执行，导致额外开销；实际耗时受编译器和硬件影响。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;反例&lt;/strong&gt;：若改为 &lt;code&gt;if (threadIdx.x &amp;lt; 128)&lt;/code&gt;，则 &lt;code&gt;Warp 0~3&lt;/code&gt; 整束执行 Path A，&lt;code&gt;Warp 4~7&lt;/code&gt; 整束执行 Path B，&lt;strong&gt;Warp 内部无分化&lt;/strong&gt;，该条件不会造成 Warp 内部分化，但不代表整个 Kernel 没有其他性能损失。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 线程全局索引计算 (tid)&lt;/h2&gt;
&lt;p&gt;编写核函数的第一步是将多维线程坐标展平为一维物理数据偏移量（类似于 C++ 二维数组行优先索引 &lt;code&gt;i * cols + j&lt;/code&gt;）。&lt;/p&gt;
&lt;h3&gt;4.1 内置坐标变量&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;gridDim&lt;/code&gt;：Grid 的维度大小（有多少个 Block）。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;blockDim&lt;/code&gt;：Block 的维度大小（每个 Block 包含多少个 Thread）。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;blockIdx&lt;/code&gt;：当前 Block 在 Grid 内的三维坐标。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;threadIdx&lt;/code&gt;：当前 Thread 在其所在 Block 内的三维坐标。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;4.2 一维索引公式与推导&lt;/h3&gt;
&lt;p&gt;当 Grid 与 Block 均为一维时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// 线性绝对索引计算
int tid = blockIdx.x * blockDim.x + threadIdx.x;
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;推导逻辑&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;blockIdx.x&lt;/code&gt;：当前 Block 前面排了几个 Block。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;blockIdx.x * blockDim.x&lt;/code&gt;：跳过前面所有 Block 所包含的线程总数。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;+ threadIdx.x&lt;/code&gt;：加上当前线程在当前 Block 内部的局部偏移。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;边界防护（Guard）&lt;/h4&gt;
&lt;p&gt;如果按向上取整计算 Block 数，且 $N$ 不是 &lt;code&gt;blockDim.x&lt;/code&gt; 的倍数，启动的线程数会大于 $N$。必须加入边界检查：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__global__ void vectorAdd(const float* A, const float* B, float* C, int N) {
    int tid = blockIdx.x * blockDim.x + threadIdx.x;

    // 越界保护，防止段错误与显存破坏
    if (tid &amp;lt; N) {
        C[tid] = A[tid] + B[tid];
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.3 二维图像/矩阵映射公式&lt;/h3&gt;
&lt;p&gt;对于二维数据矩阵（宽度 &lt;code&gt;width&lt;/code&gt;，高度 &lt;code&gt;height&lt;/code&gt;）：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int col = blockIdx.x * blockDim.x + threadIdx.x; // X 对应水平列号
int row = blockIdx.y * blockDim.y + threadIdx.y; // Y 对应垂直行号

if (col &amp;lt; width &amp;amp;&amp;amp; row &amp;lt; height) {
    int tid = row * width + col; // 行优先展平为一维内存地址
    data[tid] = ...;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;5. CUDA 内存层级与存储结构&lt;/h2&gt;
&lt;p&gt;GPU 的存储体系结构设计高度分化，理解每一层存储的生命周期、可见范围与访问延迟是性能优化的核心基石。&lt;/p&gt;
&lt;h3&gt;5.1 各级存储与可见范围&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;类型&lt;/th&gt;
&lt;th&gt;通常的位置&lt;/th&gt;
&lt;th&gt;作用范围&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;寄存器&lt;/td&gt;
&lt;td&gt;SM 片上&lt;/td&gt;
&lt;td&gt;线程私有，保存局部值和中间结果&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Shared Memory&lt;/td&gt;
&lt;td&gt;SM 片上&lt;/td&gt;
&lt;td&gt;同一个 Block 的线程显式共享，读写协作需要同步&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Local Memory&lt;/td&gt;
&lt;td&gt;设备内存地址空间，可经缓存访问&lt;/td&gt;
&lt;td&gt;逻辑上线程私有，可能保存溢出数据或局部数组&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;L1 / L2 缓存&lt;/td&gt;
&lt;td&gt;芯片内&lt;/td&gt;
&lt;td&gt;缓存部分访存；L1 通常按 SM，L2 通常跨 SM 共享&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Global Memory&lt;/td&gt;
&lt;td&gt;全局地址空间，数据通常位于设备显存&lt;/td&gt;
&lt;td&gt;设备线程可访问，Host 通常通过 CUDA API 拷贝&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Local Memory 的“局部”指作用范围，不保证在片上。实际延迟受架构、缓存命中和访问模式影响。&lt;/p&gt;
&lt;h3&gt;5.2 数据关系示意&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    A[&quot;Global Memory&quot;] --&amp;gt; B[&quot;缓存层&quot;]
    B --&amp;gt; C[&quot;线程计算与寄存器&quot;]
    D[&quot;Block 共享内存&quot;] --&amp;gt; C
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;图仅说明作用，不表示所有数据都必须经过完全相同的路径。&lt;/p&gt;
&lt;h3&gt;5.3 关键存储概念深究&lt;/h3&gt;
&lt;h4&gt;1. 寄存器 (Registers) 与溢出 (Spill)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;每个线程独占属于它自己的寄存器。&lt;/li&gt;
&lt;li&gt;SM 内的寄存器总量是物理固定的。每线程寄存器需求降低有时能增加驻留 Block 数；还受分配粒度、共享内存和硬件上限影响。&lt;/li&gt;
&lt;li&gt;若核函数内部定义过多大型本地局部数组或复杂逻辑导致寄存器不够，编译器可能将部分数据放到 &lt;strong&gt;Local Memory（局部内存）&lt;/strong&gt;。它逻辑上线程私有，可经缓存访问；额外访存可能影响性能。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;2. 共享内存 (Shared Memory)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;是程序员显式管理的块内共享存储；部分架构和 L1 共用片上资源，但并不等同于自动管理的 L1 缓存。&lt;/li&gt;
&lt;li&gt;用于解决全局内存带宽瓶颈：先将需要重复访问的数据从全局内存协作加载到共享内存，计算完成后再统一写回。&lt;/li&gt;
&lt;li&gt;物理上划分为 32 个交错的存储体（&lt;strong&gt;Banks&lt;/strong&gt;）。若 Warp 内部多个 Lane 同时访问同一个 Bank 且地址不同，会引发 &lt;strong&gt;Bank Conflict（存储体冲突）&lt;/strong&gt; 导致串行化执行。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;3. 全局内存 (Global Memory) 与合并访存 (Coalesced Access)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;容量最大，可由 CPU（Host）通过 &lt;code&gt;cudaMemcpy&lt;/code&gt; 写入读出。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;合并访存机制&lt;/strong&gt;：Warp 内 32 个线程在同一条加载指令中访问连续对齐的显存空间时，硬件会合并请求，所需扇区和事务取决于地址、对齐、访问宽度及架构。例如一个完整 Warp 各线程读取相邻 float 且地址按 32 字节对齐时，通常覆盖 4 个 32 字节扇区。若跨步稀疏访问（如跳跃遍历步长较大的矩阵列），会造成极大的显存带宽浪费。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 线程同步与执行协同&lt;/h2&gt;
&lt;p&gt;并行体系中，必须提供机制让互相独立的执行单元在关键计算节点处实现步调一致。&lt;/p&gt;
&lt;h3&gt;6.1 &lt;code&gt;__syncthreads()&lt;/code&gt; 同步栅障&lt;/h3&gt;
&lt;p&gt;CUDA 最基础的核心原语是块内同步栅障 &lt;code&gt;__syncthreads()&lt;/code&gt;。&lt;/p&gt;
&lt;h4&gt;核心作用&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;执行栅障（Execution Barrier）&lt;/strong&gt;：同一个 Block 内部的&lt;strong&gt;所有线程&lt;/strong&gt;必须全部运行到该行代码，在未全部到达前，任何一个线程都不得跨越栅障继续向下执行。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;内存栅障（Memory Fence）&lt;/strong&gt;：确保该栅障之前所有线程对 &lt;code&gt;__shared__&lt;/code&gt; 内存的写入操作对当前 Block 内的所有其他线程完全可见。&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;经典用法模式（分批协作加载共享内存）&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;__global__ void sharedMemoryDemo(const float* input, float* output) {
    __shared__ float s_data[256];
    int tid = threadIdx.x;

    // 阶段 1：256 个线程协作从慢速 Global Memory 并发读取数据到片上 Shared Memory
    s_data[tid] = input[blockIdx.x * blockDim.x + tid];

    // 关键：等待 256 个线程全部搬运完成，否则后续读数据可能读到未初始化的脏数据
    __syncthreads();

    // 阶段 2：安全消费共享内存中的相邻数据
    float temp = 0.0f;
    if (tid &amp;gt; 0) {
        temp = s_data[tid - 1] + s_data[tid]; // 安全访问相邻线程写入的数据
    }

    // 阶段 3：再次同步（如果后续还涉及对 s_data 的二次写入）
    __syncthreads();

    output[blockIdx.x * blockDim.x + tid] = temp;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.2 致命隐患：分支死锁 (Deadlock)&lt;/h3&gt;
&lt;blockquote&gt;
&lt;p&gt;[!CAUTION] 栅障条件分支死锁规则
&lt;code&gt;__syncthreads()&lt;/code&gt; &lt;strong&gt;绝不能&lt;/strong&gt;置于包含条件散布的分支内部，除非该条件的计算结果对整块 Block 内的所有线程&lt;strong&gt;严格恒等&lt;/strong&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h4&gt;错误范例&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;if (threadIdx.x &amp;lt; 128) {
    // 严重错误！
    // 只有 Warp 0~3 的 128 个线程能运行至此，Warp 4~7 的后 128 个线程永远不会执行这行。
    // 硬件将无限期挂起并导致整个系统或核函数挂起（死锁/超时崩溃）。
    __syncthreads();
} else {
    // ...
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 核心要点速查清单&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;SM&lt;/strong&gt; 是物理核集群，&lt;strong&gt;Block&lt;/strong&gt; 是软件并行块，Block 不能跨 SM 运行。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Warp&lt;/strong&gt; 是最核心的执行调度单位（固定包含 32 个逻辑线程），也是硬件资源利用率和分支分化考察的基准。&lt;/li&gt;
&lt;li&gt;一维索引推导牢记：&lt;code&gt;int tid = blockIdx.x * blockDim.x + threadIdx.x;&lt;/code&gt;，数组访问需要边界保护，grid-stride 循环也可使用循环条件保护。&lt;/li&gt;
&lt;li&gt;速度梯度：&lt;code&gt;寄存器 &amp;gt; 共享内存/L1 &amp;gt;&amp;gt; L2 &amp;gt;&amp;gt; 全局内存 (DRAM)&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;__syncthreads()&lt;/code&gt; 仅保证&lt;strong&gt;同一个 Block 内部&lt;/strong&gt;同步，不同 Block 之间在 CUDA 编程模型中&lt;strong&gt;默认不可假定任何执行先后顺序&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;hr /&gt;
&lt;h2&gt;资料与核对范围&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;项目代码：&lt;code&gt;/home/sanzenin/test/cuda_learn/kernels/reduce_float.cu&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;NotebookLM &lt;code&gt;ai infra&lt;/code&gt;：&lt;a href=&quot;https://github.com/parallel101/course/tree/aa7715d26b55bda8ad7a9444a923c916eda30b7f/08/07_atomic&quot;&gt;parallel101 atomic 示例&lt;/a&gt;、&lt;a href=&quot;https://github.com/parallel101/course/tree/aa7715d26b55bda8ad7a9444a923c916eda30b7f/08/08_block&quot;&gt;Block 规约示例&lt;/a&gt;。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.nvidia.com/cuda/archive/12.4.0/cuda-c-best-practices-guide/index.html&quot;&gt;NVIDIA CUDA 12.4 Best Practices Guide&lt;/a&gt;；&lt;a href=&quot;https://docs.nvidia.com/cuda/cuda-programming-guide/05-appendices/cpp-language-extensions.html&quot;&gt;Warp Shuffle 官方说明&lt;/a&gt;。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>CUDA 核心复习笔记（二）：延迟、吞吐与性能模型</title><link>https://sanzenin.top/posts/obsidian/02-gpu%E6%80%A7%E8%83%BD%E7%90%86%E8%AE%BA/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/02-gpu%E6%80%A7%E8%83%BD%E7%90%86%E8%AE%BA/</guid><description>学习导航：01 GPU硬件与内存 · 02 GPU性能理论 · 03 Reduction逐版代码与解析 [!abstract] 核心目标 本篇系统梳理 GPU 体系结构中的关键性能度量：厘清延迟与吞吐的物理本质，推导理论带宽与有效带宽公式，深入理解合并访存与 Occupancy 的真实代价，建立算术强度与简化 Roof</description><pubDate>Thu, 12 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;学习导航：&lt;a href=&quot;/posts/obsidian/01-gpu%E7%A1%AC%E4%BB%B6%E4%B8%8E%E5%86%85%E5%AD%98/&quot;&gt;01 GPU硬件与内存&lt;/a&gt; · &lt;a href=&quot;/posts/obsidian/02-gpu%E6%80%A7%E8%83%BD%E7%90%86%E8%AE%BA/&quot;&gt;02 GPU性能理论&lt;/a&gt; · &lt;a href=&quot;/posts/obsidian/03-reduction%E9%80%90%E7%89%88%E4%BB%A3%E7%A0%81%E4%B8%8E%E8%A7%A3%E6%9E%90/&quot;&gt;03 Reduction逐版代码与解析&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h1&gt;CUDA 核心复习笔记（二）：延迟、吞吐与性能模型&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;[!abstract] 核心目标
本篇系统梳理 GPU 体系结构中的关键性能度量：厘清&lt;strong&gt;延迟&lt;/strong&gt;与&lt;strong&gt;吞吐&lt;/strong&gt;的物理本质，推导&lt;strong&gt;理论带宽&lt;/strong&gt;与&lt;strong&gt;有效带宽&lt;/strong&gt;公式，深入理解&lt;strong&gt;合并访存&lt;/strong&gt;与 &lt;strong&gt;Occupancy&lt;/strong&gt; 的真实代价，建立&lt;strong&gt;算术强度&lt;/strong&gt;与&lt;strong&gt;简化 Roofline 模型&lt;/strong&gt;的分析直觉，并掌握基于 &lt;strong&gt;CUDA Event&lt;/strong&gt; 进行无偏基准测试的标准范式。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 延迟（Latency）与吞吐（Throughput）&lt;/h2&gt;
&lt;h3&gt;1.1 核心概念拆解&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;延迟（Latency）&lt;/strong&gt;：完成&lt;strong&gt;单次&lt;/strong&gt;操作从发起到获得结果所经历的时间。
&lt;ul&gt;
&lt;li&gt;单位：纳秒（$\text{ns}$）或时钟周期（Clock Cycles）。&lt;/li&gt;
&lt;li&gt;典型场景：一条算术指令在管线中的流水延迟（如 4~16 个周期）；一次未命中缓存的全局显存访问延迟（通常为 200~800 个周期）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;吞吐（Throughput）&lt;/strong&gt;：系统在&lt;strong&gt;单位时间&lt;/strong&gt;内完成的操作总量或传输的数据总量。
&lt;ul&gt;
&lt;li&gt;单位：$\text{TFLOPS}$（每秒万亿次浮点运算）、$\text{GB/s}$（每秒十亿字节传输）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;吞吐量 vs 吞吐效率（Throughput vs. Efficiency）&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;吞吐量&lt;/strong&gt;是绝对产出（如内核跑出了 $400\text{ GB/s}$）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;吞吐效率&lt;/strong&gt;是实际吞吐量与硬件理论上限的比值（如 $\frac{400\text{ GB/s}}{500\text{ GB/s}} = 80%$）。高效率意味着逼近物理极限，但若算法本身包含了冗余访存或无效计算，即便硬件效率达到 $95%$，整体算法实现依然可能是低效的。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;1.2 直观数值对比：货车运货模型&lt;/h3&gt;
&lt;p&gt;考虑从仓库（DRAM）向车间（SM）运送零件：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;单辆卡车&lt;/strong&gt;：容量 100 件零件，单程行驶时间 1 小时。
&lt;ul&gt;
&lt;li&gt;延迟 = $1\text{ 小时}$。&lt;/li&gt;
&lt;li&gt;若仅有 1 辆车循环运作，吞吐量 = $\frac{100\text{ 件}}{1\text{ 小时}} = 100\text{ 件/小时}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;物流车队（GPU 并发模型）&lt;/strong&gt;：公路非常宽，可以容纳 20 辆卡车同时在路上行驶（并发流水线）。
&lt;ul&gt;
&lt;li&gt;延迟依然是 $1\text{ 小时}$（单辆车不可能跑得更快）。&lt;/li&gt;
&lt;li&gt;但路上时刻维持 20 辆车，平均每 3 分钟就有一辆车抵达终点。&lt;/li&gt;
&lt;li&gt;此时系统吞吐量 = $\frac{20 \times 100\text{ 件}}{1\text{ 小时}} = 2000\text{ 件/小时}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;GPU 的设计哲学&lt;/strong&gt;：不惜牺牲单线程延迟（CPU 擅长用大缓存与分支预测压低单任务延迟），通过成千上万个并发线程来最大化整体吞吐量。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 存储带宽与计量单位：理论带宽 vs 有效带宽&lt;/h2&gt;
&lt;h3&gt;2.1 字节计量陷阱：GB 与 GiB&lt;/h3&gt;
&lt;p&gt;计算显存带宽与容量时，必须严格区分十进制与二进制前缀：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;单位名称&lt;/th&gt;
&lt;th&gt;符号&lt;/th&gt;
&lt;th&gt;字节数定义&lt;/th&gt;
&lt;th&gt;常用场景&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Gigabyte&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$\text{GB}$&lt;/td&gt;
&lt;td&gt;$10^9 = 1,000,000,000\text{ B}$&lt;/td&gt;
&lt;td&gt;硬件厂商规格、显存物理带宽、网络传输&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Gibibyte&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$\text{GiB}$&lt;/td&gt;
&lt;td&gt;$2^{30} = 1,073,741,824\text{ B}$&lt;/td&gt;
&lt;td&gt;操作系统显存占用、&lt;code&gt;cudaMalloc&lt;/code&gt; 分配空间&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning] 误差提示
$1\text{ GiB} \approx 1.074\text{ GB}$。用 $1024^3$ 得到的是 GiB/s；用 $10^9$ 得到 GB/s。比较实测与理论值时必须统一单位。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;2.2 显存理论峰值带宽&lt;/h3&gt;
&lt;p&gt;若给出每个引脚的&lt;strong&gt;有效数据速率&lt;/strong&gt;和总线位宽：&lt;/p&gt;
&lt;p&gt;$$\text{理论带宽（GB/s）}=\frac{\text{有效速率（Gb/s/引脚）}\times\text{位宽（bit）}}{8}$$&lt;/p&gt;
&lt;p&gt;例如速率为 20 Gb/s、位宽为 384 bit，理论带宽为 $20\times384/8=960$ GB/s。这是假设示例，不是你的 GPU 的实测值。若使用真实时钟而非有效速率，需要按显存类型换算，不要重复乘倍数。&lt;/p&gt;
&lt;h3&gt;2.3 有效带宽（Effective Bandwidth）&lt;/h3&gt;
&lt;p&gt;有效带宽指内核在单位时间内完成&lt;strong&gt;算法逻辑上必需&lt;/strong&gt;的数据搬运速率：&lt;/p&gt;
&lt;p&gt;$$\text{Effective Bandwidth (GB/s)} = \frac{B_r + B_w}{t \times 10^9}$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;$B_r$：算法逻辑上从全局显存读取的总字节数。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;$B_w$：算法逻辑上写回全局显存的总字节数。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;$t$：内核纯执行耗时（秒，$\text{s}$）。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;数值示例&lt;/strong&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;对长度 $N = 67,108,864$（即 $64\times 2^{20}$ 个元素）的 &lt;code&gt;float&lt;/code&gt; 单精度数组进行向量复制（$Y[i] = X[i]$）。&lt;/li&gt;
&lt;li&gt;每个 &lt;code&gt;float&lt;/code&gt; 占 $4\text{ 字节}$。&lt;/li&gt;
&lt;li&gt;$B_r = 67,108,864 \times 4\text{ B} = 268,435,456\text{ B}$。&lt;/li&gt;
&lt;li&gt;$B_w = 67,108,864 \times 4\text{ B} = 268,435,456\text{ B}$。&lt;/li&gt;
&lt;li&gt;数据总量 $B_{\text{total}} = B_r + B_w = 536,870,912\text{ B}$（约 $0.537\text{ GB}$）。&lt;/li&gt;
&lt;li&gt;假设使用 CUDA Event 测得内核执行耗时 $t = 0.8\text{ ms} = 0.0008\text{ s}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;计算&lt;/strong&gt;：
$$\text{Effective Bandwidth} = \frac{536,870,912}{0.0008 \times 10^9} \approx 671.09\text{ GB/s}$$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!note] 核心边界：L2 缓存导致的“超额带宽”现象&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;现象&lt;/strong&gt;：有时计算出的有效带宽会&lt;strong&gt;明显超过&lt;/strong&gt;硬件 DRAM 的物理理论带宽（例如在理论峰值 $960\text{ GB/s}$ 的卡上算出了 $1500\text{ GB/s}$）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;原因&lt;/strong&gt;：有效带宽公式中的 $B_r$ 和 $B_w$ 是基于&lt;strong&gt;算法代码逻辑&lt;/strong&gt;计算的。若数据在片上 L2 缓存（甚至 L1/Shared Memory）中具有极高的复用率，实际发往片外 DRAM 的物理请求极少，大部分访存直接命中 L2（缓存与显存的吞吐取决于架构和访问模式）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;适用边界&lt;/strong&gt;：
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;有效带宽&lt;/strong&gt;反映的是“算法层面的数据消费速率”。&lt;/li&gt;
&lt;li&gt;若要评估“显存物理总线饱和度”，必须使用 Nsight Compute 采集底层 DRAM 物理吞吐指标（如 &lt;code&gt;dram__bytes.sum&lt;/code&gt;），不能仅凭算法逻辑大小与物理峰值直接相除。&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 合并访存（Coalesced Memory Access）&lt;/h2&gt;
&lt;h3&gt;3.1 硬件物理机制&lt;/h3&gt;
&lt;p&gt;GPU 全局显存的物理访问不是按字节为单位发起的，而是按**固定大小、自然对齐的内存段（Memory Transactions，通常为 32 字节 Sector）**进行传输。
一个 Warp（32 个线程）在执行单条全局访存指令时，硬件访存单元会计算这 32 个线程所请求地址的覆盖范围，并将其折叠为尽可能少的 32 字节物理事务。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;合并访存（Coalesced）&lt;/strong&gt;：Warp 内 32 个线程访问的地址紧密相邻且对齐在 32 字节边界内，硬件只需最少次数的显存事务即可满足全组需求。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;非合并访存（Uncoalesced）&lt;/strong&gt;：访问地址分散、跨步较大或未对齐，迫使硬件发起大量事务，每次事务中仅有极小部分是有效数据。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3.2 逐步数值对比：连续访问 vs 跨步访问&lt;/h3&gt;
&lt;p&gt;假设一个 Warp（32 线程）中，每个线程需要读取一个 4 字节的 &lt;code&gt;float&lt;/code&gt; 数据（全 Warp 共需 $32 \times 4\text{ B} = 128\text{ 字节}$ 有效数据）：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;线程编号:  T0   T1   T2  ...  T31
需求大小:  4B   4B   4B  ...  4B  (总计 128B)
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;情况 A：对齐连续合并（Stride = 1）&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;地址分布&lt;/strong&gt;：线程 $k$ 访问基准地址 $\text{Base} + 4k$（假设 $\text{Base}$ 已经 128 字节对齐）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;地址范围&lt;/strong&gt;：$[0, 127]\text{ 字节}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;事务产生&lt;/strong&gt;：该区间恰好跨越 4 个连续的 32 字节 Sector（$4 \times 32\text{ B} = 128\text{ B}$）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;物理传输&lt;/strong&gt;：硬件发出 4 次 32 字节事务，共传输 $128\text{ 字节}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;总线利用率（Bus Efficiency）&lt;/strong&gt;：
$$\text{Efficiency} = \frac{\text{有效载荷}}{\text{物理传输}} = \frac{128\text{ B}}{128\text{ B}} = 100%$$&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;情况 B：跨步非合并（Stride = 32）&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;地址分布&lt;/strong&gt;：线程 $k$ 访问地址 $\text{Base} + 4k \times 32 = \text{Base} + 128k$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;地址特征&lt;/strong&gt;：每个线程所请求的 4 字节数据，落在了完全不同的 32 字节 Sector 中。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;事务产生&lt;/strong&gt;：32 个线程的地址互不属于任何同一个 Sector，硬件必须发出 &lt;strong&gt;32 次独立的 32 字节事务&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;物理传输&lt;/strong&gt;：总共搬运 $32 \times 32\text{ B} = 1024\text{ 字节}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;总线利用率&lt;/strong&gt;：
$$\text{Efficiency} = \frac{128\text{ B}}{1024\text{ B}} = 12.5%$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：同样的计算代码，仅因访存步长不同，此示例中请求覆盖的扇区字节数增加 8 倍；实际 DRAM 流量与运行时间还受缓存及其他瓶颈影响。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;4. Occupancy 的精确定义与延迟隐藏&lt;/h2&gt;
&lt;h3&gt;4.1 Occupancy 精确定义&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;Occupancy（占用率）&lt;/strong&gt; 是衡量 SM 计算资源预定程度的度量：&lt;/p&gt;
&lt;p&gt;$$\text{Occupancy} = \frac{\text{SM 上的当前活跃 Warp 数（Active Warps）}}{\text{SM 支持的理论最大活跃 Warp 数（Maximum Active Warps）}}$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;活跃 Warp（Active Warp）&lt;/strong&gt;：已经分配好寄存器和共享内存资源，常驻在 SM 上等待或正在被执行的 Warp。&lt;/li&gt;
&lt;li&gt;限制活跃 Warp 数量的硬性资源（木桶效应，取决于瓶颈项）：
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;寄存器堆大小（Register File Size）&lt;/strong&gt;：每个 SM 总寄存器有限，每线程使用的寄存器越多，能容纳的线程越少。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;共享内存容量（Shared Memory Size）&lt;/strong&gt;：每个 Block 申请的动态/静态共享内存。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;SM 调度上限&lt;/strong&gt;：最大 Block 数限制（例如每 SM 最多 16 或 32 个 Block）及最大线程总数限制（例如每 SM 最多 1024 或 2048 线程）。&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;4.2 资源瓶颈推算实例&lt;/h3&gt;
&lt;p&gt;假设某 GPU 架构的单个 SM 规格如下：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;最大支持 Warp 数：$64$（即最多 2048 线程）。&lt;/li&gt;
&lt;li&gt;最大支持 Block 数：$32$。&lt;/li&gt;
&lt;li&gt;SM 寄存器总数：$65536$（64K 个 32-bit 寄存器）。&lt;/li&gt;
&lt;li&gt;SM 共享内存容量：$64\text{ KB}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;现在启动一个内核，配置如下：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;每个 Block 拥有 $256$ 个线程（即 $256 / 32 = 8$ 个 Warp）。&lt;/li&gt;
&lt;li&gt;编译期分析显示：每个线程使用 $40$ 个寄存器。&lt;/li&gt;
&lt;li&gt;每个 Block 申请静态共享内存 $16\text{ KB}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;步骤计算&lt;/strong&gt;：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;线程数限制&lt;/strong&gt;：
$\text{Max Blocks}_{\text{thread}} = \lfloor 2048 / 256 \rfloor = 8\text{ 个 Block}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;寄存器限制&lt;/strong&gt;：
每个 Block 需消耗：$256 \times 40 = 10240$ 个寄存器（注：硬件通常按 allocation granule 分配，此处取简化整数）。
$\text{Max Blocks}_{\text{reg}} = \lfloor 65536 / 10240 \rfloor = 6\text{ 个 Block}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;共享内存限制&lt;/strong&gt;：
$\text{Max Blocks}_{\text{smem}} = \lfloor 64\text{ KB} / 16\text{ KB} \rfloor = 4\text{ 个 Block}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;最终驻留 Block 数&lt;/strong&gt;：
$$\text{Active Blocks} = \min(8, 6, 4) = 4\text{ 个 Block}$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;计算 Occupancy&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;当前活跃 Warp 数 $= 4\text{ Blocks} \times 8\text{ Warps/Block} = 32\text{ Warps}$。&lt;/li&gt;
&lt;li&gt;$$\text{Occupancy} = \frac{32}{64} = 50%$$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;4.3 隐藏延迟&lt;/h3&gt;
&lt;p&gt;Warp 0 等待显存读取时，如果同一 SM 上有其他&lt;strong&gt;已就绪&lt;/strong&gt;的 Warp，调度器可以先发射它们的指令，减少计算单元的空等。&lt;/p&gt;
&lt;p&gt;驻留的 Warp 不一定随时就绪；如果都在等待依赖或同一瓶颈，增加数量也不保证能继续发射指令。独立操作可以增加在途工作量，是否足够需结合架构和实测。&lt;/p&gt;
&lt;h3&gt;4.4 避坑指南：为什么 Occupancy 并不是越高越好？&lt;/h3&gt;
&lt;blockquote&gt;
&lt;p&gt;[!warning] 辟谣：不要盲目追求 100% Occupancy
高 Occupancy 仅表示驻留 Warp 相对较多，并不表示这些 Warp 已经就绪，它并不等于&lt;strong&gt;高性能&lt;/strong&gt;。过度追求 Occupancy 往往会适得其反：&lt;/p&gt;
&lt;/blockquote&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;寄存器溢出（Register Spilling）&lt;/strong&gt;：
为了拉高 Occupancy，开发者常使用编译指令（如 &lt;code&gt;__launch_bounds__&lt;/code&gt;）强行限制每个线程使用的寄存器数量。如果线程计算原本需要更多临时变量，受限的变量会被溢出到**局部显存（Local Memory）**中，本质上落入全局显存/L1 Cache，导致大量额外的显存访问，整体执行时间暴增。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;指令级并行（ILP）替代线程级并行（TLP）&lt;/strong&gt;：
隐藏延迟并非只能靠“堆线程”。单个线程如果具备独立的计算流（例如展开循环以发起多个互不依赖的读取），单个 Warp 就能在流水线中维持多笔 in-flight 操作。
&lt;ul&gt;
&lt;li&gt;高性能 Kernel 的 Occupancy 不一定达到 100%；具体性能需要在目标硬件上测量。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;缓存冲突（Cache Thrashing）&lt;/strong&gt;：
过多活跃线程同时竞争有限的片上 L1/L2 缓存，导致缓存驻留时间缩短，命中率骤降。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 指令瓶颈、带宽瓶颈与简化 Roofline 模型&lt;/h2&gt;
&lt;h3&gt;5.1 算术强度（Arithmetic Intensity, AI）&lt;/h3&gt;
&lt;p&gt;算术强度衡量算法在内存搬运成本下的计算纯度：&lt;/p&gt;
&lt;p&gt;$$\text{Arithmetic Intensity (AI)} = \frac{\text{算法总浮点运算量（FLOP）}}{\text{算法总数据移动量（Bytes）}} \quad (\text{单位：FLOP/Byte})$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;注意分母通常指与 DRAM 交换的物理字节量（或算法最低内存流量）。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;5.2 简化 Roofline 模型原理&lt;/h3&gt;
&lt;p&gt;Roofline 模型将硬件性能极限直观描绘为一张折线图：&lt;/p&gt;
&lt;p&gt;带宽上限随算术强度增长；当该上限达到计算峰值后，计算峰值构成另一条上限。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;算力天花板（Compute Roof）&lt;/strong&gt;：硬件所能提供的最高理论运算能力 $P_{\text{peak}}$（TFLOPS）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;带宽天花板（Bandwidth Roof）&lt;/strong&gt;：受限于显存传输速度，最大性能为 $\text{Attainable Performance} = \text{AI} \times B_{\text{peak}}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;系统机器平衡点 / 拐点（Machine Balance, $\text{AI}^*$）&lt;/strong&gt;：
$$\text{AI}^* = \frac{P_{\text{peak}} \text{ (TFLOPS)}}{B_{\text{peak}} \text{ (TB/s)}} = \frac{P_{\text{peak}} \text{ (GFLOPS)}}{B_{\text{peak}} \text{ (GB/s)}}$$&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;若算法 $\text{AI} &amp;lt; \text{AI}^*$&lt;/strong&gt;：位于简化模型的&lt;strong&gt;带宽上限区&lt;/strong&gt;；是否真正受带宽限制仍需实测。优化重心：合并访存、降低访存次数、Shared Memory 数据复用、算子融合（Kernel Fusion）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;若算法 $\text{AI} &amp;gt; \text{AI}^*$&lt;/strong&gt;：位于简化模型的&lt;strong&gt;计算上限区&lt;/strong&gt;；实际还可能受指令发射、延迟等因素限制。优化重心：利用 Tensor Core、提升 ILP、避免分支分歧、使用快速近似数学函数（仅在精度要求允许且确认适用时）。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;5.3 逐步数值对比：向量加法 vs 矩阵乘法&lt;/h3&gt;
&lt;p&gt;假设某 GPU 的理论参数如下：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;理论单精度算力 $P_{\text{peak}} = 10\text{ TFLOPS} = 10,000\text{ GFLOPS}$。&lt;/li&gt;
&lt;li&gt;理论显存带宽 $B_{\text{peak}} = 500\text{ GB/s}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;硬件拐点&lt;/strong&gt;：
$$\text{AI}^* = \frac{10000}{500} = 20\text{ FLOP/Byte}$$&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;内核 1：向量相加（$C[i] = A[i] + B[i]$）&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;计算量&lt;/strong&gt;：每个元素 1 次加法 = $1\text{ FLOP}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;访存量&lt;/strong&gt;：读取 $A[i], B[i]$（各 4 字节），写入 $C[i]$（4 字节），共 $12\text{ 字节}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;算术强度&lt;/strong&gt;：
$$\text{AI} = \frac{1\text{ FLOP}}{12\text{ Byte}} \approx 0.0833\text{ FLOP/Byte}$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;分析&lt;/strong&gt;：$0.0833 \ll 20$，处于极度&lt;strong&gt;带宽受限区&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;理论最高可达性能&lt;/strong&gt;：
$$P_{\text{attainable}} = 0.0833\text{ FLOP/Byte} \times 500\text{ GB/s} \approx 41.65\text{ GFLOPS}$$&lt;/li&gt;
&lt;li&gt;假设所有逻辑数据均来自 DRAM 且没有其他开销，该简化模型的上限约为计算峰值的 $0.42%$。实际还应考虑缓存、访存效率与启动开销。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;进一步理解&lt;/h4&gt;
&lt;p&gt;数据复用可以减少从某层内存搬运的字节，从而提高相对于该层内存的算术强度。真实 GEMM 的访存量还取决于尺寸、分块、缓存和输出读写，不能仅凭简化公式断定实际一定计算受限。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;6. GPU Event 性能基准测试与误差分析&lt;/h2&gt;
&lt;h3&gt;6.1 为什么直接使用 CPU 计时器会有问题？&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    A[&quot;CPU 提交 Kernel&quot;] --&amp;gt; B[&quot;GPU 排队并执行&quot;]
    B --&amp;gt; C[&quot;同步后 CPU 获取结果&quot;]
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;cudaLaunchKernel&lt;/code&gt; 是&lt;strong&gt;异步非阻塞&lt;/strong&gt;的，CPU 将命令压入驱动队列后瞬间返回（耗时通常仅几微秒）。&lt;/li&gt;
&lt;li&gt;若直接使用 C++ &lt;code&gt;std::chrono&lt;/code&gt; 环绕 kernel 调用，测出的仅仅是“CPU 提交任务的时间”，而非“GPU 真正执行的时间”。&lt;/li&gt;
&lt;li&gt;若在前后插入 &lt;code&gt;cudaDeviceSynchronize()&lt;/code&gt; 配合 CPU 计时，测量结果不仅包含 Kernel 执行本身，还会混入：
&lt;ol&gt;
&lt;li&gt;CPU 线程阻塞与唤醒的 OS 上下文切换开销。&lt;/li&gt;
&lt;li&gt;PCIe 总线驱动中断往返延迟。&lt;/li&gt;
&lt;li&gt;破坏了 GPU 原本的多 Stream 流水线并发重叠。&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;6.2 CUDA Event 标准测试范式&lt;/h3&gt;
&lt;p&gt;CUDA Event 直接由 GPU 硬件时间戳引擎在指定的 CUDA 流执行到该点时记录，具有微秒级硬件精度。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;cuda_runtime.h&amp;gt;
#include &amp;lt;iostream&amp;gt;

void benchmarkKernel() {
    cudaStream_t stream;
    cudaStreamCreate(&amp;amp;stream);

    cudaEvent_t start, stop;
    cudaEventCreate(&amp;amp;start);
    cudaEventCreate(&amp;amp;stop);

    const int WARMUP_ITERS = 10;
    const int BENCHMARK_ITERS = 100;

    // -------------------------------------------------------------
    // 1. 预热阶段 (Warm-up)：淘汰冷启动干扰
    // -------------------------------------------------------------
    for (int i = 0; i &amp;lt; WARMUP_ITERS; ++i) {
        myKernel&amp;lt;&amp;lt;&amp;lt;grid, block, 0, stream&amp;gt;&amp;gt;&amp;gt;(...);
    }
    // 等待预热结束，便于划分测试阶段
    cudaStreamSynchronize(stream);

    // -------------------------------------------------------------
    // 2. 正式测量阶段 (Measurement)
    // -------------------------------------------------------------
    // 向流中插入起始标记
    cudaEventRecord(start, stream);

    // 连续发射多次，摊薄启动与抖动误差
    for (int i = 0; i &amp;lt; BENCHMARK_ITERS; ++i) {
        myKernel&amp;lt;&amp;lt;&amp;lt;grid, block, 0, stream&amp;gt;&amp;gt;&amp;gt;(...);
    }

    // 向流中插入终止标记
    cudaEventRecord(stop, stream);

    // 仅等待 stop 事件被硬件记录，无需全设备激进同步
    cudaEventSynchronize(stop);

    // -------------------------------------------------------------
    // 3. 提取毫秒耗时并推算
    // -------------------------------------------------------------
    float total_ms = 0.0f;
    cudaEventElapsedTime(&amp;amp;total_ms, start, stop);

    float avg_ms = total_ms / BENCHMARK_ITERS;
    std::cout &amp;lt;&amp;lt; &quot;Kernel 平均执行时间: &quot; &amp;lt;&amp;lt; avg_ms &amp;lt;&amp;lt; &quot; ms&quot; &amp;lt;&amp;lt; std::endl;

    // 释放资源
    cudaEventDestroy(start);
    cudaEventDestroy(stop);
    cudaStreamDestroy(stream);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.3 预热（Warm-up）的核心必要性&lt;/h3&gt;
&lt;p&gt;若跳过预热直接测试，首次执行会包含巨大的系统偏差：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;时钟频率爬坡延迟（Clock Gating / P-State）&lt;/strong&gt;：现代 GPU 待机时处于极低功耗档位，收到计算负载到频率升至额定加速频率（Boost Clock）通常需要数毫秒，首个 Kernel 执行往往处于低频降速状态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;驱动上下文与内存页建立&lt;/strong&gt;：Unified Memory 首次缺页中断映射、首次加载模块的 JIT 编译与符号绑定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;缓存冷启动&lt;/strong&gt;：首轮执行完全面对冷的 L2 缓存，与稳态运行表现不符。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;6.4 误差来源与测试控制&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;计时分辨率精度&lt;/strong&gt;：&lt;code&gt;cudaEventElapsedTime&lt;/code&gt; 的硬件精度约为 $0.5,\mu\text{s}$。如果待测内核执行时间极短（如 $&amp;lt; 5,\mu\text{s}$），单次测量的量化误差可高达 $10%$ 以上。&lt;strong&gt;对策&lt;/strong&gt;：在 &lt;code&gt;start&lt;/code&gt; 与 &lt;code&gt;stop&lt;/code&gt; 之间循环执行 $K$ 次（如 100~1000 次），测得总耗时再除以 $K$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;温度墙与动态调频（Thermal Throttling）&lt;/strong&gt;：连续重负载测试可能导致 GPU 撞上功耗墙（Power Limit）或温度墙（Temp Limit），触发降频。&lt;strong&gt;对策&lt;/strong&gt;：基准测试应监控 &lt;code&gt;nvidia-smi&lt;/code&gt; 输出的当前时钟频率，确保测试期间 Core Clock 保持恒定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;系统环境排他性&lt;/strong&gt;：尽量减少其他后台 GPU 任务，防止其他流抢占 SM 调度资源导致尾部延迟增大。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 概念复习脑图与自测链接&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;延迟与吞吐: 时钟周期 vs 数据吞吐率，区分系统总吞吐与总线利用效率。&lt;/li&gt;
&lt;li&gt;理论带宽公式: 注意十进制 $10^9$ 转换与总线位宽乘法。&lt;/li&gt;
&lt;li&gt;合并访存原则: 32 字节对齐、连续、少事务；杜绝大步长跨步。&lt;/li&gt;
&lt;li&gt;Occupancy 评估: 由寄存器、Shared Memory、最大 Warp 决定；不高估高 Occupancy 的收益，防范 Register Spill。&lt;/li&gt;
&lt;li&gt;Roofline 分析: 寻找平衡拐点 $\text{AI}^*$；决定是攻坚访存合并还是算子计算流水。&lt;/li&gt;
&lt;li&gt;GPU 基准测试: 坚持“先预热、批处理、Event 计时、求均值”的原则。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;hr /&gt;
&lt;h2&gt;资料与核对范围&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;项目代码：&lt;code&gt;/home/sanzenin/test/cuda_learn/kernels/reduce_float.cu&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;NotebookLM &lt;code&gt;ai infra&lt;/code&gt;：&lt;a href=&quot;https://github.com/parallel101/course/tree/aa7715d26b55bda8ad7a9444a923c916eda30b7f/08/07_atomic&quot;&gt;parallel101 atomic 示例&lt;/a&gt;、&lt;a href=&quot;https://github.com/parallel101/course/tree/aa7715d26b55bda8ad7a9444a923c916eda30b7f/08/08_block&quot;&gt;Block 规约示例&lt;/a&gt;。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.nvidia.com/cuda/archive/12.4.0/cuda-c-best-practices-guide/index.html&quot;&gt;NVIDIA CUDA 12.4 Best Practices Guide&lt;/a&gt;；&lt;a href=&quot;https://docs.nvidia.com/cuda/cuda-programming-guide/05-appendices/cpp-language-extensions.html&quot;&gt;Warp Shuffle 官方说明&lt;/a&gt;。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>CUDA 学习笔记（三）：从原子操作到向量化规约（Reduction）的渐进式演进</title><link>https://sanzenin.top/posts/obsidian/03-reduction%E9%80%90%E7%89%88%E4%BB%A3%E7%A0%81%E4%B8%8E%E8%A7%A3%E6%9E%90/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/03-reduction%E9%80%90%E7%89%88%E4%BB%A3%E7%A0%81%E4%B8%8E%E8%A7%A3%E6%9E%90/</guid><description>学习导航：01 GPU硬件与内存 · 02 GPU性能理论 · 03 Reduction逐版代码与解析 本篇笔记聚焦于并行计算中最为经典的基础原语——并行规约（Reduction）。内容结合 parallel101 课程源码（07atomic、08block）的设计思路，深度解析 /home/sanzenin/test</description><pubDate>Thu, 12 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;学习导航：&lt;a href=&quot;/posts/obsidian/01-gpu%E7%A1%AC%E4%BB%B6%E4%B8%8E%E5%86%85%E5%AD%98/&quot;&gt;01 GPU硬件与内存&lt;/a&gt; · &lt;a href=&quot;/posts/obsidian/02-gpu%E6%80%A7%E8%83%BD%E7%90%86%E8%AE%BA/&quot;&gt;02 GPU性能理论&lt;/a&gt; · &lt;a href=&quot;/posts/obsidian/03-reduction%E9%80%90%E7%89%88%E4%BB%A3%E7%A0%81%E4%B8%8E%E8%A7%A3%E6%9E%90/&quot;&gt;03 Reduction逐版代码与解析&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h1&gt;CUDA 学习笔记（三）：从原子操作到向量化规约（Reduction）的渐进式演进&lt;/h1&gt;
&lt;p&gt;本篇笔记聚焦于并行计算中最为经典的基础原语——&lt;strong&gt;并行规约（Reduction）&lt;/strong&gt;。内容结合 parallel101 课程源码（&lt;code&gt;07_atomic&lt;/code&gt;、&lt;code&gt;08_block&lt;/code&gt;）的设计思路，深度解析 &lt;code&gt;/home/sanzenin/test/cuda_learn/kernels/reduce_float.cu&lt;/code&gt; 中包含的四个核心 Kernel：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;reduce_atomic&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;reduce_atomic_tree&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;reduce_multi_warp&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;reduce_multi_warpf4&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;一、 规约演进路线与小例推演（从 07_atomic 到 08_block）&lt;/h2&gt;
&lt;p&gt;规约的目标是将数组 $A$ 中的 $N$ 个元素累加为一个标量。设待规约数组为 8 个元素：
$$A = [1, 2, 3, 4, 5, 6, 7, 8]$$&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    A[&quot;输入数组&quot;] --&amp;gt; B[&quot;线程局部求和&quot;]
    B --&amp;gt; C[&quot;Warp 内规约&quot;]
    C --&amp;gt; D[&quot;Block 内合并&quot;]
    D --&amp;gt; E[&quot;多个 Block 的部分和&quot;]
    E --&amp;gt; F[&quot;第二次 Kernel 合并&quot;]
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;1. 阶段一：每元素直接全局原子加（07_atomic 基线）&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;动机&lt;/strong&gt;：最直观的实现，每个线程负责一个元素，直接向全局累加单元写入。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;数据流与小例&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;启动 8 个线程，线程 $i$ 读取 $A[i]$，执行 &lt;code&gt;atomicAdd(d_out, A[i])&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;8 个线程并发尝试写入同一个全局内存地址 &lt;code&gt;d_out&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;收益&lt;/strong&gt;：代码极简，无须处理块内同步或边界填充。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;代价&lt;/strong&gt;：&lt;strong&gt;硬件争用（Serialization）&lt;/strong&gt;。同一地址的大量原子更新可能形成竞争并限制吞吐，具体情况取决于硬件和负载。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;2. 阶段二：线程先局部累加再原子加 / Grid-Stride Loop（07_atomic 进阶）&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;动机&lt;/strong&gt;：与其让 $N$ 个线程发起 $N$ 次全局原子操作，不如让每个线程先在本地寄存器中累加多个元素，最后每个线程仅发射 1 次原子加。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;数据流与小例&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;设仅启动 2 个线程（线程 0 和线程 1）。采用 &lt;strong&gt;Grid-Stride Loop（网格跨步循环）&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;线程 0 依次累加索引：$0, 2, 4, 6 \rightarrow 1 + 3 + 5 + 7 = 16$（保存在寄存器 &lt;code&gt;local_sum&lt;/code&gt;）&lt;/li&gt;
&lt;li&gt;线程 1 依次累加索引：$1, 3, 5, 7 \rightarrow 2 + 4 + 6 + 8 = 20$（保存在寄存器 &lt;code&gt;local_sum&lt;/code&gt;）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;循环结束后发射原子操作：
&lt;ul&gt;
&lt;li&gt;线程 0：&lt;code&gt;atomicAdd(d_out, 16)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;线程 1：&lt;code&gt;atomicAdd(d_out, 20)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;收益&lt;/strong&gt;：全局原子加的次数从 $N$ 锐减至 &lt;code&gt;total_threads&lt;/code&gt;（本例中从 8 次减少至 2 次）。一般情况下同一 Warp 中相邻 Lane 同步访问相邻元素，因此有利于合并；两线程例子仅用于展示索引。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;代价&lt;/strong&gt;：每个线程的计算指令数增加；如果网格大小与数据规模不匹配，延迟隐藏效果可能减弱。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3. 阶段三：Block 级别 Shared Memory 树形规约（08_block）&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;动机&lt;/strong&gt;：在 Block 内部使用高带宽、低延迟的片上共享内存（Shared Memory）协作完成局部求和，由 Block 的 0 号线程向独立的 &lt;code&gt;out[blockIdx.x]&lt;/code&gt; 写出部分和，后续再合并。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;数据流与小例&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;线程先将全局内存加载到 &lt;code&gt;__shared__ float s_data[8]&lt;/code&gt; 中。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;树形折叠（以跨步折半为例）&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;步长 stride = 4：线程 $0 \sim 3$ 执行 &lt;code&gt;s_data[t] += s_data[t + 4]&lt;/code&gt;。
$s_data = [1+5, 2+6, 3+7, 4+8, ...] = [6, 8, 10, 12, ...]$&lt;/li&gt;
&lt;li&gt;同步：&lt;code&gt;__syncthreads()&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;步长 stride = 2：线程 $0 \sim 1$ 执行 &lt;code&gt;s_data[t] += s_data[t + 2]&lt;/code&gt;。
$s_data = [6+10, 8+12, ...] = [16, 20, ...]$&lt;/li&gt;
&lt;li&gt;同步：&lt;code&gt;__syncthreads()&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;步长 stride = 1：线程 0 执行 `s_data[0] += s_data[1] \rightarrow 16 + 20 = 36$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;最后线程 0 写出 &lt;code&gt;out[blockIdx.x] = s_data[0]&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;收益&lt;/strong&gt;：各 Block 写入不同位置，避免逐线程竞争同一全局地址；后续仍需合并。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;代价&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;每层折叠都需要 &lt;code&gt;__syncthreads()&lt;/code&gt;，带来块内屏障同步开销。&lt;/li&gt;
&lt;li&gt;随着步长缩减，活跃线程对半减少，部分线程逐渐闲置；是否发生 bank conflict 要看具体访问地址。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;二、 &lt;code&gt;reduce_float.cu&lt;/code&gt; 架构拆解：多 Warp Shuffle 与向量化&lt;/h2&gt;
&lt;p&gt;用户代码在 &lt;code&gt;/home/sanzenin/test/cuda_learn/kernels/reduce_float.cu&lt;/code&gt; 中实现了从原子操作到 Warp 原语与向量化的进阶，尤其包含了固定结构设计的 &lt;code&gt;reduce_multi_warp&lt;/code&gt; 与 &lt;code&gt;reduce_multi_warpf4&lt;/code&gt;。&lt;/p&gt;
&lt;h3&gt;1. &lt;code&gt;reduce_multi_warp&lt;/code&gt;：多 Warp 协作与寄存器洗牌&lt;/h3&gt;
&lt;p&gt;该 Kernel 固定采用 &lt;strong&gt;256 线程/Block&lt;/strong&gt; 的配置，Block 内划分情况如下：
$$\text{Block 规模} = 256 \text{ 线程} \quad \Longrightarrow \quad \frac{256}{32} = 8 \text{ 个 Warp}$$
因此，代码内部分配了固定大小的共享内存缓冲：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__shared__ float warp_sum[8];
&lt;/code&gt;&lt;/pre&gt;
&lt;h4&gt;数据流执行过程&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    A[&quot;各线程计算局部和&quot;] --&amp;gt; B[&quot;各 Warp 进行五轮 Shuffle&quot;]
    B --&amp;gt; C[&quot;各 Warp 的 Lane 0 写入 warp_sum&quot;]
    C --&amp;gt; D[&quot;Block 内同步&quot;]
    D --&amp;gt; E[&quot;Warp 0 读取八个部分和，其余 Lane 补零&quot;]
    E --&amp;gt; F[&quot;Warp 0 再进行五轮 Shuffle&quot;]
    F --&amp;gt; G[&quot;Lane 0 写出 out[blockIdx.x]&quot;]
&lt;/code&gt;&lt;/pre&gt;
&lt;ol&gt;
&lt;li&gt;256 个线程各自计算 &lt;code&gt;local_sum&lt;/code&gt;，8 个 Warp 分别执行偏移 &lt;code&gt;16, 8, 4, 2, 1&lt;/code&gt; 的规约。&lt;/li&gt;
&lt;li&gt;各 Warp 的 Lane 0 写入 &lt;code&gt;warp_sum[warp_id]&lt;/code&gt;，随后 &lt;code&gt;__syncthreads()&lt;/code&gt; 等待写入并确保块内可见。&lt;/li&gt;
&lt;li&gt;Warp 0 的 Lane 0～7 读取 8 个部分和，其余 Lane 补零。源码再次执行五轮偏移 &lt;code&gt;16, 8, 4, 2, 1&lt;/code&gt;，由 Lane 0 普通写入 &lt;code&gt;out[blockIdx.x]&lt;/code&gt;；这里不是 atomicAdd。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0xffffffff&lt;/code&gt; 要求完整 Warp 正确参与；不能不经处理就把固定 256 线程的实现改为不完整 Warp。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;2. 向量化访存：&lt;code&gt;reduce_multi_warpf4&lt;/code&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;优化动机&lt;/strong&gt;：每个线程一次加载四个 float，编译器可能生成较宽的加载指令，减少指令数。标量访问也可以合并；这不保证带宽吃满或性能提高。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;数据划分与对齐（$n/4$）&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;全局元素被视作包含 $n/4$ 个 &lt;code&gt;float4&lt;/code&gt; 向量的序列。&lt;/li&gt;
&lt;li&gt;网格步长变为以 &lt;code&gt;float4&lt;/code&gt; 为单位迭代（&lt;code&gt;stride * 4&lt;/code&gt; 元素）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;尾部处理（Tail / Remainder Handling）与 Zero-Fill&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;若 $N$ 不能被 4 整除，末尾剩余 $N \pmod 4$ 个元素无法构成完整的 &lt;code&gt;float4&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;此外，若输入内存地址未按 16 字节对齐，强制转成 &lt;code&gt;float4*&lt;/code&gt; 可能会引发未定义行为或非对齐异常。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;尾部处理原则&lt;/strong&gt;：前部整块走 &lt;code&gt;float4&lt;/code&gt; 循环，末尾剩余元素通过标量循环（逐个 &lt;code&gt;float&lt;/code&gt;）累加，或者提前实际分配到 4 的倍数并将新增元素初始化为 0，再读取完整向量。不能先进行越界或未对齐加载，再依靠补零使其安全。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;独立编译历史验收事实&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;在离线 SASS 汇编比对中，&lt;code&gt;reduce_multi_warpf4&lt;/code&gt; 确实成功被编译器展开为 &lt;strong&gt;&lt;code&gt;LDG.E.128&lt;/code&gt;&lt;/strong&gt; 宽访存指令。&lt;/li&gt;
&lt;li&gt;
&lt;blockquote&gt;
&lt;p&gt;[!IMPORTANT]
&lt;strong&gt;事实边界声明&lt;/strong&gt;：历史验收仅验证了生成 128-bit 指令的正确性，&lt;strong&gt;未对其进行独立性能 Benchmark 实测&lt;/strong&gt;。不可凭空断言其相较于标量版本的实际加速比。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3. Two-Pass 规约模式 vs 块间原子累加&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;实现机制&lt;/th&gt;
&lt;th&gt;优势&lt;/th&gt;
&lt;th&gt;代价 / 限制&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;单 Pass + 原子累加&lt;/strong&gt;（可选方案）&lt;/td&gt;
&lt;td&gt;每个 Block 内部规约出一个标量，最后通过 &lt;code&gt;atomicAdd&lt;/code&gt; 累加至全局输出。&lt;/td&gt;
&lt;td&gt;实现简单，仅启动一次 Kernel，适合中小规模数据。&lt;/td&gt;
&lt;td&gt;当 Block 数量巨大（例如上万个 Block）时，跨 Block 的原子写入仍然会产生 L2 排队。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Two-Pass 规约&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Pass 1&lt;/strong&gt;：每个 Block 规约结果写入中间数组 &lt;code&gt;d_intermediate[gridDim.x]&lt;/code&gt;。&amp;lt;br&amp;gt;&lt;strong&gt;Pass 2&lt;/strong&gt;：启动第二个 Kernel 对中间数组进行二次规约。&lt;/td&gt;
&lt;td&gt;该两阶段实现无需对同一结果做全局 atomicAdd；耗时仍需测量。&lt;/td&gt;
&lt;td&gt;需额外分配显存空间暂存中间结果，引入多一次 Kernel Launch 开销。&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;三、 同步语义、洗牌安全性与硬件屏障&lt;/h2&gt;
&lt;h3&gt;1. 同一 Stream 内的执行顺序&lt;/h3&gt;
&lt;p&gt;在 CUDA 运行时中，同一 Stream（包括默认的 Stream 0）内的操作具有严格的&lt;strong&gt;保序性（In-order execution）&lt;/strong&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;前一个 Kernel 未执行完毕时，后一个 Kernel 绝不会开始执行。&lt;/li&gt;
&lt;li&gt;因此，如果在同流中连续 launch 两次规约 Kernel，它们在 GPU 硬件上是严格串行排队的。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!NOTE]
在 &lt;code&gt;reduce_float.cu&lt;/code&gt; 的 &lt;code&gt;main&lt;/code&gt; 函数实现中，&lt;strong&gt;实际进行了两次 &lt;code&gt;reduce_multi_warp&lt;/code&gt; 的调用&lt;/strong&gt;（第一次计算 Block 部分和，第二次将部分和规约为最终结果），&lt;strong&gt;而并未调用 &lt;code&gt;reduce_multi_warpf4&lt;/code&gt;&lt;/strong&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;2. &lt;code&gt;__shfl_down_sync&lt;/code&gt; 不提供内存屏障&lt;/h3&gt;
&lt;p&gt;初学者最容易产生的一个致命误解是：&lt;em&gt;“Shuffle 函数既然带 &lt;code&gt;_sync&lt;/code&gt;，它是不是就同步了所有内存？”&lt;/em&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;答案是否定的&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;__shfl_down_sync&lt;/code&gt; 是**寄存器到寄存器（Register-to-Register）**的数据交换，仅在参与该指令的 Warp 内部 Lane 之间完成同步和值传递。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;它不具备任何内存屏障语义&lt;/strong&gt;：它不会刷新 L1/Shared Memory，也不会建立全局内存的 Release-Acquire 一致性。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;这正是 &lt;code&gt;reduce_multi_warp&lt;/code&gt; 阶段 2 必须显式调用 &lt;code&gt;__syncthreads()&lt;/code&gt; 的原因&lt;/strong&gt;：Warp 内 Lane 0 将寄存器写入 &lt;code&gt;warp_sum[8]&lt;/code&gt; 是对 Shared Memory 的操作，必须通过 &lt;code&gt;__syncthreads()&lt;/code&gt; 确保这些写入对 Warp 0 的读取线程全部可见。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3. Full Mask（&lt;code&gt;0xffffffff&lt;/code&gt;）与分支分歧风险&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;__shfl_down_sync(0xffffffff, val, offset)&lt;/code&gt; 中的第一个参数是线程掩码（Mask）。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0xffffffff&lt;/code&gt; 表示开发者承诺：&lt;strong&gt;当前 Warp 的这份示例中的 32 个线程都要正确参与这条 Shuffle 指令&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;分歧陷阱&lt;/strong&gt;：&lt;pre&gt;&lt;code&gt;if (threadIdx.x &amp;lt; 10) {
    // 致命错误：只有前 10 个线程进入，但传入了 0xffffffff
    val = __shfl_down_sync(0xffffffff, val, 2);
}
&lt;/code&gt;&lt;/pre&gt;
在 Volta 及更新架构（Independent Thread Scheduling）下，硬件要求 Mask 中指定的线程必须在程序计数器（PC）上聚合。若被掩码指定的线程因为分支分歧未到达该指令，将直接引发&lt;strong&gt;未定义行为（Undefined Behavior）甚至 GPU 挂起（Hang）&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;安全法则&lt;/strong&gt;：规约中非活跃的 Lane，必须先让它们统一参与 Shuffle（传入单位元 0），如果只让部分线程参与，必须正确构造掩码并确保每次读取的源 Lane 有效参与；仅使用 &lt;code&gt;__activemask()&lt;/code&gt; 不能自动保证任意规约正确。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;四、 浮点误差与双精度混合陷阱&lt;/h2&gt;
&lt;h3&gt;1. 浮点加法的非结合律（Non-Associativity）&lt;/h3&gt;
&lt;p&gt;根据 IEEE 754 标准，单精度通常具有 24 位有效精度（包括隐含前导位）。浮点加法并不满足结合律：
$$(A + B) + C \neq A + (B + C)$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;CPU 串行相加&lt;/strong&gt;：从索引 0 到 $N-1$ 顺序累加，随着和越来越大，较小的元素加进来时会发生严重的大数吃小数（Swamping / Truncation）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;GPU 树形规约&lt;/strong&gt;：成对两两合并，加法层级呈对数分布 $\log_2(N)$，误差积累形态与串行相加完全不同。&lt;/li&gt;
&lt;li&gt;两种求和顺序可能得到不同结果，不一定意味着 Kernel 错误；仍需结合参考值与容差验证。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;2. 主机端验证中的双精度隐式转换&lt;/h3&gt;
&lt;p&gt;在分析主程序核对逻辑时，存在一处经典的隐蔽陷阱：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;float expected = std::accumulate(vec.begin(), vec.end(), 0.0);
&lt;/code&gt;&lt;/pre&gt;
&lt;blockquote&gt;
&lt;p&gt;[!WARNING]
注意 &lt;code&gt;0.0&lt;/code&gt; 的字面量类型！&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;code&gt;0.0&lt;/code&gt; 是 &lt;code&gt;double&lt;/code&gt; 类型字面量，而 &lt;code&gt;0.0f&lt;/code&gt; 才是 &lt;code&gt;float&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;std::accumulate&lt;/code&gt; 是模板函数，累加器的类型完全由第三个参数推导：
$$\text{推导类型 } T = \text{double}$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;导致的行为&lt;/strong&gt;：在 CPU 端循环累加期间，所有的中间结果均以 &lt;strong&gt;64 位双精度浮点数（IEEE Double）&lt;/strong&gt; 进行高精度保持，通常比 float 保留更多有效数字，但 double 也会产生舍入误差。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;最终舍入&lt;/strong&gt;：累加完成后，将双精度累加结果隐式转换赋值给 &lt;code&gt;float expected&lt;/code&gt;，发生舍入，可能丢失精度。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结果对比&lt;/strong&gt;：这样得出的 &lt;code&gt;expected&lt;/code&gt; 并不是纯 32 位浮点串行累加的结果，而是“双精度高精度和的单精度投影”，它与 GPU 上全程使用 32 位单精度的树形规约值相比，可能不同，具体取决于输入和计算顺序。&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;
&lt;h3&gt;3. 容差与结果检查&lt;/h3&gt;
&lt;p&gt;推荐用 double 保存 CPU 参考值：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;double expected = std::accumulate(a.begin(), a.end(), 0.0);
double abs_err = std::abs(static_cast&amp;lt;double&amp;gt;(gpu_sum) - expected);
double tolerance = 1e-3 + 1e-5 * std::abs(expected);
bool pass = abs_err &amp;lt;= tolerance;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;判断条件为 $|GPU-CPU| \leq atol+rtol\times|CPU|$。这里的 $atol=10^{-3}$、$rtol=10^{-5}$ 只是示例，需要根据输入规模、数据分布和算子确定；正负抵消使参考值接近 0 时尤其要关注绝对误差。double 参考值不是数学精确真值。分别覆盖全 0、全 1、正负混合、大数与小数、边界长度，再检查 NaN 和 Inf 的行为。&lt;/p&gt;
&lt;p&gt;原子版本需要在每次运行前将输出初始化为零，否则会在旧值上继续累加。当前两次 &lt;code&gt;reduce_multi_warp&lt;/code&gt; 是同一 Stream 的两阶段计算；第一次写入 &lt;code&gt;partial&lt;/code&gt;，第二次以 &lt;code&gt;partial&lt;/code&gt; 为输入。只用其中一次得到的是部分和。&lt;/p&gt;
&lt;h3&gt;4. float4 的分组例子&lt;/h3&gt;
&lt;p&gt;若 &lt;code&gt;n = 11&lt;/code&gt;，&lt;code&gt;vec_n = n / 4 = 2&lt;/code&gt;：&lt;code&gt;a4[0]&lt;/code&gt; 读取 &lt;code&gt;a[0..3]&lt;/code&gt;，&lt;code&gt;a4[1]&lt;/code&gt; 读取 &lt;code&gt;a[4..7]&lt;/code&gt;，最后由 Grid 中一个线程用标量加载 &lt;code&gt;a[8..10]&lt;/code&gt;。若把分组数向上取整，最后一次 16 字节加载会包含 &lt;code&gt;a[11]&lt;/code&gt;，除非底层实际分配并初始化了该填充元素，否则存在越界风险。&lt;code&gt;a4[i]&lt;/code&gt; 的单位已经是 4 个 float，因此 Grid-stride 中的向量索引步长不再额外乘 4。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;五、 规约演进综合对比表&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;维度&lt;/th&gt;
&lt;th&gt;&lt;code&gt;reduce_atomic&lt;/code&gt; (07_atomic)&lt;/th&gt;
&lt;th&gt;&lt;code&gt;reduce_atomic_tree&lt;/code&gt; (08_block)&lt;/th&gt;
&lt;th&gt;&lt;code&gt;reduce_multi_warp&lt;/code&gt;&lt;/th&gt;
&lt;th&gt;&lt;code&gt;reduce_multi_warpf4&lt;/code&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;加载方式&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;32-bit 全局标量访存&lt;/td&gt;
&lt;td&gt;32-bit 全局访存 + Shared Mem 缓存&lt;/td&gt;
&lt;td&gt;32-bit 全局访存 + 寄存器规约&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;float4；历史构建中观察到 &lt;code&gt;LDG.E.128&lt;/code&gt;&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;同步粒度&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;依赖硬件原子单元排队&lt;/td&gt;
&lt;td&gt;块内多次 &lt;code&gt;__syncthreads()&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;一次 &lt;code&gt;__syncthreads()&lt;/code&gt; + Warp Shuffle&lt;/td&gt;
&lt;td&gt;仅一次 &lt;code&gt;__syncthreads()&lt;/code&gt; + 宽访存流水线&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;可能的瓶颈&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;同一地址原子竞争&lt;/td&gt;
&lt;td&gt;块内同步及线程闲置&lt;/td&gt;
&lt;td&gt;访存、指令或同步开销&lt;/td&gt;
&lt;td&gt;指令、访存及寄存器压力；具体需实测&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;块规模固定性&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;任意有效 Block 大小&lt;/td&gt;
&lt;td&gt;需适配树形步长（通常为 2 的幂）&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;固定 256 线程&lt;/strong&gt;（对应 &lt;code&gt;warp_sum[8]&lt;/code&gt;）&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;固定 256 线程&lt;/strong&gt;（对应 &lt;code&gt;warp_sum[8]&lt;/code&gt;）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;主程序调用现状&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;可独立测试&lt;/td&gt;
&lt;td&gt;可独立测试&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;&lt;code&gt;main&lt;/code&gt; 函数中调用 2 次&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;&lt;code&gt;main&lt;/code&gt; 中未调用；历史验收另行测试过该 Kernel&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;hr /&gt;
&lt;h1&gt;各优化版本：完整 Kernel 与逐步解析&lt;/h1&gt;
&lt;p&gt;下面代码可以逐段对照学习；在 &lt;code&gt;.cu&lt;/code&gt; 文件中使用时需要包含 &lt;code&gt;&amp;lt;cuda_runtime.h&amp;gt;&lt;/code&gt;。每个 Kernel 假设输入和输出内存不重叠，长度和索引在 int 范围内。&lt;/p&gt;
&lt;h2&gt;版本 0：每读一个数，就做一次 atomicAdd&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;目的：先得到一个容易理解的并行求和基线。&lt;/strong&gt; 每个线程按 Grid-stride 访问数组，读取一个数后立刻把它原子加到 &lt;code&gt;out[0]&lt;/code&gt;。所有线程都更新同一个地址；atomicAdd 保证单次更新的原子性，防止普通 &lt;code&gt;out[0] += a[i]&lt;/code&gt; 的并发读写丢失结果。&lt;/p&gt;
&lt;p&gt;以 8 个数 &lt;code&gt;[1,2,3,4,5,6,7,8]&lt;/code&gt; 和 2 个线程为例：线程 0 访问下标 &lt;code&gt;0,2,4,6&lt;/code&gt;，线程 1 访问 &lt;code&gt;1,3,5,7&lt;/code&gt;。两个线程一共执行 8 次 atomicAdd，执行顺序不能假定。运行前必须把 &lt;code&gt;out[0]&lt;/code&gt; 初始化为 0；直接把多个 Block 的普通加法写到同一地址会发生数据竞争。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;代价与定位：&lt;/strong&gt; 同一地址竞争多时可能限制性能；这是解释用基线，实际快慢要测试。代码中的 &lt;code&gt;gid&lt;/code&gt; 是线程在整个 Grid 中的编号，&lt;code&gt;stride&lt;/code&gt; 是整个 Grid 的线程数。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__global__ void reduce_element_atomic(const float* a, float* out, int n) {
    int gid = blockIdx.x * blockDim.x + threadIdx.x;
    int stride = blockDim.x * gridDim.x;
    // 同一线程循环处理 gid, gid + stride, ...，每次都更新全局结果。
    for (int i = gid; i &amp;lt; n; i += stride) {
        atomicAdd(out, a[i]);
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;版本 1：线程先求局部和，再做 atomicAdd&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;优化动机：减少共享结果地址上的原子操作次数。&lt;/strong&gt; 每个线程先把自己负责的所有数加到私有变量 &lt;code&gt;sum&lt;/code&gt;，循环结束后才对 &lt;code&gt;out[0]&lt;/code&gt; 做一次 atomicAdd。&lt;code&gt;sum&lt;/code&gt; 通常放在寄存器，具体由编译器决定。&lt;/p&gt;
&lt;p&gt;同样是 8 个数、2 个线程：线程 0 算 &lt;code&gt;1+3+5+7=16&lt;/code&gt;，线程 1 算 &lt;code&gt;2+4+6+8=20&lt;/code&gt;，然后各原子加一次。全局原子调用由示例的 8 次变为 2 次。实际代码每个启动的线程都会在循环后调用一次，即便某些线程没有处理元素也会原子加 0。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;代价与限制：&lt;/strong&gt; 若所有线程只分到一个数，原子次数并不会减少；一个线程处理的数过多可能降低可利用的并行度。需要预先清零输出，且浮点加法的先后顺序会影响结果。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__global__ void reduce_thread_atomic(const float* a, float* out, int n) {
    int gid = blockIdx.x * blockDim.x + threadIdx.x;
    int stride = blockDim.x * gridDim.x;
    float sum = 0.0f;
    for (int i = gid; i &amp;lt; n; i += stride) sum += a[i];
    // 多个线程仍会竞争 out[0]；调用前必须清零。
    atomicAdd(out, sum);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;版本 2：Shared Memory 树形规约&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;优化动机：先让同一个 Block 的线程合作，合出一个部分和。&lt;/strong&gt; 每个线程先做 Grid-stride 局部累加，再写 &lt;code&gt;s[tid]&lt;/code&gt;；256 个线程在共享内存中两两合并，最后只有线程 0 写 &lt;code&gt;out[blockIdx.x]&lt;/code&gt;。各 Block 输出不同的地址，这里没有对全局结果做 atomicAdd。&lt;/p&gt;
&lt;p&gt;用 8 个线程和输入 &lt;code&gt;[1,2,3,4,5,6,7,8]&lt;/code&gt; 类比：步长 4 后前四个位置是 &lt;code&gt;[6,8,10,12]&lt;/code&gt;；步长 2 后前两个位置是 &lt;code&gt;[16,20]&lt;/code&gt;；步长 1 后位置 0 是 &lt;code&gt;36&lt;/code&gt;。实际代码固定 256 线程，步长依次是 &lt;code&gt;128,64,32,16,8,4,2,1&lt;/code&gt;，共 8 轮；初始写入后同步 1 次，每轮之后同步 1 次。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;为什么同步写在 if 外面？&lt;/strong&gt; 因为 &lt;code&gt;if (tid &amp;lt; step)&lt;/code&gt; 只有一部分线程执行加法，但同一个 Block 的线程都要到达同步点，下一轮才可以安全读取上一轮写出的数据。最终输出是每个 Block 一个数，需要再合并；小数组或启动开销占主导时未必更快。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__global__ void reduce_shared(const float* a, float* out, int n) {
    __shared__ float s[256];
    int tid = threadIdx.x;
    int gid = blockIdx.x * blockDim.x + tid;
    int stride = blockDim.x * gridDim.x;
    float sum = 0.0f;
    for (int i = gid; i &amp;lt; n; i += stride) sum += a[i];

    s[tid] = sum;                // 所有线程先写自己的槽位。
    __syncthreads();             // 等待全部线程写完。

    // 256 -&amp;gt; 128 -&amp;gt; ... -&amp;gt; 1；每次相加后都要块内同步。
    for (int step = 128; step &amp;gt; 0; step &amp;gt;&amp;gt;= 1) {
        if (tid &amp;lt; step) s[tid] += s[tid + step];
        __syncthreads();         // 所有线程都执行，不放入 if。
    }
    if (tid == 0) out[blockIdx.x] = s[0];
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;版本 3：Warp Shuffle + 跨 Warp 规约&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;优化动机：在 Warp 内直接交换线程寄存器中的值，减少多轮 Shared Memory 读写和 Block 同步。&lt;/strong&gt; 这是对版本 2 的协作方式优化，不能据此推断一定更快。&lt;/p&gt;
&lt;p&gt;256 线程对应 8 个 Warp。线程 &lt;code&gt;tid=37&lt;/code&gt; 属于 &lt;code&gt;warp=37/32=1&lt;/code&gt;、&lt;code&gt;lane=37%32=5&lt;/code&gt;。第一轮规约中每个 Warp 的全部 32 个 Lane 都参加 &lt;code&gt;__shfl_down_sync&lt;/code&gt;，偏移为 &lt;code&gt;16,8,4,2,1&lt;/code&gt;，每个 Warp 的和落在 Lane 0。八个 Lane 0 写出 &lt;code&gt;warp_sum[0..7]&lt;/code&gt;，然后所有线程在 &lt;code&gt;__syncthreads()&lt;/code&gt; 会合；Shuffle 本身不能充当 Shared Memory 的内存屏障。&lt;/p&gt;
&lt;p&gt;Warp 0 的 Lane 0～7 分别读 8 个 Warp 部分和，Lane 8～31 放 0。源码中所有 32 个 Lane 仍执行 &lt;code&gt;16,8,4,2,1&lt;/code&gt; 五轮，Lane 0 普通写 &lt;code&gt;out[blockIdx.x]&lt;/code&gt;。代码中的 full mask、&lt;code&gt;warp_sum[8]&lt;/code&gt; 和每个 Warp 的 32 Lane 都依赖此处恰好启动 256 线程；不能不改代码就换任意 Block 大小。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__global__ void reduce_warp(const float* a, float* out, int n) {
    __shared__ float warp_sum[8];
    int tid = threadIdx.x;
    int lane = tid % 32;
    int warp = tid / 32;
    int gid = blockIdx.x * blockDim.x + tid;
    int stride = blockDim.x * gridDim.x;
    float sum = 0.0f;
    for (int i = gid; i &amp;lt; n; i += stride) sum += a[i];

    // 32 个 lane 全部参与；每个 Warp 的和最终保存在 lane 0。
    for (int offset = 16; offset &amp;gt; 0; offset &amp;gt;&amp;gt;= 1)
        sum += __shfl_down_sync(0xffffffffu, sum, offset);
    if (lane == 0) warp_sum[warp] = sum;
    __syncthreads();             // 等待 8 个 Warp 的结果均可见。

    if (warp == 0) {
        // Warp 0 中前 8 个 lane 读取部分和，其余 lane 补加法单位元。
        float value = (lane &amp;lt; 8) ? warp_sum[lane] : 0.0f;
        for (int offset = 16; offset &amp;gt; 0; offset &amp;gt;&amp;gt;= 1)
            value += __shfl_down_sync(0xffffffffu, value, offset);
        if (lane == 0) out[blockIdx.x] = value;
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;版本 4：float4 向量化加载 + Warp Shuffle&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;优化动机：尝试减少加载指令数量。&lt;/strong&gt; &lt;code&gt;float4&lt;/code&gt; 让一个线程以一组 4 个 float 读取数据；编译器可能生成较宽的加载指令，但不保证一定，也不意味着显存流量减少 4 倍。相邻线程的标量访问本来也可以合并，性能需在同一条件下比较。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;a4[i]&lt;/code&gt; 对应 &lt;code&gt;a[4*i]&lt;/code&gt; 至 &lt;code&gt;a[4*i+3]&lt;/code&gt;。例如 &lt;code&gt;n=11&lt;/code&gt;，&lt;code&gt;vec_n=11/4=2&lt;/code&gt;，两次完整向量加载处理 &lt;code&gt;a[0..7]&lt;/code&gt;，整个 Grid 的线程 0 再标量处理 &lt;code&gt;a[8..10]&lt;/code&gt;。向量循环中的 i 已是 float4 下标，所以循环步长仍为 &lt;code&gt;stride&lt;/code&gt;，不是 &lt;code&gt;stride * 4&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;对齐与尾部：&lt;/strong&gt; &lt;code&gt;a&lt;/code&gt; 必须按 16 字节对齐；&lt;code&gt;a+1&lt;/code&gt; 往往不满足。不能把 &lt;code&gt;vec_n&lt;/code&gt; 向上取整后加载最后不完整组，否则可能越界；只有底层额外分配且初始化好填充元素时才能安全读完整组。该示例固定 256 线程；后续归约与版本 3 一致。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__global__ void reduce_float4(const float* a, float* out, int n) {
    __shared__ float warp_sum[8];
    int tid = threadIdx.x;
    int lane = tid % 32;
    int warp = tid / 32;
    int gid = blockIdx.x * blockDim.x + tid;
    int stride = blockDim.x * gridDim.x;
    int vec_n = n / 4; // 只统计完整的四元素组，不向上取整。
    const float4* a4 = reinterpret_cast&amp;lt;const float4*&amp;gt;(a);
    float sum = 0.0f;

    // i 的单位是 float4；不再把循环步长额外乘 4。
    for (int i = gid; i &amp;lt; vec_n; i += stride) {
        float4 v = a4[i];
        sum += v.x; sum += v.y; sum += v.z; sum += v.w;
    }
    // 整个 Grid 仅让一个线程处理最多 3 个尾部元素。
    if (gid == 0) {
        for (int i = vec_n * 4; i &amp;lt; n; ++i) sum += a[i];
    }
    for (int offset = 16; offset &amp;gt; 0; offset &amp;gt;&amp;gt;= 1)
        sum += __shfl_down_sync(0xffffffffu, sum, offset);
    if (lane == 0) warp_sum[warp] = sum;
    __syncthreads();

    if (warp == 0) {
        float value = (lane &amp;lt; 8) ? warp_sum[lane] : 0.0f;
        for (int offset = 16; offset &amp;gt; 0; offset &amp;gt;&amp;gt;= 1)
            value += __shfl_down_sync(0xffffffffu, value, offset);
        if (lane == 0) out[blockIdx.x] = value;
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;如何启动和验证&lt;/h2&gt;
&lt;p&gt;下面的主机端代码展示版本 3 的完整两阶段组织：第一次输入是 &lt;code&gt;n&lt;/code&gt; 个数，输出 &lt;code&gt;blocks&lt;/code&gt; 个部分和；第二次输入长度必须是 &lt;code&gt;blocks&lt;/code&gt;。&lt;code&gt;d_partial&lt;/code&gt; 和 &lt;code&gt;d_result&lt;/code&gt; 使用不同的内存，第一阶段的输入也不要与输出重叠。float4 版本可用同样的两阶段结构，但两次输入均须满足对齐要求。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;cuda_runtime.h&amp;gt;
#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;stdexcept&amp;gt;

void check(cudaError_t e) {
    if (e != cudaSuccess) throw std::runtime_error(cudaGetErrorString(e));
}

// 前提：d_a 至少有 n 个 float；d_result 指向 1 个已分配 float；n &amp;gt;= 0。
// reduce_warp 的完整 Kernel 见上方版本 3。此示例尺寸处于 int 安全范围。
void launch_reduce(const float* d_a, float* d_result, int n) {
    constexpr int threads = 256;
    int blocks = std::max(1, std::min(256, (n + threads - 1) / threads));
    float* d_partial = nullptr;
    check(cudaMalloc(&amp;amp;d_partial, blocks * sizeof(float)));

    // 第一次：每个 Block 写一个部分和。
    reduce_warp&amp;lt;&amp;lt;&amp;lt;blocks, threads&amp;gt;&amp;gt;&amp;gt;(d_a, d_partial, n);
    check(cudaGetLastError());

    // 第二次：只有一个 Block，把 blocks 个部分和合并。
    // 默认同一 Stream 保序，所以两个 Kernel 之间无需 DeviceSynchronize。
    reduce_warp&amp;lt;&amp;lt;&amp;lt;1, threads&amp;gt;&amp;gt;&amp;gt;(d_partial, d_result, blocks);
    check(cudaGetLastError());

    check(cudaDeviceSynchronize()); // 在检查结果和释放缓冲前等待并捕获异步错误。
    check(cudaFree(d_partial));
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;版本 0、1 不使用两阶段：先 &lt;code&gt;cudaMemset(d_result, 0, sizeof(float))&lt;/code&gt;，分别启动 &lt;code&gt;reduce_element_atomic&amp;lt;&amp;lt;&amp;lt;blocks,256&amp;gt;&amp;gt;&amp;gt;(d_a,d_result,n)&lt;/code&gt; 或 &lt;code&gt;reduce_thread_atomic&amp;lt;&amp;lt;&amp;lt;blocks,256&amp;gt;&amp;gt;&amp;gt;(d_a,d_result,n)&lt;/code&gt;，检查启动与执行错误。版本 2 同样可以两次调用 &lt;code&gt;reduce_shared&lt;/code&gt;，两次都必须启动 256 线程。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;正确性验证：&lt;/strong&gt; 使用 &lt;code&gt;double expected = std::accumulate(a.begin(), a.end(), 0.0)&lt;/code&gt; 保存参考结果，再按 &lt;code&gt;abs_err &amp;lt;= atol + rtol * abs(expected)&lt;/code&gt; 比较。容差需结合输入与精度确定；不要把不同求和顺序得到的微小浮点差异直接视为错误。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;本次示例验证：&lt;/strong&gt; 在 RTX 4060 Laptop、CUDA 12.4、&lt;code&gt;nvcc -O3 -arch=sm_89&lt;/code&gt; 下，五个示例对 18 个长度做了正确性测试，包括 0、1、2、3、4、31、32、33、255、256、257、100003 和 1048579，使用正负混合且可被 FP32 精确表示的输入；并非性能 Benchmark，不能得出哪个版本更快的结论。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;对应你的项目：&lt;/strong&gt; 版本 1 对应 &lt;code&gt;reduce_atomic&lt;/code&gt;，版本 2 对应 &lt;code&gt;reduce_atomic_tree&lt;/code&gt;，版本 3 对应 &lt;code&gt;reduce_multi_warp&lt;/code&gt;，版本 4 对应 &lt;code&gt;reduce_multi_warpf4&lt;/code&gt;；版本 0 参考 NotebookLM 中 parallel101 的逐元素 atomic 基线。示例添加了教学注释并使用更清晰的名字，不代表修改了你的源码。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;资料与核对范围&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;项目代码：&lt;code&gt;/home/sanzenin/test/cuda_learn/kernels/reduce_float.cu&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;NotebookLM &lt;code&gt;ai infra&lt;/code&gt;：&lt;a href=&quot;https://github.com/parallel101/course/tree/aa7715d26b55bda8ad7a9444a923c916eda30b7f/08/07_atomic&quot;&gt;parallel101 atomic 示例&lt;/a&gt;、&lt;a href=&quot;https://github.com/parallel101/course/tree/aa7715d26b55bda8ad7a9444a923c916eda30b7f/08/08_block&quot;&gt;Block 规约示例&lt;/a&gt;。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.nvidia.com/cuda/archive/12.4.0/cuda-c-best-practices-guide/index.html&quot;&gt;NVIDIA CUDA 12.4 Best Practices Guide&lt;/a&gt;；&lt;a href=&quot;https://docs.nvidia.com/cuda/cuda-programming-guide/05-appendices/cpp-language-extensions.html&quot;&gt;Warp Shuffle 官方说明&lt;/a&gt;。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>计网</title><link>https://sanzenin.top/posts/obsidian/%E8%AE%A1%E7%BD%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E8%AE%A1%E7%BD%91/</guid><description>端系统之间两种服务方式: 服务器-客户端 P2P 报文交换 存储整个报文 分组交换 将报文划分,每个报文加上首部,独立的存储转发,在目的地组装 互联网使用分组交换 发送时延(将所有比特推上链路) 数据长度/发送速率 传播时延(信号跑完整条链路) 信道长度/传播速率 时延带宽积 传播时延\带宽 表示链数上最多的比特数</description><pubDate>Thu, 12 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/%E8%AE%A1%E7%BD%91-1794498578533.webp&quot; alt=&quot;计网-1794498578533&quot; /&gt;
端系统之间两种服务方式:
服务器-客户端 P2P
&lt;img src=&quot;/obsidian/%E8%AE%A1%E7%BD%91-1794498668950.webp&quot; alt=&quot;计网-1794498668950&quot; /&gt;
&lt;strong&gt;报文交换&lt;/strong&gt;
存储整个报文
&lt;strong&gt;分组交换&lt;/strong&gt;
将报文划分,每个报文加上首部,独立的存储转发,在目的地组装
互联网使用分组交换
&lt;img src=&quot;/obsidian/%E8%AE%A1%E7%BD%91-1794498799528.webp&quot; alt=&quot;计网-1794498799528&quot; /&gt;
&lt;img src=&quot;/obsidian/%E8%AE%A1%E7%BD%91-1794499677418.webp&quot; alt=&quot;计网-1794499677418&quot; /&gt;
&lt;img src=&quot;/obsidian/%E8%AE%A1%E7%BD%91-1794499731670.webp&quot; alt=&quot;计网-1794499731670&quot; /&gt;
发送时延(将所有比特推上链路) 数据长度/发送速率
传播时延(信号跑完整条链路) 信道长度/传播速率&lt;/p&gt;
&lt;p&gt;时延带宽积 传播时延*带宽 表示链数上最多的比特数&lt;/p&gt;
</content:encoded></item><item><title>生产者-消费者实验讲稿</title><link>https://sanzenin.top/posts/obsidian/%E7%94%9F%E4%BA%A7%E8%80%85-%E6%B6%88%E8%B4%B9%E8%80%85%E5%AE%9E%E9%AA%8C%E8%AE%B2%E7%A8%BF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%94%9F%E4%BA%A7%E8%80%85-%E6%B6%88%E8%B4%B9%E8%80%85%E5%AE%9E%E9%AA%8C%E8%AE%B2%E7%A8%BF/</guid><description>对应源码：/home/sanzenin/test/os1/producerconsumer.cpp 建议录屏时长：4 分钟左右 先编译程序： 默认运行会一直生产，展示一段后按 Ctrl+C 停止： 也可以传入任务数量，让程序生产完指定数量后自动结束： 录屏时把终端字号调大一点，保证生产者和三个消费者的输出都能看清。 老</description><pubDate>Mon, 02 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;生产者-消费者实验讲稿&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;对应源码：&lt;code&gt;/home/sanzenin/test/os_1/producer_consumer.cpp&lt;/code&gt;
建议录屏时长：4 分钟左右&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2&gt;录屏准备&lt;/h2&gt;
&lt;p&gt;先编译程序：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cd /home/sanzenin/test/os_1
cmake -S . -B build
cmake --build build -j
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;默认运行会一直生产，展示一段后按 &lt;code&gt;Ctrl+C&lt;/code&gt; 停止：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;./build/producer_consumer
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也可以传入任务数量，让程序生产完指定数量后自动结束：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;./build/producer_consumer 24
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;录屏时把终端字号调大一点，保证生产者和三个消费者的输出都能看清。&lt;/p&gt;
&lt;h2&gt;讲稿正文&lt;/h2&gt;
&lt;h3&gt;1. 开场&lt;/h3&gt;
&lt;p&gt;老师好，这次实验我做的是生产者—消费者问题。程序用 C++17 写，里面有 1 个生产者线程和 3 个消费者线程，它们共用一个消息队列。&lt;/p&gt;
&lt;p&gt;生产者每生成一条消息，就把它放进队列；消费者从队列里取消息。队列是共享资源，所以生产和取消息不能同时修改队列。消费者在队列为空的时候要等待，不能一直空转。&lt;/p&gt;
&lt;h3&gt;2. MessageQueue 的设计&lt;/h3&gt;
&lt;p&gt;先看队列。&lt;code&gt;MessageQueue&lt;/code&gt; 里用 &lt;code&gt;std::deque&amp;lt;int&amp;gt;&lt;/code&gt; 保存任务编号，题目要求队列默认可以存放无限多条消息，所以这里没有设置容量上限。&lt;/p&gt;
&lt;p&gt;队列用 &lt;code&gt;std::mutex&lt;/code&gt; 保护共享数据，用 &lt;code&gt;std::condition_variable&lt;/code&gt; 让消费者在队列为空时等待。&lt;code&gt;stopped_&lt;/code&gt; 表示生产者是否已经结束。这个标志不能省，否则消费者分不清队列为空是因为暂时没有消息，还是因为程序已经结束。&lt;/p&gt;
&lt;p&gt;输出部分另外用了一个 &lt;code&gt;output_mutex&lt;/code&gt;。终端也是共享资源，多个线程同时输出时，需要保证一行内容不会被另一个线程插进来。&lt;/p&gt;
&lt;h3&gt;3. 入队函数&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;push&lt;/code&gt; 的代码是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;void push(int task)
{
    {
        std::lock_guard&amp;lt;std::mutex&amp;gt; lock(mutex_);
        queue_.push_back(task);
    }
    ready_.notify_one();
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;生产者调用 &lt;code&gt;push&lt;/code&gt; 时，&lt;code&gt;lock_guard&lt;/code&gt; 只在入队这一段加锁。任务放进队尾后锁马上释放，然后通知一个正在等待的消费者。一次只放入一条消息，所以这里用 &lt;code&gt;notify_one&lt;/code&gt; 就够了。&lt;/p&gt;
&lt;h3&gt;4. 出队函数&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;pop&lt;/code&gt; 的代码是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;bool pop(int&amp;amp; task)
{
    std::unique_lock&amp;lt;std::mutex&amp;gt; lock(mutex_);
    ready_.wait(lock, [this] { return stopped_ || !queue_.empty(); });

    if (queue_.empty()) {
        return false;
    }

    task = queue_.front();
    queue_.pop_front();
    return true;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里用 &lt;code&gt;unique_lock&lt;/code&gt;，因为 &lt;code&gt;wait&lt;/code&gt; 等待时要暂时释放锁，被唤醒后再重新加锁。&lt;code&gt;wait&lt;/code&gt; 的条件是队列非空或者已经停止。&lt;/p&gt;
&lt;p&gt;醒来后如果队列为空，说明程序已经停止，&lt;code&gt;pop&lt;/code&gt; 返回 &lt;code&gt;false&lt;/code&gt;，消费者线程结束。否则取出队首任务。取任务的过程一直在锁里，所以三个消费者不会拿到同一条消息。&lt;/p&gt;
&lt;h3&gt;5. 停止函数&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;stop&lt;/code&gt; 的代码是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;void stop()
{
    {
        std::lock_guard&amp;lt;std::mutex&amp;gt; lock(mutex_);
        stopped_ = true;
    }
    ready_.notify_all();
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里用 &lt;code&gt;notify_all&lt;/code&gt;，因为可能有多个消费者都在等待。生产者结束后，需要把它们全部唤醒，让每个消费者重新检查队列。&lt;/p&gt;
&lt;h3&gt;6. 生产者循环&lt;/h3&gt;
&lt;p&gt;生产者线程是一个 &lt;code&gt;while&lt;/code&gt; 循环：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while (keep_running &amp;amp;&amp;amp; (total_tasks == 0 || task &amp;lt;= total_tasks)) {
    queue.push(task);
    printLine(&quot;任务 &quot; + std::to_string(task) + &quot; 已生产。&quot;);
    std::this_thread::sleep_for(std::chrono::milliseconds(150));
    ++task;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;total_tasks&lt;/code&gt; 为 0 时表示无限生产，按 &lt;code&gt;Ctrl+C&lt;/code&gt; 结束；传了任务数量时，循环到指定数量就停止。每生产一条消息等待 150 毫秒，方便观察输出。&lt;/p&gt;
&lt;h3&gt;7. 消费者循环&lt;/h3&gt;
&lt;p&gt;三个消费者线程都执行同一个 &lt;code&gt;while&lt;/code&gt; 循环：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while (queue.pop(task)) {
    std::this_thread::sleep_for(std::chrono::milliseconds(60));
    printLine(&quot;消费者 &quot; + std::to_string(id) +
              &quot; 取走任务 &quot; + std::to_string(task));
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;取到任务后等待 60 毫秒再打印。哪个消费者拿到哪条任务不是固定的，取决于线程调度。&lt;/p&gt;
&lt;h3&gt;8. 主线程&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;main&lt;/code&gt; 里先创建三个消费者线程，再创建生产者线程。消费者启动时队列还是空的，所以会先在条件变量上等待。&lt;/p&gt;
&lt;p&gt;生产者结束后，主线程调用 &lt;code&gt;queue.stop()&lt;/code&gt;，然后回收三个消费者。消费者会先把队列里剩下的任务处理完，再退出。&lt;/p&gt;
&lt;p&gt;程序还注册了 &lt;code&gt;SIGINT&lt;/code&gt; 信号处理函数。按 &lt;code&gt;Ctrl+C&lt;/code&gt; 时，&lt;code&gt;std::atomic&amp;lt;bool&amp;gt;&lt;/code&gt; 类型的 &lt;code&gt;keep_running&lt;/code&gt; 被置为 &lt;code&gt;false&lt;/code&gt;，生产者循环停止，主线程继续完成收尾。&lt;/p&gt;
&lt;h3&gt;9. 运行演示&lt;/h3&gt;
&lt;p&gt;默认运行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;./build/producer_consumer
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;终端里会看到类似这样的输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;程序已启动，按 Ctrl+C 停止。
任务 1 已生产。
消费者 1 取走任务 1
任务 2 已生产。
消费者 2 取走任务 2
任务 3 已生产。
消费者 3 取走任务 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;展示一段时间后按 &lt;code&gt;Ctrl+C&lt;/code&gt;，程序会把剩余消息处理完再退出。也可以直接运行 &lt;code&gt;./build/producer_consumer 24&lt;/code&gt;，生产 24 条后自动结束。&lt;/p&gt;
&lt;h3&gt;10. 结尾&lt;/h3&gt;
&lt;p&gt;这个程序的关键在 &lt;code&gt;MessageQueue&lt;/code&gt;：&lt;code&gt;deque&lt;/code&gt; 负责存消息，&lt;code&gt;mutex&lt;/code&gt; 保证互斥，&lt;code&gt;condition_variable&lt;/code&gt; 负责等待和唤醒，&lt;code&gt;stopped_&lt;/code&gt; 负责结束。线程函数本身比较简单，只负责生产和消费。&lt;/p&gt;
&lt;p&gt;我的讲解结束，谢谢老师。&lt;/p&gt;
&lt;h2&gt;答辩备用&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;为什么消费者不用 &lt;code&gt;while&lt;/code&gt; 一直检查队列？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;忙等会持续占用 CPU。条件变量让消费者在队列为空时睡眠，收到通知后再检查队列。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;为什么 &lt;code&gt;push&lt;/code&gt; 用 &lt;code&gt;lock_guard&lt;/code&gt;，&lt;code&gt;pop&lt;/code&gt; 用 &lt;code&gt;unique_lock&lt;/code&gt;？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;push&lt;/code&gt; 不需要手动释放锁，&lt;code&gt;lock_guard&lt;/code&gt; 足够；&lt;code&gt;pop&lt;/code&gt; 调用 &lt;code&gt;wait&lt;/code&gt; 时需要在等待期间释放锁，所以必须使用 &lt;code&gt;unique_lock&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;为什么停止时使用 &lt;code&gt;notify_all&lt;/code&gt;？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;生产者结束时可能有多个消费者正在等待，&lt;code&gt;notify_all&lt;/code&gt; 可以唤醒全部消费者，让它们检查退出条件。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;无界队列有什么风险？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;如果生产者速度长期快于消费者，队列会持续增长并占用更多内存。实际系统中通常会设置容量上限，并增加队列满时生产者等待的逻辑。&lt;/p&gt;
</content:encoded></item><item><title>00-集合论与映射</title><link>https://sanzenin.top/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/</guid><description>这一章整理后续群论中用到的集合论与映射知识，主要包括： 1. 等价关系、等价类与集合划分； 2. 映射的单射、满射、双射与可逆性； 3. 选择公理与常见等价命题； 4. 商集上的映射定义与良定性检验。 - 数学对象 属于集合 记作 ；不属于记作 。 - 子集包含： 。 - 集合相等：由外延公理，两个集合相等当且仅当互为</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;00-集合论与映射&lt;/h1&gt;
&lt;p&gt;这一章整理后续群论中用到的集合论与映射知识，主要包括：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;等价关系、等价类与集合划分；&lt;/li&gt;
&lt;li&gt;映射的单射、满射、双射与可逆性；&lt;/li&gt;
&lt;li&gt;选择公理与常见等价命题；&lt;/li&gt;
&lt;li&gt;商集上的映射定义与良定性检验。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 集合与基本运算&lt;/h2&gt;
&lt;h3&gt;1.1 集合、子集与外延公理&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;数学对象 $a$ 属于集合 $A$ 记作 $a \in A$；不属于记作 $a \notin A$。&lt;/li&gt;
&lt;li&gt;子集包含：$A \subseteq B \iff \forall x (x \in A \implies x \in B)$。&lt;/li&gt;
&lt;li&gt;集合相等：由外延公理，两个集合相等当且仅当互为子集：
$$A = B \iff A \subseteq B \text{ 且 } B \subseteq A$$
因此证明两集合相等的通用范式是双向验证包含关系：先任取 $x \in A$ 推导 $x \in B$，再任取 $y \in B$ 推导 $y \in A$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;1.2 交、并、差与补集&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;并集：$A \cup B = {x \mid x \in A \lor x \in B}$。&lt;/li&gt;
&lt;li&gt;交集：$A \cap B = {x \mid x \in A \land x \in B}$。&lt;/li&gt;
&lt;li&gt;差集：$A \setminus B = {x \in A \mid x \notin B}$。&lt;/li&gt;
&lt;li&gt;全集 $U$ 下的绝对补集：$A^c = U \setminus A$。&lt;/li&gt;
&lt;li&gt;对称差：$A \Delta B = (A \setminus B) \cup (B \setminus A) = (A \cup B) \setminus (A \cap B)$。&lt;/li&gt;
&lt;li&gt;De Morgan 律：
$$(A \cup B)^c = A^c \cap B^c, \qquad (A \cap B)^c = A^c \cup B^c$$&lt;/li&gt;
&lt;li&gt;分配律：
$$A \cap (B \cup C) = (A \cap B) \cup (A \cap C)$$
$$A \cup (B \cap C) = (A \cup B) \cap (A \cup C)$$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;1.3 幂集与笛卡尔积&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;幂集：集合 $A$ 的全部子集构成的集合族记作 $\mathcal{P}(A) = {S \mid S \subseteq A}$。若 $|A| = n$，则 $|\mathcal{P}(A)| = 2^n$。&lt;/li&gt;
&lt;li&gt;笛卡尔积：$A \times B = {(a, b) \mid a \in A, b \in B}$。笛卡尔积是有序对集合，代数系统中的二元运算（如映射 $\cdot: G \times G \to G$）与二元关系均基于笛卡尔积定义。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 关系、等价关系与集合划分&lt;/h2&gt;
&lt;h3&gt;2.1 二元关系&lt;/h3&gt;
&lt;p&gt;集合 $A$ 上的二元关系 $R$ 是笛卡尔积的一个子集 $R \subseteq A \times A$。若 $(a, b) \in R$，记作 $a R b$。
常见基本性质：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;自反性：$\forall a \in A,\ a R a$；&lt;/li&gt;
&lt;li&gt;对称性：$\forall a, b \in A,\ a R b \implies b R a$；&lt;/li&gt;
&lt;li&gt;传递性：$\forall a, b, c \in A,\ a R b \land b R c \implies a R c$；&lt;/li&gt;
&lt;li&gt;反对称性：$\forall a, b \in A,\ a R b \land b R a \implies a = b$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;2.2 等价关系与等价类&lt;/h3&gt;
&lt;p&gt;同时满足自反性、对称性与传递性的二元关系称为&lt;strong&gt;等价关系&lt;/strong&gt;，通常记作 $\sim$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;等价类&lt;/strong&gt;：元素 $a \in A$ 所在的等价类定义为：
$$[a] = {x \in A \mid x \sim a}$$
其中 $a$ 称为该等价类的一个代表元。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;商集&lt;/strong&gt;：由关于 $\sim$ 的全体等价类构成的集合族记作：
$$A/\sim = {[a] \mid a \in A}$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;自然投影&lt;/strong&gt;：映射 $\pi: A \to A/\sim$ 定义为 $\pi(a) = [a]$，$\pi$ 恒为满射。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;2.3 等价类的二分性质&lt;/h3&gt;
&lt;h4&gt;定理 0.1（等价类相交即全同）&lt;/h4&gt;
&lt;p&gt;设 $\sim$ 是 $A$ 上的等价关系，$a, b \in A$。下列命题等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$a \sim b$；&lt;/li&gt;
&lt;li&gt;$[a] \cap [b] \neq \emptyset$；&lt;/li&gt;
&lt;li&gt;$[a] = [b]$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;(1) $\implies$ (3)&lt;/strong&gt;：设 $a \sim b$。任取 $x \in [a]$，有 $x \sim a$。由传递性 $x \sim b$，故 $x \in [b]$，即 $[a] \subseteq [b]$。由对称性 $b \sim a$，同理可得 $[b] \subseteq [a]$。两边互含，故 $[a] = [b]$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(3) $\implies$ (2)&lt;/strong&gt;：由自反性 $a \in [a]$。若 $[a] = [b]$，则 $a \in [b]$，从而 $a \in [a] \cap [b]$，交集非空。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(2) $\implies$ (1)&lt;/strong&gt;：若存在 $c \in [a] \cap [b]$，则 $c \sim a$ 且 $c \sim b$。由对称性 $a \sim c$，再由传递性 $a \sim c \land c \sim b \implies a \sim b$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!NOTE] 推论
任意两个等价类要么完全相同，要么互不相交。不存在部分重叠的情况。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;2.4 等价关系与划分的对应定理&lt;/h3&gt;
&lt;p&gt;集合 $A$ 的一个划分是指一族非空子集 $\mathcal{P} = {A_i}_{i \in I}$，满足：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;非空：$\forall i \in I, A_i \neq \emptyset$；&lt;/li&gt;
&lt;li&gt;两两不交：$i \neq j \implies A_i \cap A_j = \emptyset$；&lt;/li&gt;
&lt;li&gt;全覆盖：$\bigcup_{i \in I} A_i = A$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;定理 0.2（等价关系与集合划分的对应）&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;若 $\sim$ 是 $A$ 上的等价关系，则商集 $A/\sim$ 是 $A$ 的一个划分。&lt;/li&gt;
&lt;li&gt;反之，若 $\mathcal{P}$ 是 $A$ 的一个划分，定义关系 $x \sim_{\mathcal{P}} y \iff \exists P \in \mathcal{P}, x, y \in P$，则 $\sim_{\mathcal{P}}$ 是 $A$ 上的等价关系，且其商集恰为 $\mathcal{P}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;由自反性，每个 $a \in [a]$，故等价类非空且全并为 $A$；由定理 0.1，不同等价类两两不交。因此 $A/\sim$ 构成划分。&lt;/li&gt;
&lt;li&gt;自反性由划分的覆盖性保证；对称性由定义的对称性保证；传递性：若 $x, y \in P_1$ 且 $y, z \in P_2$，则 $y \in P_1 \cap P_2$。因划分两两不交，必有 $P_1 = P_2$，故 $x, z \in P_1$，即 $x \sim_{\mathcal{P}} z$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 映射、像与原像&lt;/h2&gt;
&lt;h3&gt;3.1 映射定义与基本概念&lt;/h3&gt;
&lt;p&gt;映射 $f: A \to B$ 指：对定义域 $A$ 中的每个元素 $x$，在陪域 $B$ 中存在唯一确定的元素 $f(x)$ 与之对应。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;定义域记作 $\operatorname{dom}(f) = A$，陪域记作 $\operatorname{cod}(f) = B$。&lt;/li&gt;
&lt;li&gt;像集：$\operatorname{Im} f = f(A) = {f(x) \mid x \in A}$。&lt;/li&gt;
&lt;li&gt;子集 $S \subseteq A$ 的像：$f(S) = {f(x) \mid x \in S}$。&lt;/li&gt;
&lt;li&gt;子集 $T \subseteq B$ 的原像（逆像）：$f^{-1}(T) = {x \in A \mid f(x) \in T}$。
当 $T = {b}$ 时，$f^{-1}({b})$ 称为点 $b$ 的纤维。原像记号对任意映射均有定义，不依赖可逆性。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3.2 像与原像的运算性质&lt;/h3&gt;
&lt;h4&gt;定理 0.3（原像对集合运算的保持性质）&lt;/h4&gt;
&lt;p&gt;设 $f: A \to B$，$T \subseteq B$，${T_i}_{i \in I}$ 为 $B$ 的子集族。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f^{-1}\left(\bigcup_{i \in I} T_i\right) = \bigcup_{i \in I} f^{-1}(T_i)$；&lt;/li&gt;
&lt;li&gt;$f^{-1}\left(\bigcap_{i \in I} T_i\right) = \bigcap_{i \in I} f^{-1}(T_i)$；&lt;/li&gt;
&lt;li&gt;$f^{-1}(B \setminus T) = A \setminus f^{-1}(T)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
以 (2) 为例：
$$x \in f^{-1}\left(\bigcap_{i \in I} T_i\right) \iff f(x) \in \bigcap_{i \in I} T_i \iff \forall i \in I, f(x) \in T_i \iff \forall i \in I, x \in f^{-1}(T_i) \iff x \in \bigcap_{i \in I} f^{-1}(T_i)$$
式 (1) 与 (3) 同理可证。 $\blacksquare$&lt;/p&gt;
&lt;h4&gt;定理 0.4（像的运算性质与单射判定）&lt;/h4&gt;
&lt;p&gt;设 $f: A \to B$，$S_1, S_2 \subseteq A$。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f(S_1 \cup S_2) = f(S_1) \cup f(S_2)$；&lt;/li&gt;
&lt;li&gt;$f(S_1 \cap S_2) \subseteq f(S_1) \cap f(S_2)$；&lt;/li&gt;
&lt;li&gt;$f$ 是单射 $\iff$ 对任意 $S_1, S_2 \subseteq A$，恒有 $f(S_1 \cap S_2) = f(S_1) \cap f(S_2)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;(1) 与 (2) 由定义直接推出。&lt;/li&gt;
&lt;li&gt;证明 (3)：
&lt;ul&gt;
&lt;li&gt;充分性：设 $f$ 为单射。任取 $y \in f(S_1) \cap f(S_2)$，存在 $x_1 \in S_1, x_2 \in S_2$ 使得 $f(x_1) = y = f(x_2)$。由单射性，$x_1 = x_2 \in S_1 \cap S_2$，故 $y \in f(S_1 \cap S_2)$，等号成立。&lt;/li&gt;
&lt;li&gt;必要性：反证法。若 $f$ 不是单射，存在 $a_1 \neq a_2$ 使得 $f(a_1) = f(a_2) = y$。令 $S_1 = {a_1}, S_2 = {a_2}$，则 $S_1 \cap S_2 = \emptyset \implies f(S_1 \cap S_2) = \emptyset$，但 $f(S_1) \cap f(S_2) = {y} \neq \emptyset$，矛盾。故 $f$ 必为单射。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 单射、满射与双射&lt;/h2&gt;
&lt;h3&gt;4.1 基本定义与有限集合性质&lt;/h3&gt;
&lt;p&gt;设 $f: A \to B$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;单射&lt;/strong&gt;：若 $\forall a_1, a_2 \in A,\ f(a_1) = f(a_2) \implies a_1 = a_2$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射&lt;/strong&gt;：若 $\forall b \in B,\ \exists a \in A \text{ 使得 } f(a) = b$（即 $\operatorname{Im} f = B$）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;双射&lt;/strong&gt;：$f$ 既是单射又是满射。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;有限集合性质（鸽巢原理）：若 $|A| = |B| &amp;lt; \infty$，则对映射 $f: A \to B$：
$$f \text{ 是单射} \iff f \text{ 是满射} \iff f \text{ 是双射}$$
无限集合中此等价性失效。例如 $f: \mathbb{Z} \to \mathbb{Z}, x \mapsto 2x$ 是单射但非满射；$g(x) = \lfloor x/2 \rfloor$ 是满射但非单射。&lt;/p&gt;
&lt;h3&gt;4.2 单射等价定理&lt;/h3&gt;
&lt;h4&gt;定理 0.5（单射等价定理）&lt;/h4&gt;
&lt;p&gt;设 $A, B$ 非空，$f: A \to B$。下列命题等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f$ 是单射；&lt;/li&gt;
&lt;li&gt;$f$ 存在左逆：存在映射 $g: B \to A$ 使得 $g \circ f = I_A$；&lt;/li&gt;
&lt;li&gt;$f$ 左可消：对任意集合 $C$ 及映射 $h, k: C \to A$，$f \circ h = f \circ k \implies h = k$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;(1) $\implies$ (2)&lt;/strong&gt;：设 $f$ 单射。固定选取 $a_0 \in A$。定义 $g: B \to A$：若 $b \in \operatorname{Im} f$，由单射性满足 $f(a) = b$ 的 $a$ 唯一，令 $g(b) = a$；若 $b \notin \operatorname{Im} f$，令 $g(b) = a_0$。则对任意 $x \in A$，$g(f(x)) = x$，即 $g \circ f = I_A$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(2) $\implies$ (3)&lt;/strong&gt;：设存在左逆 $g$。若 $f \circ h = f \circ k$，两端左复合 $g$：
$$g \circ (f \circ h) = g \circ (f \circ k) \implies (g \circ f) \circ h = (g \circ f) \circ k \implies I_A \circ h = I_A \circ k \implies h = k$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(3) $\implies$ (1)&lt;/strong&gt;：任取 $a_1, a_2 \in A$ 使得 $f(a_1) = f(a_2)$。设单元素集 $C = {&lt;em&gt;}$，构造映射 $h(&lt;/em&gt;)=a_1, k(*)=a_2$，则 $f \circ h = f \circ k$。由左可消性 $h = k$，故 $a_1 = a_2$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;4.3 满射等价定理&lt;/h3&gt;
&lt;h4&gt;定理 0.6（满射等价定理）&lt;/h4&gt;
&lt;p&gt;设 $A, B$ 非空，$f: A \to B$。下列命题等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f$ 是满射；&lt;/li&gt;
&lt;li&gt;$f$ 存在右逆：存在映射 $g: B \to A$ 使得 $f \circ g = I_B$（此方向需要选择公理）；&lt;/li&gt;
&lt;li&gt;$f$ 右可消：对任意集合 $D$ 及映射 $h, k: B \to D$，$h \circ f = k \circ f \implies h = k$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;(1) $\implies$ (2)&lt;/strong&gt;：因 $f$ 为满射，每个纤维 $f^{-1}({b})$ 均非空。根据选择公理，可在每个纤维中选出一个元素 $a_b$。定义 $g(b) = a_b$，则 $f(g(b)) = f(a_b) = b$，即 $f \circ g = I_B$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(2) $\implies$ (3)&lt;/strong&gt;：设存在右逆 $g$。若 $h \circ f = k \circ f$，两端右复合 $g$：
$$(h \circ f) \circ g = (k \circ f) \circ g \implies h \circ (f \circ g) = k \circ (f \circ g) \implies h \circ I_B = k \circ I_B \implies h = k$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;(3) $\implies$ (1)&lt;/strong&gt;：反证法。若 $f$ 不是满射，取 $b_0 \in B \setminus \operatorname{Im} f$。设 $D = {0, 1}$，构造映射：
$$h(b) = 0 \quad (\forall b \in B), \qquad k(b) = \begin{cases} 0, &amp;amp; b \neq b_0 \ 1, &amp;amp; b = b_0 \end{cases}$$
对任意 $a \in A$，$f(a) \neq b_0$，故 $h(f(a)) = k(f(a)) = 0$，即 $h \circ f = k \circ f$。由右可消性得 $h = k$。但 $h(b_0) = 0 \neq 1 = k(b_0)$，矛盾。故 $f$ 必为满射。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;4.4 双射与可逆性&lt;/h3&gt;
&lt;h4&gt;定理 0.7（双射与可逆性充要条件）&lt;/h4&gt;
&lt;p&gt;映射 $f: A \to B$ 可逆（即同时存在满足 $g \circ f = I_A$ 与 $f \circ g = I_B$ 的映射 $g$）当且仅当 $f$ 是双射。
此时逆映射唯一，记作 $f^{-1}$。
若 $f: A \to B$ 与 $g: B \to C$ 均为双射，则复合映射 $g \circ f$ 亦为双射，且满足反序求逆：
$$(g \circ f)^{-1} = f^{-1} \circ g^{-1}$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$f$ 为双射当且仅当其同时存在左逆 $g_1$ 和右逆 $g_2$。由结合律：
$$g_1 = g_1 \circ I_B = g_1 \circ (f \circ g_2) = (g_1 \circ f) \circ g_2 = I_A \circ g_2 = g_2$$
故左逆与右逆必重合且唯一。&lt;/li&gt;
&lt;li&gt;复合映射求逆直接代入验证：
$$(f^{-1} \circ g^{-1}) \circ (g \circ f) = f^{-1} \circ (g^{-1} \circ g) \circ f = f^{-1} \circ I_B \circ f = f^{-1} \circ f = I_A$$
反向复合同样成立，由逆映射唯一性结论得证。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 选择公理与常见等价命题&lt;/h2&gt;
&lt;h3&gt;5.1 选择公理的三种等价表述&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;选择函数形式&lt;/strong&gt;：设 $\mathcal{X}$ 是一族非空集合，则存在选择函数 $c: \mathcal{X} \to \bigcup_{A \in \mathcal{X}} A$，满足：
$$\forall A \in \mathcal{X},\ c(A) \in A$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;笛卡尔积形式&lt;/strong&gt;：由非空集合构成的任意集合族 ${A_i}&lt;em&gt;{i \in I}$ 的笛卡尔积非空：
$$\prod&lt;/em&gt;{i \in I} A_i \neq \emptyset$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;两两不交形式&lt;/strong&gt;：设 $\mathcal{X}$ 是一族两两不交的非空集合，则存在集合 $C$，使得对每个 $A \in \mathcal{X}$，恰有 $|C \cap A| = 1$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;5.2 直观理解与使用边界&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;有限个非空集合的选择可用一阶逻辑和归纳法证明，不需要选择公理。&lt;/li&gt;
&lt;li&gt;无限集但有确定排序规则（如正整数集选最小元素），也不需要选择公理。&lt;/li&gt;
&lt;li&gt;罗素隐喻：无穷双鞋子（分左右）选一只不需要选择公理（规定选左脚即可）；对没有指定选择规则的无限多双袜子，ZF 一般不能保证同时选出一只；可数多双对应可数的二元集合选择原则，比完整选择公理弱，完整选择公理足以保证。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;5.3 常见等价命题与 Zorn 引理&lt;/h3&gt;
&lt;p&gt;在 ZF 公理系统下，下列命题与选择公理等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;满射必有右逆&lt;/strong&gt;：任意非空集合间的满射均存在右逆映射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;良序定理&lt;/strong&gt;：任意集合上均可定义一个良序关系（每个非空子集必有最小元）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Zorn 引理&lt;/strong&gt;：设 $(P, \le)$ 是非空偏序集。若 $P$ 的每条链（全序子集）在 $P$ 中都有上界，则 $P$ 至少存在一个极大元。
&lt;ul&gt;
&lt;li&gt;代数应用：证明任意非零含幺环必有极大理想、任意向量空间必有 Hamel 基。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;基数三分律&lt;/strong&gt;：任意两集合的基数均可比较大小。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;5.4 逻辑地位与典型推论&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;独立性（以 ZF 一致为前提）：哥德尔的可构造宇宙给出选择公理与 ZF 的相对一致性；柯恩的结果给出其独立性，ZF 既不能证明也不能否定选择公理。主流数学通常在 ZFC 公理体系下展开。&lt;/li&gt;
&lt;li&gt;典型推论：实数轴上的 Vitali 不可测集、Banach-Tarski 分球悖论。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 商集上的映射与良定性&lt;/h2&gt;
&lt;h3&gt;6.1 良定性要求&lt;/h3&gt;
&lt;p&gt;在商集 $A/\sim$ 上通过代表元定义映射：
$$F: A/\sim \to B, \qquad F([a]) := \Phi(a)$$
由于同一等价类 $[a]$ 可以取不同的代表元（若 $a \sim a&apos;$ 则 $[a] = [a&apos;]$），必须验证：
$$a \sim a&apos; \implies \Phi(a) = \Phi(a&apos;)$$
若该条件不成立，同一输入会计算出不同输出，规则无法构成映射。这一验证称为良定性检验（代表元无关性）。&lt;/p&gt;
&lt;h3&gt;6.2 商集诱导映射定理&lt;/h3&gt;
&lt;h4&gt;定理 0.8（商集诱导映射定理）&lt;/h4&gt;
&lt;p&gt;设 $\sim$ 是集合 $A$ 上的等价关系，$\pi: A \to A/\sim$（$a \mapsto [a]$）为自然投影。设 $f: A \to B$ 是映射。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;存在映射 $\bar{f}: A/\sim \to B$ 使得 $\bar{f} \circ \pi = f$ 当且仅当：
$$\forall x, y \in A,\ x \sim y \implies f(x) = f(y)$$
此时 $\bar{f}$ 唯一，由 $\bar{f}([a]) = f(a)$ 给出。&lt;/li&gt;
&lt;li&gt;在条件 (1) 成立的前提下，$\bar{f}$ 是单射 $\iff (\forall x, y \in A, f(x) = f(y) \implies x \sim y)$。&lt;/li&gt;
&lt;li&gt;$\operatorname{Im} \bar{f} = \operatorname{Im} f$。特别地，若 $f$ 是满射，则 $\bar{f}$ 也是满射。&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;flowchart LR
    A[&quot;集合 A&quot;] -- &quot;f&quot; --&amp;gt; B[&quot;集合 B&quot;]
    A -- &quot;π&quot; --&amp;gt; Q[&quot;商集 A/~&quot;]
    Q -. &quot;f̄&quot; .-&amp;gt; B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $\bar{f}$ 存在且满足 $\bar{f} \circ \pi = f$，则 $\bar{f}([a]) = \bar{f}(\pi(a)) = f(a)$，定义唯一。若 $x \sim y \implies f(x) = f(y)$，则 $[x] = [y] \implies f(x) = f(y)$，规则良定，且满足 $(\bar{f} \circ \pi)(a) = \bar{f}([a]) = f(a)$。&lt;/li&gt;
&lt;li&gt;由单射定义：$\bar{f}([x]) = \bar{f}([y]) \iff f(x) = f(y)$。该式能推出 $[x] = [y]$（即 $x \sim y$）当且仅当 $f(x) = f(y) \implies x \sim y$。&lt;/li&gt;
&lt;li&gt;$\operatorname{Im}\bar{f} = {\bar{f}([a]) \mid a \in A} = {f(a) \mid a \in A} = \operatorname{Im} f$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;6.3 典型正例与反例&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;正例&lt;/strong&gt;：在模 $n$ 剩余类集合 $\mathbb{Z}_n = \mathbb{Z}/n\mathbb{Z}$ 上定义 $F([a]) = [ka]$（$k \in \mathbb{Z}$）。
若 $[a] = [b]$，则 $a \equiv b \pmod n \implies n \mid (a - b) \implies n \mid k(a - b) \implies [ka] = [kb]$。映射良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;反例 1&lt;/strong&gt;：定义 $F: \mathbb{Z}/n\mathbb{Z} \to \mathbb{Z}, F([a]) = a$。
在模 3 下，$[0] = [3]$，但 $F([0]) = 0 \neq 3 = F([3])$，不良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;反例 2&lt;/strong&gt;：在有理数构造中，对集合 $\mathbb{Z} \times (\mathbb{Z} \setminus {0})$ 定义等价关系 $(a, b) \sim (c, d) \iff ad = bc$。
若尝试定义映射 $H([(a, b)]) = a + b$：因 $(1, 2) \sim (2, 4)$，但 $1 + 2 = 3 \neq 6 = 2 + 4$，同一个等价类给出不同结果，不良定。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 常见易混淆点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;像交集与原像交集&lt;/strong&gt;：原像完全保持交集 $f^{-1}(T_1 \cap T_2) = f^{-1}(T_1) \cap f^{-1}(T_2)$；像只满足单向包含 $f(S_1 \cap S_2) \subseteq f(S_1) \cap f(S_2)$，等号仅在单射时恒成立。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;原像记号与逆映射&lt;/strong&gt;：集合原像 $f^{-1}(T)$ 对任意映射均合法；元素反函数 $f^{-1}(y)$ 仅在双射时存在。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;商集元素与代表元&lt;/strong&gt;：商集 $A/\sim$ 的元素是等价类（子集），而不是代表元；$[a] = [b]$ 对应 $a \sim b$，并不代表 $a = b$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;复合映射求逆顺序&lt;/strong&gt;：可逆映射复合后求逆必须反序：$(g \circ f)^{-1} = f^{-1} \circ g^{-1}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;8. 与后续章节的对应关系&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;本章内容&lt;/th&gt;
&lt;th&gt;后续章节位置&lt;/th&gt;
&lt;th&gt;对应代数概念&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;笛卡尔积与二元运算&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/&quot;&gt;01-群与子群&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;群公理（二元运算的封闭性与结合律）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;等价关系与划分&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;模 $H$ 同余、陪集划分群、Lagrange 定理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;消去律与可逆性&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;单同态核判据、变换群置换求逆&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;商集良定性与诱导映射&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;商群乘法良定性、第一同构定理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;选择公理与 Zorn 引理&lt;/td&gt;
&lt;td&gt;环论与模论&lt;/td&gt;
&lt;td&gt;极大理想存在性、向量空间基的存在性&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
</content:encoded></item><item><title>01-群与子群</title><link>https://sanzenin.top/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/</guid><description>设 是一个非空集合， 是定义在 上的二元运算（即映射 ）。代数系统 称为一个群（Group），若满足以下四条公理： 1. 封闭性（Closure）： ， 。 2. 结合律（Associativity）： ， 。 3. 单位元存在性（Identity）： ，使得 ， 。 4. 逆元存在性（Inverse）： ， ，使得</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;01-群与子群&lt;/h1&gt;
&lt;h2&gt;1. 群的公理与初等性质&lt;/h2&gt;
&lt;h3&gt;1.1 严格表述&lt;/h3&gt;
&lt;p&gt;设 $G$ 是一个非空集合，$\cdot$ 是定义在 $G$ 上的二元运算（即映射 $\cdot: G \times G \to G$）。代数系统 $(G, \cdot)$ 称为一个&lt;strong&gt;群（Group）&lt;/strong&gt;，若满足以下四条公理：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;封闭性（Closure）&lt;/strong&gt;：$\forall a, b \in G$，$a \cdot b \in G$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结合律（Associativity）&lt;/strong&gt;：$\forall a, b, c \in G$，$(a \cdot b) \cdot c = a \cdot (b \cdot c)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单位元存在性（Identity）&lt;/strong&gt;：$\exists e \in G$，使得 $\forall a \in G$，$a \cdot e = e \cdot a = a$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;逆元存在性（Inverse）&lt;/strong&gt;：$\forall a \in G$，$\exists a^{-1} \in G$，使得 $a \cdot a^{-1} = a^{-1} \cdot a = e$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;若群运算还满足&lt;strong&gt;交换律（Commutativity）&lt;/strong&gt;：$\forall a, b \in G$，$a \cdot b = b \cdot a$，则称 $G$ 为&lt;strong&gt;阿贝尔群（Abelian Group，交换群）&lt;/strong&gt;。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;约定：通常省略乘号，将 $a \cdot b$ 简记为 $ab$。加法运算下的群通常显式写为 $(G, +)$，单位元记为 $0$，逆元记为 $-a$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;1.2 数学直觉&lt;/h3&gt;
&lt;p&gt;群抽象了可逆变换的代数特征。结合律保证了多次变换的复合与加括号次序无关；单位元对应恒等变换；逆元对应反向逆变换。&lt;/p&gt;
&lt;h3&gt;1.3 初等性质及其形式化证明&lt;/h3&gt;
&lt;h4&gt;定理 1.1（单位元与逆元的唯一性）&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;群 $G$ 中的单位元 $e$ 是唯一的。&lt;/li&gt;
&lt;li&gt;对任意 $a \in G$，$a$ 的逆元 $a^{-1}$ 是唯一的。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;设 $e_1, e_2$ 均为 $G$ 的单位元。由 $e_1$ 是单位元，有 $e_1 e_2 = e_2$；由 $e_2$ 是单位元，有 $e_1 e_2 = e_1$。因此 $e_1 = e_2$。&lt;/li&gt;
&lt;li&gt;设 $b, c$ 均为 $a$ 的逆元，即 $ab = ba = e$ 且 $ac = ca = e$。由结合律：
$$b = b e = b (a c) = (b a) c = e c = c$$
逆元唯一。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;定理 1.2（群的消去律）&lt;/h4&gt;
&lt;p&gt;设 $a, b, c \in G$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $ab = ac$，则 $b = c$（左消去律）。&lt;/li&gt;
&lt;li&gt;若 $ba = ca$，则 $b = c$（右消去律）。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
在 $ab = ac$ 两边左乘 $a^{-1}$：$a^{-1}(ab) = a^{-1}(ac) \implies (a^{-1}a)b = (a^{-1}a)c \implies eb = ec \implies b = c$。同理，在 $ba = ca$ 两边右乘 $a^{-1}$ 得到 $b = c$。 $\blacksquare$&lt;/p&gt;
&lt;h4&gt;定理 1.3（求逆运算性质）&lt;/h4&gt;
&lt;p&gt;对任意 $a, b \in G$，$(ab)^{-1} = b^{-1}a^{-1}$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
直接计算 $(b^{-1}a^{-1})$ 与 $(ab)$ 的复合：
$$(ab)(b^{-1}a^{-1}) = a(b b^{-1})a^{-1} = a e a^{-1} = a a^{-1} = e$$
$$(b^{-1}a^{-1})(ab) = b^{-1}(a^{-1}a)b = b^{-1} e b = b^{-1} b = e$$
由逆元的唯一性，必有 $(ab)^{-1} = b^{-1}a^{-1}$。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 阿贝尔群的核心判定&lt;/h2&gt;
&lt;h3&gt;2.1 严格表述与定理&lt;/h3&gt;
&lt;h4&gt;定理 1.4（平方乘积判定准则）&lt;/h4&gt;
&lt;p&gt;设 $G$ 是群。$G$ 是阿贝尔群当且仅当对任意 $a, b \in G$，均有：
$$(ab)^2 = a^2 b^2$$&lt;/p&gt;
&lt;h4&gt;定理 1.5（高阶幂次判定准则）&lt;/h4&gt;
&lt;p&gt;设 $G$ 是群。$G$ 是阿贝尔群当且仅当对任意 $a, b \in G$ 及任意正整数 $t \in \mathbb{Z}^+$，均有：
$$(ab)^t = a^t b^t$$&lt;/p&gt;
&lt;h3&gt;2.2 形式化证明&lt;/h3&gt;
&lt;h4&gt;证明定理 1.4：&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：若 $G$ 是阿贝尔群，则 $\forall a, b \in G$，$ab = ba$。
$$(ab)^2 = (ab)(ab) = a(ba)b = a(ab)b = (aa)(bb) = a^2 b^2$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：若对任意 $a, b \in G$ 均有 $(ab)^2 = a^2 b^2$。展开两边：
$$abab = aabb$$
两边利用群的左消去律消去 $a$：$bab = abb$。
再利用群的右消去律消去 $b$：$ba = ab$。
由 $a, b$ 的任意性，$G$ 是阿贝尔群。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;证明定理 1.5：&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：若 $G$ 是阿贝尔群，对 $t$ 施加数学归纳法。
当 $t=1$ 时，$(ab)^1 = ab = a^1 b^1$ 显然成立。
假设 $t=k$ 时结论成立，即 $(ab)^k = a^k b^k$。则：
$$(ab)^{k+1} = (ab)^k (ab) = (a^k b^k)(ab) = a^k (b^k a) b$$
在阿贝尔群中，元素满足交换律，故 $b^k a = a b^k$。因此：
$$a^k (a b^k) b = (a^k a)(b^k b) = a^{k+1} b^{k+1}$$
由归纳原理，必要性得证。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：已知对一切正整数 $t$ 均有 $(ab)^t = a^t b^t$。特别取 $t=2$，即得 $(ab)^2 = a^2 b^2$。由定理 1.4 的充分性证明，推得 $ba = ab$，$G$ 必为阿贝尔群。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;2.3 最小例子与反例&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;最小阿贝尔群&lt;/strong&gt;：平凡群 ${e}$（1 阶），二阶循环群 $\mathbb{Z}_2 = {0, 1}$（模 2 加法）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;最小非阿贝尔群&lt;/strong&gt;：3 次对称群 $S_3$（阶数为 $3! = 6$）。取对换 $\sigma = (1\ 2)$ 与轮换 $\tau = (1\ 2\ 3)$，计算可知 $\sigma\tau = (2\ 3) \neq (1\ 3) = \tau\sigma$。同时 $(\sigma\tau)^2 = (2\ 3)^2 = (1)$，而 $\sigma^2 \tau^2 = (1)(1\ 3\ 2) = (1\ 3\ 2) \neq (1)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 元素的阶（Order）&lt;/h2&gt;
&lt;h3&gt;3.1 严格表述&lt;/h3&gt;
&lt;p&gt;设 $G$ 是群，$a \in G$。
若存在正整数 $m$ 使得 $a^m = e$，则称 $a$ 为&lt;strong&gt;有限阶元素&lt;/strong&gt;，满足该条件的&lt;strong&gt;最小正整数&lt;/strong&gt; $m$ 称为元素 $a$ 的&lt;strong&gt;阶（Order）&lt;/strong&gt;，记作 $\operatorname{ord}(a) = m$（或 $|a| = m$）。
若不存在这样的正整数，则称 $a$ 为&lt;strong&gt;无限阶元素&lt;/strong&gt;，记作 $\operatorname{ord}(a) = \infty$。&lt;/p&gt;
&lt;h3&gt;3.2 形式化证明：阶的整除性质&lt;/h3&gt;
&lt;h4&gt;定理 1.6（阶整除引理）&lt;/h4&gt;
&lt;p&gt;设 $a \in G$ 且 $\operatorname{ord}(a) = m &amp;lt; \infty$。对任意整数 $k \in \mathbb{Z}$：
$$a^k = e \iff m \mid k$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：若 $m \mid k$，存在整数 $q$ 使得 $k = qm$。则 $a^k = a^{qm} = (a^m)^q = e^q = e$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：已知 $a^k = e$。由带余除法，存在唯一整数 $q, r$ 使得：
$$k = qm + r, \quad 0 \le r &amp;lt; m$$
计算幂次：
$$a^k = a^{qm + r} = (a^m)^q a^r = e^q a^r = a^r \implies a^r = e$$
若 $r &amp;gt; 0$，则 $r$ 是一个比 $m$ 更小的严格正整数，满足 $a^r = e$。这与 $m$ 是满足 $a^m = e$ 的最小正整数矛盾。
因此只能有 $r = 0$，即 $k = qm$，故 $m \mid k$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 子群（Subgroup）及其判定&lt;/h2&gt;
&lt;h3&gt;4.1 严格表述&lt;/h3&gt;
&lt;p&gt;设 $(G, \cdot)$ 是群，$H$ 是 $G$ 的非空子集。如果 $H$ 关于 $G$ 原有的运算 $\cdot$ 也构成一个群，则称 $H$ 是 $G$ 的&lt;strong&gt;子群（Subgroup）&lt;/strong&gt;，记作 $H \le G$。若 $H \ne G$，称 $H$ 为真子群，记作 $H &amp;lt; G$。&lt;/p&gt;
&lt;h3&gt;4.2 形式化证明：子群的三种判定定理&lt;/h3&gt;
&lt;h4&gt;定理 1.7（两步判定法）&lt;/h4&gt;
&lt;p&gt;设 $H$ 是群 $G$ 的非空子集。$H \le G$ 当且仅当：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;运算封闭性&lt;/strong&gt;：$\forall a, b \in H \implies ab \in H$；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求逆封闭性&lt;/strong&gt;：$\forall a \in H \implies a^{-1} \in H$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;定理 1.8（一步判定法）&lt;/h4&gt;
&lt;p&gt;设 $H$ 是群 $G$ 的非空子集。$H \le G$ 当且仅当：
$$\forall a, b \in H \implies ab^{-1} \in H$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：若 $H \le G$，由子群公理，$H$ 对求逆和乘法均封闭，故 $b \in H \implies b^{-1} \in H \implies ab^{-1} \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：已知 $H \ne \emptyset$ 且 $\forall a, b \in H, ab^{-1} \in H$。
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;单位元存在&lt;/strong&gt;：因为 $H \ne \emptyset$，必存在某个元素 $x \in H$。在已知条件中令 $a = x, b = x$，得 $x x^{-1} = e \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;逆元存在&lt;/strong&gt;：已知 $e \in H$。对任意 $y \in H$，在已知条件中令 $a = e, b = y$，得 $e y^{-1} = y^{-1} \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;封闭性&lt;/strong&gt;：对任意 $a, b \in H$，由逆元存在性可知 $b^{-1} \in H$。在已知条件中令第一个元为 $a$，第二个元为 $b^{-1}$，得 $a(b^{-1})^{-1} = ab \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结合律&lt;/strong&gt;：由于 $H \subseteq G$，$G$ 中运算满足结合律，限制在 $H$ 上同样满足结合律。
综上四点，$H \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;定理 1.9（有限子集的判定法）&lt;/h4&gt;
&lt;p&gt;设 $H$ 是群 $G$ 的&lt;strong&gt;有限&lt;/strong&gt;非空子集。若 $H$ 对 $G$ 的运算满足&lt;strong&gt;封闭性&lt;/strong&gt;（即 $\forall a, b \in H \implies ab \in H$），则 $H \le G$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
只需证明 $H$ 对求逆封闭。
任取 $a \in H$。考虑元素幂序列：
$$a^1, a^2, a^3, \dots, a^k, \dots$$
由 $H$ 的运算封闭性，序列中的所有元素都属于 $H$。
因为集合 $H$ 是有限集，该序列中不可能所有元素互不相同，必存在不同的正整数 $i, j$（设 $i &amp;gt; j \ge 1$），使得：
$$a^i = a^j$$
在等式两边右乘 $j$ 次 $a^{-1}$，得到：
$$a^{i-j} = e$$
由于 $i &amp;gt; j$，差值 $i - j \ge 1$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $i - j = 1$，则 $a = e \in H$，其逆元 $a^{-1} = e \in H$。&lt;/li&gt;
&lt;li&gt;若 $i - j &amp;gt; 1$，则 $i - j - 1 \ge 1$。等式两边左乘 $a^{-1}$：
$$a^{-1} = a^{i - j - 1}$$
因为 $i - j - 1$ 是正整数，由封闭性，$a^{i - j - 1} \in H$，所以 $a^{-1} \in H$。
结合封闭性与结合律，得证 $H \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!WARNING] 条件反例
定理 1.9 中“有限”条件不可缺少。
反例：全体正整数集合 $\mathbb{Z}^+$ 在整数加法群 $(\mathbb{Z}, +)$ 中加法封闭，但它不是子群（没有单位元 $0$，也没有负逆元）。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 子群的运算与构造&lt;/h2&gt;
&lt;h3&gt;5.1 子群的交集&lt;/h3&gt;
&lt;h4&gt;定理 1.10&lt;/h4&gt;
&lt;p&gt;设 ${H_i}&lt;em&gt;{i \in I}$ 是群 $G$ 的一族子群，则它们的交集仍然是 $G$ 的子群：
$$H = \bigcap&lt;/em&gt;{i \in I} H_i \le G$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;对任意 $i \in I$，$e \in H_i$，故 $e \in \bigcap_{i \in I} H_i = H$，$H \ne \emptyset$。&lt;/li&gt;
&lt;li&gt;任取 $a, b \in H$。则对每个 $i \in I$，均有 $a, b \in H_i$。
因为每个 $H_i \le G$，所以 $ab^{-1} \in H_i$。
从而 $ab^{-1} \in \bigcap_{i \in I} H_i = H$。
由一步判定法，$H \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;5.2 子群的并集与真子群覆盖定理&lt;/h3&gt;
&lt;h4&gt;定理 1.11&lt;/h4&gt;
&lt;p&gt;群 $G$ 不能表示为两个真子群的并集。即若 $H_1 &amp;lt; G$ 且 $H_2 &amp;lt; G$，则 $G \ne H_1 \cup H_2$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明（反证法）：&lt;/strong&gt;
假设 $G = H_1 \cup H_2$。
由于 $H_1, H_2$ 均为真子群，必有 $H_1 \not\subseteq H_2$ 且 $H_2 \not\subseteq H_1$（若有包含关系，例如 $H_1 \subseteq H_2$，则 $H_1 \cup H_2 = H_2 = G$，与 $H_2 &amp;lt; G$ 矛盾）。
因此，存在元素 $a \in H_1 \setminus H_2$，以及元素 $b \in H_2 \setminus H_1$。
考虑元素 $c = ab$。由群封闭性，$c \in G$。因此 $c \in H_1 \cup H_2$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $c \in H_1$：则 $b = a^{-1}c$。因为 $a \in H_1 \implies a^{-1} \in H_1$，且 $c \in H_1$，由子群封闭性，$b \in H_1$，与 $b \notin H_1$ 矛盾。&lt;/li&gt;
&lt;li&gt;若 $c \in H_2$：则 $a = c b^{-1}$。因为 $b \in H_2 \implies b^{-1} \in H_2$，且 $c \in H_2$，由子群封闭性，$a \in H_2$，与 $a \notin H_2$ 矛盾。
两种情况均导出矛盾，故假设不成立，$G \ne H_1 \cup H_2$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;5.3 子群乘积集 $H_1 H_2$&lt;/h3&gt;
&lt;h4&gt;定理 1.12&lt;/h4&gt;
&lt;p&gt;设 $H_1, H_2 \le G$，定义集合乘积：
$$H_1 H_2 = {h_1 h_2 \mid h_1 \in H_1, h_2 \in H_2}$$
则 $H_1 H_2 \le G \iff H_1 H_2 = H_2 H_1$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：设 $H_1 H_2 \le G$。
对任意 $x \in H_1 H_2$，由于子群对求逆封闭，$x^{-1} \in H_1 H_2$，设 $x^{-1} = h_1 h_2$（$h_1 \in H_1, h_2 \in H_2$）。
则 $x = (x^{-1})^{-1} = (h_1 h_2)^{-1} = h_2^{-1} h_1^{-1}$。
因为 $h_2^{-1} \in H_2, h_1^{-1} \in H_1$，所以 $x \in H_2 H_1$。由此 $H_1 H_2 \subseteq H_2 H_1$。
反之，任取 $y \in H_2 H_1$，设 $y = h_2 h_1$。则 $y^{-1} = h_1^{-1} h_2^{-1} \in H_1 H_2$。
因为 $H_1 H_2$ 是子群，其逆元 $(y^{-1})^{-1} = y \in H_1 H_2$。由此 $H_2 H_1 \subseteq H_1 H_2$。
故 $H_1 H_2 = H_2 H_1$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：设 $H_1 H_2 = H_2 H_1$。
&lt;ol&gt;
&lt;li&gt;$e = ee \in H_1 H_2 \implies H_1 H_2 \ne \emptyset$。&lt;/li&gt;
&lt;li&gt;任取 $x, y \in H_1 H_2$。设 $x = h_1 h_2, y = k_1 k_2$。
则 $x y^{-1} = (h_1 h_2)(k_2^{-1} k_1^{-1}) = h_1 (h_2 k_2^{-1}) k_1^{-1}$。
记 $h_3 = h_2 k_2^{-1} \in H_2$。则 $h_3 k_1^{-1} \in H_2 H_1$。
利用条件 $H_2 H_1 = H_1 H_2$，存在 $h&apos;_1 \in H_1, h&apos;_2 \in H_2$ 使得 $h_3 k_1^{-1} = h&apos;_1 h&apos;_2$。
代入可得：$x y^{-1} = h_1 (h&apos;_1 h&apos;_2) = (h_1 h&apos;_1) h&apos;_2 \in H_1 H_2$。
由一步判定法，$H_1 H_2 \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;推论&lt;/strong&gt;：若 $G$ 是阿贝尔群，则对任意两个子群 $H_1, H_2 \le G$，乘积集 $H_1 H_2$ 恒为 $G$ 的子群。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;5.4 群的中心（Center）&lt;/h3&gt;
&lt;h4&gt;定义 1.13&lt;/h4&gt;
&lt;p&gt;群 $G$ 的**中心（Center）**定义为所有与全群每一个元素都可交换的元素构成的集合：
$$Z(G) = {z \in G \mid \forall x \in G, zx = xz}$$&lt;/p&gt;
&lt;h4&gt;定理 1.14&lt;/h4&gt;
&lt;p&gt;对任意群 $G$，$Z(G) \le G$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;对一切 $x \in G$，$ex = xe = x$，故 $e \in Z(G)$，$Z(G) \ne \emptyset$。&lt;/li&gt;
&lt;li&gt;任取 $a, b \in Z(G)$。首先验证 $b^{-1} \in Z(G)$：
由于 $bx = xb$，两边左乘 $b^{-1}$、右乘 $b^{-1}$：
$$b^{-1}(bx)b^{-1} = b^{-1}(xb)b^{-1} \implies xb^{-1} = b^{-1}x$$
故 $b^{-1} \in Z(G)$。&lt;/li&gt;
&lt;li&gt;对任意 $x \in G$：
$$(ab^{-1})x = a(b^{-1}x) = a(xb^{-1}) = (ax)b^{-1} = (xa)b^{-1} = x(ab^{-1})$$
故 $ab^{-1} \in Z(G)$。由一步判定法，$Z(G) \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 核心易错点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;求逆次序&lt;/strong&gt;：$(ab)^{-1} = b^{-1}a^{-1}$，不可直接写为 $a^{-1}b^{-1}$（除非已知群满足交换律）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;消去律的适用范围&lt;/strong&gt;：群中的消去律由逆元保证；一般半群或环不能直接套用。反过来，有消去律不代表有逆元，例如正整数加法半群也满足消去律。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;有限子群判定条件&lt;/strong&gt;：只有在子集非空且有限时，“封闭性”才能单独保证逆元存在；无限子集必须显式证明对求逆封闭。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子群并集通常不是子群&lt;/strong&gt;：两个子群的并集通常不是子群。例如在 $(\mathbb{Z}, +)$ 中，$2\mathbb{Z} \cup 3\mathbb{Z}$ 不是子群，因为 $2+3=5 \notin 2\mathbb{Z} \cup 3\mathbb{Z}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子群乘积的封闭性&lt;/strong&gt;：非交换群中两个子群的集合乘积 $H_1 H_2$ 通常不构成子群，充要条件是 $H_1 H_2 = H_2 H_1$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 前后知识连接&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;（二元运算、映射可逆性、结合律下左右逆元唯一性）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;子群概念是后续构造循环子群（&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/&quot;&gt;02-循环群与生成元.md&lt;/a&gt;）的基础。&lt;/li&gt;
&lt;li&gt;子群用于对全群进行陪集划分（&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群.md&lt;/a&gt;）。&lt;/li&gt;
&lt;li&gt;群的中心 $Z(G)$ 是后续内自同构群同构定理 $G/Z(G) \cong \operatorname{Inn}(G)$（&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley.md&lt;/a&gt;）中的同态核。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与方法套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（子群一步判定法模板、抽屉原理逆元构造模板）。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>02-循环群与生成元</title><link>https://sanzenin.top/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/</guid><description>设 是一个群。如果存在元素 ，使得群中的每一个元素都可以表示为 的整数次幂，即： 则称 为由元素 生成的循环群（Cyclic Group），元素 称为群 的一个生成元（Generator）。 在加法记号下，循环群的元素表示为整数倍： 循环群是由单个元素通过重复运算（乘方或倍数）展开生成的群。其元素分布取决于生成元的阶：</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;02-循环群与生成元&lt;/h1&gt;
&lt;h2&gt;1. 循环群的定义与表示&lt;/h2&gt;
&lt;h3&gt;1.1 严格表述&lt;/h3&gt;
&lt;p&gt;设 $G$ 是一个群。如果存在元素 $a \in G$，使得群中的每一个元素都可以表示为 $a$ 的整数次幂，即：
$$G = {a^k \mid k \in \mathbb{Z}} =: \langle a \rangle$$
则称 $G$ 为由元素 $a$ 生成的&lt;strong&gt;循环群（Cyclic Group）&lt;/strong&gt;，元素 $a$ 称为群 $G$ 的一个&lt;strong&gt;生成元（Generator）&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;在加法记号下，循环群的元素表示为整数倍：
$$G = {k a \mid k \in \mathbb{Z}} =: \langle a \rangle$$&lt;/p&gt;
&lt;h3&gt;1.2 数学直觉&lt;/h3&gt;
&lt;p&gt;循环群是由单个元素通过重复运算（乘方或倍数）展开生成的群。其元素分布取决于生成元的阶：若生成元阶为无限，元素序列不发生循环；若生成元阶为有限，元素序列呈周期性循环。&lt;/p&gt;
&lt;h3&gt;1.3 基础性质：交换性&lt;/h3&gt;
&lt;h4&gt;定理 2.1&lt;/h4&gt;
&lt;p&gt;任何循环群都是阿贝尔群（交换群）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $G = \langle a \rangle$。任取 $x, y \in G$，由循环群定义，存在整数 $s, t \in \mathbb{Z}$ 使得 $x = a^s, y = a^t$。
利用指数运算性质：
$$xy = a^s a^t = a^{s+t} = a^{t+s} = a^t a^s = yx$$
因此 $G$ 是交换群。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 循环群分类定理&lt;/h2&gt;
&lt;h3&gt;2.1 严格表述与定理&lt;/h3&gt;
&lt;h4&gt;定理 2.2（循环群分类定理）&lt;/h4&gt;
&lt;p&gt;设 $G = \langle a \rangle$ 是循环群：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $\operatorname{ord}(a) = \infty$（无限循环群），则 $G \cong (\mathbb{Z}, +)$；&lt;/li&gt;
&lt;li&gt;若 $\operatorname{ord}(a) = m$（$m$ 阶有限循环群），则 $G \cong (\mathbb{Z}_m, +)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;2.2 形式化证明&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;证明情形 1（无限循环群）：&lt;/strong&gt;
定义映射 $f: \mathbb{Z} \to G$ 为 $f(k) = a^k$（$\forall k \in \mathbb{Z}$）。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：$f(k_1 + k_2) = a^{k_1 + k_2} = a^{k_1} a^{k_2} = f(k_1) f(k_2)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：由 $G = \langle a \rangle$，任何元素均形如 $a^k = f(k)$，故 $f$ 为满射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射性&lt;/strong&gt;：若 $f(k_1) = f(k_2)$，则 $a^{k_1} = a^{k_2} \implies a^{k_1 - k_2} = e$。
若 $k_1 \ne k_2$，不妨设 $k_1 &amp;gt; k_2$，则 $k_1 - k_2$ 为正整数且使得 $a^{k_1 - k_2} = e$，这与 $\operatorname{ord}(a) = \infty$ 矛盾。
因此必有 $k_1 = k_2$，$f$ 为单射。
综上，$f$ 是同构映射，故 $G \cong (\mathbb{Z}, +)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明情形 2（有限循环群）：&lt;/strong&gt;
定义映射 $\phi: \mathbb{Z}_m \to G$ 为 $\phi([k]) = a^k$（其中 $[k] \in \mathbb{Z}_m$）。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;良定性&lt;/strong&gt;：若 $[k_1] = [k_2]$，则 $k_1 \equiv k_2 \pmod m \implies k_1 - k_2 = qm$。
从而 $a^{k_1} = a^{k_2 + qm} = a^{k_2} (a^m)^q = a^{k_2} e^q = a^{k_2}$。映射良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：$\phi([k_1] + [k_2]) = \phi([k_1 + k_2]) = a^{k_1 + k_2} = a^{k_1} a^{k_2} = \phi([k_1]) \phi([k_2])$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射性&lt;/strong&gt;：若 $\phi([k_1]) = \phi([k_2])$，则 $a^{k_1 - k_2} = e$。由定理 1.6（阶整除引理），$m \mid (k_1 - k_2)$，即 $[k_1] = [k_2]$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：对任意 $x \in G$，由循环群定义存在 $0 \le k &amp;lt; m$ 使得 $x = a^k = \phi([k])$，故为满射。
故 $\phi$ 是群同构，即 $G \cong (\mathbb{Z}_m, +)$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 有限循环群元素阶的计算公式&lt;/h2&gt;
&lt;h3&gt;3.1 严格表述与定理&lt;/h3&gt;
&lt;h4&gt;定理 2.3（元素阶公式）&lt;/h4&gt;
&lt;p&gt;设 $G = \langle a \rangle$ 是 $n$ 阶有限循环群，则对任意整数 $k \in \mathbb{Z}$，元素 $a^k$ 的阶为：
$$\operatorname{ord}(a^k) = \frac{n}{\gcd(n, k)}$$&lt;/p&gt;
&lt;h3&gt;3.2 形式化证明&lt;/h3&gt;
&lt;p&gt;记 $m = \operatorname{ord}(a^k)$，$d = \gcd(n, k)$。
设 $n = d n_1$，$k = d k_1$，其中 $\gcd(n_1, k_1) = 1$。
根据元素阶的定义：
$$(a^k)^m = e \iff a^{km} = e$$
由于 $\operatorname{ord}(a) = n$，由定理 1.6（阶整除引理）：
$$a^{km} = e \iff n \mid km$$
代入 $n = d n_1$ 与 $k = d k_1$：
$$d n_1 \mid d k_1 m \iff n_1 \mid k_1 m$$
因为 $\gcd(n_1, k_1) = 1$，由数论中的欧几里得引理（若互质数整除乘积，则必整除另一因子）：
$$n_1 \mid m$$
因此，使得 $(a^k)^m = e$ 成立的最小正整数 $m$ 必须取为：
$$m = n_1 = \frac{n}{d} = \frac{n}{\gcd(n, k)}$$
即 $\operatorname{ord}(a^k) = \frac{n}{\gcd(n, k)}$。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 生成元的判定与分布定理&lt;/h2&gt;
&lt;h3&gt;4.1 有限循环群生成元定理&lt;/h3&gt;
&lt;h4&gt;定理 2.4&lt;/h4&gt;
&lt;p&gt;设 $G = \langle a \rangle$ 是 $n$ 阶有限循环群。元素 $a^k$ 是 $G$ 的生成元当且仅当：
$$\gcd(k, n) = 1$$
因此，群 $G$ 的生成元总个数等于欧拉函数值 $\phi(n)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
$a^k$ 是 $G$ 的生成元当且仅当由它生成的子群包含 $n$ 个元素，即其阶达到全群的阶：
$$\operatorname{ord}(a^k) = n$$
由定理 2.3：
$$\frac{n}{\gcd(n, k)} = n \iff \gcd(n, k) = 1$$
在区间 $1 \le k \le n$ 内，满足 $\gcd(k, n) = 1$ 的整数个数定义为欧拉函数 $\phi(n)$。 $\blacksquare$&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;推论（素数阶群的生成元）&lt;/strong&gt;：若群阶 $n = p$ 为素数，则群内除了单位元 $e = a^0$ 之外的任意元素 $a^k$（$1 \le k \le p-1$）均满足 $\gcd(k, p) = 1$，因此全部都是生成元，生成元总数为 $\phi(p) = p - 1$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;4.2 无限循环群的生成元&lt;/h3&gt;
&lt;h4&gt;定理 2.5&lt;/h4&gt;
&lt;p&gt;任何无限循环群 $G = \langle a \rangle$ 只有且仅有两个生成元，即 $a$ 与 $a^{-1}$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $x = a^k$ 是 $G$ 的生成元。
因为 $x$ 能生成全群，基准元素 $a \in G$ 必须能被 $x$ 生成，即存在整数 $s \in \mathbb{Z}$ 使得：
$$a = x^s = (a^k)^s = a^{ks}$$
两边左乘 $a^{-1}$ 得 $a^{ks - 1} = e$。
由于 $G$ 是无限循环群，其生成元不存在使 $a^m = e$ 的非零整数指数：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $ks - 1 &amp;gt; 0$，则 $ks - 1$ 为正整数，直接与 $\operatorname{ord}(a) = \infty$ 矛盾；&lt;/li&gt;
&lt;li&gt;若 $ks - 1 &amp;lt; 0$，两边取逆得到 $a^{-(ks-1)} = e$，其中 $-(ks-1) &amp;gt; 0$ 为正整数，同样与 $\operatorname{ord}(a) = \infty$ 矛盾。
因此指数只能严格为 0：
$$ks - 1 = 0 \implies ks = 1$$
因为 $k, s \in \mathbb{Z}$，该整数方程仅有两组整数解：
$$k = 1 \quad \text{或} \quad k = -1$$
因此 $x = a^1 = a$ 或 $x = a^{-1}$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 循环群的子群结构定理&lt;/h2&gt;
&lt;h3&gt;5.1 子群必为循环群&lt;/h3&gt;
&lt;h4&gt;定理 2.6&lt;/h4&gt;
&lt;p&gt;循环群的任何子群都必定是循环群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $G = \langle a \rangle$ 是循环群，$H \le G$。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $H = {e}$，则 $H = \langle e \rangle$ 显然为循环群。&lt;/li&gt;
&lt;li&gt;若 $H \ne {e}$，因为 $H \subseteq G$，存在非零整数 $t$ 使得 $a^t \in H$。
由于 $H$ 是子群，$(a^t)^{-1} = a^{-t} \in H$。因此 $H$ 中必定包含正整数次幂。
根据正整数的良序原则，取集合 ${k \in \mathbb{Z}^+ \mid a^k \in H}$ 中的&lt;strong&gt;最小正整数&lt;/strong&gt;，记为 $m$。
我们证明：$H = \langle a^m \rangle$。
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;包含性 $\langle a^m \rangle \subseteq H$&lt;/strong&gt;：由于 $a^m \in H$ 且 $H$ 是子群，由封闭性知对一切 $q \in \mathbb{Z}$ 均有 $(a^m)^q \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;包含性 $H \subseteq \langle a^m \rangle$&lt;/strong&gt;：任取 $h \in H$，设 $h = a^k$。
由带余除法，存在唯一整数 $q, r$ 使得：
$$k = qm + r, \quad 0 \le r &amp;lt; m$$
变形得：$a^r = a^{k - qm} = a^k (a^m)^{-q}$。
因为 $a^k \in H$ 且 $(a^m)^{-q} \in H$，由子群封闭性，必有 $a^r \in H$。
若 $r &amp;gt; 0$，则 $r$ 是满足 $a^r \in H$ 且 $r &amp;lt; m$ 的正整数，与 $m$ 的最小性产生矛盾。
因此必有 $r = 0$，即 $k = qm$。
从而 $h = a^k = (a^m)^q \in \langle a^m \rangle$。
综上，$H = \langle a^m \rangle$ 必为循环群。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;5.2 有限循环群子群的因数一一对应定理&lt;/h3&gt;
&lt;h4&gt;定理 2.7&lt;/h4&gt;
&lt;p&gt;设 $G = \langle a \rangle$ 是 $n$ 阶有限循环群：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$G$ 的任意子群的阶必定整除 $n$；&lt;/li&gt;
&lt;li&gt;反之，对于 $n$ 的每一个正因数 $d$（$d \mid n$），$G$ &lt;strong&gt;有且仅有一个&lt;/strong&gt;阶为 $d$ 的子群，且该子群显式由元素 $a^{n/d}$ 生成：
$$H_d = \left\langle a^{n/d} \right\rangle$$&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;整除性&lt;/strong&gt;：由后续 Lagrange 定理，有限群的子群阶必整除群阶。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;存在性&lt;/strong&gt;：令 $b = a^{n/d}$。由定理 2.3 阶计算公式：
$$\operatorname{ord}(b) = \frac{n}{\gcd(n, n/d)} = \frac{n}{n/d} = d$$
故由 $b$ 生成的子群 $H_d = \langle a^{n/d} \rangle$ 其阶恰好为 $d$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;唯一性&lt;/strong&gt;：设 $H$ 是 $G$ 中任意一个阶为 $d$ 的子群。
由定理 2.6，$H$ 必为循环群，设 $H = \langle a^k \rangle$。
因为 $|H| = d$，所以 $\operatorname{ord}(a^k) = d$。由阶计算公式：
$$\frac{n}{\gcd(n, k)} = d \implies \gcd(n, k) = \frac{n}{d}$$
因此整数 $k$ 可以写成：
$$k = \frac{n}{d} t, \quad \text{其中 } \gcd(t, d) = 1$$
这说明生成元 $a^k = \left(a^{n/d}\right)^t = b^t$。
因为 $\gcd(t, d) = 1$，由定理 2.4，在 $d$ 阶循环群 $\langle b \rangle$ 中，$b^t$ 也是该群的生成元，即：
$$\langle b^t \rangle = \langle b \rangle$$
因此：
$$H = \langle a^k \rangle = \langle b^t \rangle = \langle b \rangle = \left\langle a^{n/d} \right\rangle = H_d$$
这就证明了 $d$ 阶子群的唯一性。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;推论&lt;/strong&gt;：$n$ 阶有限循环群的子群总数，严格等于整数 $n$ 的正因数个数 $\tau(n)$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 循环群的同态传递与自同构群&lt;/h2&gt;
&lt;h3&gt;6.1 同态像的循环性&lt;/h3&gt;
&lt;h4&gt;定理 2.8&lt;/h4&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态。若 $G = \langle a \rangle$ 是循环群，则其同态像 $\operatorname{Im}f$ 也是循环群，并且由像点 $f(a)$ 生成：
$$\operatorname{Im}f = \langle f(a) \rangle$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
任取 $y \in \operatorname{Im}f$，存在 $x \in G$ 使得 $f(x) = y$。
由 $G = \langle a \rangle$，存在整数 $k$ 使得 $x = a^k$。
利用同态保持乘积的性质：
$$y = f(a^k) = (f(a))^k \in \langle f(a) \rangle$$
反之，对任意 $(f(a))^k \in \langle f(a) \rangle$，由 $(f(a))^k = f(a^k)$ 知其属于 $\operatorname{Im}f$。
故 $\operatorname{Im}f = \langle f(a) \rangle$。 $\blacksquare$&lt;/p&gt;
&lt;h3&gt;6.2 有限循环群满同态的存在条件&lt;/h3&gt;
&lt;h4&gt;定理 2.9&lt;/h4&gt;
&lt;p&gt;设 $G$ 是 $m$ 阶有限循环群，$G&apos;$ 是 $n$ 阶有限循环群。
存在满同态 $f: G \to G&apos;$ 当且仅当：
$$n \mid m$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：若存在满同态 $f: G \to G&apos;$，根据后续同态基本定理，$G/\operatorname{Ker}f \cong G&apos;$。
由 Lagrange 定理，群阶满足 $|G&apos;| = |G| / |\operatorname{Ker}f| \implies n = m / |\operatorname{Ker}f|$，因此 $n \mid m$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：若 $n \mid m$，设 $G = \langle a \rangle, G&apos; = \langle b \rangle$。
定义映射 $f(a^k) = b^k$。
验证良定性：若 $a^{k_1} = a^{k_2}$，则 $m \mid (k_1 - k_2)$。因为 $n \mid m$，必有 $n \mid (k_1 - k_2)$，从而 $b^{k_1} = b^{k_2}$。
直接验证可得 $f(a^{k_1} a^{k_2}) = f(a^{k_1 + k_2}) = b^{k_1 + k_2} = b^{k_1} b^{k_2} = f(a^{k_1}) f(a^{k_2})$，且像包含生成元 $b$，故为满同态。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;6.3 循环群自同构群的完整形式化证明&lt;/h3&gt;
&lt;h4&gt;定理 2.10&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;无限循环群的自同构群：$\operatorname{Aut}(\mathbb{Z}) \cong \mathbb{Z}_2$。&lt;/li&gt;
&lt;li&gt;有限循环群的自同构群：$\operatorname{Aut}(\mathbb{Z}_n) \cong \mathbb{Z}_n^\times$（模 $n$ 简化剩余系乘法群），阶数为 $\phi(n)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;严格形式化证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;无限循环群情形&lt;/strong&gt;：
设 $f \in \operatorname{Aut}(\mathbb{Z})$。因为 $f$ 是同构，$f$ 必须将生成元映射为生成元。
由定理 2.5，$\mathbb{Z}$ 的生成元只有 $1$ 和 $-1$。
&lt;ul&gt;
&lt;li&gt;若 $f(1) = 1$，由加群同态性质，对任意 $n \in \mathbb{Z}$，$f(n) = f(n \cdot 1) = n f(1) = n$，即 $f = \operatorname{id}_{\mathbb{Z}}$（恒等映射）；&lt;/li&gt;
&lt;li&gt;若 $f(1) = -1$，同理 $f(n) = -n$，即 $f = -\operatorname{id}&lt;em&gt;{\mathbb{Z}}$。
直接验证可知这两个映射均为自同构。复合运算满足 $(-\operatorname{id}) \circ (-\operatorname{id}) = \operatorname{id}$，因此 $\operatorname{Aut}(\mathbb{Z}) = {\operatorname{id}&lt;/em&gt;{\mathbb{Z}}, -\operatorname{id}_{\mathbb{Z}}} \cong \mathbb{Z}_2$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;有限循环群情形&lt;/strong&gt;：
考察群 $(\mathbb{Z}_n, +)$。定义映射：
$$\Psi: \operatorname{Aut}(\mathbb{Z}_n) \to \mathbb{Z}_n^\times, \quad \Psi(f) = f([1])$$
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;值域良定&lt;/strong&gt;：因 $f$ 为自同构，必定将生成元映射为生成元。$[1]$ 是 $\mathbb{Z}_n$ 的生成元，故 $f([1])$ 也是生成元。由定理 2.4，若 $f([1]) = [k]$，则必有 $\gcd(k, n) = 1$，即 $f([1]) \in \mathbb{Z}_n^\times$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;群同态性&lt;/strong&gt;：任取 $f, g \in \operatorname{Aut}(\mathbb{Z}_n)$。设 $g([1]) = [b]$。
利用加法群同态性质：
$$\Psi(f \circ g) = (f \circ g)([1]) = f(g([1])) = f([b]) = f(b[1]) = b f([1])$$
在乘法群 $\mathbb{Z}_n^\times$ 中，其乘积为 $[b] f([1]) = \Psi(g) \Psi(f) = \Psi(f) \Psi(g)$（因为 $\mathbb{Z}_n^\times$ 是交换群）。故 $\Psi$ 是同态映射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射性&lt;/strong&gt;：设 $\Psi(f) = \Psi(g)$，即 $f([1]) = g([1])$。对任意 $[x] \in \mathbb{Z}_n$：
$$f([x]) = f(x[1]) = x f([1]) = x g([1]) = g(x[1]) = g([x])$$
故映射 $f = g$。因此 $\Psi$ 是单射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：任取 $[k] \in \mathbb{Z}_n^\times$，即 $\gcd(k, n) = 1$。
定义映射 $f_k: \mathbb{Z}_n \to \mathbb{Z}_n$ 为 $f_k([x]) = [kx]$。
容易验证 $f_k$ 良定且满足加法同态；由 $\gcd(k, n) = 1$，同态核为 ${[x] \mid [kx] = [0]} = {[0]}$，故 $f_k$ 是单同态，有限集上的单同态必为双射，故 $f_k \in \operatorname{Aut}(\mathbb{Z}_n)$。
且 $\Psi(f_k) = f_k([1]) = [k]$。故 $\Psi$ 是满射。
综上，$\Psi$ 是群同构，即 $\operatorname{Aut}(\mathbb{Z}_n) \cong \mathbb{Z}_n^\times$，其阶数为 $|\mathbb{Z}_n^\times| = \phi(n)$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 最小例子与反面典型&lt;/h2&gt;
&lt;h3&gt;最小例子&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;模 12 加群 $\mathbb{Z}_{12}$ 的因数对应&lt;/strong&gt;：
$12$ 的因数集合为 ${1, 2, 3, 4, 6, 12}$。子群恰好有 6 个：
&lt;ul&gt;
&lt;li&gt;$1$ 阶：$\langle [0] \rangle = {[0]}$；&lt;/li&gt;
&lt;li&gt;$2$ 阶：$\langle [6] \rangle = {[0], [6]}$；&lt;/li&gt;
&lt;li&gt;$3$ 阶：$\langle [4] \rangle = {[0], [4], [8]}$；&lt;/li&gt;
&lt;li&gt;$4$ 阶：$\langle [3] \rangle = {[0], [3], [6], [9]}$；&lt;/li&gt;
&lt;li&gt;$6$ 阶：$\langle [2] \rangle = {[0], [2], [4], [6], [8], [10]}$；&lt;/li&gt;
&lt;li&gt;$12$ 阶：$\langle [1] \rangle = \mathbb{Z}_{12}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;反面典型：不是循环群的交换群&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;克莱因四元群（Klein 4-group, $V_4$ 或 $K_4$）&lt;/strong&gt;：
$V_4 = {e, a, b, c}$，运算规律为 $a^2 = b^2 = c^2 = e$，$ab = c$。
$V_4$ 是阿贝尔群，阶为 4，但群内非单位元的最大阶仅为 2，不存在 4 阶元，因此不是循环群。这证明了&lt;strong&gt;阿贝尔群不一定是循环群&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;8. 核心易错点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;生成元判定条件&lt;/strong&gt;：在有限循环群中，元素成为生成元的充要条件是指数与模数互质。在偶数加群 $2\mathbb{Z}$ 中只有 $2$ 和 $-2$ 能生成全群；在 $\mathbb{Z}_m$ 中只有与 $m$ 互质的数才能当生成元。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;素数阶群元素的阶&lt;/strong&gt;：素数阶群中非单位元的阶直接等于素数 $p$，而不是“与 $p$ 互质”。正因为阶达到了全阶，才成为生成元。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同构映射单位元对齐&lt;/strong&gt;：复数乘法群 $U_4 = {1, i, -1, -i}$ 同构于 $(\mathbb{Z}_4, +)$ 时，乘法单位元 $1$ 对应加法零元 $[0]$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;生成元个数计算&lt;/strong&gt;：$\phi(n)$ 计算公式为 $n \prod_{p \mid n} (1 - 1/p)$，例如 $\phi(20) = 20 \times (1 - 1/2) \times (1 - 1/5) = 8$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;9. 前后知识连接&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：群公理、阿贝尔群判定、元素阶引理（&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/&quot;&gt;01-群与子群.md&lt;/a&gt;）、初等数论（带余除法、欧几里得引理、欧拉函数）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;循环群分类定理给出了最标准的群同构原型，为商群与自然同态（&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态.md&lt;/a&gt;）提供基础模型。&lt;/li&gt;
&lt;li&gt;素数阶必循环的推论在 Lagrange 定理推论（&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群.md&lt;/a&gt;）中由因数整除性直接导出。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与证明套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（易错点 5、易错点 6；模板 4 带余除法最小正整数法证明循环性）。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>05-三大同构定理</title><link>https://sanzenin.top/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/</guid><description>设 是群同态。则： 1. 是群 的正规子群（ ）； 2. 商群 与同态像 同构： 特别地，如果 是满同态（即 ），则有： 同态映射会在目标群中产生重叠与压缩。代数证明表明，原群中映射到同一个像点的所有元素，恰好构成核的正规陪集 。商群 将这些具有相同像点的陪集视为单个元素，从而消除了原同态中的重叠现象，诱导出与同态像之</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;05-三大同构定理&lt;/h1&gt;
&lt;h2&gt;1. 群同态基本定理（第一同构定理）&lt;/h2&gt;
&lt;h3&gt;1.1 严格表述与定理&lt;/h3&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$\operatorname{Ker}f$ 是群 $G$ 的正规子群（$\operatorname{Ker}f \triangleleft G$）；&lt;/li&gt;
&lt;li&gt;商群 $G/\operatorname{Ker}f$ 与同态像 $\operatorname{Im}f$ 同构：
$$G/\operatorname{Ker}f \cong \operatorname{Im}f$$&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;特别地，如果 $f$ 是满同态（即 $\operatorname{Im}f = G&apos;$），则有：
$$G/\operatorname{Ker}f \cong G&apos;$$&lt;/p&gt;
&lt;h3&gt;1.2 数学直觉&lt;/h3&gt;
&lt;p&gt;同态映射会在目标群中产生重叠与压缩。代数证明表明，原群中映射到同一个像点的所有元素，恰好构成核的正规陪集 $a\operatorname{Ker}f$。商群 $G/\operatorname{Ker}f$ 将这些具有相同像点的陪集视为单个元素，从而消除了原同态中的重叠现象，诱导出与同态像之间的双射同构。&lt;/p&gt;
&lt;h3&gt;1.3 严格形式化证明&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
第 1 部分 $\operatorname{Ker}f \triangleleft G$ 已在定理 4.6 中证明，此处证明第 2 部分。
记 $K = \operatorname{Ker}f$。
定义从商群 $G/K$ 到像集 $\operatorname{Im}f$ 的映射：
$$\bar{f}: G/K \to \operatorname{Im}f, \quad \bar{f}(aK) = f(a) \quad (\forall a \in G)$$&lt;/p&gt;
&lt;p&gt;逐步验证以下四项：&lt;/p&gt;
&lt;h4&gt;步骤 1：验证映射良定性（Well-defined）&lt;/h4&gt;
&lt;p&gt;设 $aK = bK \in G/K$。
由定理 3.2，$a^{-1}b \in K = \operatorname{Ker}f$。
由同态核定义：
$$f(a^{-1}b) = e&apos;$$
利用同态保持运算与逆元性质：
$$(f(a))^{-1} f(b) = e&apos; \implies f(a) = f(b)$$
因此：
$$\bar{f}(aK) = f(a) = f(b) = \bar{f}(bK)$$
映射结果与代表元的选择无关，$\bar{f}$ 是良定的。&lt;/p&gt;
&lt;h4&gt;步骤 2：验证映射是单射（Injective）&lt;/h4&gt;
&lt;p&gt;设 $aK, bK \in G/K$，且满足：
$$\bar{f}(aK) = \bar{f}(bK) \implies f(a) = f(b)$$
在群 $G&apos;$ 中两边左乘 $(f(a))^{-1}$：
$$(f(a))^{-1} f(b) = e&apos; \implies f(a^{-1}b) = e&apos;$$
由同态核定义：
$$a^{-1}b \in \operatorname{Ker}f = K$$
由定理 3.2，推得：
$$aK = bK$$
故 $\bar{f}$ 是单射。&lt;/p&gt;
&lt;h4&gt;步骤 3：验证映射是满射（Surjective）&lt;/h4&gt;
&lt;p&gt;任取 $y \in \operatorname{Im}f$。
由像集定义，存在 $a \in G$ 使得 $f(a) = y$。
选取陪集元素 $aK \in G/K$，代入映射规则：
$$\bar{f}(aK) = f(a) = y$$
因此像集中的每一个元素都存在原像，$\bar{f}$ 是满射。&lt;/p&gt;
&lt;h4&gt;步骤 4：验证映射保持群运算（Homomorphism）&lt;/h4&gt;
&lt;p&gt;任取 $aK, bK \in G/K$。
利用商群的乘法定义 $(aK)(bK) = (ab)K$，以及 $f$ 本身的同态性质：
$$\bar{f}((aK)(bK)) = \bar{f}((ab)K) = f(ab) = f(a)f(b) = \bar{f}(aK)\bar{f}(bK)$$
故 $\bar{f}$ 保持乘法运算。&lt;/p&gt;
&lt;p&gt;综合以上四步，$\bar{f}$ 是 $G/K$ 到 $\operatorname{Im}f$ 的双射同态（群同构）。
因此：
$$G/\operatorname{Ker}f \cong \operatorname{Im}f \quad \blacksquare$$&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;1.4 五大经典应用实例&lt;/h3&gt;
&lt;p&gt;利用同态基本定理证明 $G/N \cong H$ 的标准方法是：构造从 $G$ 到 $H$ 的满同态 $f$，并验证 $\operatorname{Ker}f = N$。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;序号&lt;/th&gt;
&lt;th&gt;经典实例&lt;/th&gt;
&lt;th&gt;满同态构造 $f$&lt;/th&gt;
&lt;th&gt;同态核 $\operatorname{Ker}f$&lt;/th&gt;
&lt;th&gt;同构结论&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;1&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;整数模运算&lt;/td&gt;
&lt;td&gt;$f: \mathbb{Z} \to \mathbb{Z}_m, \ f(n) = [n]$&lt;/td&gt;
&lt;td&gt;$m\mathbb{Z}$&lt;/td&gt;
&lt;td&gt;$\mathbb{Z}/m\mathbb{Z} \cong \mathbb{Z}_m$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;2&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;实数乘法正负符号&lt;/td&gt;
&lt;td&gt;$f: \mathbb{R}^* \to ({1, -1}, \cdot), \ f(x) = \frac{x}{|x|}$&lt;/td&gt;
&lt;td&gt;$\mathbb{R}^+$（正实数乘法群）&lt;/td&gt;
&lt;td&gt;$\mathbb{R}^*/\mathbb{R}^+ \cong ({1, -1}, \cdot) \cong \mathbb{Z}_2$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;3&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;复平面单位圆缠绕&lt;/td&gt;
&lt;td&gt;$f: \mathbb{R} \to S^1, \ f(x) = \mathrm{e}^{2\pi \mathrm{i} x}$&lt;/td&gt;
&lt;td&gt;$\mathbb{Z}$（所有周期整点）&lt;/td&gt;
&lt;td&gt;$\mathbb{R}/\mathbb{Z} \cong S^1$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;4&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;矩阵行列式群&lt;/td&gt;
&lt;td&gt;$f: \mathrm{GL}_n(\mathbb{R}) \to \mathbb{R}^*, \ f(A) = \det(A)$&lt;/td&gt;
&lt;td&gt;$\mathrm{SL}_n(\mathbb{R})$（行列式为 1 的矩阵群）&lt;/td&gt;
&lt;td&gt;$\mathrm{GL}_n(\mathbb{R})/\mathrm{SL}_n(\mathbb{R}) \cong \mathbb{R}^*$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;5&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;置换符号映射（$n\ge2$）&lt;/td&gt;
&lt;td&gt;$f: S_n \to ({1, -1}, \cdot), \ f(\sigma) = \operatorname{sgn}(\sigma)$&lt;/td&gt;
&lt;td&gt;$A_n$（全体偶置换构成的交代群）&lt;/td&gt;
&lt;td&gt;$S_n/A_n \cong \mathbb{Z}_2$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 第二同构定理（菱形同构定理 / Diamond Isomorphism Theorem）&lt;/h2&gt;
&lt;h3&gt;2.1 严格表述与定理&lt;/h3&gt;
&lt;p&gt;设 $G$ 是群，$H \le G$ 是 $G$ 的子群，$N \triangleleft G$ 是 $G$ 的正规子群。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;乘积集 $HN$ 是 $G$ 的子群（$HN \le G$），且 $N \triangleleft HN$；&lt;/li&gt;
&lt;li&gt;交集 $H \cap N$ 是 $H$ 的正规子群（$H \cap N \triangleleft H$）；&lt;/li&gt;
&lt;li&gt;存在自然同构：
$$HN/N \cong H/(H \cap N)$$&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    HN[&quot;HN (顶端乘积子群)&quot;]
    H[&quot;H (左侧普通子群)&quot;]
    N[&quot;N (右侧正规子群)&quot;]
    HN_CAP[&quot;H ∩ N (底端交集子群)&quot;]

    HN --- H
    HN --- N
    H --- HN_CAP
    N --- HN_CAP
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.2 形式化证明&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;证明步骤 1：证明 $HN \le G$ 且 $N \triangleleft HN$&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$e = ee \in HN \implies HN \ne \emptyset$。&lt;/li&gt;
&lt;li&gt;任取 $x_1, x_2 \in HN$，设 $x_1 = h_1 n_1, x_2 = h_2 n_2$（$h_i \in H, n_i \in N$）。
$$x_1 x_2^{-1} = (h_1 n_1)(n_2^{-1} h_2^{-1}) = h_1 (n_1 n_2^{-1}) h_2^{-1}$$
记 $n_3 = n_1 n_2^{-1} \in N$。因为 $N \triangleleft G$，对全群共轭封闭，故：
$$n_3 h_2^{-1} = h_2^{-1} (h_2 n_3 h_2^{-1}) = h_2^{-1} n_4, \quad \text{其中 } n_4 \in N$$
代入得：
$$x_1 x_2^{-1} = h_1 (h_2^{-1} n_4) = (h_1 h_2^{-1}) n_4$$
因为 $h_1 h_2^{-1} \in H, n_4 \in N$，所以 $x_1 x_2^{-1} \in HN$。由定理 1.8（一步判定法），$HN \le G$。&lt;/li&gt;
&lt;li&gt;对任意 $n \in N$，有 $n = e n \in HN$，故包含关系 $N \subseteq HN$ 成立。对任意 $x = hn \in HN$ 及 $n_0 \in N$：
$$x n_0 x^{-1} = (hn) n_0 (hn)^{-1} = h (n n_0 n^{-1}) h^{-1}$$
因为 $N \triangleleft G$，所以 $n n_0 n^{-1} \in N$ 且 $h (n n_0 n^{-1}) h^{-1} \in N$。故 $x n_0 x^{-1} \in N$。因此 $N \triangleleft HN$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;证明步骤 2：利用第一同构定理证明同构&lt;/strong&gt;
定义映射：
$$\phi: H \to HN/N, \quad \phi(h) = hN \quad (\forall h \in H)$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：任取 $h_1, h_2 \in H$。
$$\phi(h_1 h_2) = (h_1 h_2)N = (h_1 N)(h_2 N) = \phi(h_1)\phi(h_2)$$
故 $\phi$ 是群同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：任取商群 $HN/N$ 中的元素 $y$。
根据乘积集定义，$y = (hn)N$（其中 $h \in H, n \in N$）。
因为 $n \in N \implies nN = N$，由陪集性质：
$$(hn)N = h(nN) = hN = \phi(h)$$
这说明商群中的每一个陪集都能在 $H$ 中找到原像，故 $\phi$ 是满射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求解同态核 $\operatorname{Ker}\phi$&lt;/strong&gt;：
商群 $HN/N$ 的单位元是陪集 $N$。
$$\operatorname{Ker}\phi = {h \in H \mid \phi(h) = N} = {h \in H \mid hN = N}$$
由定理 3.1，$hN = N \iff h \in N$。
因此：
$$\operatorname{Ker}\phi = {h \in H \mid h \in N} = H \cap N$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;得出结论&lt;/strong&gt;：
因为 $\phi: H \to HN/N$ 是满同态，且 $\operatorname{Ker}\phi = H \cap N$。
由群同态基本定理（定理 5.1），直接得出：
$$H \cap N \triangleleft H \quad \text{且} \quad H/(H \cap N) \cong HN/N \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;2.3 最小例子&lt;/h3&gt;
&lt;p&gt;在克莱因四元群 $K_4 = {e, a, b, c}$ 中，所有子群均为正规子群。
取 $H = {e, a}, N = {e, b}$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;乘积群 $HN = {e, a, b, ab} = {e, a, b, c} = K_4$；&lt;/li&gt;
&lt;li&gt;交集 $H \cap N = {e}$；&lt;/li&gt;
&lt;li&gt;代入第二同构定理：
$$HN/N = K_4 / {e, b} \cong \mathbb{Z}_2$$
$$H / (H \cap N) = {e, a} / {e} \cong {e, a} \cong \mathbb{Z}_2$$
两边阶数均为 2，结构相同。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 第三同构定理（商群约分定理）&lt;/h2&gt;
&lt;h3&gt;3.1 严格表述与定理&lt;/h3&gt;
&lt;p&gt;设 $H, K$ 都是群 $G$ 的正规子群，且满足包含关系 $K \subseteq H \subseteq G$。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$H/K$ 是商群 $G/K$ 的正规子群（$H/K \triangleleft G/K$）；&lt;/li&gt;
&lt;li&gt;存在自然同构：
$$(G/K) / (H/K) \cong G/H$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;3.2 形式化证明&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
构造从商群 $G/K$ 到商群 $G/H$ 的映射：
$$f: G/K \to G/H, \quad f(aK) = aH \quad (\forall a \in G)$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;良定性&lt;/strong&gt;：
设 $aK = bK$。由定理 3.2，$a^{-1}b \in K$。
因为已知 $K \subseteq H$，所以 $a^{-1}b \in H$。
由定理 3.2，推得 $aH = bH$，即 $f(aK) = f(bK)$。
故映射 $f$ 良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：
任取 $aK, bK \in G/K$：
$$f((aK)(bK)) = f(abK) = abH = (aH)(bH) = f(aK)f(bK)$$
故 $f$ 是同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：
对任意 $aH \in G/H$，取 $aK \in G/K$ 即可得到 $f(aK) = aH$。故 $f$ 是满射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求解同态核 $\operatorname{Ker}f$&lt;/strong&gt;：
商群 $G/H$ 的单位元是陪集 $H$。
$$\operatorname{Ker}f = {aK \in G/K \mid f(aK) = H} = {aK \in G/K \mid aH = H}$$
在群中，$aH = H \iff a \in H$。因此：
$$\operatorname{Ker}f = {aK \in G/K \mid a \in H} = H/K$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;套用第一同构定理&lt;/strong&gt;：
因为 $f: G/K \to G/H$ 是满同态，且 $\operatorname{Ker}f = H/K$。
由群同态基本定理直接得出：
$$H/K \triangleleft G/K \quad \text{且} \quad (G/K)/(H/K) \cong G/H \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;3.3 最小例子与计算实例&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;整数加群的连续商群&lt;/strong&gt;：
取 $G = \mathbb{Z}$，$H = 2\mathbb{Z}$（偶数群），$K = 6\mathbb{Z}$（6 的倍数群）。
包含关系 $6\mathbb{Z} \subseteq 2\mathbb{Z} \subseteq \mathbb{Z}$ 成立。
&lt;ul&gt;
&lt;li&gt;$G/K = \mathbb{Z}/6\mathbb{Z} = \mathbb{Z}_6 = {[0], [1], [2], [3], [4], [5]}$；&lt;/li&gt;
&lt;li&gt;$H/K = 2\mathbb{Z}/6\mathbb{Z} = {[0], [2], [4]} \le \mathbb{Z}_6$；&lt;/li&gt;
&lt;li&gt;商群 $\mathbb{Z}_6 / {[0], [2], [4]}$ 的阶为 $6/3 = 2$；&lt;/li&gt;
&lt;li&gt;代入第三同构定理：
$$\frac{\mathbb{Z}/6\mathbb{Z}}{2\mathbb{Z}/6\mathbb{Z}} \cong \frac{\mathbb{Z}}{2\mathbb{Z}} \cong \mathbb{Z}_2$$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 满同态下的正规性保持定理&lt;/h2&gt;
&lt;h3&gt;4.1 严格表述与定理&lt;/h3&gt;
&lt;h4&gt;定理 5.2&lt;/h4&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群的&lt;strong&gt;满同态&lt;/strong&gt;。若 $N \triangleleft G$，则其同态像也是目标群的正规子群：
$$f(N) \triangleleft G&apos;$$&lt;/p&gt;
&lt;h3&gt;4.2 形式化证明&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
由定理 4.6(1)，子群的同态像仍为子群，故 $f(N) \le G&apos;$。
验证正规性：任取 $y \in G&apos;$，以及任意 $x \in f(N)$。
需证明：
$$y x y^{-1} \in f(N)$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;因为 $f$ 是满射，对任意 $y \in G&apos;$，存在 $g \in G$ 使得 $f(g) = y$；&lt;/li&gt;
&lt;li&gt;因为 $x \in f(N)$，由像集定义，存在 $n \in N$ 使得 $f(n) = x$。
代入共轭式中，利用群同态保持运算与求逆的性质：
$$y x y^{-1} = f(g) f(n) (f(g))^{-1} = f(g) f(n) f(g^{-1}) = f(g n g^{-1})$$
因为已知 $N \triangleleft G$，对任意 $g \in G, n \in N$，必有：
$$g n g^{-1} \in N$$
因此，其像点 $f(g n g^{-1})$ 属于集合 $f(N)$：
$$y x y^{-1} = f(g n g^{-1}) \in f(N)$$
由正规子群定义，$f(N) \triangleleft G&apos;$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!WARNING] 条件反例：非满同态不成立
若 $f$ 不是满射，结论不成立。
反例：取包含映射 $i: H \to G$（其中 $H \le G$ 且 $H$ 不是 $G$ 的正规子群）。$H \triangleleft H$ 在自身中是正规的，但 $i(H) = H$ 在群 $G$ 中不是正规子群。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 核心易错点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态基本定理证明的良定性前提&lt;/strong&gt;：定义 $\bar{f}(aK) = f(a)$ 时，必须优先证明代表元选取无关性，否则映射不成立。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第二同构定理的正规子群位置&lt;/strong&gt;：第二同构定理要求至少有一个子群是正规子群（$N \triangleleft G$）；若两个均仅为普通子群，乘积 $HN$ 甚至不是子群。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第三同构定理的包含链&lt;/strong&gt;：必须满足 $K \subseteq H \subseteq G$ 且两者均正规，才能构成商群之间的同构。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;定理 5.2 对满射的依赖&lt;/strong&gt;：正规性取决于全群环境，只有满同态才能保证任意共轭元素 $y$ 存在原像 $g$ 来调动母群正规性。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 前后知识连接&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：商集与映射分解（&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;）、商群乘法良定性、同态核正规性、单同态核判据（&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态.md&lt;/a&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;第一同构定理是证明内自同构群定理 $G/Z(G) \cong \operatorname{Inn}(G)$（&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley.md&lt;/a&gt;）的核心工具。&lt;/li&gt;
&lt;li&gt;第一同构定理是近世代数中判定商代数系统同构结构的普适方法。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与证明套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（模板 2 第一同构定理构建商群同构四步法）。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>06-置换群-内自同构-Cayley</title><link>https://sanzenin.top/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/</guid><description>设 是一个非空集合。从 到 自身的一个双射（一一对应映射）称为 上的一个一一变换。 全体一一变换构成的集合记作 （或 ）。 当集合 时，从 到 的双射称为 次置换（Permutation）。 包含所有 次置换的集合记作 （或 ），称为 次对称群（Symmetric Group）。对称群 的任何一个子群都称为置换群。 在</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;06-置换群-内自同构-Cayley&lt;/h1&gt;
&lt;h2&gt;1. 对称群 $S_n$ 与一一变换群&lt;/h2&gt;
&lt;h3&gt;1.1 严格表述&lt;/h3&gt;
&lt;p&gt;设 $A$ 是一个非空集合。从 $A$ 到 $A$ 自身的一个双射（一一对应映射）称为 $A$ 上的一个&lt;strong&gt;一一变换&lt;/strong&gt;。
全体一一变换构成的集合记作 $E(A)$（或 $\operatorname{Sym}(A)$）。
当集合 $A = {1, 2, \dots, n}$ 时，从 $A$ 到 $A$ 的双射称为 &lt;strong&gt;$n$ 次置换（Permutation）&lt;/strong&gt;。
包含所有 $n$ 次置换的集合记作 $S_n$（或 $\operatorname{Sym}(n)$），称为 &lt;strong&gt;$n$ 次对称群（Symmetric Group）&lt;/strong&gt;。对称群 $S_n$ 的任何一个子群都称为&lt;strong&gt;置换群&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;1.2 运算方向约定&lt;/h3&gt;
&lt;p&gt;在置换的乘法（函数复合）中，本文遵循函数作用的标准次序——&lt;strong&gt;从右向左复合&lt;/strong&gt;：
$$(\sigma \tau)(x) := \sigma(\tau(x)), \quad \forall x \in A$$
即右侧置换 $\tau$ 先作用，左侧置换 $\sigma$ 后作用。&lt;/p&gt;
&lt;h3&gt;1.3 形式化证明：$E(A)$ 在映射复合下构成群&lt;/h3&gt;
&lt;h4&gt;定理 6.1&lt;/h4&gt;
&lt;p&gt;设 $A$ 是非空集合，代数系统 $(E(A), \circ)$ 构成一个群。特别地，对称群 $S_n$ 构成阶为 $n!$ 的有限群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;封闭性&lt;/strong&gt;：任取 $\sigma, \tau \in E(A)$。
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;单射&lt;/strong&gt;：若 $(\sigma \circ \tau)(x_1) = (\sigma \circ \tau)(x_2) \implies \sigma(\tau(x_1)) = \sigma(\tau(x_2))$。因 $\sigma$ 为单射，故 $\tau(x_1) = \tau(x_2)$；又因 $\tau$ 为单射，故 $x_1 = x_2$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射&lt;/strong&gt;：任取 $z \in A$。因 $\sigma$ 为满射，存在 $y \in A$ 使得 $\sigma(y) = z$；因 $\tau$ 为满射，存在 $x \in A$ 使得 $\tau(x) = y$。从而 $(\sigma \circ \tau)(x) = \sigma(\tau(x)) = \sigma(y) = z$。
故 $\sigma \circ \tau$ 仍为双射，$\sigma \circ \tau \in E(A)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结合律&lt;/strong&gt;：映射复合满足结合律：$&lt;a href=&quot;x&quot;&gt;(\sigma \circ \tau) \circ \mu&lt;/a&gt; = \sigma(\tau(\mu(x))) = &lt;a href=&quot;x&quot;&gt;\sigma \circ (\tau \circ \mu)&lt;/a&gt;$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单位元&lt;/strong&gt;：恒等映射 $I_A(x) = x$ 为双射，且满足 $\sigma \circ I_A = I_A \circ \sigma = \sigma$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;逆元&lt;/strong&gt;：因 $\sigma$ 是双射，其反函数 $\sigma^{-1}: A \to A$ 存在且同为双射，满足 $\sigma \circ \sigma^{-1} = \sigma^{-1} \circ \sigma = I_A$。
综上，$(E(A), \circ)$ 构成群。
当 $|A| = n$ 时，集合 $A$ 到自身的不同双射总数等于 $n$ 个元素的全排列数 $n!$，故 $|S_n| = n!$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 循环置换（轮换）与不相交分解&lt;/h2&gt;
&lt;h3&gt;2.1 循环置换的定义&lt;/h3&gt;
&lt;p&gt;设 $\sigma \in S_n$。若存在互不相同的下标序列 $(j_1, j_2, \dots, j_r)$（$r \ge 2$），使得：
$$\sigma(j_1) = j_2, \quad \sigma(j_2) = j_3, \quad \dots, \quad \sigma(j_r) = j_1$$
并且对不属于该序列的其余元素 $k$ 均有 $\sigma(k) = k$，则称 $\sigma$ 为一个 &lt;strong&gt;$r$ 项循环置换（或长为 $r$ 的轮换）&lt;/strong&gt;，记作：
$$\sigma = (j_1\ j_2\ \dots\ j_r)$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;长为 2 的轮换称为&lt;strong&gt;对换（Transposition）&lt;/strong&gt;，记作 $(a\ b)$。&lt;/li&gt;
&lt;li&gt;若两个轮换包含变动的数字完全无交集，称它们&lt;strong&gt;互不相交（Disjoint）&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;2.2 不相交轮换的可交换性&lt;/h3&gt;
&lt;h4&gt;定理 6.2&lt;/h4&gt;
&lt;p&gt;若 $\alpha, \beta \in S_n$ 是两个互不相交的循环置换，则它们可以交换次序：
$$\alpha \beta = \beta \alpha$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $\alpha$ 变动的数字集合为 $A$，$\beta$ 变动的数字集合为 $B$。已知 $A \cap B = \emptyset$。
对任意 $x \in {1, 2, \dots, n}$ 逐点讨论：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $x \in A$：因 $A \cap B = \emptyset$，故 $x \notin B$，得 $\beta(x) = x$。
从而 $(\alpha \beta)(x) = \alpha(\beta(x)) = \alpha(x)$。
又因 $\alpha(x) \in A$，故 $\alpha(x) \notin B$，得 $\beta(\alpha(x)) = \alpha(x)$。
因此 $(\alpha \beta)(x) = (\beta \alpha)(x) = \alpha(x)$。&lt;/li&gt;
&lt;li&gt;若 $x \in B$：同理可得 $(\alpha \beta)(x) = (\beta \alpha)(x) = \beta(x)$。&lt;/li&gt;
&lt;li&gt;若 $x \notin A$ 且 $x \notin B$：则 $\alpha(x) = x, \beta(x) = x$，显然 $(\alpha \beta)(x) = (\beta \alpha)(x) = x$。
综上，对所有元素均有 $(\alpha \beta)(x) = (\beta \alpha)(x)$，故 $\alpha \beta = \beta \alpha$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;2.3 不相交轮换分解定理与置换的阶&lt;/h3&gt;
&lt;h4&gt;定理 6.3（不相交轮换分解定理）&lt;/h4&gt;
&lt;p&gt;任何一个有限置换 $\sigma \in S_n$ 都可以唯一地表示为若干个互不相交且长度均 $\ge 2$ 的循环置换之积（在不计因式乘法先后次序的意义下）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;存在性&lt;/strong&gt;：对置换 $\sigma$ 实际变动的元素个数 $t = |{x \mid \sigma(x) \ne x}|$ 施加数学归纳法。
&lt;ul&gt;
&lt;li&gt;当 $t = 0$ 时，$\sigma = I$ 为恒等置换（空乘积），命题成立。&lt;/li&gt;
&lt;li&gt;假设变动元素个数 $&amp;lt; s$（$s \ge 1$）的所有置换均能分解为互不相交循环之积。&lt;/li&gt;
&lt;li&gt;考虑变动元素个数为 $s$ 的置换 $\sigma$。取变动元素 $j_1$，考察轨道序列 $j_1, \sigma(j_1), \sigma^2(j_1), \dots$。因集合有限，该序列必有重复项。设第一个满足 $\sigma^r(j_1) \in {j_1, \sigma(j_1), \dots, \sigma^{r-1}(j_1)}$ 的正整数为 $r$。&lt;/li&gt;
&lt;li&gt;若 $\sigma^r(j_1) = \sigma^i(j_1)$（$0 &amp;lt; i &amp;lt; r$），由单射性两边作用 $\sigma^{-1}$ 得 $\sigma^{r-1}(j_1) = \sigma^{i-1}(j_1)$，与 $r$ 的最小性矛盾。因此必有 $\sigma^r(j_1) = j_1$。&lt;/li&gt;
&lt;li&gt;定义循环 $\tau_1 = (j_1\ \sigma(j_1)\ \dots\ \sigma^{r-1}(j_1))$。令 $\sigma_1 = \sigma \tau_1^{-1}$，则 $\sigma_1$ 在 ${j_1, \dots, \sigma^{r-1}(j_1)}$ 上恒等，实际变动元素个数为 $s - r &amp;lt; s$。&lt;/li&gt;
&lt;li&gt;由归纳假设，$\sigma_1$ 可分解为与 $\tau_1$ 均不相交的循环之积 $\tau_2 \cdots \tau_k$。故 $\sigma = \tau_1 \tau_2 \cdots \tau_k$。存在性得证。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;唯一性&lt;/strong&gt;：设 $\sigma = \tau_1 \cdots \tau_k = \rho_1 \cdots \rho_m$ 为两组互不相交循环之积（每项长 $\ge 2$）。
任取变动元素 $x$。在第一组分解中，$x$ 恰好属于唯一的循环（不妨设为 $\tau_1$），且对所有整数 $d$ 有 $\sigma^d(x) = \tau_1^d(x)$。
在第二组分解中，$x$ 也必属于唯一的循环（不妨设为 $\rho_1$），同理对所有整数 $d$ 有 $\sigma^d(x) = \rho_1^d(x)$。
因此 $\tau_1$ 与 $\rho_1$ 的轨道集合都是 ${\sigma^d(x) \mid d \ge 0}$，且其在循环中的轮换作用完全由 $\sigma$ 在该轨道上的映射确定。故 $\tau_1$ 与 $\rho_1$ 作为置换完全相等（至多循环内部起点写法不同）。
两边消去 $\tau_1 = \rho_1$ 并对变动元素集合重复上述论证，最终可得 $k = m$ 且两组循环因子集合完全一致。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;定理 6.4（置换求阶公式）&lt;/h4&gt;
&lt;p&gt;设置换 $\sigma$ 分解为互不相交循环之积 $\sigma = \tau_1 \tau_2 \cdots \tau_k$，其中各循环的长度分别为 $r_1, r_2, \dots, r_k$。则置换 $\sigma$ 的阶为：
$$\operatorname{ord}(\sigma) = \operatorname{lcm}(r_1, r_2, \dots, r_k)$$&lt;/p&gt;
&lt;p&gt;约定空列表的 LCM 为 1，对应恒等置换的阶。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
因各循环 $\tau_i$ 互不相交，由定理 6.2 它们两两可交换。
因此对任意正整数 $m$：$\sigma^m = \tau_1^m \tau_2^m \cdots \tau_k^m$。
又因各循环作用的变动集合互不相交，$\sigma^m = I \iff \forall i \in {1, \dots, k}, \tau_i^m = I$。
单个长为 $r_i$ 的循环其阶等于长度 $r_i$，即 $\operatorname{ord}(\tau_i) = r_i$。
由阶的整除性质，$\tau_i^m = I \iff r_i \mid m$。
使得所有 $r_i \mid m$ 成立的最小正整数 $m$ 即为最小公倍数 $\operatorname{lcm}(r_1, \dots, r_k)$。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 对换、奇偶置换与交代群 $A_n$&lt;/h2&gt;
&lt;h3&gt;3.1 任意置换的对换分解&lt;/h3&gt;
&lt;h4&gt;定理 6.5&lt;/h4&gt;
&lt;p&gt;当 $n \ge 2$ 时，任何置换都可以表示为有限个对换的乘积。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
由定理 6.3，只需证明任意轮换均能分解为对换之积即可。
直接验证公式：
$$(j_1\ j_2\ \dots\ j_r) = (j_1\ j_r)(j_1\ j_{r-1}) \cdots (j_1\ j_3)(j_1\ j_2)$$
从右向左依次复合追踪各元素：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$j_1 \mapsto j_2$（最右侧对换将 $j_1$ 变到 $j_2$，其余对换均不动 $j_2$）；&lt;/li&gt;
&lt;li&gt;$j_k \mapsto j_1 \mapsto j_{k+1}$（第 $k-1$ 个对换将 $j_k$ 变到 $j_1$，紧接着第 $k$ 个对换将 $j_1$ 变到 $j_{k+1}$）；&lt;/li&gt;
&lt;li&gt;$j_r \mapsto j_1$（最左侧对换将 $j_r$ 变到 $j_1$）。
映射结果与 $(j_1\ j_2\ \dots\ j_r)$ 完全相同。一个长为 $r$ 的循环可分解为 $r - 1$ 个对换。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3.2 对换个数奇偶性不变量定理&lt;/h3&gt;
&lt;p&gt;置换分解为对换的乘积方式并不唯一，但分解所得对换个数的奇偶性是客观不变量。&lt;/p&gt;
&lt;h4&gt;定理 6.6（对换奇偶性不变量定理）&lt;/h4&gt;
&lt;p&gt;设置换 $\sigma \in S_n$。若 $\sigma$ 既能表示为 $k$ 个对换之积，又能表示为 $m$ 个对换之积，则 $k \equiv m \pmod 2$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
考虑 $n$ 元多项式（差分多项式）：
$$\Delta(x_1, x_2, \dots, x_n) = \prod_{1 \le i &amp;lt; j \le n} (x_j - x_i)$$
对任意置换 $\sigma \in S_n$，定义其对多项式的变量置换作用为：
$$\sigma(\Delta) = \prod_{1 \le i &amp;lt; j \le n} (x_{\sigma(j)} - x_{\sigma(i)})$$
因 $\sigma$ 为双射，${ {\sigma(i), \sigma(j)} \mid 1 \le i &amp;lt; j \le n }$ 遍历了全集合的所有两元子集。故乘积中的每一个因子 $x_{\sigma(j)} - x_{\sigma(i)}$ 在绝对值上对应原本的某个因子 $x_q - x_p$（$p &amp;lt; q$），仅差符号。
因此必存在常数 $c_\sigma \in {1, -1}$，使得 $\sigma(\Delta) = c_\sigma \Delta$。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性质&lt;/strong&gt;：对任意 $\sigma, \tau \in S_n$：
$$(\sigma \tau)(\Delta) = \sigma(\tau(\Delta)) = \sigma(c_\tau \Delta) = c_\tau \sigma(\Delta) = c_\tau c_\sigma \Delta = (c_\sigma c_\tau) \Delta$$
因此 $c_{\sigma \tau} = c_\sigma c_\tau$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;计算单个对换的符号常数&lt;/strong&gt;：
考虑任意对换 $\rho = (s\ t)$（设 $1 \le s &amp;lt; t \le n$）。考察乘积中各因式 $(x_j - x_i)$（$i &amp;lt; j$）在 $\rho$ 作用下的符号变化：
&lt;ul&gt;
&lt;li&gt;若 ${i, j} \cap {s, t} = \emptyset$，因子不变；&lt;/li&gt;
&lt;li&gt;对因子 $(x_t - x_s)$，作用后变为 $x_s - x_t = -(x_t - x_s)$，符号反转一次；&lt;/li&gt;
&lt;li&gt;对满足 $s &amp;lt; k &amp;lt; t$ 的每个 $k$：
因子 $x_k - x_s$ 变为 $x_k - x_t = -(x_t - x_k)$；
因子 $x_t - x_k$ 变为 $x_s - x_k = -(x_k - x_s)$；
这两个因子均反号，其乘积不变号；这样的中间元素共有 $t - s - 1$ 个，产生 $2(t - s - 1)$ 次变号；&lt;/li&gt;
&lt;li&gt;对 $k &amp;lt; s$ 或 $k &amp;gt; t$ 的元素，同样成对保持符号不变。
综上，受对换 $\rho$ 作用反号的因子总数为 $1 + 2(t - s - 1)$，恒为奇数。
因此对任意对换 $\rho$，均有 $c_\rho = -1$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;完成证明&lt;/strong&gt;：
若 $\sigma = \tau_1 \tau_2 \cdots \tau_k = \rho_1 \rho_2 \cdots \rho_m$（各 $\tau_i, \rho_j$ 均为对换），则：
$$c_\sigma = (-1)^k = (-1)^m$$
从而 $(-1)^k = (-1)^m \implies k \equiv m \pmod 2$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;3.3 奇偶置换与交代群 $A_n$&lt;/h3&gt;
&lt;h4&gt;定义 6.7&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;能表示为&lt;strong&gt;偶数个&lt;/strong&gt;对换之积的置换称为&lt;strong&gt;偶置换&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;能表示为&lt;strong&gt;奇数个&lt;/strong&gt;对换之积的置换称为&lt;strong&gt;奇置换&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;由定理 6.5，长为 $r$ 的循环可分解为 $r - 1$ 个对换。因此：长度为奇数的循环是偶置换，长度为偶数的循环是奇置换。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;定理 6.8（交代群的子群性质与阶数）&lt;/h4&gt;
&lt;p&gt;$S_n$ 中全体偶置换构成的集合关于置换乘法构成一个群，称为 &lt;strong&gt;$n$ 次交代群（Alternating Group）&lt;/strong&gt;，记作 $A_n$。
当 $n \ge 2$ 时，其阶数为：
$$|A_n| = \frac{n!}{2}$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;子群性质&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;单位元 $I$ 是零个对换的乘积（空乘积），故 $I \in A_n$。&lt;/li&gt;
&lt;li&gt;设 $\sigma$ 含偶数 $2k$ 个对换，$\tau$ 含偶数 $2m$ 个对换，则 $\sigma\tau$ 含 $2k + 2m$ 个对换，仍为偶数，故封闭。&lt;/li&gt;
&lt;li&gt;$\sigma^{-1} = (\tau_1 \cdots \tau_{2k})^{-1} = \tau_{2k} \cdots \tau_1$ 包含 $2k$ 个对换，故 $\sigma^{-1} \in A_n$。因此 $A_n \le S_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;阶数证明&lt;/strong&gt;：
设 $S_n$ 中全体奇置换构成的集合为 $B_n$。固定对换 $\rho = (1\ 2)$。
定义映射 $f: A_n \to B_n, f(\sigma) = \rho \sigma$。
&lt;ul&gt;
&lt;li&gt;偶置换左乘一个对换变为奇置换，映射良定。&lt;/li&gt;
&lt;li&gt;单射性：若 $\rho \sigma_1 = \rho \sigma_2$，左乘 $\rho^{-1}$ 即得 $\sigma_1 = \sigma_2$。&lt;/li&gt;
&lt;li&gt;满射性：对任意 $\mu \in B_n$，$\rho \mu$ 为偶置换（$\rho \mu \in A_n$），且 $f(\rho \mu) = \rho^2 \mu = \mu$。
故 $f$ 是双射，从而 $|A_n| = |B_n|$。
又因 $S_n = A_n \cup B_n$ 且 $A_n \cap B_n = \emptyset$，故 $|A_n| + |B_n| = n! \implies |A_n| = \frac{n!}{2}$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 3-轮换生成交代群定理&lt;/h2&gt;
&lt;h4&gt;定理 6.9&lt;/h4&gt;
&lt;p&gt;当 $n \ge 3$ 时，$n$ 次交代群 $A_n$ 是由全体 3-轮换生成的：
$$A_n = \langle (a\ b\ c) \mid a, b, c \in {1, 2, \dots, n} \rangle$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
任取 $\sigma \in A_n$。由偶置换定义，$\sigma$ 可以分解为偶数个对换的乘积：
$$\sigma = (\tau_1 \tau_2)(\tau_3 \tau_4) \cdots (\tau_{2k-1} \tau_{2k})$$
只需证明：&lt;strong&gt;任意两个对换的乘积 $\tau \rho$ 均可表示为 3-轮换或其乘积&lt;/strong&gt;。
设 $\tau = (a\ b), \rho = (c\ d)$。按涉及的互异元素个数分类讨论：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;重叠 2 个元素&lt;/strong&gt;（对换相同）：
$$(a\ b)(a\ b) = I = (a\ b\ c)(a\ c\ b)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;重叠 1 个元素&lt;/strong&gt;（不妨设公共元素为 $a$）：
从右向左复合验证：
$$(a\ b)(a\ c) = (a\ c\ b)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;重叠 0 个元素&lt;/strong&gt;（4 个元素 $a, b, c, d$ 互不相同）：
在中间插入 $(b\ c)(b\ c) = I$：
$$(a\ b)(c\ d) = (a\ b) \cdot [(b\ c)(b\ c)] \cdot (c\ d) = [(a\ b)(b\ c)] \cdot [(b\ c)(c\ d)]$$
利用情况 2 的结论：$[(a\ b)(b\ c)] = (a\ b\ c)$，$[(b\ c)(c\ d)] = (b\ c\ d)$。
因此：
$$(a\ b)(c\ d) = (a\ b\ c)(b\ c\ d)$$
为两个 3-轮换之积。
综合上述三种情形，任意两个对换之积均可表示为 3-轮换之积，故全体 3-轮换生成 $A_n$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 置换的共轭与循环型&lt;/h2&gt;
&lt;h3&gt;5.1 置换共轭的作用形式&lt;/h3&gt;
&lt;h4&gt;定理 6.10（置换共轭公式）&lt;/h4&gt;
&lt;p&gt;设 $\sigma = (i_1\ i_2\ \dots\ i_r)$ 是 $S_n$ 中的一个 $r$-循环，$\tau \in S_n$ 是任意置换。则共轭置换 $\tau \sigma \tau^{-1}$ 仍然是长为 $r$ 的循环，且形式为：
$$\tau \sigma \tau^{-1} = (\tau(i_1)\ \tau(i_2)\ \dots\ \tau(i_r))$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
对任意 $x \in {1, \dots, n}$ 计算 $(\tau \sigma \tau^{-1})(x)$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若 $x = \tau(i_k)$（$1 \le k \le r$）：
&lt;ul&gt;
&lt;li&gt;第一步：$\tau^{-1}(x) = i_k$；&lt;/li&gt;
&lt;li&gt;第二步：$\sigma(i_k) = i_{k+1}$（约定 $k=r$ 时下一项为 $i_1$）；&lt;/li&gt;
&lt;li&gt;第三步：$\tau(i_{k+1})$。
连起来得到 $(\tau \sigma \tau^{-1})(\tau(i_k)) = \tau(i_{k+1})$。这与循环 $(\tau(i_1)\ \dots\ \tau(i_r))$ 在元素 $\tau(i_k)$ 上的映射一致。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;若 $x \notin {\tau(i_1), \dots, \tau(i_r)}$：
则 $\tau^{-1}(x) \notin {i_1, \dots, i_r}$。
由定义 $\sigma(\tau^{-1}(x)) = \tau^{-1}(x)$。
再由左侧 $\tau$ 作用得 $\tau(\tau^{-1}(x)) = x$。即该元素保持不动。
综合两类情形，公式成立。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;5.2 循环型与共轭类分类定理&lt;/h3&gt;
&lt;p&gt;置换的不相交循环长度序列（包含长为 1 的不动点循环）称为该置换的&lt;strong&gt;循环型（Cycle Type）&lt;/strong&gt;。&lt;/p&gt;
&lt;h4&gt;定理 6.11（共轭类与循环型充要条件）&lt;/h4&gt;
&lt;p&gt;在对称群 $S_n$ 中，两个置换 $\sigma, \sigma&apos;$ 共轭当且仅当它们具有相同的循环型。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;必要性&lt;/strong&gt;：设存在 $\tau \in S_n$ 使得 $\sigma&apos; = \tau \sigma \tau^{-1}$。
将 $\sigma$ 写为不相交循环之积 $\sigma = \pi_1 \pi_2 \cdots \pi_k$。
由定理 6.10，$\sigma&apos; = \tau \pi_1 \tau^{-1} \cdot \tau \pi_2 \tau^{-1} \cdots \tau \pi_k \tau^{-1}$。
因 $\tau$ 是双射，每个循环 $\tau \pi_j \tau^{-1}$ 的长度与 $\pi_j$ 完全相同，且变动元素集合两两不相交。
故 $\sigma&apos;$ 与 $\sigma$ 具有完全相同的循环型。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性&lt;/strong&gt;：设 $\sigma$ 与 $\sigma&apos;$ 具有相同的循环型。
将两者的不相交循环分解（包括长度为 1 的不动点）按循环长度从大到小依次写出：
$$\sigma = (a_{1,1}\ \dots\ a_{1, r_1})(a_{2,1}\ \dots\ a_{2, r_2}) \cdots (a_{m,1}\ \dots\ a_{m, r_m})$$
$$\sigma&apos; = (b_{1,1}\ \dots\ b_{1, r_1})(b_{2,1}\ \dots\ b_{2, r_2}) \cdots (b_{m,1}\ \dots\ b_{m, r_m})$$
其中 $\sum_{i=1}^m r_i = n$，且 ${a_{i,j}}$ 与 ${b_{i,j}}$ 分别构成了集合 ${1, 2, \dots, n}$ 的完整排列。
定义映射 $\tau: {1, \dots, n} \to {1, \dots, n}$ 为：
$$\tau(a_{i, j}) = b_{i, j} \quad (1 \le i \le m, 1 \le j \le r_i)$$
因 $\tau$ 将全集的一个全排列映为另一个全排列，故 $\tau$ 是双射，$\tau \in S_n$。
由定理 6.10：
$$\tau \sigma \tau^{-1} = (\tau(a_{1,1})\ \dots\ \tau(a_{1, r_1})) \cdots (\tau(a_{m,1})\ \dots\ \tau(a_{m, r_m})) = \sigma&apos;$$
故 $\sigma$ 与 $\sigma&apos;$ 在 $S_n$ 中共轭。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 【选读】单群与 $A_5$ 的单群性&lt;/h2&gt;
&lt;h3&gt;6.1 单群（Simple Group）的定义&lt;/h3&gt;
&lt;p&gt;如果非平凡群 $G\ne{e}$ 除了平凡子群 ${e}$ 和其自身 $G$ 之外，&lt;strong&gt;不存在任何其他正规子群&lt;/strong&gt;，则称群 $G$ 为&lt;strong&gt;单群（Simple Group）&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;6.2 交代群 $A_5$ 的单群性（依赖群作用与共轭类划分）&lt;/h3&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;依赖声明&lt;/strong&gt;：本小节引用 $A_5$ 的完整共轭类分解 $1, 15, 20, 12, 12$（包括 3-轮换、双对换各自形成单个 $A_5$ 共轭类，以及 5-轮换分裂）作为外部结论。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h4&gt;结论 6.12&lt;/h4&gt;
&lt;p&gt;5 次交代群 $A_5$（阶数为 60）是一个单群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;推导过程：&lt;/strong&gt;
设 $N \triangleleft A_5$ 为正规子群。正规子群对共轭运算封闭，因此 $N$ 必定是由 $A_5$ 内部若干个完整的共轭类构成的并集，且必须包含单位元类。
$A_5$ 中 60 个元素划分为 5 个共轭类：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;单位元类 $C_1$：大小为 $1$；&lt;/li&gt;
&lt;li&gt;双对换类 $C_{2,2}$（形如 $(a\ b)(c\ d)$）：大小为 $\frac{\binom{5}{4} \times 3}{1} = 15$；&lt;/li&gt;
&lt;li&gt;3-轮换类 $C_3$（形如 $(a\ b\ c)$）：大小为 $\binom{5}{3} \times 2 = 20$；&lt;/li&gt;
&lt;li&gt;5-轮换类在 $A_5$ 中分裂为两个类 $C_5&apos;, C_5&apos;&apos;$：大小各为 $12$。
总计：$1 + 15 + 20 + 12 + 12 = 60$。
若存在正规子群 $N$，其阶数 $|N|$ 必须满足以下两个条件：&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;$|N| = 1 + 15 a + 20 b + 12 c + 12 d$（其中 $a, b, c, d \in {0, 1}$）；&lt;/li&gt;
&lt;li&gt;由 Lagrange 定理，$|N| \mid 60$。
逐一检查所有非空选择组合的和：&lt;/li&gt;
&lt;li&gt;取 1 个非单位元类：$1+12=13, 1+15=16, 1+20=21$，均不能整除 60；&lt;/li&gt;
&lt;li&gt;取 2 个非单位元类：$1+12+12=25, 1+12+15=28, 1+12+20=33, 1+15+20=36$，均不能整除 60；&lt;/li&gt;
&lt;li&gt;取 3 个非单位元类：$1+12+12+15=40, 1+12+12+20=45, 1+12+15+20=48$，均不能整除 60；&lt;/li&gt;
&lt;li&gt;取 4 个非单位元类（全选）：$1+12+12+15+20=60$，对应全群 $N = A_5$；&lt;/li&gt;
&lt;li&gt;不取非单位元类：$|N|=1$，对应平凡子群 $N={e}$。
因此 $A_5$ 不存在非平凡正规子群，$A_5$ 必为单群。
（注：更一般的群论结果表明当 $n \ge 5$ 时 $A_n$ 均为单群，该性质在伽罗瓦理论中与代数方程的可解性相关，属于后续群论内容。）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 自同构群与内自同构群&lt;/h2&gt;
&lt;h3&gt;7.1 内自同构的严格定义与验证&lt;/h3&gt;
&lt;h4&gt;定理 6.13&lt;/h4&gt;
&lt;p&gt;设 $G$ 是群。对固定元素 $g \in G$，定义映射：
$$\sigma_g: G \to G, \quad \sigma_g(x) = g x g^{-1} \quad (\forall x \in G)$$
则 $\sigma_g$ 是群 $G$ 的一个自同构（$\sigma_g \in \operatorname{Aut}(G)$），称为由 $g$ 诱导的&lt;strong&gt;内自同构（Inner Automorphism）&lt;/strong&gt;。
全体内自同构构成的集合记作 $\operatorname{Inn}(G) = {\sigma_g \mid g \in G}$，它是自同构群 $\operatorname{Aut}(G)$ 的子群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：
$$\sigma_g(xy) = g(xy)g^{-1} = g x (g^{-1} g) y g^{-1} = (g x g^{-1})(g y g^{-1}) = \sigma_g(x)\sigma_g(y)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射&lt;/strong&gt;：若 $\sigma_g(x) = \sigma_g(y) \implies g x g^{-1} = g y g^{-1}$。两边左乘 $g^{-1}$、右乘 $g$，得 $x = y$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射&lt;/strong&gt;：对任意 $y \in G$，取 $x = g^{-1} y g \in G$，则 $\sigma_g(x) = g(g^{-1}yg)g^{-1} = y$。
故 $\sigma_g$ 是双射同态，$\sigma_g \in \operatorname{Aut}(G)$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;7.2 内自同构群与群中心的商群同构&lt;/h3&gt;
&lt;h4&gt;定理 6.14&lt;/h4&gt;
&lt;p&gt;设 $G$ 是群，$Z(G)$ 是群的中心。则：
$$G/Z(G) \cong \operatorname{Inn}(G)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
构造映射：
$$\Psi: G \to \operatorname{Inn}(G), \quad \Psi(g) = \sigma_g$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;同态性&lt;/strong&gt;：对任意 $g, h \in G$ 及 $x \in G$：
$$\sigma_{gh}(x) = (gh)x(gh)^{-1} = g(hxh^{-1})g^{-1} = \sigma_g(\sigma_h(x)) = (\sigma_g \circ \sigma_h)(x)$$
由映射相等的定义，$\sigma_{gh} = \sigma_g \circ \sigma_h$，即 $\Psi(gh) = \Psi(g)\Psi(h)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：由 $\operatorname{Inn}(G)$ 的定义，每个内自同构均形如 $\sigma_g = \Psi(g)$，故 $\Psi$ 是满同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;求解同态核 $\operatorname{Ker}\Psi$&lt;/strong&gt;：
$\operatorname{Aut}(G)$ 的单位元是恒等变换 $I_G$。
$$\operatorname{Ker}\Psi = {g \in G \mid \Psi(g) = I_G} = {g \in G \mid \sigma_g = I_G}$$
$$\sigma_g = I_G \iff \forall x \in G, gxg^{-1} = x \iff \forall x \in G, gx = xg$$
与群中每个元素均可交换的元素集合正是群中心 $Z(G)$。因此：
$$\operatorname{Ker}\Psi = Z(G)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;应用第一同构定理&lt;/strong&gt;：
由定理 5.1（第一同构定理），自然诱导同构：
$$G/\operatorname{Ker}\Psi \cong \operatorname{Im}\Psi \implies G/Z(G) \cong \operatorname{Inn}(G) \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;8. 凯莱定理（Cayley&apos;s Theorem）&lt;/h2&gt;
&lt;h3&gt;8.1 严格表述&lt;/h3&gt;
&lt;h4&gt;定理 6.15（Cayley 定理）&lt;/h4&gt;
&lt;p&gt;任何群 $G$ 都与集合 $G$ 上的一个变换群同构。
特别地，任何 $n$ 阶有限群都同构于 $n$ 次对称群 $S_n$ 的某个子群（即同构于一个置换群）。&lt;/p&gt;
&lt;h3&gt;8.2 形式化证明&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $G$ 是群，$E(G)$ 是集合 $G$ 到自身的全体双射构成的群。
对任意 $a \in G$，定义左乘变换：
$$L_a: G \to G, \quad L_a(x) = ax \quad (\forall x \in G)$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;验证 $L_a \in E(G)$（$L_a$ 是双射）&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;单射：若 $L_a(x_1) = L_a(x_2) \implies ax_1 = ax_2 \implies x_1 = x_2$（群消去律）。&lt;/li&gt;
&lt;li&gt;满射：对任意 $y \in G$，取 $x = a^{-1}y \in G$，则 $L_a(x) = a(a^{-1}y) = y$。
故 $L_a$ 为双射，$L_a \in E(G)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;构造映射&lt;/strong&gt;：
定义 $\Phi: G \to E(G)$ 为 $\Phi(a) = L_a$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;验证 $\Phi$ 是群同态&lt;/strong&gt;：
任取 $a, b \in G$。对任意 $x \in G$：
$$(L_a \circ L_b)(x) = L_a(L_b(x)) = L_a(bx) = a(bx) = (ab)x = L_{ab}(x)$$
因此 $L_a \circ L_b = L_{ab}$，即 $\Phi(a) \circ \Phi(b) = \Phi(ab)$，$\Phi$ 为群同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;验证 $\Phi$ 是单同态&lt;/strong&gt;：
考察同态核：
$$\operatorname{Ker}\Phi = {a \in G \mid \Phi(a) = I_G} = {a \in G \mid L_a = I_G}$$
若 $L_a = I_G$，则对所有 $x \in G$ 均有 $ax = x$。
特别取 $x = e$，得 $ae = e \implies a = e$。
故 $\operatorname{Ker}\Phi = {e}$，由定理 4.7，$\Phi$ 为单同态。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;得出同构结论&lt;/strong&gt;：
$\Phi$ 在其同态像 $\bar{G} = \operatorname{Im}\Phi = {L_a \mid a \in G} \le E(G)$ 上构成双射同态。
因此：
$$G \cong \bar{G} \le E(G) \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;8.3 左乘与右乘的区别&lt;/h3&gt;
&lt;p&gt;若定义右乘变换 $R_a(x) = xa$，计算复合映射：
$$(R_a \circ R_b)(x) = R_a(R_b(x)) = R_a(xb) = (xb)a = x(ba) = R_{ba}(x)$$
若群为非交换群，存在 $ab \ne ba$，则 $R_a \circ R_b = R_{ba} \ne R_{ab}$。该映射反转了运算次序，构成了反同态。
若定义带逆元的右侧作用 $R&apos;_a(x) = x a^{-1}$，则 $(R&apos;_a \circ R&apos;&lt;em&gt;b)(x) = (x b^{-1}) a^{-1} = x (b^{-1} a^{-1}) = x (ab)^{-1} = R&apos;&lt;/em&gt;{ab}(x)$，同样可构成群同态。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;9. 核心易错点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;置换复合次序&lt;/strong&gt;：代数计算约定为 $(\sigma\tau)(x) = \sigma(\tau(x))$ 从右向左复合计算，避免按矩阵书写顺序从左向右读取。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;长循环分解为对换&lt;/strong&gt;：$r$-循环 $(j_1\ j_2\ \dots\ j_r)$ 分解为 $r-1$ 个对换 $(j_1\ j_r)(j_1\ j_{r-1}) \cdots (j_1\ j_2)$，不能拆分成独立的两个非重叠对换。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;借桥分解的元素对应&lt;/strong&gt;：在将两个不相交对换 $(a\ b)(c\ d)$ 改写为 3-轮换乘积时，借助恒等式 $(a\ b)(c\ d) = (a\ b\ c)(b\ c\ d)$，需注意元素排列顺序。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单群的同态像&lt;/strong&gt;：单群没有非平凡正规子群，因此任何从单群出发的群同态，其核要么为 ${e}$（此时为单同态），要么为全群（此时像为平凡群 ${e&apos;}$）。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;10. 前后知识连接&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：群公理（&lt;code&gt;01-群与子群.md&lt;/code&gt;）、Lagrange 定理与商群（&lt;code&gt;03-陪集-Lagrange-正规子群.md&lt;/code&gt;）、第一同构定理（&lt;code&gt;05-三大同构定理.md&lt;/code&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;Cayley 定理证明了置换群可作为有限群的具体模型。&lt;/li&gt;
&lt;li&gt;循环分解与置换求阶是算法竞赛中置换环分析、快速幂及 Burnside/Pólya 计数（&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;）的基础。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>2026-07至10 算法三个月回顾（用户提供）</title><link>https://sanzenin.top/posts/obsidian/2026-07%E8%87%B310-%E7%AE%97%E6%B3%95%E4%B8%89%E4%B8%AA%E6%9C%88%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/2026-07%E8%87%B310-%E7%AE%97%E6%B3%95%E4%B8%89%E4%B8%AA%E6%9C%88%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/</guid><description>来源：用户在本次任务中粘贴的三个月复盘。以下规整保存全部题目线索和关键归因，不是原始对话逐字导出。名义范围 2026-07-25 至 10-25；记录主要集中在 8 月中下旬至 10 月下旬，7 月下旬和 8 月上旬不完整。没有会话 URL，不能据此声称独立核验了每道题的提交或当时版本。 归因修正：Hydra 第一版</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;2026-07至10 算法三个月回顾（用户提供）&lt;/h1&gt;
&lt;p&gt;来源：用户在本次任务中粘贴的三个月复盘。以下规整保存全部题目线索和关键归因，不是原始对话逐字导出。名义范围 2026-07-25 至 10-25；记录主要集中在 8 月中下旬至 10 月下旬，7 月下旬和 8 月上旬不完整。没有会话 URL，不能据此声称独立核验了每道题的提交或当时版本。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;归因修正&lt;/strong&gt;：Hydra 第一版 WA 是先前助手给出的代码问题，不计为用户个人代码错误。对“为什么成立”的追问，记录为证明学习，不自动记作错误。&lt;/p&gt;
&lt;h2&gt;八月线索&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;日期 / 题目&lt;/th&gt;
&lt;th&gt;摘要中的问题&lt;/th&gt;
&lt;th&gt;归类&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;08-14 树上碰撞&lt;/td&gt;
&lt;td&gt;同节点同时间的 map 键被覆盖；n=1,m=2 同时出生应立即碰撞&lt;/td&gt;
&lt;td&gt;实际实现问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-17 P2495 消耗战&lt;/td&gt;
&lt;td&gt;LCA 补点、固定根、多询问清理&lt;/td&gt;
&lt;td&gt;理解与状态维护&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-18 CF505E Bamboos&lt;/td&gt;
&lt;td&gt;二分后的砍伐调度判定、截止时间&lt;/td&gt;
&lt;td&gt;判定建模&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-18 CF2207B&lt;/td&gt;
&lt;td&gt;对抗性贪心不直观&lt;/td&gt;
&lt;td&gt;证明理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-19 极角几何&lt;/td&gt;
&lt;td&gt;atan2l、三角函数影长 WA&lt;/td&gt;
&lt;td&gt;实际代码问题，根因待原题核实&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-19 Slot Machine&lt;/td&gt;
&lt;td&gt;顺序统计、等间隔期望&lt;/td&gt;
&lt;td&gt;数学理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-20 约数扫描线&lt;/td&gt;
&lt;td&gt;扫 ma 而非 n；divisors[i] 与 divisors[a[i]] 混淆；int 乘法先溢出&lt;/td&gt;
&lt;td&gt;实际实现问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-24 ICPC Board&lt;/td&gt;
&lt;td&gt;局部棋盘约束推全局周期构造&lt;/td&gt;
&lt;td&gt;性质发现&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-25 Upside Down Dijkstra&lt;/td&gt;
&lt;td&gt;按输入顺序任意选择父边、未检查可达&lt;/td&gt;
&lt;td&gt;构造结构问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-26 Red Black Tree II&lt;/td&gt;
&lt;td&gt;二分+多次LCA扫描 TLE；距离赋值、上界、排序后取错极值&lt;/td&gt;
&lt;td&gt;复杂度与实现&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-27 Sub-cycle Graph&lt;/td&gt;
&lt;td&gt;路径块、孤立点、排列与除重&lt;/td&gt;
&lt;td&gt;组合理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;08-30 Gas Station&lt;/td&gt;
&lt;td&gt;二分下界、上界不足、深递归&lt;/td&gt;
&lt;td&gt;判定与边界&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;九月线索&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;日期 / 题目&lt;/th&gt;
&lt;th&gt;摘要中的问题&lt;/th&gt;
&lt;th&gt;归类&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;09-01 Billion Players Game&lt;/td&gt;
&lt;td&gt;最坏收益化成价格的一次函数，取区间端点&lt;/td&gt;
&lt;td&gt;建模&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-01 Jewels Building&lt;/td&gt;
&lt;td&gt;任意长度构造、单点特例、前缀 OR&lt;/td&gt;
&lt;td&gt;DP转移理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-02 Erratic Lights&lt;/td&gt;
&lt;td&gt;数组越界、漏概率归一化（如 2^cnt[0] 分母）&lt;/td&gt;
&lt;td&gt;实际实现/事件问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-02 Arcade Crane&lt;/td&gt;
&lt;td&gt;BFS 未pop、erase范围、三元组越界、漏操作数&lt;/td&gt;
&lt;td&gt;实际实现问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-03 Canal Crossing&lt;/td&gt;
&lt;td&gt;端点 XOR 差分错误地父传子&lt;/td&gt;
&lt;td&gt;实际实现问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-03 Chamber of Secrets 2&lt;/td&gt;
&lt;td&gt;奇偶分类、半块环构造&lt;/td&gt;
&lt;td&gt;构造理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-03 Optimal Strategy&lt;/td&gt;
&lt;td&gt;相同最大值奇偶性、插入组合数；元素数pre与块数含义不一致&lt;/td&gt;
&lt;td&gt;计数与变量语义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-03 Arithmetic Sequence&lt;/td&gt;
&lt;td&gt;固定公差后绝对值和用中位数&lt;/td&gt;
&lt;td&gt;数学理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-06 ICPC Online RGB&lt;/td&gt;
&lt;td&gt;区间颜色计数差转二维偏序&lt;/td&gt;
&lt;td&gt;建模缺口&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-13 MEX区间计数&lt;/td&gt;
&lt;td&gt;j&lt;em&gt;i与j&lt;/em&gt;x、pre与dp混用、端点n+1、漏取模；重叠与调和复杂度&lt;/td&gt;
&lt;td&gt;实际实现/建模问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-18 循环矩阵&lt;/td&gt;
&lt;td&gt;二维转一维环&lt;/td&gt;
&lt;td&gt;结构发现&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-18 栈操作约束&lt;/td&gt;
&lt;td&gt;只看栈顶不足，需理解生存时间区间&lt;/td&gt;
&lt;td&gt;状态理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-19 Strips&lt;/td&gt;
&lt;td&gt;最少条数后反向调整位置&lt;/td&gt;
&lt;td&gt;贪心理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-21 动态线性基&lt;/td&gt;
&lt;td&gt;基向量和整个生成空间的区别&lt;/td&gt;
&lt;td&gt;线性代数理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;09-28 XOR等差三元组&lt;/td&gt;
&lt;td&gt;同时维护多个大小关系的数位DP&lt;/td&gt;
&lt;td&gt;状态理解&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;十月线索&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;日期 / 题目&lt;/th&gt;
&lt;th&gt;摘要中的问题&lt;/th&gt;
&lt;th&gt;归类&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;10-02 DSU on Tree + XOR&lt;/td&gt;
&lt;td&gt;提前return跳过cnt回滚，污染后续检查&lt;/td&gt;
&lt;td&gt;实际状态维护问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-08 概率DP&lt;/td&gt;
&lt;td&gt;offset漏加、枚举d却写死下标&lt;/td&gt;
&lt;td&gt;实际实现问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-09 DivMEX&lt;/td&gt;
&lt;td&gt;质数幂int溢出、多测未clear、空后缀l&amp;lt;=n而非l&amp;lt;n&lt;/td&gt;
&lt;td&gt;实际实现问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-09 DAG状压红包&lt;/td&gt;
&lt;td&gt;漏起点收益、重复领取、不可达参与转移&lt;/td&gt;
&lt;td&gt;DP初始化问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-09 CF1418E&lt;/td&gt;
&lt;td&gt;只算强怪，漏盾破后弱怪贡献&lt;/td&gt;
&lt;td&gt;实际分类遗漏&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-11 二进制DP&lt;/td&gt;
&lt;td&gt;ndp未分配、错位号、负数移位、1&amp;lt;&amp;lt;i&lt;/td&gt;
&lt;td&gt;实际实现问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-12 Target Infection&lt;/td&gt;
&lt;td&gt;非单调二分为何成立&lt;/td&gt;
&lt;td&gt;离散介值理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-12 CF144D&lt;/td&gt;
&lt;td&gt;漏边上另一端的更短路径&lt;/td&gt;
&lt;td&gt;最短路建模问题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-14至25 Excuse for Breaks&lt;/td&gt;
&lt;td&gt;多个0向局部单0归约的证明&lt;/td&gt;
&lt;td&gt;性质与证明&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同期 左偏树&lt;/td&gt;
&lt;td&gt;右路径对数界、dist&lt;/td&gt;
&lt;td&gt;不变量理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同期 SOS DP&lt;/td&gt;
&lt;td&gt;子集/超集方向、重复统计&lt;/td&gt;
&lt;td&gt;集合语义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同期 Min-Max Tree&lt;/td&gt;
&lt;td&gt;删边极差转路径端点差&lt;/td&gt;
&lt;td&gt;数学转化&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-20 Cryptarithm&lt;/td&gt;
&lt;td&gt;当前块信息、前缀最优何时更新&lt;/td&gt;
&lt;td&gt;状态理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同期 Hydra&lt;/td&gt;
&lt;td&gt;历史影响不能只看相邻两轮&lt;/td&gt;
&lt;td&gt;助手首版WA，作为模型反例&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同期 循环排列哈希&lt;/td&gt;
&lt;td&gt;随机哈希和真实结构的对应&lt;/td&gt;
&lt;td&gt;随机化理解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同期 最大值期望&lt;/td&gt;
&lt;td&gt;CDF做差、尾和与线性期望&lt;/td&gt;
&lt;td&gt;数学建模&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同期 最高位递归&lt;/td&gt;
&lt;td&gt;重置性质与递归边界&lt;/td&gt;
&lt;td&gt;状态与终止性&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;更细的 10 月 14–25 日条目保存在 &lt;a href=&quot;/posts/obsidian/2026-10-%E7%AE%97%E6%B3%95%E5%AF%B9%E8%AF%9D%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/&quot;&gt;2026-10 算法对话回顾（用户提供）&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;摘要给出的跨题模式&lt;/h2&gt;
&lt;p&gt;性质发现；状态或不变量不准确；实现边界与变量含义；最优性证明；概率与计数划分；复杂度；局部与全局约束。这是主观复盘框架，不是各类错误频率的统计结论。&lt;/p&gt;
&lt;p&gt;二刷题目清单与每题验收条件见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/#%E4%B8%89%E4%B8%AA%E6%9C%88%E4%BA%8C%E5%88%B7%E6%B8%85%E5%8D%95&quot;&gt;算法竞赛个人易错点&lt;/a&gt;。&lt;/p&gt;
</content:encoded></item><item><title>2026-10 算法对话回顾（用户提供）</title><link>https://sanzenin.top/posts/obsidian/2026-10-%E7%AE%97%E6%B3%95%E5%AF%B9%E8%AF%9D%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/2026-10-%E7%AE%97%E6%B3%95%E5%AF%B9%E8%AF%9D%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/</guid><description>来源：用户在本次任务中粘贴的网页端对话回顾，覆盖约 2026-10-14 至 2026-10-25。本页保存其关键信息并规整格式；不是逐字对话导出。当前浏览器停留在 ChatGPT 登录页，用户已要求先整理本地、网页对话稍后补，因此未独立核验原对话，暂无会话 URL 或完整题意。 原摘要的判断是：优先改进性质发现、状态</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;2026-10 算法对话回顾（用户提供）&lt;/h1&gt;
&lt;p&gt;来源：用户在本次任务中粘贴的网页端对话回顾，覆盖约 2026-10-14 至 2026-10-25。本页保存其关键信息并规整格式；不是逐字对话导出。当前浏览器停留在 ChatGPT 登录页，用户已要求先整理本地、网页对话稍后补，因此未独立核验原对话，暂无会话 URL 或完整题意。&lt;/p&gt;
&lt;p&gt;原摘要的判断是：优先改进性质发现、状态设计和边界验证。它属于基于对话的主观评估，不是错误频率统计，也不能由此推断所有询问都属于错误。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;日期 / 主题&lt;/th&gt;
&lt;th&gt;摘要记载&lt;/th&gt;
&lt;th&gt;类型&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;10-24 最高位贪心递归&lt;/td&gt;
&lt;td&gt;先考虑普通按位 DP，没立即发现操作重置连续计数；n=2,3 的递推可能不缩小&lt;/td&gt;
&lt;td&gt;性质发现、终止性&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-24 最大值期望&lt;/td&gt;
&lt;td&gt;提出 (1/m)(k/m)^(n-1) 作为最大值恰为 k 的概率&lt;/td&gt;
&lt;td&gt;明确的事件建模错误&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-23 Slot Machine&lt;/td&gt;
&lt;td&gt;未立即发现历史最小 n-1 个数与最新值的状态不变量&lt;/td&gt;
&lt;td&gt;性质发现&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-22 循环排列博弈&lt;/td&gt;
&lt;td&gt;反复询问奇数情况及策略最优性&lt;/td&gt;
&lt;td&gt;证明理解，不能直接算错误&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-20 Cryptarithm&lt;/td&gt;
&lt;td&gt;怀疑 dp[i][j] 缺少当前块位置&lt;/td&gt;
&lt;td&gt;对状态充分性的质疑，需看定义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-18 状压分组&lt;/td&gt;
&lt;td&gt;考虑过 dp[mask][rem]、先取模&lt;/td&gt;
&lt;td&gt;冗余状态与转移语义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-16 Retest Queue&lt;/td&gt;
&lt;td&gt;询问 SOS 超集方向和拒绝费用&lt;/td&gt;
&lt;td&gt;集合方向、费用定义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10-15 Matrix Game&lt;/td&gt;
&lt;td&gt;使用 k^a，忽略共同取值要求同一组行&lt;/td&gt;
&lt;td&gt;组合见证对象不清&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;摘要还列出了以下实际实现问题，但不能据此声称当前代码仍未修复：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;clz&lt;/code&gt; 与 &lt;code&gt;ctz&lt;/code&gt; 混淆；零输入未处理。&lt;/li&gt;
&lt;li&gt;状压空集初始化、扩展方向和最终组数不一致。&lt;/li&gt;
&lt;li&gt;扫描线用 &lt;code&gt;i++, cnt += events[i].second&lt;/code&gt;，索引先变导致跳事件或越界。&lt;/li&gt;
&lt;li&gt;右侧先按 &lt;code&gt;long long&lt;/code&gt; 乘，最后赋给 &lt;code&gt;__int128&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;DFS 入口遗漏、未跳父亲、叶子或空 DP 状态。&lt;/li&gt;
&lt;li&gt;左偏树混淆 dist 与键值，空节点和新节点初始化不全。&lt;/li&gt;
&lt;li&gt;括号树虚拟根与真实节点编号冲突、答案组成漏项。&lt;/li&gt;
&lt;li&gt;反对角线范围、单行单列和数组边界。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;建议落地为九项提交检查：性质、状态充分且无冗余、最优性、概率/集合方向、DFS、递归收缩、下标/虚拟点/空集、提前提升数值类型、极小与极值数据。&lt;/p&gt;
&lt;p&gt;原摘要建议的练习节奏是每天两道性质题、一道 DP 状态题、一段十行内证明。这里只记录建议；未创建日程或任务。&lt;/p&gt;
&lt;p&gt;整理后的可执行检查和反例见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;；数学推导见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
</content:encoded></item><item><title>90-易错点与证明套路</title><link>https://sanzenin.top/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/</guid><description>- 典型错误：计算 时，先看 把数字变到哪里，再看 把结果变到哪里（从左往右计算）。 - 说明与纠正：置换乘法本质是函数的复合，公式定义为： 右侧置换 先作用，左侧置换 后作用。 - 典型错误：看到长为 4 的轮换 ，错误拆成两个对换 。 - 说明与纠正： - 是两个互不相交的 2-循环之积，表示 1 与 3 互换、5</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;90-易错点与证明套路&lt;/h1&gt;
&lt;h2&gt;1. 经典概念易错点复盘&lt;/h2&gt;
&lt;h3&gt;易错点 1：置换复合运算的读取方向&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：计算 $\sigma\tau$ 时，先看 $\sigma$ 把数字变到哪里，再看 $\tau$ 把结果变到哪里（从左往右计算）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：置换乘法本质是&lt;strong&gt;函数的复合&lt;/strong&gt;，公式定义为：
$$(\sigma\tau)(x) = \sigma(\tau(x))$$
右侧置换 $\tau$ 先作用，左侧置换 $\sigma$ 后作用。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 2：循环记号与对换拆分的混淆&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：看到长为 4 的轮换 $(1\ 3\ 5\ 2)$，错误拆成两个对换 $(1\ 3)(5\ 2)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;$(1\ 3)(5\ 2)$ 是两个互不相交的 2-循环之积，表示 1 与 3 互换、5 与 2 互换；&lt;/li&gt;
&lt;li&gt;$(1\ 3\ 5\ 2)$ 是长为 4 的单一大轮换，拆成对换必须用标准公式：
$$(j_1\ j_2\ \dots\ j_r) = (j_1\ j_r)(j_1\ j_{r-1})\cdots(j_1\ j_2)$$
长为 4 的循环拆成对换需要 $4 - 1 = 3$ 个对换：$(1\ 2)(1\ 5)(1\ 3)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 3：循环长度与奇偶置换的对应关系&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：误以为“3-循环是奇置换，4-循环是偶置换”。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;长为 $r$ 的循环可分解为 $r-1$ 个对换；&lt;/li&gt;
&lt;li&gt;3-循环分解为 $3-1 = 2$ 个对换，属于&lt;strong&gt;偶置换&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;4-循环分解为 $4-1 = 3$ 个对换，属于&lt;strong&gt;奇置换&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;2-循环（对换）分解为 $2-1 = 1$ 个对换，属于&lt;strong&gt;奇置换&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 4：不相交对换改写为 3-轮换时的元素对齐&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：拆分两个无交集的对换 $(1\ 3)(2\ 4)$ 时，顺序写反导致映射不一致。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;标准改写公式&lt;/strong&gt;：
$$(a\ b)(c\ d) = [(a\ b)(b\ c)] \cdot [(b\ c)(c\ d)] = (a\ b\ c)(b\ c\ d)$$
插入中间项 $(b\ c)(b\ c) = I$ 后，从右向左复合需确保公共元素顺序对应。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 5：素数阶群与循环群元素阶的表述&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：认为“素数阶群中每个元素的阶都与群阶互质”。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;在有限群中，每个元素的阶必须是群阶的因数（Lagrange 定理推论）；&lt;/li&gt;
&lt;li&gt;若群阶为素数 $p$，其正因数只有 $1$ 和 $p$；&lt;/li&gt;
&lt;li&gt;除了单位元（阶为 1）外，其余所有非单位元的阶均等于 $p$，从而每个非单位元都能生成该群。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 6：群同构时单位元的对应&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：复数乘法群 $U_4 = {1, i, -1, -i}$ 同构于 $(\mathbb{Z}_4, +)$ 时，误认为乘法单位元 $1$ 对应加法群里的元素 $1$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：同构映射必须保持单位元性质（$f(e) = e&apos;$）。
&lt;ul&gt;
&lt;li&gt;乘法群 $U_4$ 的单位元是复数 $1$；&lt;/li&gt;
&lt;li&gt;加法群 $(\mathbb{Z}_4, +)$ 的单位元是剩余类 $[0]$；&lt;/li&gt;
&lt;li&gt;故必须有 $f(1) = [0]$，生成元 $i$ 对应生成元 $[1]$（或 $[3]$）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 7：商群乘法良定性的验证&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：定义商群乘法 $(aN)(bN) = (ab)N$ 时，认为该运算显然封闭且无需验证良定性。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：陪集由代表元给出，若选择不同代表元 $a_1 \in aN, b_1 \in bN$，乘积代表元 $a_1 b_1$ 是否仍落在 $(ab)N$ 中，依赖于正规性 $N \triangleleft G$。若 $N$ 不是正规子群，该二元运算在陪集集合上不良定。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 8：Lagrange 定理逆命题不成立&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：看到群阶能被 $d$ 整除，就断定群内必有 $d$ 阶子群。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：Lagrange 定理仅给出子群阶必须整除群阶的必要条件。典型反例为 12 阶的交代群 $A_4$，它没有 6 阶子群。只有在有限循环群中，群阶的每个正因数才对应唯一的子群。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 9：右乘变换诱导同构的反同态问题&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：定义右乘映射 $R_a(x) = xa$，并直接断言 $a \mapsto R_a$ 给出群同构。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：在非交换群中，$(R_a \circ R_b)(x) = xba = R_{ba}(x) \ne R_{ab}(x)$，乘法次序被颠倒，构成反同态。必须使用左乘 $L_a(x) = ax$，或定义带逆元的右乘 $R&apos;_a(x) = x a^{-1}$ 才能构成同态。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;易错点 10：子群链指数公式（塔式法则）不需正规性假设&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;典型错误&lt;/strong&gt;：误以为 $[G:K] = [G:H][H:K]$ 必须假设 $H$ 或 $K$ 为正规子群。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;说明与纠正&lt;/strong&gt;：塔式法则仅需子群包含关系 $K \le H \le G$，其证明直接来自陪集的细分与双射配对，不依赖正规性。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 核心证明推导模板&lt;/h2&gt;
&lt;h3&gt;模板 1：子群一步判定法&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明非空子集 $H \subseteq G$ 是群 $G$ 的子群（$H \le G$）。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. [非空性]：指出单位元 e ∈ H，说明 H ≠ ∅。
2. [任取元]：任取 a, b ∈ H。
3. [算复合]：计算乘积 ab⁻¹（加法群中为 a - b）。
4. [落回集]：利用 H 的定义条件或已知性质，推导出 ab⁻¹ ∈ H。
   根据子群判定定理，得出 H ≤ G。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;模板 2：第一同构定理构建商群同构&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明商群 $G/N \cong G&apos;$。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. [构造映射]：构造从群 G 到目标群 G&apos; 的映射 f: G → G&apos;。
2. [验证满同态]：
   - 证明同态性：f(ab) = f(a)f(b)；
   - 证明满射性：对任意 y ∈ G&apos;，证明存在 x ∈ G 使得 f(x) = y。
3. [求解同态核]：
   Ker(f) = {x ∈ G | f(x) = e&apos;}。
   根据同态核定义解方程，证明 Ker(f) = N。
4. [应用定理]：
   由第一同构定理，得出 N ◁ G 且 G/N ≅ G&apos;。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;模板 3：单同态判定（通过同态核）&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明群同态 $f: G \to G&apos;$ 是单同态。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 写出同态核定义：Ker(f) = {x ∈ G | f(x) = e&apos;}。
2. 任取 x ∈ Ker(f)，由 f(x) = e&apos; 出发，结合群性质推出 x = e。
3. 说明 Ker(f) ⊆ {e}，从而 Ker(f) = {e}。
4. 由单同态判据（定理 4.7），得出 f 为单同态。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;模板 4：循环群子群证明（最小步长与带余除法）&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明循环群的子群必为循环群。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 设 G = ⟨a⟩。若 H = {e}，则 H = ⟨e⟩，结论成立。
2. 若 H ≠ {e}，取集合 {k ∈ ℤ⁺ | aᵏ ∈ H} 中的最小正整数，记为 m。
3. 任取 aˢ ∈ H，由带余除法：s = qm + r，其中 0 ≤ r &amp;lt; m。
4. 变形得 a^r = a^s (a^m)^(-q)。由子群运算封闭性，aʳ ∈ H。
5. 若 r &amp;gt; 0，与 m 的最小性矛盾，故必有 r = 0，从而 s = qm。
6. 结论：H = ⟨aᵐ⟩ 为循环群。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;模板 5：指数为 2 的子群必正规&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明 $[G : H] = 2 \implies H \triangleleft G$。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 任取 g ∈ G。若 g ∈ H，由子群封闭性 gH = H = Hg。
2. 若 g ∉ H：
   - 因 [G : H] = 2，左陪集只有两个：H 和 gH，它们构成全群划分，故 gH = G \ H；
   - 同理，右陪集也只有两个：H 和 Hg，故 Hg = G \ H；
3. 对比两式得到 gH = Hg。
4. 综合两类情况，对所有 g ∈ G 均有 gH = Hg，故 H ◁ G。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;模板 6：有限子群封闭性判定（抽屉原理构造逆元）&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;目标&lt;/strong&gt;：证明有限群 $G$ 的非空子集 $H \subseteq G$ 仅需运算封闭即可构成子群。
&lt;strong&gt;推导步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 任取 a ∈ H。考察元素幂序列 a, a², a³, ...。
2. 由乘法封闭性，该序列中所有元素均属于 H。
3. 因 H 为有限集合，由抽屉原理，必存在正整数 i &amp;gt; j ≥ 1 使得 aⁱ = aʲ。
4. 两边消去 aʲ，得 aⁱ⁻ʲ = e ∈ H（其中 i - j ≥ 1）。
5. 若 i - j = 1，则 a = e，a⁻¹ = e ∈ H；
   若 i - j &amp;gt; 1，则 a⁻¹ = aⁱ⁻ʲ⁻¹ ∈ H（因 i - j - 1 ≥ 1 为正整数）。
6. 由逆元封闭性与运算封闭性，H ≤ G。
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Dirichlet生成函数</title><link>https://sanzenin.top/posts/obsidian/dirichlet%E5%8D%B7%E7%A7%AF%E4%BB%A5%E5%8F%8A%E8%8E%AB%E6%AF%94%E4%B9%8C%E6%96%AF%E5%8F%8D%E6%BC%94/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/dirichlet%E5%8D%B7%E7%A7%AF%E4%BB%A5%E5%8F%8A%E8%8E%AB%E6%AF%94%E4%B9%8C%E6%96%AF%E5%8F%8D%E6%BC%94/</guid><description>其乘法运算运算为 定义 1. 2.当 时,有 性质 不严谨证明 对于n的所有真分数集合 ,其数量显然为n 将其约分,对于分母d,显然有约分后的集合 ,其中 且显然 即 ,得证 定义 性质 证明 当n=1时,显然成立 n&gt;1时,由算术基本定理, 令 显然, 其中 ,得证 证明 当 时显然成立 当 时,由算术基本定理, 令</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Dirichlet生成函数&lt;/h1&gt;
&lt;p&gt;$F(x)=\sum_{i=1}^{\infty}\frac{a_{i}}{i^x}$&lt;/p&gt;
&lt;p&gt;其乘法运算运算为
$\sum_{i=1}^{\infty}\frac{a_{i}}{i^x} \sum_{i=1}^{\infty}\frac{b_i}{i^x}=\sum_{i=1}^{\infty}\frac{1}{i^x}\sum_{d|i}^{}a_{d}b_{\frac{i}{d}}$&lt;/p&gt;
&lt;h1&gt;积性函数&lt;/h1&gt;
&lt;p&gt;&lt;strong&gt;定义&lt;/strong&gt;
1.$f(1)=1$&lt;/p&gt;
&lt;p&gt;2.当$gcd(a,b)=1$时,有$f(ab)=f(a)f(b)$&lt;/p&gt;
&lt;h1&gt;欧拉函数&lt;/h1&gt;
&lt;p&gt;$\varphi(n)=\sum_{i=1}^{n}[\gcd(i,n)=1]$
&lt;strong&gt;性质&lt;/strong&gt;
$\sum_{d|n}^{}\phi(d)=n$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;不严谨证明&lt;/strong&gt;
对于n的所有真分数集合
$\frac{0}{n},\frac{1}{n},\dots,\frac{n-1}{n}$,其数量显然为n
将其约分,对于分母d,显然有约分后的集合$\frac{a_{1}}{d},\dots \frac{a_{\phi(d)}}{d}$,其中$a_{i}集合为d所有互质的数,$且显然$d|n$
即$\sum_{d|n}^{}\phi(d)=n$,得证&lt;/p&gt;
&lt;h1&gt;莫比乌斯函数&lt;/h1&gt;
&lt;p&gt;定义
$$\mu(n)=\begin{cases}
1,&amp;amp;n=1 \
(-1)^s,&amp;amp;n=p_{1}p_{2}\dots p_{s} \
0, &amp;amp;n包含相同质因子
\end{cases}$$
&lt;strong&gt;性质&lt;/strong&gt;
$\sum_{d|n}^{}\mu(d)=[n=1]$
&lt;strong&gt;证明&lt;/strong&gt;
当n=1时,显然成立
n&amp;gt;1时,由算术基本定理,$n=p_1^{s_1}p_2^{s_2}\dots p_r^{s_r}$
令$n&apos;=p_1p_2\dots p_r$
显然,$\sum_{d|n}\mu(d)=\sum_{d|n&apos;}\mu(d)$
其中 $\sum_{d|n&apos;}\mu(d)=1 + (-1)\binom{r}{1}+(-1)^{2}\binom{r}{2}+\dots +(-1)^r\binom{r}{r}=(1+(-1))^r=0$,得证&lt;/p&gt;
&lt;h1&gt;莫比乌斯函数与欧拉函数联系&lt;/h1&gt;
&lt;p&gt;$$\sum_{d|n}\mu(d) \frac{n}{d}=\phi(n)$$
&lt;strong&gt;证明&lt;/strong&gt;
当$n=1$时显然成立
当$n&amp;gt;1$时,由算术基本定理,$n=p_1^{s_1}p_2^{s_2}\dots p_r^{s_r}$
令$n&apos;=p_1p_2\dots p_r$
则$\sum_{d|n}\mu(d)\frac{n}{d}=n\sum^{}_{d|n&apos;}\frac{\mu(d)}{d}$
展开得 $n(1-(\frac{1}{p_1}+\frac{1}{p_2}+\dots)+(\frac{1}{p_1 p_2} +\frac{1}{p_1 p_3}+\dots)-\dots)$
$=n(1-\frac{1}{p_1})(1-\frac{1}{p_2})\dots(1-\frac{1}{p_n})$
$=\phi(n)$&lt;/p&gt;
&lt;h1&gt;Dirichlet卷积&lt;/h1&gt;
&lt;p&gt;&lt;strong&gt;定义&lt;/strong&gt;
$f,g$ 是任意两个算术函数，其 Dirichlet 卷积定义为
$$(f*g)(n)=\sum^{}_{d|n}f(d)g(\frac{n}{d})$$
Dirichlet卷积的意义是取遍n的所有约数对
&lt;strong&gt;规律&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;交换律: $f&lt;em&gt;g=g&lt;/em&gt;f$&lt;/li&gt;
&lt;li&gt;结合律 $f*(g&lt;em&gt;h)=(f&lt;/em&gt;g)*h$&lt;/li&gt;
&lt;li&gt;分配律 $(f+g)&lt;em&gt;h=f&lt;/em&gt;h+g*h$&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;其单位元为$\epsilon(n)=[n=1]$
其他常用函数为$常数函数1(n)=1,恒等函数id(n)=n$&lt;/p&gt;
&lt;h3&gt;常用卷积关系&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;$\sum_{d|n} \mu(d) = [n = 1] \iff \mu * 1 = \epsilon$&lt;/li&gt;
&lt;li&gt;$\sum_{d|n} \varphi(d) = n \iff \varphi * 1 = id$&lt;/li&gt;
&lt;li&gt;$\sum_{d|n} \mu(d) \frac{n}{d} = \varphi(n) \iff \mu * id = \varphi$&lt;/li&gt;
&lt;li&gt;$f * \epsilon = f$&lt;/li&gt;
&lt;li&gt;$f * 1 \neq f$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h3&gt;证明&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;1. 证明 $\mu * 1 = \epsilon$：&lt;/strong&gt;
$$(\mu * 1)(n) = \sum_{d|n} \mu(d) 1\left(\frac{n}{d}\right) = \sum_{d|n} \mu(d) = [n = 1] = \epsilon(n)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2. 证明 $\varphi * 1 = id$：&lt;/strong&gt;
$$(\varphi * 1)(n) = \sum_{d|n} \varphi(d) 1\left(\frac{n}{d}\right) = \sum_{d|n} \varphi(d) = n = id(n)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;3. 证明 $\mu * id = \varphi$：&lt;/strong&gt;
$$(\mu * id)(n) = \sum_{d|n} \mu(d) id\left(\frac{n}{d}\right) = \sum_{d|n} \mu(d) \frac{n}{d} = \varphi(n)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;4. 证明 $f * \epsilon = f$：&lt;/strong&gt;
$$(f * \epsilon)(n) = \sum_{d|n} f(d) \epsilon\left(\frac{n}{d}\right) = \sum_{d|n} f(d) \left[\frac{n}{d} = 1\right] = f(n)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;5. 关于 $f * 1$：&lt;/strong&gt;
$$(f * 1)(n) = \sum_{d|n} f(d) 1\left(\frac{n}{d}\right) = \sum_{d|n} f(d)$$&lt;/p&gt;
&lt;h1&gt;莫比乌斯反演 (Möbius Inversion)&lt;/h1&gt;
&lt;h4&gt;核心公式&lt;/h4&gt;
&lt;p&gt;$$f(n) = \sum_{d|n} g(d) \iff g(n) = \sum_{d|n} \mu(d) f\left(\frac{n}{d}\right)$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$f,g$ 为任意算术函数，不要求积性；若二者积性，其卷积也积性。&lt;/li&gt;
&lt;li&gt;$f(n)$ 称为 $g(n)$ 的&lt;strong&gt;莫比乌斯变换&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;$g(n)$ 称为 $f(n)$ 的&lt;strong&gt;莫比乌斯逆变换&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;证明方法（利用迪利克雷卷积）&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;充分性证明&lt;/strong&gt;：
若 $f = g * 1$，则：
$$\mu * f = \mu * g * 1 = g * \mu * 1 = g * \epsilon = g$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必要性证明&lt;/strong&gt;：
若 $g = \mu * f$，则：
$$g * 1 = \mu * f * 1 = f * \mu * 1 = f * \epsilon = f$$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!note] 2026-10-25 校订
修正欧拉函数的示性函数位置；Dirichlet 卷积和莫比乌斯反演不要求输入函数积性。可直接使用的倍数反演与计数例子见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#4-gcd-%E6%81%B0%E5%A5%BD%E5%80%BC-%E5%85%88%E7%AE%97%E5%80%8D%E6%95%B0%E6%9D%A1%E4%BB%B6-%E5%86%8D%E5%8F%8D%E6%BC%94&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
</content:encoded></item><item><title>抽象代数的竞赛用法</title><link>https://sanzenin.top/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/</guid><description>先把题目中的对象和操作说清楚：对象是余数、排列、向量还是多项式？操作能否结合、交换、撤销？随后才能判断应该用群、环、域中的哪条性质。下列竞赛模型由这些定义推导，例子均为独立构造；完整定义与证明见本章后续八节。 | 题面信号 | 先问什么 | 可落地的方法 | | --- | --- | --- | | 环上重复跳跃、模</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;抽象代数的竞赛用法&lt;/h1&gt;
&lt;p&gt;先把题目中的对象和操作说清楚：对象是余数、排列、向量还是多项式？操作能否结合、交换、撤销？随后才能判断应该用群、环、域中的哪条性质。下列竞赛模型由这些定义推导，例子均为独立构造；完整定义与证明见本章后续八节。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;题面信号&lt;/th&gt;
&lt;th&gt;先问什么&lt;/th&gt;
&lt;th&gt;可落地的方法&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;环上重复跳跃、模意义下加减&lt;/td&gt;
&lt;td&gt;所有操作生成了哪些余数？&lt;/td&gt;
&lt;td&gt;GCD、线性同余、循环群的阶&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同一洗牌执行巨大次数&lt;/td&gt;
&lt;td&gt;每个位置属于哪个循环？&lt;/td&gt;
&lt;td&gt;循环分解，每环对长度取模&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;换位、三轮换、能否复原&lt;/td&gt;
&lt;td&gt;操作改变奇偶性吗？&lt;/td&gt;
&lt;td&gt;符号同态、置换不变量&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;许多输入得到同一个输出&lt;/td&gt;
&lt;td&gt;映射是否保持运算？&lt;/td&gt;
&lt;td&gt;核、陪集、像，计算纤维大小&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;把大量状态归为同一类&lt;/td&gt;
&lt;td&gt;换代表元后，所有后继仍等价吗？&lt;/td&gt;
&lt;td&gt;良定性、商结构，证明状态压缩&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;模除法、模高斯消元&lt;/td&gt;
&lt;td&gt;被除数所在结构中是否有逆元？&lt;/td&gt;
&lt;td&gt;单位群；素数域与合数环分开&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;旋转或翻转视为相同&lt;/td&gt;
&lt;td&gt;各对象的等价类大小相同吗？&lt;/td&gt;
&lt;td&gt;群作用、Burnside，数不动点&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;NTT、异或系数、多项式取模&lt;/td&gt;
&lt;td&gt;系数在哪个域？根的阶和模多项式是什么？&lt;/td&gt;
&lt;td&gt;单位根、有限域、商环&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;1. 模环上的移动：可达性先算生成子群&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 状态为 $x\bmod m$，可反复加减固定步长 $a_1,\ldots,a_k$，问能否从 $s$ 到达 $t$、有多少可达状态，或多久回到起点。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; 令 $g=\gcd(m,a_1,\ldots,a_k)$。所有可达增量组成 $\mathbb Z_m$ 的子群，恰为 $g$ 的倍数；因此&lt;/p&gt;
&lt;p&gt;$$
t\text{ 可达}\iff g\mid(t-s),\qquad #\text{可达状态}=m/g.
$$&lt;/p&gt;
&lt;p&gt;单一步长 $a$ 的最小正周期是 $m/\gcd(m,a)$。证明分两边：每个操作保留模 $g$ 的余数；Bezout 恒等式给出 $g$ 的整数线性组合，从而所有 $g$ 的倍数都能生成。若只有“加”、无次数上限，在有限模环上同样能通过重复加法模拟逆操作。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 先约去 GCD 判断可解，再用扩展欧几里得求某个操作次数；若问最短步数，还需考虑允许的操作及边权，不能仅凭可达性得到距离。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 在 12 个位置的环上每次加 8，从 0 出发依次为 $0,8,4,0$：只到达 3 个位置。再允许加 6，则 $g=2$，可到达全部偶数位置。若每种操作次数有上限，以上充分性不再自动成立。&lt;/p&gt;
&lt;p&gt;这是循环群及其子群在加法模环上的应用。基础见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/50c134275caf32dbf4430ab097185157_MIT18_703S13_pra_l_4.pdf&quot;&gt;MIT 18.703：循环群&lt;/a&gt;；对应笔记 &lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/&quot;&gt;02-循环群与生成元&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;2. 巨大次数置换：逐环取模，通常不用算全局 LCM&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 洗牌、重排、轮换的规则固定，每个位置恰有一个前驱和后继，执行 $K$ 次，$K$ 可能是十进制大整数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 把 $p$ 分解成不相交循环 $c_0,c_1,\ldots,c_{\ell-1}$，满足 $p(c_i)=c_{(i+1)\bmod\ell}$。则&lt;/p&gt;
&lt;p&gt;$$
p^K(c_i)=c_{(i+K)\bmod\ell}.
$$&lt;/p&gt;
&lt;p&gt;遍历所有位置 $O(n)$；每个不同环长需要 $K\bmod\ell$，大整数可逐位维护余数。只有题目真的问“整体最早复原次数”时，才计算各环长 LCM；LCM 本身可能超过 64 位。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; $p=(1\ 2\ 3)(4\ 5)$，阶为 6。执行 2026 次后，三环移 1 格，二环不动，所以 $1\mapsto2$、$4\mapsto4$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;方向检查。&lt;/strong&gt; 若规则是“原位置 $i$ 的物品移到 $p(i)$”，则写 &lt;code&gt;new[p[i]]=old[i]&lt;/code&gt;；若定义是 &lt;code&gt;new[i]=old[p[i]]&lt;/code&gt;，移动方向相反。先用一个三环验方向。一般函数图可能带入树，必须先处理进环前的路径，不能把任意映射都当置换。&lt;/p&gt;
&lt;p&gt;不相交循环分解与阶公式见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/1216f598a733ff16876a797b6174bb7b_MIT18_703S13_pra_l_5.pdf&quot;&gt;MIT 18.703：置换群&lt;/a&gt;；证明见 &lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;3. 置换奇偶性：先证明不可能，再讨论怎么构造&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 操作是交换、三轮换，题目要求复原、限制操作次数奇偶，或问状态之间能否互达。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; 置换符号是到 ${+1,-1}$ 的同态。一次任意对换改变符号；三轮换是两个对换的乘积，保留符号。若分解后有 $c$ 个循环（含不动点），则符号为 $(-1)^{n-c}$。任意两位置可交换时，最少交换次数为 $n-c$：一次交换至多增加一个循环，而一个长 $\ell$ 的循环可用 $\ell-1$ 次交换拆开。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; $p=(1\ 2\ 3)(4\ 5)$ 有 $n-c=5-2=3$，是奇置换，不能仅靠三轮换复原。若操作允许任意三个不同位置的三轮换，则偶置换可以复原；若只允许某些局部三轮换，还要证明这些操作能生成全部目标状态。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;使用边界。&lt;/strong&gt; 有重复值时，交换两个相等值可以改变“带标签置换”的奇偶性却不改变可见序列，因此不能直接把互异排列的必要条件搬到重复值排序。滑块拼图也必须把空格位置的变化一起纳入不变量。&lt;/p&gt;
&lt;p&gt;证明见 &lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-6-%E5%AF%B9%E6%8D%A2%E5%A5%87%E5%81%B6%E6%80%A7%E4%B8%8D%E5%8F%98%E9%87%8F%E5%AE%9A%E7%90%86&quot;&gt;06-置换群-内自同构-Cayley&lt;/a&gt;。这一节给出的是从符号同态推导的竞赛判据。&lt;/p&gt;
&lt;h2&gt;4. 同态、核与像：一份解加上所有零解&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 问某种线性/同余变换能产生哪些输出，某个输出有几个原像，或者多个方程解集为什么大小相同。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; 若 $f:G\to H$ 是有限群同态，$f(x_0)=y$，则所有映到 $y$ 的元素恰为陪集 $x_0\ker f$。所以每个可达输出有 $|\ker f|$ 个原像，而且 $|G|=|\ker f|,|\operatorname{Im}f|$。要先检查映射保持运算；任意非线性函数没有这一保证。核与像的基础见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/fd33efba1e39ed8ca373aed383caa3e0_MIT18_703S13_pra_l_8.pdf&quot;&gt;MIT 18.703：同态与核&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例一。&lt;/strong&gt; $f:\mathbb Z_{12}\to\mathbb Z_{12}$，$f(x)=8x$。核是 ${0,3,6,9}$，像是 ${0,4,8}$。因此 $8x\equiv4\pmod{12}$ 有 4 个解，分别为 $2,5,8,11$，而右端为 2 时无解。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例二。&lt;/strong&gt; $\mathbb F_2$ 上 $Ax=b$，有 $n$ 个变量、秩为 $r$。若无矛盾行，零空间有 $n-r$ 个自由变量，解数为 $2^{n-r}$；否则为 0。例如 $x_1\oplus x_2=1$，$x_2\oplus x_3=0$，解为 $(1,0,0)$ 和 $(0,1,1)$，恰为一份解加零空间。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 同余用扩欧先查 GCD；二进制线性方程用 XOR 高斯消元或带方程信息的线性基。不要把“能表示的不同异或值个数 $2^r$”与“每个异或值对应多少下标子集 $2^{n-r}$”混为一谈。进一步理论见 &lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;5. 商结构与 DP 压缩：同类状态的下一步也必须同类&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 想只存余数、排序后的集合、某个哈希值或当前答案，忽略原状态的其他信息。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用步骤。&lt;/strong&gt; 明确等价关系 $x\sim y$；对每个合法操作 $T$ 检查：操作是否合法、代价和可观察收益是否一致，而且 $x\sim y$ 是否推出 $T(x)\sim T(y)$。若选择依赖状态，必须能逐项对应可选操作。这样才可以在等价类上定义转移；计数问题还要保留每类的权重或转移重数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 存 $x\bmod3$ 能支持任意整数加法、乘法，因为换代表元不会改变结果的余数；却不能支持 $T(x)=\lfloor x/2\rfloor$：$0\equiv3\pmod3$，但结果为 0、1，已经不同余。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;如何判断状态不足。&lt;/strong&gt; 主动找两个被合并的历史，并让它们面对同一个后续操作；若合法性或最优剩余值不同，就必须加信息。哈希碰撞控制的是表示错误概率，不能代替这个充分性证明。商集上的良定性见 &lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-8-%E5%95%86%E9%9B%86%E8%AF%B1%E5%AF%BC%E6%98%A0%E5%B0%84%E5%AE%9A%E7%90%86&quot;&gt;00-集合论与映射&lt;/a&gt;；群商还要求正规性，见 &lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;6. 群、环、域：为什么有的模数可以除，有的不行&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 公式里出现除法、约分、高斯消元的主元，或要把巨大指数按周期缩小。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;判断。&lt;/strong&gt; $\mathbb Z_m$ 在加法下是群；在乘法下只有与 $m$ 互质的元素有逆元，它们组成单位群。$m=p$ 为素数时，全部非零元素可逆，才可把通常的域上线性代数直接用于模运算。&lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/50c134275caf32dbf4430ab097185157_MIT18_703S13_pra_l_4.pdf&quot;&gt;MIT 循环群讲义&lt;/a&gt;证明了单位群与 Euler 定理；&lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/cef5dd050c4f35579c59cd70288fbd77_MIT18_703S13_pra_l_14.pdf&quot;&gt;MIT 环讲义&lt;/a&gt;给出了模环中的零因子。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 模 12 下 $5^{-1}=5$，但 6 无逆元；$6\cdot2\equiv6\cdot4\equiv0$，不能约去 6 得到 $2\equiv4$。因此复合模高斯消元不能把任意非零主元拿来求逆。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 使用 &lt;code&gt;cp::inv_mod(a,m)&lt;/code&gt; 并处理无逆元；素数模快速幂逆元要求 $a\not\equiv0$。对互质底数，指数可模元素的阶或 $\varphi(m)$；不互质时不能直接套 Euler 缩指数。比如 $2^4\bmod8=0$，把指数模 $\varphi(8)=4$ 后变成 $2^0\bmod8=1$。&lt;/p&gt;
&lt;h2&gt;7. 群作用与去重：不能看到旋转就除以 n&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 染色、项链、棋盘等对象在旋转/翻转下视为相同。先列清允许的变换：只旋转通常是循环群，旋转和翻转是二面体群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与证明。&lt;/strong&gt; 对有限群 $G$ 的作用，每个对象的轨道大小为 $|G|/|\operatorname{Stab}(x)|$；具有对称性的对象会有较小轨道，所以等价类并不统一有 $|G|$ 个元素。轨道与稳定子的基础见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/96221ce2d5b1077b3e5d3c5e08c88afe_MIT18_703S13_pra_l_23.pdf&quot;&gt;MIT 18.703：群作用&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;对固定对 $(g,x)$（满足 $g\cdot x=x$）双计数：一个轨道里所有点的稳定子大小之和恰为 $|G|$，故&lt;/p&gt;
&lt;p&gt;$$
#\text{轨道}=\frac1{|G|}\sum_{g\in G}|\operatorname{Fix}(g)|.
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 先把每个变换看成位置置换。不受其他条件限制的 $q$ 色染色要被该变换固定，同一个位置循环必须同色，因而有 $q^{c(g)}$ 种。圆环旋转 $r$ 格时有 $\gcd(n,r)$ 个位置循环。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 长为 4 的二色圆环，仅视旋转相同：四种旋转的不动点数为 $16,2,4,2$，答案 $(16+2+4+2)/4=6$，直接 $16/4=4$ 会漏算。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;边界。&lt;/strong&gt; 限制某种颜色数量、相邻颜色或图结构时，固定染色数需在循环压缩后的约束上重新计算，不能一律用 $q^{c(g)}$。取模时只有 $|G|$ 与模数互质才可乘逆元；否则在能保留整除信息的模数或整数范围下先求和再除。&lt;/p&gt;
&lt;h2&gt;8. NTT：单位根的阶决定能处理的长度&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 两组数按“下标和”组合，需要求 $c_k=\sum_{i+j=k}a_i b_j$；把它看成多项式乘法。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; 在素数域 $\mathbb F_p$ 中选阶恰为 $L$ 的元素 $\omega$。本册的二进制 NTT 要求 $L$ 是 2 的幂且 $L\mid(p-1)$；若 $g$ 为原根，可取 $\omega=g^{(p-1)/L}$。逆变换还要除以 $L$。ACL 的卷积接口明确给出了素数模与可用二次幂长度条件。&lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/convolution.html&quot;&gt;ACL convolution 官方文档&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用。&lt;/strong&gt; 先取 $L\ge|a|+|b|-1$ 的最小 2 次幂，检查根是否存在，再补零。模数 $998244353=119\cdot2^{23}+1$ 支持最长 $2^{23}$；调用本册 &lt;code&gt;cp::convolution&lt;/code&gt;。任意改模数，原根和最大长度都要一起重推。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; $(1+2x)(3+4x)=3+10x+8x^2$，需补到长度 4。模 7 的乘法群阶为 6，没有阶为 4 的元素，不能照搬长度 4 的常规 NTT。若不补零，算的是模 $x^L-1$ 的循环卷积，会让高次项绕回低位。&lt;/p&gt;
&lt;h2&gt;9. 有限域不等于“整数模一个同样大的数”&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;识别。&lt;/strong&gt; 题目使用二进制多项式、CRC、扩域，或声称有 $p^k$ 个域元素。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化。&lt;/strong&gt; $\mathbb F_p[x]/(f)$ 在 $f$ 不可约时是域；若 $\deg f=k$，每个元素可用次数小于 $k$ 的余式表示，共 $p^k$ 个。原因是任意非零余式 $a$ 与 $f$ 互质，扩展 Euclid 给出 $ua+vf=1$，从而 $u$ 是其逆元。二、三次多项式可通过检查基域上有无根判断不可约，高次不能只检查根。&lt;a href=&quot;https://ocw.mit.edu/courses/18-703-modern-algebra-spring-2013/5002c8bba6f97a9f750f2aca8b804db7_MIT18_703S13_pra_l_21.pdf&quot;&gt;MIT 18.703：多项式环&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;例。&lt;/strong&gt; 在 $\mathbb F_2$ 上，$f=x^2+x+1$ 在 0、1 都不为 0，故不可约。记 $\alpha=[x]$，则 $\alpha^2=\alpha+1$，$\alpha(\alpha+1)=1$。四个元素为 $0,1,\alpha,\alpha+1$；加法按位 XOR，乘法先做无进位多项式乘法，再模 $f$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;边界。&lt;/strong&gt; $\mathbb Z_4$ 中 $2\cdot2=0$，因此不是这个四元域。若模 $x^2+1=(x+1)^2$，非零 $x+1$ 的平方为 0，商环也不是域。CRC 的模多项式按检测需求选取，不保证不可约；不要因此假设所有非零余数都有逆元。&lt;/p&gt;
&lt;h2&gt;阅读顺序&lt;/h2&gt;
&lt;p&gt;竞赛应用先读本节和数学套路中的对应条目；需要证明时按“集合与映射 → 群与子群 → 循环群 / 陪集 → 商群与同态 → 同构定理 → 置换群”阅读。章节末的抽象代数易错点整理的是概念与证明；个人竞赛复盘单独放在全书最后。&lt;/p&gt;
&lt;p&gt;&amp;lt;!-- algebra-code-start --&amp;gt;&lt;/p&gt;
&lt;h2&gt;10. 可直接复制的代数代码&lt;/h2&gt;
&lt;p&gt;完整 GNU C++17 头文件，不依赖 &lt;code&gt;cp_ready.hpp&lt;/code&gt; 或第三方库；命名空间为 &lt;code&gt;cp_algebra&lt;/code&gt;。提交单文件时将头文件放在 &lt;code&gt;main&lt;/code&gt; 前，并删除示例中的本地 &lt;code&gt;include&lt;/code&gt;。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;接口&lt;/th&gt;
&lt;th&gt;输入与返回&lt;/th&gt;
&lt;th&gt;前提与代价&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;solve_binary(n, rows)&lt;/td&gt;
&lt;td&gt;每行是 &lt;code&gt;(系数位掩码,右端0/1)&lt;/code&gt;；返回是否有解、秩、特解、零空间基&lt;/td&gt;
&lt;td&gt;0≤n≤63，位j对应变量j；O(mn+n²)时间，O(m+n)空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;determinant_prime(a,p)&lt;/td&gt;
&lt;td&gt;方阵的行列式模p；空方阵返回1&lt;/td&gt;
&lt;td&gt;p为素数；O(n³+n log p)时间、O(n²)空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;spanning_trees_prime(n,edges,p)&lt;/td&gt;
&lt;td&gt;无向图生成树边权乘积之和，模p&lt;/td&gt;
&lt;td&gt;n≥1，顶点0-based，p素数；平行边累加，自环忽略，单点返回1；O(n³+n log p+m)时间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;lagrange_consecutive(y,t,p)&lt;/td&gt;
&lt;td&gt;y[i]=F(i)，返回F(t)模p&lt;/td&gt;
&lt;td&gt;已证明次数≤d，d=y.size()-1&amp;lt;p，p素数；O(d+log p)时间、O(d)空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;permutation_power(p,K)&lt;/td&gt;
&lt;td&gt;返回每个原位置执行K次后的目的地&lt;/td&gt;
&lt;td&gt;p为0-based双射，K为64位非负整数；O(n)时间/空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;power_sum(A,n,M)&lt;/td&gt;
&lt;td&gt;返回 &lt;code&gt;(A^n, Σ A^i)&lt;/code&gt;，求和i=0..n-1&lt;/td&gt;
&lt;td&gt;M≥2可为合数，n为64位非负整数；O(log n)时间、O(1)空间&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;&lt;strong&gt;解读二进制方程返回值。&lt;/strong&gt; 若无解，不读取特解与零空间基；若有解，全部解为 &lt;code&gt;particular&lt;/code&gt; 异或任意一个零空间基子集，解数为 &lt;code&gt;2^(n-rank)&lt;/code&gt;。题目若要求非空选择且目标为0，需要扣掉空选择。枚举所有解的成本本身是指数级，不要把基向量个数当解数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;检查运算结构。&lt;/strong&gt; &lt;code&gt;prime&lt;/code&gt; 接口将“p是素数”作为调用前提，不进行素性检测。合数模矩阵不能直接套用。生成树权值在这里是每棵树内相乘，不是树边权相加；无解图返回0，权值在模意义下抵消也可能得到0，不能据此反推原图不连通。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#pragma once
#include &amp;lt;bits/stdc++.h&amp;gt;

namespace cp_algebra {
using i64 = long long;
using i128 = __int128_t;
using u64 = std::uint64_t;

inline i64 norm(i64 x, i64 mod) {
    assert(mod &amp;gt;= 2);
    x %= mod;
    return x &amp;lt; 0 ? x + mod : x;
}
inline i64 power(i64 a, u64 e, i64 mod) {
    a = norm(a, mod);
    i64 r = 1;
    for (; e; e &amp;gt;&amp;gt;= 1, a = (i128)a * a % mod)
        if (e &amp;amp; 1) r = (i128)r * a % mod;
    return r;
}

// Each row is (coefficient mask, RHS). Variable j is bit j, 0 &amp;lt;= n &amp;lt;= 63.
// With a solution: x = particular XOR any subset of nullspace vectors.
struct BinarySolution {
    bool consistent;
    int rank;
    u64 particular;
    std::vector&amp;lt;u64&amp;gt; nullspace;
};
inline BinarySolution solve_binary(int n, std::vector&amp;lt;std::pair&amp;lt;u64, bool&amp;gt;&amp;gt; rows) {
    assert(0 &amp;lt;= n &amp;amp;&amp;amp; n &amp;lt;= 63);
    for (auto [a, b] : rows) { (void)b; assert((a &amp;gt;&amp;gt; n) == 0); }
    int m = (int)rows.size(), r = 0;
    std::vector&amp;lt;int&amp;gt; pivot;
    for (int col = 0; col &amp;lt; n &amp;amp;&amp;amp; r &amp;lt; m; ++col) {
        int at = r;
        while (at &amp;lt; m &amp;amp;&amp;amp; !(rows[at].first &amp;gt;&amp;gt; col &amp;amp; 1)) ++at;
        if (at == m) continue;
        std::swap(rows[r], rows[at]);
        for (int i = 0; i &amp;lt; m; ++i) if (i != r &amp;amp;&amp;amp; (rows[i].first &amp;gt;&amp;gt; col &amp;amp; 1)) {
            rows[i].first ^= rows[r].first;
            rows[i].second = rows[i].second != rows[r].second;
        }
        pivot.push_back(col);
        ++r;
    }
    for (auto [a, b] : rows) if (a == 0 &amp;amp;&amp;amp; b) return {false, r, 0, {}};
    BinarySolution ans{true, r, 0, {}};
    std::vector&amp;lt;bool&amp;gt; is_pivot(n, false);
    for (int i = 0; i &amp;lt; r; ++i) {
        is_pivot[pivot[i]] = true;
        if (rows[i].second) ans.particular |= u64(1) &amp;lt;&amp;lt; pivot[i];
    }
    for (int f = 0; f &amp;lt; n; ++f) if (!is_pivot[f]) {
        u64 v = u64(1) &amp;lt;&amp;lt; f;
        for (int i = 0; i &amp;lt; r; ++i)
            if (rows[i].first &amp;gt;&amp;gt; f &amp;amp; 1) v |= u64(1) &amp;lt;&amp;lt; pivot[i];
        ans.nullspace.push_back(v);
    }
    return ans;
}

// Prime mod is a caller precondition. Empty determinant is 1.
// O(n^3 + n log mod) time and O(n^2) copied storage; no primality test.
inline i64 determinant_prime(std::vector&amp;lt;std::vector&amp;lt;i64&amp;gt;&amp;gt; a, i64 mod) {
    assert(mod &amp;gt;= 2);
    int n = (int)a.size();
    for (auto &amp;amp;row : a) {
        assert((int)row.size() == n);
        for (auto &amp;amp;x : row) x = norm(x, mod);
    }
    i64 answer = 1;
    for (int col = 0; col &amp;lt; n; ++col) {
        int at = col;
        while (at &amp;lt; n &amp;amp;&amp;amp; a[at][col] == 0) ++at;
        if (at == n) return 0;
        if (at != col) { std::swap(a[at], a[col]); answer = norm(-answer, mod); }
        i64 p = a[col][col], inv = power(p, (u64)(mod - 2), mod);
        answer = (i128)answer * p % mod;
        for (int i = col + 1; i &amp;lt; n; ++i) {
            i64 factor = (i128)a[i][col] * inv % mod;
            for (int j = col; j &amp;lt; n; ++j) {
                i64 sub = (i128)factor * a[col][j] % mod;
                a[i][j] = a[i][j] &amp;gt;= sub ? a[i][j] - sub : mod - (sub - a[i][j]);
            }
        }
    }
    return answer;
}

struct Edge { int u, v; i64 weight = 1; };
// Undirected weighted Matrix-Tree: sum of products of edge weights, modulo prime.
// Vertices 0..n-1, n &amp;gt;= 1. Parallel edges add; self-loops have no effect.
inline i64 spanning_trees_prime(int n, const std::vector&amp;lt;Edge&amp;gt; &amp;amp;edges, i64 mod) {
    assert(n &amp;gt;= 1 &amp;amp;&amp;amp; mod &amp;gt;= 2);
    std::vector&amp;lt;std::vector&amp;lt;i64&amp;gt;&amp;gt; a(n - 1, std::vector&amp;lt;i64&amp;gt;(n - 1));
    auto add = [&amp;amp;](int u, int v, i64 w) {
        if (u &amp;lt; n - 1 &amp;amp;&amp;amp; v &amp;lt; n - 1) a[u][v] = ((i128)a[u][v] + w) % mod;
    };
    for (auto [u, v, weight] : edges) {
        assert(0 &amp;lt;= u &amp;amp;&amp;amp; u &amp;lt; n &amp;amp;&amp;amp; 0 &amp;lt;= v &amp;amp;&amp;amp; v &amp;lt; n);
        if (u == v) continue;
        i64 w = norm(weight, mod), neg = w ? mod - w : 0;
        add(u, u, w); add(v, v, w); add(u, v, neg); add(v, u, neg);
    }
    return determinant_prime(std::move(a), mod);
}

// Values y[i] = F(i), i=0..d, of a polynomial of degree &amp;lt;= d over F_mod.
// Caller guarantees prime mod and d &amp;lt; mod. O(d + log mod) time, O(d) storage.
inline i64 lagrange_consecutive(const std::vector&amp;lt;i64&amp;gt; &amp;amp;y, i64 t, i64 mod) {
    assert(mod &amp;gt;= 2 &amp;amp;&amp;amp; !y.empty());
    int d = (int)y.size() - 1;
    assert(d &amp;lt; mod);
    t = norm(t, mod);
    if (t &amp;lt;= d) return norm(y[(int)t], mod);
    std::vector&amp;lt;i64&amp;gt; pre(d + 2, 1), suf(d + 2, 1), invfact(d + 1, 1);
    i64 fact = 1;
    for (int i = 1; i &amp;lt;= d; ++i) fact = (i128)fact * i % mod;
    invfact[d] = power(fact, (u64)(mod - 2), mod);
    for (int i = d; i &amp;gt; 0; --i) invfact[i - 1] = (i128)invfact[i] * i % mod;
    for (int i = 0; i &amp;lt;= d; ++i) pre[i + 1] = (i128)pre[i] * norm(t - i, mod) % mod;
    for (int i = d; i &amp;gt;= 0; --i) suf[i] = (i128)suf[i + 1] * norm(t - i, mod) % mod;
    i64 answer = 0;
    for (int i = 0; i &amp;lt;= d; ++i) {
        i64 term = (i128)norm(y[i], mod) * pre[i] % mod * suf[i + 1] % mod;
        term = (i128)term * invfact[i] % mod * invfact[d - i] % mod;
        if ((d - i) &amp;amp; 1) term = term ? mod - term : 0;
        answer = ((i128)answer + term) % mod;
    }
    return answer;
}

// Valid permutation p[i] = destination of original position i; exponent K &amp;gt;= 0.
// Returns p^K(i) for every i; O(n). Apply values as new[result[i]] = old[i].
inline std::vector&amp;lt;int&amp;gt; permutation_power(const std::vector&amp;lt;int&amp;gt; &amp;amp;p, u64 k) {
    int n = (int)p.size();
    std::vector&amp;lt;int&amp;gt; indeg(n), answer(n);
    for (int v : p) { assert(0 &amp;lt;= v &amp;amp;&amp;amp; v &amp;lt; n); ++indeg[v]; }
    for (int count : indeg) { (void)count; assert(count == 1); }
    std::vector&amp;lt;bool&amp;gt; seen(n, false);
    for (int i = 0; i &amp;lt; n; ++i) if (!seen[i]) {
        std::vector&amp;lt;int&amp;gt; cycle;
        for (int v = i; !seen[v]; v = p[v]) { seen[v] = true; cycle.push_back(v); }
        std::size_t shift = k % cycle.size();
        for (std::size_t j = 0; j &amp;lt; cycle.size(); ++j)
            answer[cycle[j]] = cycle[(j + shift) % cycle.size()];
    }
    return answer;
}

// Returns (A^n, 1+A+...+A^(n-1)) mod M, for any M &amp;gt;= 2 (including composite).
// Binary composition of consecutive blocks; O(log n), no modular division.
inline std::pair&amp;lt;i64, i64&amp;gt; power_sum(i64 a, u64 n, i64 mod) {
    i64 result_p = 1, result_s = 0, block_p = norm(a, mod), block_s = 1;
    while (n) {
        if (n &amp;amp; 1) {
            result_s = ((i128)result_s + (i128)result_p * block_s) % mod;
            result_p = (i128)result_p * block_p % mod;
        }
        block_s = ((i128)block_s + (i128)block_p * block_s) % mod;
        block_p = (i128)block_p * block_p % mod;
        n &amp;gt;&amp;gt;= 1;
    }
    return {result_p, result_s};
}
} // namespace cp_algebra
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;11. 完整调用示例&lt;/h2&gt;
&lt;p&gt;下面的输出依次是：方程有解/秩/自由变量数，三角形生成树数，平方和插值值，置换2026次后的目的地，等比和。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &quot;cp_algebra.hpp&quot;
using namespace std;
using namespace cp_algebra;
int main() {
    auto s = solve_binary(3, {{0b011, true}, {0b110, false}});
    cout &amp;lt;&amp;lt; s.consistent &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt; s.rank &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt; s.nullspace.size() &amp;lt;&amp;lt; &apos;\n&apos;;
    cout &amp;lt;&amp;lt; spanning_trees_prime(3, {{0,1,1}, {1,2,1}, {2,0,1}}, 1000000007) &amp;lt;&amp;lt; &apos;\n&apos;;
    cout &amp;lt;&amp;lt; lagrange_consecutive({0,1,5,14}, 4, 1000000007) &amp;lt;&amp;lt; &apos;\n&apos;;
    auto p = permutation_power({1,2,0,4,3}, 2026);
    for (int v : p) cout &amp;lt;&amp;lt; v + 1 &amp;lt;&amp;lt; &apos; &apos;;
    cout &amp;lt;&amp;lt; &apos;\n&apos; &amp;lt;&amp;lt; power_sum(3, 4, 7).second &amp;lt;&amp;lt; &apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;预期输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1 2 1
3
30
2 3 1 4 5
5
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>模拟退火：赛场可读模板与使用场景</title><link>https://sanzenin.top/posts/obsidian/%E6%A8%A1%E6%8B%9F%E9%80%80%E7%81%AB%E7%9A%84%E9%80%82%E7%94%A8%E6%83%85%E5%BD%A2%E4%B8%8E%E5%88%86%E7%B1%BB%E6%A8%A1%E6%9D%BF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%A8%A1%E6%8B%9F%E9%80%80%E7%81%AB%E7%9A%84%E9%80%82%E7%94%A8%E6%83%85%E5%BD%A2%E4%B8%8E%E5%88%86%E7%B1%BB%E6%A8%A1%E6%9D%BF/</guid><description>模拟退火就是反复尝试“小改一下当前方案”：改好了就接受，改差了也偶尔接受；开始时比较敢接受变差，后来越来越谨慎。整个过程另外记住见过的最好方案，最后输出它。 接受变差，是为了给后续更好的改变留机会。例如现在的任务分配暂时比较均衡，但需要先把一个任务挪走，才能再挪另一个任务，得到更好的分配。只允许每一步立即改善，可能一直</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;模拟退火：赛场可读模板与使用场景&lt;/h1&gt;
&lt;p&gt;模拟退火就是反复尝试“小改一下当前方案”：改好了就接受，改差了也偶尔接受；开始时比较敢接受变差，后来越来越谨慎。整个过程另外记住见过的最好方案，最后输出它。&lt;/p&gt;
&lt;p&gt;接受变差，是为了给后续更好的改变留机会。例如现在的任务分配暂时比较均衡，但需要先把一个任务挪走，才能再挪另一个任务，得到更好的分配。只允许每一步立即改善，可能一直走不出当前分配。&lt;/p&gt;
&lt;p&gt;本节先用文字和具体例子说明，再给一份有中文注释、能直接编译的单文件程序。代码中的“代价”统一为越小越好。退火属于尝试寻找好方案的方法，不保证找到真正最优解；在必须得到精确答案的普通比赛里，不能仅凭多跑几次就认为一定能过。&lt;a href=&quot;https://img.atcoder.jp/intro-heuristics/editorial.pdf&quot;&gt;AtCoder 官方入门题解的比赛形式与退火说明&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;1. 什么时候值得考虑&lt;/h2&gt;
&lt;p&gt;题目满足下面几件事，才适合继续考虑退火：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;能先做出一个合法的完整方案。&lt;/li&gt;
&lt;li&gt;给你一个方案，你能算出它有多好，例如总路程、完成时间、冲突数。&lt;/li&gt;
&lt;li&gt;能只改变方案的一小部分，并且这种改变有机会让结果变好。&lt;/li&gt;
&lt;li&gt;所有方案太多，暂时没有找到能保证最优的快速算法，而题目允许近似结果或按得分评价。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;如果题目本来就能用排序、枚举、背包DP或其他确定算法解决，先用那些方法。尤其是“恰选几个数使总和最大”，排序后选最大的即可，不需要退火。&lt;/p&gt;
&lt;p&gt;如果只有完整正确的方案得1分，其余全部得0分，大量尝试都没有区别，退火也很难判断该往哪里走。可以先看能否用“有几处冲突”“还违反几条要求”衡量接近程度，但最后仍必须检查输出是否合法。&lt;/p&gt;
&lt;h2&gt;2. 使用场景：分别存什么、算什么、改什么&lt;/h2&gt;
&lt;p&gt;下面的“方案”就是你在代码中保存的一组数、一个排列、几个坐标或每件物品的归属。&lt;/p&gt;
&lt;h3&gt;场景一：从很多候选中恰好选几个&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 从很多候选店址里选5个，让更多住户附近有店。两家店的覆盖可能重叠，因此不能只给每个店址独立打分后取前5名。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：当前选中的店址，以及其余未选店址。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：统计住户被覆盖的总数；因为本模板比较的是“代价越小越好”，可以把覆盖数取负数作为代价。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：移除一个已选店址，加入一个未选店址。始终还是5个。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：不要只随机翻转一个“选/不选”标记，那样会改变选中数量。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;本节完整代码就采用这种“一换一”的写法，不过评分换成“选中数的总和离目标多远”，方便手算和检查。&lt;/p&gt;
&lt;h3&gt;场景二：调整一个访问顺序或工作顺序&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 所有城市都要访问一次，调整访问顺序，使总路程更短。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：一个城市编号排列。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：按排列顺序累加相邻城市的距离；如果题目要求回到起点，还要加最后一个城市到起点的距离。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：交换两个城市的位置，或把一段访问顺序反过来。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：固定起点、固定终点等限制要保留；如果单行道导致来回距离不同，反转一段后，里面每条路的代价也要重新计算。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;开始时直接重算整条路线最容易写对。以后需要加速，再研究哪些边真的发生了变化；不用一开始就背一个看不懂的距离差公式。&lt;/p&gt;
&lt;h3&gt;场景三：把任务分给几台机器，尽量均衡&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 把若干任务分给3台机器，每个任务有耗时，希望最忙的机器也能尽快做完。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：每个任务分给哪台机器。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：先累加每台机器的总耗时，再取其中最大值作为代价。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：把一个任务移到另一台机器，或交换两台机器上的各一个任务。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：若每台机器还有限额、不能空着或必须恰好分到几件任务，新方案也必须满足这些要求。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;“让最长耗时最小”和“让各组耗时的平方和最小”是不同目标，要按题目要求评分，不能随便互换。若改动先破坏当前方案再检查，拒绝时很容易忘记恢复；本节使用候选副本，被拒绝后直接丢弃。&lt;/p&gt;
&lt;h3&gt;场景四：在一个区域里找一个合适的位置&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 在给定矩形里放一个点，希望它离最近的障碍点尽可能远。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：当前横坐标和纵坐标。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：算出它到每个障碍点的距离，取最小距离；希望这个距离越大越好，因此评分时取负数。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：横坐标、纵坐标各随机加减一点。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：点不能跑出矩形；有禁入区域时也要检查。越界的候选可以直接丢弃，不必强行挤到边界。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;坐标改动幅度和温度分开设。温度决定“多大的代价变差还能容忍”，坐标幅度决定“这一跳能移动多远”。例如区域宽1000，却每次只移动0.001，可能跑很久也走不到别处。&lt;/p&gt;
&lt;p&gt;也不是所有找位置的题都需要退火：一条直线上最小化距离和，可以找中位数；最小化平方距离和，可以找平均位置；覆盖所有点的最小圆，本书有专门算法。先识别这些结构。&lt;/p&gt;
&lt;h3&gt;场景五：调整布局，减少冲突&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 在棋盘上摆放若干对象，希望相互冲突的对数尽量少。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：每个对象的位置。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：统计冲突对数，越少越好。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：移动一个对象，或交换两个对象的位置。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：不能放在禁用格、不能重叠等硬性要求，要在生成候选时检查。不能把“冲突还剩1对”当成已经满足无冲突要求。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;如果只移动一个对象总是无法改善，可以尝试同时移动少量对象，但每次都把整个布局随机重做，通常又很难保留已经得到的好部分。&lt;/p&gt;
&lt;h3&gt;场景六：方案要经过一段模拟才能评分&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;例子。&lt;/strong&gt; 修改任务顺序后，要按题目规则模拟执行，才知道总完成时间。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;保存什么&lt;/strong&gt;：当前执行顺序或操作安排。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;怎样算好坏&lt;/strong&gt;：完整模拟得到的完成时间或题目给定得分。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;随机改哪里&lt;/strong&gt;：交换少量位置，或者只取出一小段任务重新安排。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必须注意&lt;/strong&gt;：一次评分如果很慢，能尝试的次数就少。先估算运行量，再决定跑几轮；不要只把降温系数改得更接近1。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;“改一小部分，再完整检查候选”是容易写对的起点。官方入门题解也建议，把以后加速用的局部评分与完整重算对照检查。&lt;a href=&quot;https://img.atcoder.jp/intro-heuristics/editorial.pdf&quot;&gt;AtCoder 官方入门题解，第4节&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;3. 接受规则：只需要看当前、候选、最好这三个词&lt;/h2&gt;
&lt;p&gt;假设代价越小越好：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;候选代价比当前小，接受。&lt;/li&gt;
&lt;li&gt;候选代价和当前相同，也可以接受，给下一次改变换一个起点。&lt;/li&gt;
&lt;li&gt;候选代价比当前大，才按概率决定是否接受。&lt;/li&gt;
&lt;li&gt;一旦遇到比历史最好还好的方案，就把它单独保存。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;一定和当前比较。&lt;/strong&gt; 假设最好代价是0，当前代价是10，候选代价是8。8比当前的10好，应当直接接受；不要因为它比历史最好的0差，就把它误判成一次变差。&lt;/p&gt;
&lt;p&gt;代码使用下面这句计算“接受变差”的概率：&lt;/p&gt;
&lt;p&gt;&lt;code&gt;exp(-变差幅度 / 温度)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;exp&lt;/code&gt; 是 C++ 的指数函数，这里你只需要掌握结果的变化方向：变差幅度越大，概率越小；温度越高，概率越大。注意前面的负号，且只在候选更差的分支计算。&lt;a href=&quot;https://www.gnu.org/software/gsl/doc/html/siman.html&quot;&gt;GSL 官方文档中的接受规则&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;例如当前代价100、候选代价110，变差了10：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;温度&lt;/th&gt;
&lt;th&gt;大约有多大概率接受&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;100&lt;/td&gt;
&lt;td&gt;90%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;37%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;0.005%&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;随机生成一个0到1的小数，若它小于上面算出的概率，就接受。&lt;code&gt;rand()&lt;/code&gt; 的原始返回值是整数，不能直接拿来和这个概率比较。&lt;/p&gt;
&lt;h2&gt;4. 参数怎样在现场调&lt;/h2&gt;
&lt;p&gt;代码里有四个参数需要先看：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;参数&lt;/th&gt;
&lt;th&gt;示例设置&lt;/th&gt;
&lt;th&gt;改动后有什么影响&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;开始温度&lt;/td&gt;
&lt;td&gt;1000&lt;/td&gt;
&lt;td&gt;越大，开始时越愿意接受变差&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;停止温度&lt;/td&gt;
&lt;td&gt;0.01&lt;/td&gt;
&lt;td&gt;越小，后期越不容易接受变差&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;每步降温系数&lt;/td&gt;
&lt;td&gt;0.995&lt;/td&gt;
&lt;td&gt;每尝试一次温度乘它；越接近1，尝试次数越多&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;重启次数&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;从几个不同起点分别跑，始终保存全程最好方案&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;这些只是示例值。先看看随机小改一次时，代价通常会变差多少：如果常常变差几万，开始温度1000可能太低；如果通常只变差1，开始温度1000就会非常宽松。不能把同一组数当作所有题的固定答案。&lt;/p&gt;
&lt;p&gt;用当前参数，每轮大约尝试2300次，5轮共约1.2万次。本模板每次复制整个方案、重新计算代价，所用时间还要乘上方案大小。如果题目有很多数据组，所有数据组的运行量也要相加。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;重启不是继续上一轮。&lt;/strong&gt; 本例第一轮从原顺序开始，后面打乱顺序，换新的初始选择，再恢复开始温度。随机数生成器只初始化一次，不要每次重启都用同一种子重新创建，否则可能把同一条搜索过程重复跑几遍。&lt;/p&gt;
&lt;h2&gt;5. 完整模板在解决什么问题&lt;/h2&gt;
&lt;p&gt;例题：给出若干整数，恰好选出指定个数，让它们的总和尽量接近目标。&lt;/p&gt;
&lt;p&gt;输入：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4 2 14
2 5 9 12
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思是从4个数里选2个，希望总和接近14。可以选2和12，也可以选5和9，误差都是0。输出第一行是找到的最小误差，第二行是选中数的原下标，从1开始；例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0
1 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不同合法选择的输出顺序可以不同。误差必须和输出的选择对应。&lt;/p&gt;
&lt;p&gt;这道例题只是方便展示退火的完整过程：实际遇到选数题，仍应先看能否枚举或用背包DP准确解决。本程序不把“运行结束”当成“已经证明最优”。&lt;/p&gt;
&lt;p&gt;方案用一个下标排列保存：&lt;strong&gt;前面指定数量的位置表示选中，后面的位置表示未选中&lt;/strong&gt;。例如排列 &lt;code&gt;0 3 1 2&lt;/code&gt; 表示选中原下标0和3，也就是数2和12。随机从前半部分和后半部分各取一个位置交换，选中的数量始终不变。&lt;/p&gt;
&lt;p&gt;输入前提：个数不能为负，选取数量在0到总个数之间；所有输入数的绝对值之和，再加目标的绝对值，不超过 &lt;code&gt;10^15&lt;/code&gt;。代码按这个范围使用 &lt;code&gt;long long&lt;/code&gt;，避免求和、做差和取绝对值溢出。&lt;/p&gt;
&lt;h2&gt;6. 带中文注释的完整单文件代码&lt;/h2&gt;
&lt;p&gt;代码里的三处“换题改这里”分别对应：计算代价、调整温度、生成一次合法的小改动。更换方案的数据结构时，也要同步修改初解和输出。&lt;/p&gt;
&lt;p&gt;&amp;lt;!-- annealing-code-start --&amp;gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;

// 完整例题：从 n 个整数中恰好选 k 个，让它们的总和尽量接近 target。
// 输入：n k target，下一行 n 个整数。
// 输出：找到的最小误差，下一行输出选中的原下标（从 1 开始）。
// 数值前提：所有数的绝对值之和，再加上 target 的绝对值，不超过 10^15。
// 因此下面的整数求和、相减和取绝对值都不会溢出。
int n, k;
ll target;
vector&amp;lt;ll&amp;gt; value;

// 随机数生成器只初始化一次。固定种子方便本地复现。
mt19937 rng(20261025);
uniform_real_distribution&amp;lt;double&amp;gt; random01(0.0, 1.0);

vector&amp;lt;int&amp;gt; best_order;  // 搜索过程中，见过的最好方案。
ll best_cost = LLONG_MAX;

// 【换题改这里 1】如何计算一个方案的代价。这里代价越小越好。
// order 存所有数的原下标，前 k 个位置表示选中，后面表示未选中。
ll calculate_cost(const vector&amp;lt;int&amp;gt;&amp;amp; order) {
    ll sum = 0;
    for (int i = 0; i &amp;lt; k; ++i) sum += value[order[i]];
    return abs(sum - target);
}

void simulated_annealing(vector&amp;lt;int&amp;gt; current_order) {
    ll current_cost = calculate_cost(current_order);
    if (current_cost &amp;lt; best_cost) {
        best_cost = current_cost;
        best_order = current_order;
    }

    // 全不选或全选时，选中的集合已经固定，不存在“一换一”的改变。
    // 先返回，避免下面构造空范围的随机数分布。
    if (k == 0 || k == n) return;

    uniform_int_distribution&amp;lt;int&amp;gt; pick_selected(0, k - 1);
    uniform_int_distribution&amp;lt;int&amp;gt; pick_unselected(k, n - 1);

    // 【换题改这里 2】根据一次变差的常见幅度调温，下面只是示例参数。
    const double start_temperature = 1000.0;  // 大：开始时较愿意接受变差。
    const double stop_temperature = 0.01;     // 小：结束前主要保留改善。
    const double cooling = 0.995;             // 每尝试一次，温度乘这个数。

    for (double temperature = start_temperature;
         temperature &amp;gt; stop_temperature;
         temperature *= cooling) {

        // 复制一份候选。若不接受它，直接丢弃，当前方案就不会被改坏。
        vector&amp;lt;int&amp;gt; candidate_order = current_order;

        // 【换题改这里 3】随机小改一次，并保证新方案仍然合法。
        // 从选中区和未选中区各取一个位置，交换后仍然恰选 k 个数。
        int selected_pos = pick_selected(rng);
        int unselected_pos = pick_unselected(rng);
        swap(candidate_order[selected_pos], candidate_order[unselected_pos]);

        ll candidate_cost = calculate_cost(candidate_order);

        // 必须和“当前方案”比较，不能和 best_cost 比较。
        bool accept_candidate = candidate_cost &amp;lt;= current_cost;

        if (!accept_candidate) {
            ll worse_by = candidate_cost - current_cost;  // 到这里一定为正。

            // exp 是 C++ 的指数函数。参数越负，返回的概率越接近 0。
            // 变差越多，接受概率越低；温度越高，接受概率越高。
            double probability = exp(-static_cast&amp;lt;double&amp;gt;(worse_by) / temperature);
            accept_candidate = random01(rng) &amp;lt; probability;
        }

        if (accept_candidate) {
            current_order = std::move(candidate_order);
            current_cost = candidate_cost;

            // 接受变差只是为了继续探索，最好方案必须另外保存。
            if (current_cost &amp;lt; best_cost) {
                best_cost = current_cost;
                best_order = current_order;
            }
        }
        // 没接受：候选副本被丢弃，不需要再交换回去。
    }
}

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

    if (!(cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k &amp;gt;&amp;gt; target)) return 0;
    if (n &amp;lt; 0 || k &amp;lt; 0 || k &amp;gt; n) return 0;
    value.resize(n);
    for (ll&amp;amp; x : value) cin &amp;gt;&amp;gt; x;

    // order = [0, 1, ..., n-1]，第一次从原顺序开始。
    vector&amp;lt;int&amp;gt; order(n);
    iota(order.begin(), order.end(), 0);

    const int restarts = 5;
    for (int run = 0; run &amp;lt; restarts; ++run) {
        // 后面几次打乱顺序，换一个起点；沿用同一个随机数生成器。
        if (run &amp;gt; 0) shuffle(order.begin(), order.end(), rng);
        simulated_annealing(order);
    }

    // 输出 best_order 对应的代价和方案，不输出最后停留的 current_order。
    cout &amp;lt;&amp;lt; best_cost &amp;lt;&amp;lt; &apos;\n&apos;;
    for (int i = 0; i &amp;lt; k; ++i) {
        if (i) cout &amp;lt;&amp;lt; &apos; &apos;;
        cout &amp;lt;&amp;lt; best_order[i] + 1;
    }
    cout &amp;lt;&amp;lt; &apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在模板目录编译：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;g++ -std=c++17 -O2 -Wall -Wextra ready/annealing_readable.cpp -o /tmp/cp-annealing
/tmp/cp-annealing
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;7. 改成自己的题时，按这个顺序检查&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;先确定代码里保存什么。例如选中的下标、城市顺序、每件物品的组别、点的坐标。&lt;/li&gt;
&lt;li&gt;写一个完整评分函数，能手算的小例必须和它一致。若原目标越大越好，可用它的相反数作为代价；取负前先检查类型范围。&lt;/li&gt;
&lt;li&gt;写一次随机小改动，确认它不会违反恰选数量、位置范围、容量等限制。非法候选直接丢弃，并继续降温。&lt;/li&gt;
&lt;li&gt;始终比较候选与当前，接受后同时更新当前方案和当前代价；遇到全程最好时，把方案与代价一起保存。&lt;/li&gt;
&lt;li&gt;先保持完整重算的写法。确实太慢时，再只计算受改动影响的部分，并与完整评分对照。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;例如改成城市路线：方案仍然可以是编号排列，评分改成总路程，小改动改为交换两个允许移动的位置，输出改为访问顺序。改成点坐标：方案要改成横纵坐标，评分按题目要求计算，随机改动改为坐标加减，并检查范围。&lt;/p&gt;
&lt;p&gt;这份程序会修改全局的最好方案；若改为多组数据，每组开始前重置 &lt;code&gt;best_cost&lt;/code&gt; 并清空 &lt;code&gt;best_order&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E7%BC%96%E8%AF%91%E5%99%A8%E9%A2%84%E5%A4%84%E7%90%86/&quot;&gt;算法竞赛编译器预处理&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;。&lt;/p&gt;
</content:encoded></item><item><title>算法竞赛个人易错点</title><link>https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/</guid><description>这份清单以“发现性质 → 定义状态 → 证明正确 → 检查实现”为顺序。目标是每个问题都有一个可以立刻执行的动作，而不是泛泛地提醒仔细。 - 对话摘要：2026-07至10 算法三个月回顾（用户提供） 与 2026-10 算法对话回顾（用户提供）。名义范围 2026-07-25 至 10-25，主要记录集中在 8 月中</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛个人易错点&lt;/h1&gt;
&lt;p&gt;这份清单以“发现性质 → 定义状态 → 证明正确 → 检查实现”为顺序。目标是每个问题都有一个可以立刻执行的动作，而不是泛泛地提醒仔细。&lt;/p&gt;
&lt;h2&gt;证据范围&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;对话摘要&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/2026-07%E8%87%B310-%E7%AE%97%E6%B3%95%E4%B8%89%E4%B8%AA%E6%9C%88%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/&quot;&gt;2026-07至10 算法三个月回顾（用户提供）&lt;/a&gt; 与 &lt;a href=&quot;/posts/obsidian/2026-10-%E7%AE%97%E6%B3%95%E5%AF%B9%E8%AF%9D%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/&quot;&gt;2026-10 算法对话回顾（用户提供）&lt;/a&gt;。名义范围 2026-07-25 至 10-25，主要记录集中在 8 月中下旬后；没有独立读取原始网页会话，不把摘要中的追问算成错误次数。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;本地核对&lt;/strong&gt;：读取 &lt;code&gt;/home/sanzenin/test/algo&lt;/code&gt; 的代码及相关讲解；当前版本可能已经修复当时错误。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;实现复现&lt;/strong&gt;：对明确的整数移位问题运行 UBSan。其余条件性风险会写明输入前提，不能等同于原题 WA。&lt;/li&gt;
&lt;li&gt;优先级是复习建议，不是统计错误率；本次没有批量修改你的题目解答。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;归因&lt;/strong&gt;：Hydra 首版 WA 来自先前助手代码，不算用户代码错误；只作为历史信息不足的模型反例。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;1. 动态过程：太早进入算法，漏掉不变量&lt;/h2&gt;
&lt;p&gt;对话摘要中的最高位递归和 Slot Machine，都属于“自然模型复杂，换个状态很短”。&lt;/p&gt;
&lt;p&gt;开写前花两分钟做这三件事：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;手动操作三个状态，写出共同保留的对象。&lt;/li&gt;
&lt;li&gt;把“历史”改写成已保留集合、极值、差值、计数或顺序统计量。&lt;/li&gt;
&lt;li&gt;检查只给这个压缩状态，是否能恢复下一次操作。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;例&lt;/strong&gt;：Slot Machine 在“先删最大、再补新数”的规则下，状态是历史最小 $n-1$ 个数加最新值。原理和最终样本数见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#16-%E9%A1%BA%E5%BA%8F%E7%BB%9F%E8%AE%A1%E9%87%8F-%E5%85%88%E5%8C%BA%E5%88%86%E8%BF%9E%E7%BB%AD%E4%B8%8E%E7%A6%BB%E6%95%A3&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;停止条件&lt;/strong&gt;：找不到性质时再进入 DP / 搜索；不要因为“像按位题”就默认每位独立。若某操作重置了连续计数，逐位状态必须体现重置，或按最高位分段处理。&lt;/p&gt;
&lt;h2&gt;2. DP：同时检查“少存了什么”和“多存了什么”&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;充分性判据&lt;/strong&gt;：同一状态的任意两段历史，未来允许的决策和最优剩余代价是否相同？相同才能合并。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;冗余性判据&lt;/strong&gt;：某个维度能否由其他维度唯一算出？能就不必存。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;本人近期场景&lt;/th&gt;
&lt;th&gt;判断&lt;/th&gt;
&lt;th&gt;立刻执行&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;状压分组 &lt;code&gt;dp[mask][rem]&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;rem=sum[mask]%T&lt;/code&gt; 可恢复&lt;/td&gt;
&lt;td&gt;删余数维，单独检查 T&amp;gt;0、空集与答案换算&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cryptarithm 当前块位置&lt;/td&gt;
&lt;td&gt;对话里提出的是合理质疑&lt;/td&gt;
&lt;td&gt;看状态定义是否含最后选到的位置&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;括号树&lt;/td&gt;
&lt;td&gt;深度、已处理兄弟和祖先前缀是不同量&lt;/td&gt;
&lt;td&gt;画含两棵子树的括号森林再标状态&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;树形 DP&lt;/td&gt;
&lt;td&gt;同一节点不同父边约束可能影响未来&lt;/td&gt;
&lt;td&gt;明确树根、状态参数和转移依赖&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;可直接查看 &lt;a href=&quot;/home/sanzenin/test/algo/Cryptarithm_%E9%80%9A%E4%BF%97%E8%AE%B2%E8%A7%A3.md:66&quot;&gt;本地 Cryptarithm 讲解&lt;/a&gt;。其中 $f_j(i)$ 已定义为“当前副本最后选在位置 $i$”，&lt;strong&gt;没有缺少这个位置&lt;/strong&gt;。副本数已计入费用，不必再存。预收整份删除费 $W=x+nz$ 后，每保留一项退还 $z$，转移为&lt;/p&gt;
&lt;p&gt;$$f_j(i)=\min(\min_{t&amp;lt;i}f_{j-1}(t),\min_tf_{j-1}(t)+W)+y|a_i-b_j|-z.$$&lt;/p&gt;
&lt;p&gt;不要把你对状态的追问误写成“你提交了状态不足的错误解”。&lt;/p&gt;
&lt;h2&gt;3. 概率：先用一句中文说清事件&lt;/h2&gt;
&lt;p&gt;对话摘要明确记录过把 $\frac1m(k/m)^{n-1}$ 当成最大值恰为 $k$ 的概率。&lt;/p&gt;
&lt;p&gt;这其实固定了一个样本等于 $k$，其他样本不超过 $k$。正确事件应为“所有样本不超过 $k$，但不全小于 $k$”：&lt;/p&gt;
&lt;p&gt;$$P(\max X_i=k)=(k/m)^n-((k-1)/m)^n.$$&lt;/p&gt;
&lt;p&gt;固定反例 &lt;code&gt;n=2,m=2&lt;/code&gt;：四种结果，最大值为 2 的有三种，概率 $3/4$。若你的式子算不出它，先修事件再写代码。&lt;/p&gt;
&lt;p&gt;连续顺序统计的分母为“参与排序样本数 + 1”。Slot Machine 最新样本被单独保留时，不参与旧历史最小值的排序；本地 &lt;code&gt;nowcoder_2026_summer/10/e.cpp:17&lt;/code&gt; 分母为 $n+k$，要从 $n+k-1$ 个旧样本解释，不能死背。&lt;/p&gt;
&lt;h2&gt;4. SOS：先画包含方向，费用另算&lt;/h2&gt;
&lt;p&gt;对话摘要中的 Retest Queue 涉及超集方向、拒绝费用；没有完整题面，不能补造它的费用公式。&lt;/p&gt;
&lt;p&gt;通用检查用两位掩码：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;01&lt;/code&gt; 的子集是 &lt;code&gt;00,01&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;01&lt;/code&gt; 的超集是 &lt;code&gt;01,11&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;所有“包含我要求的特征”的候选，应查询超集。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;x &amp;amp; y == 0&lt;/code&gt; 应查询固定位宽补集的子集，不是超集。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;写注释 &lt;code&gt;dp[S] = ...&lt;/code&gt; 后再写循环。费用必须按接受/拒绝事件分别列式，不能因为 SOS 统计了人数就默认这些人都支付同样费用。&lt;/p&gt;
&lt;h2&gt;5. 计数：先固定见证对象&lt;/h2&gt;
&lt;p&gt;对话摘要中 Matrix Game 的 $k^a$ 漏了“相同取值属于同一组行”的要求。&lt;/p&gt;
&lt;p&gt;以后每个乘法因子旁写含义：“先选哪组行”“再选颜色”“后选列”。如果两个因子都在重新挑行组，它们通常不能直接相乘。鸽巢前把鸽子和巢写成具体元组。&lt;/p&gt;
&lt;p&gt;最小验证：取 2–3 行、2–3 列，枚举矩阵或选择对象，检查“同一行组”是不是被多个局部选择偷换。&lt;/p&gt;
&lt;h2&gt;6. 贪心 / 博弈：可行不等于最优&lt;/h2&gt;
&lt;p&gt;循环排列奇偶策略等问题在摘要中属于证明理解，不直接记为错误。&lt;/p&gt;
&lt;p&gt;用两段式证明：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;能保证&lt;/strong&gt;：给出一个合法策略，说明不变量如何持续。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;不能更好&lt;/strong&gt;：给出对手反制、下界或交换论证，封住更优结果。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;若证明“只考虑这几种情况”，必须说明任意其他方案如何归约到它们。小规模 Minimax 可帮助发现策略，但打表一致不能代替证明；有循环的博弈还需定义终止和和局。&lt;/p&gt;
&lt;h2&gt;7. 位操作：类型由左操作数决定&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;本地确定问题&lt;/strong&gt;：&lt;a href=&quot;/home/sanzenin/test/algo/cf/cf1077/d.cpp:71&quot;&gt;cf/cf1077/d.cpp&lt;/a&gt; 循环包括 &lt;code&gt;i=32&lt;/code&gt;，重建时使用 &lt;code&gt;(bit_p &amp;lt;&amp;lt; i)&lt;/code&gt;、&lt;code&gt;(bit_q &amp;lt;&amp;lt; i)&lt;/code&gt;；&lt;code&gt;bit_p&lt;/code&gt; 是 &lt;code&gt;int&lt;/code&gt;。即使赋给 &lt;code&gt;long long&lt;/code&gt;，右侧也已按 32 位移位。UBSan 对输入 &lt;code&gt;1\n1 1\n&lt;/code&gt; 可复现“shift exponent 32 ... 32-bit type int”。&lt;/p&gt;
&lt;p&gt;修正形式：&lt;code&gt;(1ULL * bit_p &amp;lt;&amp;lt; i)&lt;/code&gt;，并保证 &lt;code&gt;0&amp;lt;=i&amp;lt;64&lt;/code&gt;。若结果必须为有符号数，还需保证最高位不会越过可表示范围。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// GNU C++17；只对非零 unsigned long long x 调用
int low = __builtin_ctzll(x);       // 最低 1 的位号
int high = 63 - __builtin_clzll(x); // 最高 1 的位号
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;0 要先特判；&lt;code&gt;1 &amp;lt;&amp;lt; k&lt;/code&gt; 的位宽仍是 int，&lt;code&gt;1ULL &amp;lt;&amp;lt; k&lt;/code&gt; 才是无符号 64 位。&lt;/p&gt;
&lt;h2&gt;8. 128 位：把强制转换移到第一个危险运算前&lt;/h2&gt;
&lt;p&gt;摘要记录过中间乘法先溢出的问题。本地 &lt;a href=&quot;/home/sanzenin/test/algo/reginonals/26xian/h.cpp:46&quot;&gt;26xian/h.cpp&lt;/a&gt; 也保留了条件性风险：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cur += (__int128)(pos - last) * (x - y * cnt);
// y*cnt 与 pos-last 都先以 long long 计算。
// 如果参数上界允许超过 long long，改为：
cur += ((__int128)pos - last) * ((__int128)x - (__int128)y * cnt);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是否触发依赖原题上界，本次未把它宣判为原题 WA。&lt;code&gt;sum&lt;/code&gt;、累加量和最终 &lt;code&gt;(long long)ans&lt;/code&gt; 也要核对范围。打印 128 位使用配套 &lt;code&gt;to_string128&lt;/code&gt;，不要为了输出强行缩回 64 位。&lt;/p&gt;
&lt;h2&gt;9. 扫描线：每次只推进一个明确动作&lt;/h2&gt;
&lt;p&gt;摘要记录过 &lt;code&gt;i++, cnt += events[i].second&lt;/code&gt; 先跳索引的错误。当前 &lt;code&gt;26xian/h.cpp&lt;/code&gt; 已使用先读再递增，不能记为仍未修复。&lt;/p&gt;
&lt;p&gt;推荐固定写法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while (i &amp;lt; events.size() &amp;amp;&amp;amp; events[i].first == pos) {
    cnt += events[i].second;
    ++i;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;顺序固定为“用旧斜率走到 pos → 记录值 → 合并 pos 的全部事件”。测试同坐标两个开始事件、开始与结束重合、零长度区间。没有证明单峰时，不把断点扫描随意替换成三分。&lt;/p&gt;
&lt;h2&gt;10. DFS、左偏树、括号树：结构检查不能只靠样例&lt;/h2&gt;
&lt;p&gt;摘要中的结构错误建立以下固定检查：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;对象&lt;/th&gt;
&lt;th&gt;不变量&lt;/th&gt;
&lt;th&gt;极小数据&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;DFS&lt;/td&gt;
&lt;td&gt;从根调用；无向边跳父亲；孩子先算完再合并&lt;/td&gt;
&lt;td&gt;单点、长度 3 的链、星形树&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DP&lt;/td&gt;
&lt;td&gt;叶子值正确，不可达不会被普通 0 混入&lt;/td&gt;
&lt;td&gt;不能选择任何对象的状态&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;左偏树&lt;/td&gt;
&lt;td&gt;堆序；左 dist &amp;gt;= 右 dist；dist=右 dist+1&lt;/td&gt;
&lt;td&gt;空堆合并、单点 pop、重复键&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;空堆&lt;/td&gt;
&lt;td&gt;&lt;code&gt;dist[0]=0&lt;/code&gt;、新叶子 dist=1（或统一另一套约定）&lt;/td&gt;
&lt;td&gt;merge(0,0)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;括号树&lt;/td&gt;
&lt;td&gt;0 仅作为虚拟根，真实点从 1 起&lt;/td&gt;
&lt;td&gt;&lt;code&gt;()&lt;/code&gt;、&lt;code&gt;()()&lt;/code&gt;、&lt;code&gt;(())&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;反对角线&lt;/td&gt;
&lt;td&gt;$i+j=d$ 时 max(1,d-m)&amp;lt;=i&amp;lt;=min(n,d-1)&lt;/td&gt;
&lt;td&gt;1x1、1xm、nx1、2x3&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;如果同时处理相邻对角线的并集，范围可能要包含哨兵 0，必须注明；不能用一个看似宽松的区间默默访问真实数组以外的位置。&lt;/p&gt;
&lt;p&gt;本地 &lt;code&gt;nowcoder_2026_summer/3/j.cpp&lt;/code&gt; 对新节点设置 &lt;code&gt;dist=1&lt;/code&gt;，空点默认 0；它体现了正确的一套约定。&lt;/p&gt;
&lt;h2&gt;11. 递归必须有严格下降的量&lt;/h2&gt;
&lt;p&gt;摘要记录最高位递归在 $n=2,3$ 可能不缩小。本地 &lt;code&gt;cf/cf1129/d1.cpp&lt;/code&gt; 目前只有小值分支和未完成的主体，不是可直接用的模板，也不能从它推断完整递推正确。&lt;/p&gt;
&lt;p&gt;对每条递归边写出 $measure(next)&amp;lt;measure(cur)$；可用 n、剩余位数、未处理节点数或字典序二元组。把 0、1、2、3 逐个代入，若出现自己调自己，增加基例或改递推。&lt;/p&gt;
&lt;h2&gt;12. 状态规模与内存是实现的一部分&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/home/sanzenin/test/algo/nowcoder_2026_summer/8/m.cpp:26&quot;&gt;nowcoder/8/m.cpp&lt;/a&gt; 分配约一百万个 &lt;code&gt;vector&amp;lt;int&amp;gt;(28)&lt;/code&gt;：仅 int 负载约 106.8 MiB，另有约 22.9 MiB 的 vector 对象（典型 64 位实现）和一百万次堆分配开销。更适合连续 &lt;code&gt;vector&amp;lt;array&amp;lt;int,26&amp;gt;&amp;gt;&lt;/code&gt; 或按实际 Trie 节点数分配。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/home/sanzenin/test/algo/cf/1523D.cpp:38&quot;&gt;cf/1523D.cpp&lt;/a&gt; 抽样 20 次；若一次命中支持最优答案的样本概率至少 1/2，且各次独立，理论漏掉概率至多 $2^{-20}$。仍需证明行内压缩位数小，否则 $2^{siz}$ 无法承受。&lt;/li&gt;
&lt;li&gt;$2^{22}$ 个 &lt;code&gt;int&lt;/code&gt; 约 16 MiB，&lt;code&gt;long long&lt;/code&gt; 约 32 MiB；有多份数组时按峰值相加。时间按轮数乘 $B2^B$，不能只看一次 SOS。&lt;/li&gt;
&lt;li&gt;哈希/随机化要注明正确性概率；&lt;code&gt;TODO&lt;/code&gt;、空 solve、未完成函数不能仅凭能编译就收入可用模板。本地 &lt;code&gt;cf/453A.cpp&lt;/code&gt; 是空壳，应使用已推导的公式而非复制这个文件。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;13. 已核对的笔记错误&lt;/h2&gt;
&lt;p&gt;本次修正 &lt;code&gt;DIRICHLET卷积以及莫比乌斯反演.md&lt;/code&gt; 的两处数学表达：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;欧拉函数为 $\varphi(n)=\sum_{i=1}^n[\gcd(i,n)=1]$，示性条件在方括号内。&lt;/li&gt;
&lt;li&gt;Dirichlet 卷积与莫比乌斯反演对任意算术函数成立，不要求积性。积性是在需要利用质因子独立计算时附加的性质。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这两处是笔记校订证据，不等于近期对话里反复出错。&lt;/p&gt;
&lt;h2&gt;三个月新增：相同模式在不同题型中的表现&lt;/h2&gt;
&lt;h3&gt;重复键不是可以随意丢弃的历史&lt;/h3&gt;
&lt;p&gt;摘要中树上碰撞的 &lt;code&gt;rev[x][dep[x]+s]=i&lt;/code&gt; 覆盖前一人。最小反例：一个节点、两个人同在时刻 0 出生，应该立即碰撞。&lt;/p&gt;
&lt;p&gt;插入映射前先问：&lt;strong&gt;同 key 的两个对象是否等价，还是它们相遇就是事件？&lt;/strong&gt; 对应处理可为计数、保存全部 ID、插入失败即触发；不是一律把 map 改 multimap。比如只维护最小费用时，同 key 取 min 就合理。&lt;/p&gt;
&lt;h3&gt;树上差分：先确定恢复的是边还是根路径&lt;/h3&gt;
&lt;p&gt;两端点 XOR 标记 &lt;code&gt;d[u]^=1,d[v]^=1&lt;/code&gt; 后，恢复边覆盖奇偶要子传父。对子树边 $(parent[v],v)$，删边形成的割中，每条路径跨割当且仅当一个端点在子树内，因此子树 XOR 就是边覆盖奇偶。&lt;/p&gt;
&lt;p&gt;父传子通常恢复已定义的根到点前缀；它不能替代端点标记的子树汇总。调用 &lt;code&gt;cp::tree_path_xor_edges&lt;/code&gt; 可得到按输入边顺序的覆盖奇偶，采用迭代遍历避免深链递归。&lt;/p&gt;
&lt;h3&gt;回滚与清理是算法的一部分&lt;/h3&gt;
&lt;p&gt;DSU on Tree 的 &lt;code&gt;keep=false&lt;/code&gt; 分支，对自己临时加入的状态必须清理，即使已经找到答案。虚树的邻接边、访问标记、多测答案集合也都要明确归属。&lt;/p&gt;
&lt;p&gt;固定写法是先保存 &lt;code&gt;found&lt;/code&gt;，继续执行必要清理，再返回。也可让每次 check 拥有独立局部容器，或用作用域恢复器。&lt;strong&gt;不能把 keep=true 的保留状态一并清空&lt;/strong&gt;，应逐项说明哪些状态归本层所有。&lt;/p&gt;
&lt;p&gt;测试：连续调用同一 check 两次应得相同结果；交换兄弟处理顺序应不改变答案；两组测试用例交换顺序后输出只交换、不变化。&lt;/p&gt;
&lt;h3&gt;数值域、位置域、压缩编号分清&lt;/h3&gt;
&lt;p&gt;约数扫描线摘要中的 &lt;code&gt;divisors[i]&lt;/code&gt;/&lt;code&gt;divisors[a[i]]&lt;/code&gt;、扫 &lt;code&gt;ma&lt;/code&gt;/扫 &lt;code&gt;n&lt;/code&gt;，与 MEX 中 &lt;code&gt;j*i&lt;/code&gt;/&lt;code&gt;j*x&lt;/code&gt;、&lt;code&gt;pre&lt;/code&gt;/&lt;code&gt;dp&lt;/code&gt; 混用，根源都是变量含义漂移。&lt;/p&gt;
&lt;p&gt;对每个数组写一句 &lt;code&gt;数组[谁] = 什么&lt;/code&gt;：&lt;code&gt;divisors[value]&lt;/code&gt;、&lt;code&gt;last[valueId]&lt;/code&gt;、&lt;code&gt;dp[prefixLength]&lt;/code&gt;、&lt;code&gt;events[position]&lt;/code&gt;。把 idx、value、rank 分开命名，离散编号只能用于比较/索引，原始距离不能用编号差代替。&lt;/p&gt;
&lt;p&gt;差值 DP 封装 &lt;code&gt;idx(d)=d+offset&lt;/code&gt;，包括初始化 &lt;code&gt;idx(0)&lt;/code&gt;；切勿只给转移加 offset。&lt;/p&gt;
&lt;h3&gt;二分必须证明边界与整个检查复杂度&lt;/h3&gt;
&lt;p&gt;Gas Station 的“容量至少最大边权”仅在&lt;strong&gt;不能在边内部增设站、完整走边需要足够油量&lt;/strong&gt;的模型下成立；若允许边内加站，结论要重证。题名不能代替题意。&lt;/p&gt;
&lt;p&gt;开区间二分先写 &lt;code&gt;check(lo)=false,check(hi)=true&lt;/code&gt;（或相反），推导上界或在有可行性保证时扩大上界；无解和乘二溢出单独处理。复杂度按 &lt;code&gt;轮数 × check&lt;/code&gt; 算，嵌套 LCA 再乘 $\log n$；不要把判定扫描误认为一次总共只扫一遍。&lt;/p&gt;
&lt;h3&gt;最短路边内部必须比较两个入口&lt;/h3&gt;
&lt;p&gt;CF144D 边 $(u,v,w)$ 上、距 u 为 x 的点：&lt;/p&gt;
&lt;p&gt;$$D(x)=\min(dis[u]+x,dis[v]+w-x).$$&lt;/p&gt;
&lt;p&gt;候选 $x=L-dis[u]$ 必须满足 $0&amp;lt;x&amp;lt;w$，以及另一方向 $dis[v]+w-x\ge L$。等号表示从两端得到同一个候选，要去重。最小反例：只有一条长度 10 的边，却有另一条路让 &lt;code&gt;dis[u]=dis[v]=0&lt;/code&gt;；从 u 看 x=7 是 L=7，但实际最短距离是 3。（可用两端与源点各连零权边实现；若原题边权要求正，可统一把两端距离改为 1、目标改为 8。）&lt;/p&gt;
&lt;p&gt;本地 &lt;code&gt;cf/144D.cpp&lt;/code&gt; 当前已比较另一端，等号用顶点编号约束去重；摘要中的错误不应写成当前版本仍存在。&lt;/p&gt;
&lt;h3&gt;概率必须覆盖全部类别&lt;/h3&gt;
&lt;p&gt;Erratic Lights 的“方案数漏除总方案数”和 CF1418E 的“漏弱怪贡献”是两类错误。前者核对样本空间权重；后者把对象分类后逐类写指示变量。&lt;/p&gt;
&lt;p&gt;强怪被挡不代表弱怪永远不造成伤害：盾牌破后遇到弱怪仍可能贡献。强怪数量恰等于耐久时，是检测“强怪贡献为 0、弱怪仍可能非零”的有效边界。公式与假设见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/#22-%E5%88%86%E7%B1%BB%E6%9C%9F%E6%9C%9B-%E4%B8%8D%E8%A6%81%E6%BC%8F%E6%8E%89%E8%A2%AB%E7%8A%B6%E6%80%81%E6%94%B9%E5%8F%98%E7%9A%84%E5%8F%A6%E4%B8%80%E7%B1%BB&quot;&gt;算法竞赛数学套路&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;BFS、容器与几何的固定动作&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;BFS 每次取队首后立即 pop；visited/距离在入队时更新，避免重复入队。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;erase(first,last)&lt;/code&gt; 使用半开区间；空范围是 first==last，别把结尾迭代器解引用。&lt;/li&gt;
&lt;li&gt;先明确输出是否需要操作数，再输出完整操作序列；回放操作验证最终状态与每步合法性。&lt;/li&gt;
&lt;li&gt;反三角函数前检查几何是否有解，再对理论在 [-1,1] 的值 clamp；不能靠 clamp 掩盖本来无交点的情况。&lt;/li&gt;
&lt;li&gt;构造图的父边来自指定遍历树，验证源点可达及构造后算法产生的顺序；输入顺序不天然等于遍历顺序。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;三个月二刷清单&lt;/h2&gt;
&lt;p&gt;这些题名来自用户提供的回顾；没有完整题面/官方编号的条目暂不补造链接。每题完成的标准是恢复性质、证明和代码，而不是读完题解。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;[ ] 树上碰撞：两个相同键触发事件，不被覆盖。&lt;/li&gt;
&lt;li&gt;[ ] Gas Station：解释站点位置限制、可行上下界、深链。&lt;/li&gt;
&lt;li&gt;[ ] Erratic Lights：每项权重说明概率空间、全部下标合法。&lt;/li&gt;
&lt;li&gt;[ ] Canal Crossing：用割解释子传父，手算三点链。&lt;/li&gt;
&lt;li&gt;[ ] RGB 分段：两个前缀差推偏序，query在insert前。&lt;/li&gt;
&lt;li&gt;[ ] MEX 区间计数：变量含义不漂移、空区间、重叠约束、小规模暴力。&lt;/li&gt;
&lt;li&gt;[ ] DSU on Tree + XOR：keep=false清理、重复check、兄弟顺序无关。&lt;/li&gt;
&lt;li&gt;[ ] CF1418E：强怪和弱怪两类贡献、强怪数等于耐久。&lt;/li&gt;
&lt;li&gt;[ ] CF144D：两个入口、边端点、相等候选去重。&lt;/li&gt;
&lt;li&gt;[ ] Cryptarithm：说清最后位置、开新副本、P更新时机。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;提交前九项检查&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;[ ] 写出一个可验证的不变量 / 单调性 / 结构化简。&lt;/li&gt;
&lt;li&gt;[ ] DP 状态足以决定未来，没有可推导的多余维度。&lt;/li&gt;
&lt;li&gt;[ ] 贪心或博弈有“能保证”和“不能更好”两部分。&lt;/li&gt;
&lt;li&gt;[ ] 概率事件、计数见证、子集 / 超集方向写成一句中文。&lt;/li&gt;
&lt;li&gt;[ ] DFS 有入口，父亲与叶子处理一致，深链考虑递归栈。&lt;/li&gt;
&lt;li&gt;[ ] 每个递归分支严格缩小，0、1、2、3 都能终止。&lt;/li&gt;
&lt;li&gt;[ ] 空集、虚拟点、闭区间、同坐标事件合法。&lt;/li&gt;
&lt;li&gt;[ ] 乘法、减法、移位先确定类型；模减法规范化；分母可逆。&lt;/li&gt;
&lt;li&gt;[ ] 手算重复值与边界；需要时用不同思路的暴力对拍。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;一轮复盘怎么用&lt;/h2&gt;
&lt;p&gt;每道题只记四行：&lt;strong&gt;题面触发器 → 我漏掉的性质 → 最小反例 → 下次固定动作&lt;/strong&gt;。没有出错、只是认真追问证明的题，记录为“证明待巩固”。&lt;/p&gt;
&lt;p&gt;优先补：最大值概率、SOS 方向、mask 删维、最高位递归收缩、同坐标事件。每题写五行状态 / 证明，比重复复制模板更有针对性。&lt;/p&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%BB%8F%E5%85%B8trick/&quot;&gt;经典Trick&lt;/a&gt;。&lt;/p&gt;
</content:encoded></item><item><title>算法竞赛增补核对记录</title><link>https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E5%A2%9E%E8%A1%A5%E6%A0%B8%E5%AF%B9%E8%AE%B0%E5%BD%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E5%A2%9E%E8%A1%A5%E6%A0%B8%E5%AF%B9%E8%AE%B0%E5%BD%95/</guid><description>本地代码根目录 /home/sanzenin/test/algo 共发现 2354 份 .cpp。按文件修改时间筛出 2026-09-25 至 10-25 的 126 份代码（排除 tempCodeRunnerFile.cpp）；修改时间不是提交时间、AC时间或对话日期。本次读取了这些文件的目录与元信息，针对下表等候选</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛增补核对记录&lt;/h1&gt;
&lt;h2&gt;本轮范围&lt;/h2&gt;
&lt;p&gt;本地代码根目录 &lt;code&gt;/home/sanzenin/test/algo&lt;/code&gt; 共发现 2354 份 &lt;code&gt;.cpp&lt;/code&gt;。按文件修改时间筛出 2026-09-25 至 10-25 的 126 份代码（排除 &lt;code&gt;tempCodeRunnerFile.cpp&lt;/code&gt;）；修改时间不是提交时间、AC时间或对话日期。本次读取了这些文件的目录与元信息，针对下表等候选阅读核心实现，&lt;strong&gt;不是逐题审查2354份代码&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;读取vault算法目录及根目录CSES相关笔记的目录，重点核对《经典Trick》、FFT/NTT、Dirichlet卷积、概率期望、虚树与可并堆等现有内容。抽象代数课程笔记不作为本次全部重写的对象。&lt;/p&gt;
&lt;p&gt;对话来源是用户本次提供的两份回顾，见 &lt;a href=&quot;/posts/obsidian/2026-07%E8%87%B310-%E7%AE%97%E6%B3%95%E4%B8%89%E4%B8%AA%E6%9C%88%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/&quot;&gt;2026-07至10 算法三个月回顾（用户提供）&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/2026-10-%E7%AE%97%E6%B3%95%E5%AF%B9%E8%AF%9D%E5%9B%9E%E9%A1%BE-%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B/&quot;&gt;2026-10 算法对话回顾（用户提供）&lt;/a&gt;。Windows侧Kimi桥接可用，但ChatGPT显示登录页；用户已要求先整理本地、网页稍后补。没有独立抓取原始会话，不补造缺失时间段记录。&lt;/p&gt;
&lt;h2&gt;已有代码 → 原记录缺口 → 本次落点&lt;/h2&gt;
&lt;p&gt;“缺口”指9月手册/专题未完整覆盖或没有便于直接使用的接口，不代表这项知识完全不在你的其他笔记中。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;本地来源（均相对代码根目录）&lt;/th&gt;
&lt;th&gt;可归纳内容&lt;/th&gt;
&lt;th&gt;原记录状况&lt;/th&gt;
&lt;th&gt;本轮落点&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;cf/165E.cpp&lt;/td&gt;
&lt;td&gt;固定位宽补集查询子集见证&lt;/td&gt;
&lt;td&gt;原手册没有SOS专题&lt;/td&gt;
&lt;td&gt;Trick O、subset_witness&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cf/449D.cpp&lt;/td&gt;
&lt;td&gt;超集zeta + AND=0容斥&lt;/td&gt;
&lt;td&gt;原手册未完整收录&lt;/td&gt;
&lt;td&gt;Trick O、count_and_zero，预处理2的幂&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cf/1523D.cpp&lt;/td&gt;
&lt;td&gt;随机抽样、压缩活跃位、超集统计&lt;/td&gt;
&lt;td&gt;未说明误差与复杂度&lt;/td&gt;
&lt;td&gt;个人易错点的概率与规模检查&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cf/cf1125/f.cpp&lt;/td&gt;
&lt;td&gt;指数奇偶向量、前缀对称差&lt;/td&gt;
&lt;td&gt;Trick只有基础位运算&lt;/td&gt;
&lt;td&gt;Trick P、数学套路3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;luogu/P5664.cpp&lt;/td&gt;
&lt;td&gt;严格多数坏事件互斥、差值DP&lt;/td&gt;
&lt;td&gt;原手册缺模型说明&lt;/td&gt;
&lt;td&gt;Trick Q、数学套路6&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;atcoder/atcoder480/f.cpp&lt;/td&gt;
&lt;td&gt;sum[mask]决定余数、删维&lt;/td&gt;
&lt;td&gt;缺独立状态审查&lt;/td&gt;
&lt;td&gt;Trick R、数学套路7&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;nowcoder_2026_summer/8/m.cpp&lt;/td&gt;
&lt;td&gt;下一次使用、缓存淘汰、Trie对象&lt;/td&gt;
&lt;td&gt;PBDS代码有，应用模型没提炼&lt;/td&gt;
&lt;td&gt;Trick S、单项缓存模板与批次限制&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;reginonals/26xian/h.cpp&lt;/td&gt;
&lt;td&gt;截断函数断点、斜率扫描&lt;/td&gt;
&lt;td&gt;原手册仅几何扫描线&lt;/td&gt;
&lt;td&gt;Trick T、clipped_cost_min&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;reginonals/21nanjing/j.cpp&lt;/td&gt;
&lt;td&gt;差值质因子、向上下倍数调整&lt;/td&gt;
&lt;td&gt;数论代码未写触发器&lt;/td&gt;
&lt;td&gt;Trick U、数学套路1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;reginonals/23xian/f.cpp&lt;/td&gt;
&lt;td&gt;原根指数域、循环卷积、快速幂&lt;/td&gt;
&lt;td&gt;FFT/NTT专题已有，旧全集未收全&lt;/td&gt;
&lt;td&gt;Trick V、数学套路13&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;luogu/P4245.cpp、atcoder/practice2/f.cpp&lt;/td&gt;
&lt;td&gt;多模/单模卷积、逆变换归一化&lt;/td&gt;
&lt;td&gt;旧全集缺NTT直接用接口&lt;/td&gt;
&lt;td&gt;固定模数convolution、约束说明&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cf/144D.cpp&lt;/td&gt;
&lt;td&gt;边内部距离取两端min，相等去重&lt;/td&gt;
&lt;td&gt;旧全集只有Dijkstra基础&lt;/td&gt;
&lt;td&gt;三个月易错点，当前代码已考虑两端&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cf/1418E.cpp&lt;/td&gt;
&lt;td&gt;强/弱两类不同贡献概率&lt;/td&gt;
&lt;td&gt;旧概率笔记缺该边界反例&lt;/td&gt;
&lt;td&gt;数学套路22；当前代码已含两类&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;nowcoder_2026_summer/10/e.cpp&lt;/td&gt;
&lt;td&gt;历史最小值不变量、样本数&lt;/td&gt;
&lt;td&gt;期望表有，但不变量需解释&lt;/td&gt;
&lt;td&gt;数学套路16&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;nowcoder_2026_summer/6/f.cpp&lt;/td&gt;
&lt;td&gt;Z函数、前缀与后缀字典序、偏序&lt;/td&gt;
&lt;td&gt;原手册字符串只有KMP/Trie等&lt;/td&gt;
&lt;td&gt;z_function；题面特定26位DP未直接模板化&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;atcoder/atcoder477/f.cpp&lt;/td&gt;
&lt;td&gt;行范围前缀差 + 双BIT区间加和&lt;/td&gt;
&lt;td&gt;原数据结构专题已有部分&lt;/td&gt;
&lt;td&gt;阅读后保留原专题，未重复贴整题&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;atcoder/atcoder479/e.cpp、f.cpp&lt;/td&gt;
&lt;td&gt;删边子树/补集贡献、排名与逆序对&lt;/td&gt;
&lt;td&gt;BIT/逆序对旧手册已有&lt;/td&gt;
&lt;td&gt;贡献法触发器，未把题面特定式冒充通用公式&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cf/cf1128/e.cpp&lt;/td&gt;
&lt;td&gt;括号树祖先路径与已处理子树&lt;/td&gt;
&lt;td&gt;原手册缺近期边界&lt;/td&gt;
&lt;td&gt;结构不变量检查&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;nowcoder_2026_summer/3/j.cpp&lt;/td&gt;
&lt;td&gt;左偏树合并与空点dist约定&lt;/td&gt;
&lt;td&gt;旧手册已有左偏树&lt;/td&gt;
&lt;td&gt;核对新点初始化，避免重复收录&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cf/cf1077/d.cpp&lt;/td&gt;
&lt;td&gt;数位关系与重建位宽&lt;/td&gt;
&lt;td&gt;当前代码存在确定的32位移位UB&lt;/td&gt;
&lt;td&gt;最小输入UBSan复现，易错点7&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cf/cf1129/d1.cpp、cf/453A.cpp&lt;/td&gt;
&lt;td&gt;未完成递归、空solve&lt;/td&gt;
&lt;td&gt;不能视为可用模板&lt;/td&gt;
&lt;td&gt;明确未收录为已验证实现&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;来自用户回顾、没有冒称独立读到原提交的增补：RGB前缀差转二维偏序、Canal Crossing边路径XOR差分、DSU on Tree回滚、碰撞重复键。其通用实现另外做了对拍。&lt;/p&gt;
&lt;h2&gt;旧笔记与生成器修复&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;《经典Trick》原A–N保留，新补O–Z共12条，增加完整整理入口。&lt;/li&gt;
&lt;li&gt;欧拉函数示性条件写回方括号内；纠正Dirichlet卷积/莫比乌斯反演“不要求积性”。&lt;/li&gt;
&lt;li&gt;旧生成器按已不存在的早期标题切片，可能空截取；改为完整导入当前Trick，不再依赖这些字符串。&lt;/li&gt;
&lt;li&gt;贡献法全文保留为Markdown说明，避免把整篇公式说明塞进cpp块。&lt;/li&gt;
&lt;li&gt;新目录使用显式稳定锚点；导入专题标题下移并跳过代码块，防止源代码中的&lt;code&gt;#include&lt;/code&gt;被改坏。&lt;/li&gt;
&lt;li&gt;生成前检查每节非空，完成后原子替换输出；源文件缺失会停止，不覆盖现有手册。&lt;/li&gt;
&lt;li&gt;后续按用户要求补齐Pandoc/XeLaTeX生成流程，PDF已更新为校订合订本；代码修订与检查见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%9D%BF%E5%AD%90%E6%A3%80%E6%9F%A5%E6%8A%A5%E5%91%8A/&quot;&gt;算法竞赛板子检查报告&lt;/a&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;验证记录&lt;/h2&gt;
&lt;p&gt;环境：本机g++，GNU C++17；&lt;code&gt;-Wall -Wextra&lt;/code&gt;；ASan与UBSan。随机种子固定为20261025。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;ready/verify.cpp&lt;/code&gt;：&lt;strong&gt;PASS 97881 independent checks&lt;/strong&gt;。这是断言检查数，不是评测题数或AC数量。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;floor/ceil通过整数不等式检查，含&lt;code&gt;LLONG_MIN / -1&lt;/code&gt;；逆元与gcd互质性核对；组合数对照Pascal递推。&lt;/li&gt;
&lt;li&gt;floor_sum对照逐项整除；子集/超集zeta对照双重集合枚举并做逆变换。&lt;/li&gt;
&lt;li&gt;AND=0计数对照枚举所有非空下标子集；GCD对与区间计数对照直接枚举。&lt;/li&gt;
&lt;li&gt;Z对照逐后缀字符匹配；NTT对照二重循环卷积，覆盖空输入、负系数与跨多层变换。&lt;/li&gt;
&lt;li&gt;离线缓存对照枚举所有缓存状态的最优DP：穷举三种对象、长度0至7、容量0至3的访问序列。&lt;/li&gt;
&lt;li&gt;断点扫描对照小整数参数完全枚举；树差分对照逐条BFS恢复路径；二维最大值对照已插入点逐个扫描，含重复坐标、负数、空结构。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;ready/example.cpp&lt;/code&gt;编译并核对预期输出；笔记中的头文件代码与真实头文件一致。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;确定问题复现：只读编译 &lt;code&gt;cf/cf1077/d.cpp&lt;/code&gt;，输入 &lt;code&gt;1\n1 1\n&lt;/code&gt;，UBSan报告第71行 &lt;code&gt;shift exponent 32 is too large for 32-bit type int&lt;/code&gt;。没有改原刷题代码。&lt;/p&gt;
&lt;p&gt;验证范围补充：本页97881项是上轮通用增补的记录。后续已逐段检查第一至八章并修复明确问题，报告见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%9D%BF%E5%AD%90%E6%A3%80%E6%9F%A5%E6%8A%A5%E5%91%8A/&quot;&gt;算法竞赛板子检查报告&lt;/a&gt;；仍未远程判题，也未通过Obsidian GUI逐页验收。PDF另外检查中文、公式、图片和代码排版。用户应按接口前提和原题模型选择模板。&lt;/p&gt;
&lt;h2&gt;文件与维护&lt;/h2&gt;
&lt;p&gt;主入口 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B4%E7%90%86%E7%B4%A2%E5%BC%95/&quot;&gt;算法竞赛整理索引&lt;/a&gt;；可复制接口 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;；证明与触发器 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;；个人复盘 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;本地整理稿 &lt;code&gt;/home/sanzenin/algo_templates/notes&lt;/code&gt;；&lt;code&gt;refresh_notes.py&lt;/code&gt; 刷新与代码同源的模板笔记，&lt;code&gt;build_book.py&lt;/code&gt; 生成全集，&lt;code&gt;sync_vault.py&lt;/code&gt; 同步vault，&lt;code&gt;verify_notes.py&lt;/code&gt; 检查链接、同步和实际复制代码。代码主仓库保持原样。&lt;/p&gt;
&lt;p&gt;修改前原文备份位于 &lt;code&gt;/home/sanzenin/algo_templates/.backups/20261025-205142&lt;/code&gt;，包含sha256清单。备份在WSL ext4中，不混入Obsidian检索。&lt;/p&gt;
</content:encoded></item><item><title>算法竞赛数学套路</title><link>https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/</guid><description>这章按“题面长什么样 → 把什么量写出来 → 怎样算”组织。每个模式都给出可手算的小例、成立条件与实现入口。引用的原题用来提供练习模型；没有题解的原题链接，不代表其中已经给出了本章推导。 实现接口见 算法竞赛模板增补，代数结构与相应代码见 抽象代数的竞赛用法。本章的 cp:: 接口来自配套 ready/cpready.</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛数学套路&lt;/h1&gt;
&lt;p&gt;这章按“题面长什么样 → 把什么量写出来 → 怎样算”组织。每个模式都给出可手算的小例、成立条件与实现入口。引用的原题用来提供练习模型；没有题解的原题链接，不代表其中已经给出了本章推导。&lt;/p&gt;
&lt;p&gt;实现接口见 &lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;，代数结构与相应代码见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。本章的 &lt;code&gt;cp::&lt;/code&gt; 接口来自配套 &lt;code&gt;ready/cp_ready.hpp&lt;/code&gt;，索引约定以接口说明为准。&lt;/p&gt;
&lt;h2&gt;0. 题面信号 → 第一反应&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;题面信号&lt;/th&gt;
&lt;th&gt;先定义的量&lt;/th&gt;
&lt;th&gt;应用方向&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;若干数一起平移、要求最终同余&lt;/td&gt;
&lt;td&gt;差值及差值的 GCD&lt;/td&gt;
&lt;td&gt;1、2、27&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;乘积、完全幂、约数、阶乘整除&lt;/td&gt;
&lt;td&gt;每个质数的指数&lt;/td&gt;
&lt;td&gt;3、26&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GCD 恰好是某值、两数互质&lt;/td&gt;
&lt;td&gt;“都被 d 整除”的宽条件&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;区间和整除、数量相等或比较&lt;/td&gt;
&lt;td&gt;前缀余数、前缀差&lt;/td&gt;
&lt;td&gt;25、23&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;非空、至少一个、每类都出现&lt;/td&gt;
&lt;td&gt;坏事件及其交集&lt;/td&gt;
&lt;td&gt;5、6、29&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;不能越界的括号、网格路径&lt;/td&gt;
&lt;td&gt;前缀高度、第一次越界点&lt;/td&gt;
&lt;td&gt;30&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;旋转相同、重复执行置换&lt;/td&gt;
&lt;td&gt;置换循环及固定点&lt;/td&gt;
&lt;td&gt;20、35&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;配对指标相加、二项式加权&lt;/td&gt;
&lt;td&gt;系数序列或生成函数&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;XOR 可达、开关翻转、解的个数&lt;/td&gt;
&lt;td&gt;GF(2) 的秩与自由变量&lt;/td&gt;
&lt;td&gt;31&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;巨大步数、固定规则迭代&lt;/td&gt;
&lt;td&gt;状态转移、特征递推&lt;/td&gt;
&lt;td&gt;28、34&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;树的数量、保证联通的选边方案&lt;/td&gt;
&lt;td&gt;拉普拉斯矩阵&lt;/td&gt;
&lt;td&gt;32&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;最大值、第 k 小、等到收集齐&lt;/td&gt;
&lt;td&gt;CDF、指示变量、等待阶段&lt;/td&gt;
&lt;td&gt;15–17、36、37&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;最小绝对偏差、重排、平均分配&lt;/td&gt;
&lt;td&gt;斜率、交换差、边际费用&lt;/td&gt;
&lt;td&gt;18、19、38、39&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;操作很多但每步变化受限&lt;/td&gt;
&lt;td&gt;守恒量、势能、相邻差&lt;/td&gt;
&lt;td&gt;40、41&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;一、数论：把数值限制改写成整除与指数&lt;/h2&gt;
&lt;h3&gt;1. 同步操作：先研究差值&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：几个数同时加减；操作似乎要追踪大数，但它们的相对差异很小。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：若 $(a,b)\to(a-t,b-t)$，则 $d=b-a$ 不变。要使平移后两数都被 $p$ 整除，必要且充分的是 $p\mid d$ 且 $t\equiv a\pmod p$。先分解 $d$，再枚举允许的约数或质因子；若随后同时除以 $p$，新差值为 $d/p$，状态可改为 $(a,d)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$(14,20)$ 的差是 6。同时减 2 后变成 $(12,18)$，可同除 6；要同除 5 则无论怎样同步平移都不可能，因为 $5\nmid6$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：题目必须允许相应平移，并核对正数范围、方向和费用。$d=0$ 时不能靠枚举其质因子解决。试除分解 $O(\sqrt{|d|})$；不是对所有“同时操作”题都存在同样递推。&lt;/p&gt;
&lt;h3&gt;2. 自选模数：同余变整除&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：自己选模数，让一组数余数相同；询问最大可行模数或有多少模数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：写出 $a_i\equiv a_1\pmod m$，即 $m\mid(a_i-a_1)$。求&lt;/p&gt;
&lt;p&gt;$$g=\gcd(|a_2-a_1|,\ldots,|a_n-a_1|).$$&lt;/p&gt;
&lt;p&gt;所有候选恰为 $g$ 的正约数，再检查题目额外限制；若求无上界的最大模数且 $g&amp;gt;0$，答案就是 $g$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[8,14,20]$ 的差值 GCD 为 6，可选 $1,2,3,6$；模 6 均余 2。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：$g=0$ 代表原数全相同，可能没有有限最大值。指定余数 $r$ 时还须 $0\le r&amp;lt;m$，并改算 $\gcd(a_i-r)$。求 GCD 为 $O(n\log V)$；列约数可 $O(\sqrt g)$。其基础是扩展欧几里得维护的整数线性组合关系，参见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/number-theory/euclid.h&quot;&gt;KACTL euclid 作者实现&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;3. 乘积条件 → 质因子指数状态&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：乘积为平方、完全 $k$ 次幂；把一个给定整数拆成有序因子的方案数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：正整数 $x=\prod_p p^{e_p}$。完全 $k$ 次幂要求所有指数和模 $k$ 为 0；用前缀指数向量 $P_i$，区间条件成为 $P_r=P_{l-1}$。平方时向量加法就是 XOR，同类前缀有 $c$ 个便贡献 $\binom c2$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[2,8,3,12]$ 的非空平方乘积区间有 $[2,8]$、$[3,12]$、整个数组，共 3 个。若求 $a_1a_2a_3=12$ 的正整数有序解，$12=2^2 3$；分配两个指数分别有 $\binom42$、$\binom32$ 种，乘积为 18。后一类模型见 &lt;a href=&quot;https://img.atcoder.jp/abc110/editorial.pdf&quot;&gt;ABC110 D 官方题解&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：必须存规范指数向量，不能把质数的数值直接 XOR 当作无碰撞编码。$k&amp;gt;2$ 时仍比较两个前缀相等；若做“当前向量与另一个数配成完全幂”的查询，才查相反向量。0 与负号分别处理。筛最小质因子 $O(V\log\log V)$，分解每个数 $O(\log V)$，向量比较/哈希费用另计。&lt;/p&gt;
&lt;h3&gt;4. GCD 恰好值：先算倍数条件，再反演&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：统计 GCD 等于 $d$ 的对、元组，或把所有 GCD 加起来；直接枚举每一对太慢。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：令 $c_d$ 为能被 $d$ 整除的元素数，$e_d$ 为 GCD 恰为 $d$ 的无序下标对数。宽条件包含所有倍数：&lt;/p&gt;
&lt;p&gt;$$\binom{c_d}{2}=\sum_{k\ge1}e_{kd},\qquad e_d=\binom{c_d}{2}-\sum_{k\ge2}e_{kd}.$$&lt;/p&gt;
&lt;p&gt;从大到小消去真倍数即可。若是长度 $N$、每项在 $[1,K]$ 的序列，把 $\binom{c_d}{2}$ 换成 $\lfloor K/d\rfloor^N$；这是 &lt;a href=&quot;https://atcoder.jp/contests/abc162/tasks/abc162_e?lang=en&quot;&gt;ABC162 E 原题&lt;/a&gt; 的可行入口。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[2,3,4]$ 中 $c_1=3,c_2=2$，所以 $e_2=1,e_1=3-1=2$；GCD 之和为 4。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：正整数、值域 $V$ 可开数组时，倍数筛 $O(V\log V)$；接口 &lt;code&gt;cp::exact_gcd_pairs&lt;/code&gt;。只要互质对可用 $\sum_d\mu(d)\binom{c_d}{2}$；求 GCD 和可用 $\sum_d\varphi(d)\binom{c_d}{2}$，依据 $\sum_{d\mid g}\varphi(d)=g$，见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/number-theory/phiFunction.h&quot;&gt;KACTL phi 恒等式&lt;/a&gt;。有序、自配对和含 0 的模型需重新计数。&lt;/p&gt;
&lt;h3&gt;11. 模运算里的除法&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：组合数、平均值、等价类计数中的除法；写出闭式后分母可能与模数不互质。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把“整数先除后取模”和“模数域内求逆”分开。后者只在 $\gcd(b,M)=1$ 时可写 $a/b\equiv a,b^{-1}\pmod M$。一般模数用扩展欧几里得；接口 &lt;code&gt;cp::inv_mod&lt;/code&gt; 返回可选值。其前提见 &lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/math.html&quot;&gt;ACL inv_mod 文档&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$6/2=3$，但模 6 时 2 没有逆元，不能做 &lt;code&gt;6*inv(2)&lt;/code&gt;。若已知整数 $A$ 被正整数 $b$ 整除，可算 $r=A\bmod(bM)$，再用 $r/b\bmod M$；这里取模是非负余数，$6\bmod12=6$，除 2 得 3。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：素数模阶乘组合数 &lt;code&gt;cp::Comb&amp;lt;P&amp;gt;&lt;/code&gt; 要求预处理上界 $N&amp;lt;P$。$N\ge P$ 可考虑 Lucas 的逐位组合数，但小组合数仍要可算。扩欧求逆 $O(\log M)$，组合数预处理 $O(N)$、查询 $O(1)$。模 $bM$ 方法须证明整除并控制乘积范围。&lt;/p&gt;
&lt;h3&gt;13. 模素数的乘法 → 指数加法&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：统计模 $p$ 乘积的分布，反复合并乘积；$p$ 是素数且非零值域可以遍历。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：找原根 $g$，建表 $g^e\leftrightarrow e$。非零乘法满足 $g^i g^j=g^{i+j\bmod(p-1)}$，于是将频数映射到指数域，做长度 $p-1$ 的循环卷积；可先线性卷积再折叠下标。原根与有限循环群的前提见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：模 7 取原根 3，幂依次是 $1,3,2,6,4,5$。$2\cdot4$ 的指数为 $2+4\equiv0\pmod6$，对应结果 1。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：0 单独统计；单位元 1 的指数是 0。合数的全部非零剩余不一定构成循环群，不可照搬。已知原根后建表 $O(p)$，每次卷积 $O(p\log p)$；&lt;code&gt;cp::convolution&lt;/code&gt; 的系数模数与这里的剩余模数 $p$ 是两个不同角色。普通卷积限制见 &lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/convolution.html&quot;&gt;ACL convolution&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;14. 除法：整除分块与 floor_sum 分清&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：$n$ 可到 $10^{12}$，公式含 $\lfloor n/i\rfloor$；或者要数一条直线下面的格点。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：前者从 $l$ 出发，令 $q=\lfloor n/l\rfloor,r=\lfloor n/q\rfloor$，区间 $[l,r]$ 商相同，用前缀权重一次求贡献。比如&lt;/p&gt;
&lt;p&gt;$$\sum_{i=1}^n\sigma(i)=\sum_{d=1}^n d\lfloor n/d\rfloor,$$&lt;/p&gt;
&lt;p&gt;正是 &lt;a href=&quot;https://cses.fi/problemset/task/1082&quot;&gt;CSES Sum of Divisors&lt;/a&gt; 的原题模型。后者 $\sum_{i=0}^{n-1}\lfloor(ai+b)/m\rfloor$ 则用类欧几里得 &lt;code&gt;cp::floor_sum_nonnegative&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$n=5$ 时加权分块为 $1\cdot5+2\cdot2+(3+4+5)\cdot1=21$。另有 $\sum_{i=0}^3\lfloor(3i+1)/5\rfloor=0+0+1+2=3$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：商分块 $O(\sqrt n)$；线性分子 floor_sum 为 $O(\log m)$。配套接口要求非负参数、$m&amp;gt;0$、答案可放进 i128；与 ACL 的溢出约定不同。负数用 &lt;code&gt;cp::floor_div/ceil_div&lt;/code&gt;，C++ 向零截断不等于数学 floor。&lt;/p&gt;
&lt;h3&gt;25. 区间整除与抽屉：把连续段变成两个前缀&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：存在/统计区间和被 $m$ 整除；长度与模数接近，要求证明一定有解。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：令 $P_0=0,P_i=(\sum_{j\le i}a_j)\bmod m$，区间和整除等价于两个前缀余数相同。扫描时先加 &lt;code&gt;cnt[P_i]&lt;/code&gt; 再递增；存在性方面，$m+1$ 个前缀放进 $m$ 个余数类，必有两个相同。&lt;a href=&quot;https://cses.fi/problemset/task/1662&quot;&gt;CSES Subarray Divisibility&lt;/a&gt; 提供了含负数的练习模型。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,2,3]$ 模 3 的前缀是 $[0,1,0,0]$，余数 0 出现 3 次，答案 $\binom32=3$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：$m&amp;gt;0$；负数余数规范为 $(x%m+m)%m$。求余数 $r\ne0$ 的区间应在线查询 $P_i-r$，不能只把频数任意两两配对而忽略顺序。数组 $O(n+m)$ 或哈希期望 $O(n)$；存在性只保证非空区间，不保证题目额外长度限制。&lt;/p&gt;
&lt;h3&gt;26. 阶乘和组合数的整除：数质因子，不构造大整数&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：$n!$ 末尾有几个 0、组合数能否被 $p^k$ 整除、约分后剩多少个 $p$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：每个 $p$ 的倍数贡献一次、$p^2$ 的倍数再贡献一次，因此&lt;/p&gt;
&lt;p&gt;$$v_p(n!)=\sum_{t\ge1}\lfloor n/p^t\rfloor,\quad
v_p\binom nr=v_p(n!)-v_p(r!)-v_p((n-r)!).$$&lt;/p&gt;
&lt;p&gt;循环不断做 &lt;code&gt;n/=p; ans+=n&lt;/code&gt;，避免直接生成 $p^t$ 溢出。十进制尾零取 $\min(v_2,v_5)$；一般基数 $B=\prod p^{b_p}$ 取 $\min_p\lfloor v_p/b_p\rfloor$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$v_5(25!)=5+1=6$，所以 $25!$ 十进制尾零为 6。$\binom52=10$ 的 $v_2=3-1-1=1$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：$p$ 必须是质数；合数基数先分解。每个质数 $O(\log_p n)$。若还要组合数模 $p^k$，须同时维护去掉 $p$ 因子的单位部分，不能只靠指数；可接 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt; 的“单位与可逆元”判断。质因子指数分配的原题对应见 &lt;a href=&quot;https://img.atcoder.jp/abc110/editorial.pdf&quot;&gt;ABC110 D 官方题解&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;27. 周期条件同时满足：广义 CRT 与同余方程&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：多个定期事件同时发生；某量对几个模数的余数分别已知；模数未必互质。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：合并 $x\equiv r\pmod m$ 与 $x\equiv s\pmod n$，代入 $x=r+mt$，得到 $mt\equiv s-r\pmod n$。设 $g=\gcd(m,n)$，无解当且仅当 $g\nmid(s-r)$；否则除以 $g$ 后求逆，得到唯一模 $\operatorname{lcm}(m,n)$ 的解类。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$x\equiv2\pmod6,x\equiv5\pmod9$：$6t\equiv3\pmod9$，约成 $2t\equiv1\pmod3$，故 $t\equiv2$，$x\equiv14\pmod{18}$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：周期为正数，余数先规范化；“没有解”与“最早解为 0”不同。合并 $k$ 条约束约 $O(k\log L)$，$L$ 是合并后的模数规模。板子 &lt;code&gt;crt.cpp&lt;/code&gt; 处理一般正模数，LCM 超过 i64 会报溢出；接口语义可对照 &lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/math.html&quot;&gt;ACL crt&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;28. 幂塔和重复乘法：周期从哪里开始？&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：指数极大、十进制字符串指数、重复乘同一个数；想把指数直接对 $\varphi(M)$ 取模。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先判断 $\gcd(a,M)$。互质时欧拉定理允许周期化；非互质时，序列可能先进入前导段，之后才循环。也可将 $M$ 分解成互质质数幂，对 $v_p(a)$ 分析何时幂变成 0，再 CRT 合并。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：模 8 的 $2^e$ 在 $e=1,2,3,4$ 时为 $2,4,0,0$；直接把 $e=4$ 取成 $e\bmod\varphi(8)=0$，会误得 1。相反，模 7 的 $3^{100}$ 可用 $100\bmod6=4$，结果 4。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：欧拉降幂要求互质；非互质要同时知道指数余数与是否超过阈值，板子 &lt;code&gt;extended_euler.cpp&lt;/code&gt; 处理十进制大指数。0 指数和题目对 $0^0$ 的约定独立检查。&lt;a href=&quot;https://cses.fi/problemset/task/1712&quot;&gt;CSES Exponentiation II&lt;/a&gt; 明确给出了这类边界。读长为 $D$ 的指数加快速幂通常 $O(D+\log M)$，分解 $M$ 费用另计。&lt;/p&gt;
&lt;h2&gt;二、计数：先确定对象、交集和唯一归属&lt;/h2&gt;
&lt;h3&gt;5. 集合关系：SOS 方向与容斥&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：bit 集合包含、两个数 AND 为 0、选择若干数后 AND/OR 的取值。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：子集和 $F(S)=\sum_{T\subseteq S}f(T)$ 从少 bit 向多 bit 传播；超集和反向。&lt;code&gt;x &amp;amp; y == 0&lt;/code&gt; 等价于 $y\subseteq FULL\mathbin{\char94}x$。若数非空下标子集 AND 为 0，令 $c_S$ 为包含 $S$ 所有 bit 的元素数，则&lt;/p&gt;
&lt;p&gt;$$#=\sum_{S\subseteq FULL}(-1)^{|S|}(2^{c_S}-1).$$&lt;/p&gt;
&lt;p&gt;固定某个选择、其 AND 为 $A$，上式把它计算 $\sum_{S\subseteq A}(-1)^{|S|}=[A=\varnothing]$ 次。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,2,3]$ 中 AND 为 0 的非空下标子集只有 ${1,2}$ 与 ${1,2,3}$，共 2 个。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：固定 $B$ 位、$a_i\in[0,2^B)$；相同数值的不同下标仍是不同选择。&lt;code&gt;cp::sos&lt;/code&gt;、&lt;code&gt;subset_witness&lt;/code&gt;、&lt;code&gt;count_and_zero&lt;/code&gt;，$O(n+B2^B)$。位外层才能保证每种选位组合传播一次；整数 SOS 要防溢出。三种位卷积的原作者接口见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/FastSubsetTransform.h&quot;&gt;KACTL FastSubsetTransform&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;6. 严格多数：坏事件可能互斥&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：要求没有一种颜色/类型占所选总数的一半以上；直接做多类别计数状态太大。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：若每个选中对象只属一类，两个类别不可能同时占严格多数。因此合法数等于总数减去每个“类别 $j$ 占严格多数”的方案数。固定 $j$，只需跟踪差 $d=#j-#其他$，把多类变成两类。&lt;/p&gt;
&lt;p&gt;若每行可不选或选一个对象，权重为 $a_{ij}$、行和 $s_i$，则总非空方案 $\prod_i(1+s_i)-1$，转移&lt;/p&gt;
&lt;p&gt;$$new[d]=old[d]+a_{ij}old[d-1]+(s_i-a_{ij})old[d+1].$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：三次独立选 A/B，总数 8。A 严格多数有 4 种，B 有 4 种，所以无严格多数的方案为 0；两次选择则合法的是 AB、BA，共 2 种。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：“至少一半”不是互斥事件；对象可同时属于多类也不适用。$n$ 行、$m$ 类，直接差值 DP 为 $O(mn^2)$、空间 $O(n)$。先写出两个坏事件不可能同时发生的证明，再决定不做高阶容斥。&lt;/p&gt;
&lt;h3&gt;8. 贡献法：先换求和顺序&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：所有区间/点对的和；每个对象在许多答案里重复出现。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把“枚举所有答案再求和”交换成“枚举一个元素/边，数它被用几次”。1-based 数组元素 $a_i$ 对所有子数组元素和贡献 $a_i i(n-i+1)$；树边权 $w$，删边一侧有 $s$ 点，对无序点对距离和贡献 $ws(n-s)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：数组 $[1,2,3]$ 贡献 $1\cdot3+2\cdot4+3\cdot3=20$。三点路径边权 2、3，贡献 $2\cdot1\cdot2+3\cdot2\cdot1=10$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;扩展与前提&lt;/strong&gt;：子数组最大值可令左边最近严格大于为 $L$、右边最近大于等于为 $R$，贡献 $a_i(i-L)(R-i)$；相等元素左右必须一边严格、一边非严格，指定唯一归属。$[2,2]$ 的三个子数组最大值之和是 6。树 DFS/单调栈均为 $O(n)$，乘法在运算前转 i128。贡献求和的概率版本见 36。&lt;/p&gt;
&lt;h3&gt;9. 分球入盒、上下界与组合恒等式&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：相同物品分给有编号的容器；整数解之和固定，每项带上下界。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：$x_1+\cdots+x_k=n,x_i\ge0$，用 $k-1$ 个隔板分出 $k$ 组，数量 $\binom{n+k-1}{k-1}$；&lt;a href=&quot;https://cses.fi/problemset/task/1716&quot;&gt;CSES Distributing Apples&lt;/a&gt; 正是此模型。有下界先令 $y_i=x_i-L_i$；上界 $y_i\le V_i$ 用容斥：&lt;/p&gt;
&lt;p&gt;$$\sum_{S\subseteq[k]}(-1)^{|S|}\binom{n-\sum_iL_i-\sum_{i\in S}(V_i+1)+k-1}{k-1}.$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$x_1+x_2+x_3=4,0\le x_i\le2$，总数 $\binom62-3\binom32=15-9=6$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：容器有编号、物品不可区分；若物品可区分，通常变成多项式系数或 $k^n$。无效上标的组合数视为 0；$k=0$ 单独处理。一般上界容斥 $O(2^k)$，相同上界可按 $|S|$ 合并成 $O(k)$。乘积求和先尝试按选择数分类的范德蒙德恒等式 $\sum_i\binom ai\binom b{r-i}=\binom{a+b}r$。&lt;/p&gt;
&lt;h3&gt;10. 组合题：先固定“哪些位置”，再数“填什么值”&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：先选位置再分颜色/对象；“出现某种结构”的见证可能不唯一；公式看似是几个组合数相乘。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把方案显式写为元组，例如“选出的行集合 $R$、公共颜色 $c$、列集合 $C$”。验证每个最终对象对应几个元组，才能决定相乘后是否除重。多重集排列可依次选每种字符的位置，得到 $n!/\prod_c n_c!$；作者实现见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/combinatorial/multinomial.h&quot;&gt;KACTL multinomial&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：AAB 的不同排列为 $\binom32\binom11=3$。但“统计有相等字母对的长度 3 二元串”不能直接选一对位置再选公共颜色再填另一个：这会得到 $3\cdot2\cdot2=12$，AAA/BBB 各被算 3 次，真实所有 8 个串都满足。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：鸽巢证明需明确“鸽子是什么、巢是什么、每只鸽子是否唯一入巢”。见证不唯一时规定唯一归属、容斥或双计数，不能随意除一个常数。阶乘预处理 $O(n)$ 后多项式系数通常 $O(#类别)$；分母逆元仍受 11 的限制。&lt;/p&gt;
&lt;h3&gt;20. 对称计数：Burnside 的适用边界&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：旋转/翻转后视为同一方案；直接除以对称操作个数会得到非整数或不对的答案。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先确定作用群 $G$，再逐个操作数保持不变的对象：&lt;/p&gt;
&lt;p&gt;$$#\text{等价类}=\frac1{|G|}\sum_{g\in G}|\operatorname{Fix}(g)|.$$&lt;/p&gt;
&lt;p&gt;颜色必须在操作产生的每个位置循环上相同；有 $c$ 个循环、每处任取 $q$ 色时固定点数 $q^c$。该方法见 &lt;a href=&quot;https://cses.fi/book/book.pdf&quot;&gt;Competitive Programmer&apos;s Handbook 第 22 章&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$2\times2$ 黑白格仅按旋转去重，四种旋转的循环数为 $4,1,2,1$，答案 $(16+2+4+2)/4=6$；原题应用见 &lt;a href=&quot;https://cses.fi/problemset/task/2210&quot;&gt;CSES Counting Grids&lt;/a&gt;。长度 4 的二色项链仅旋转去重，同样得到 6。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：合法集合必须在群作用下封闭；固定某个编号位置的限制可能破坏对称。旋转与二面体群（含镜像）分开。直接枚举操作与循环 $O(|G|n)$，规则旋转常能按 GCD/约数合并。模数整除 $|G|$ 时不能直接求逆，回看 11。&lt;/p&gt;
&lt;h3&gt;29. 至少一个、每类都出现、没人拿回原物：显式定义坏事件&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：至少被一个数整除；分配后每类都出现；排列无固定点。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：令 $A_i$ 为第 $i$ 个坏事件，再计算交集而不是凭印象写正负号。$k$ 个有编号盒子都非空，放 $n$ 个有区别的球：&lt;/p&gt;
&lt;p&gt;$$\sum_{j=0}^k(-1)^j\binom kj(k-j)^n.$$&lt;/p&gt;
&lt;p&gt;至少被一个给定数整除则交集是被其 LCM 整除，贡献 $\lfloor N/\operatorname{lcm}\rfloor$；只有两两互质时才能把 LCM 简化为乘积。&lt;a href=&quot;https://cses.fi/problemset/task/2185&quot;&gt;CSES Prime Multiples&lt;/a&gt; 给定的是不同质数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$1\ldots20$ 中被 2 或 5 整除有 $10+4-2=12$ 个。3 个有编号球放入 2 个非空盒子有 $2^3-2=6$ 种。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：直接子集容斥 $O(2^k k)$，构造 LCM 前先检查是否超过 $N$，避免溢出。错排数由相同思路得 $D_n=\sum_j(-1)^j\binom nj(n-j)!$，也可 $D_n=(n-1)(D_{n-1}+D_{n-2})$、$D_0=1,D_1=0$；$D_4=9$，可练 &lt;a href=&quot;https://cses.fi/problemset/task/1717&quot;&gt;CSES Christmas Party&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;30. 前缀不能为负：Catalan 与反射&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：合法括号、上右路径不能越过对角线；总数容易，难点是每个前缀都合法。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把左括号记 $+1$、右括号记 $-1$。从高度 0 走 $2n$ 步回 0，总数 $\binom{2n}n$；把第一次到 $-1$ 之前的步反向，坏路径与终点高度 2 的路径一一对应，数为 $\binom{2n}{n-1}$。两者相减得到 Catalan 数。&lt;/p&gt;
&lt;p&gt;若给定前缀始终合法、当前高度 $h$、余 $m$ 步，则还需 $u=(m-h)/2$ 个上步，完成数为&lt;/p&gt;
&lt;p&gt;$$\binom mu-\binom m{u+h+1}.$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：长度 6、前缀 &lt;code&gt;(()&lt;/code&gt;，$h=1,m=3,u=1$，完成数 $\binom31-\binom33=2$，与 &lt;a href=&quot;https://cses.fi/problemset/task/2187&quot;&gt;CSES Bracket Sequences II&lt;/a&gt; 的样例相符。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：先检查总长奇偶、前缀是否曾负、$u$ 是否为整数且在 $[0,m]$；有多种括号或额外禁区需重新建模。组合数预处理 $O(N)$ 后每问 $O(1)$；用相减形式可避开对 $n+1$ 的模除法。&lt;/p&gt;
&lt;h2&gt;三、代数：把可达、计数和巨大步数变成结构运算&lt;/h2&gt;
&lt;h3&gt;12. 卷积：先判断指标如何组合&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：要对所有 $k$ 计算 $\sum_i a_i b_{k-i}$，或合并两组和、长度、选择数量的分布。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：写 $A(x)=\sum_i a_ix^i$，乘法中 $x^ix^j=x^{i+j}$，所以 $[x^k]AB$ 就是指标和为 $k$ 的配对数。若权重为 $\sum_i\binom ni a_ib_{n-i}$，先除阶乘：卷积 $A_i=a_i/i!,B_i=b_i/i!$，再乘 $n!$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,2]*[3,4]=[3,10,8]$。标记对象分成两部分时，$a_i=b_i=1,n=3$ 得 $\sum_i\binom3i=8$，对应 $3!\sum_i1/(i!(3-i)!)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：指标取模是循环卷积，按 OR/AND/XOR 合并是相应集合变换，$ij=k$ 则是约数卷积；不能把这些直接当普通 NTT。&lt;code&gt;cp::convolution&lt;/code&gt; 固定模 $998244353$，二次幂长度至多 $2^{23}$，$O(N\log N)$；限制见 &lt;a href=&quot;https://atcoder.github.io/ac-library/production/document_en/convolution.html&quot;&gt;ACL 文档&lt;/a&gt;。阶乘归一化须分母可逆。多模 CRT 还原后再取任意模，必须有真实系数范围保证或拆系数，不能只看目标模数互质。&lt;/p&gt;
&lt;h3&gt;31. XOR 可达与开关系统：先求秩，再数方案&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：每个操作最多用一次且只翻转 0/1；选若干数 XOR 成目标；问多少种选择可达同一结果。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把每次操作写成一列 0/1 向量，是否选择操作记为 $x_i$，要求 $Ax=b$，运算在 GF(2)。消元若产生 $0=1$ 则无解；有解且 $n$ 个变量、秩 $r$，自由变量可任取，所以有 $2^{n-r}$ 组解。所有可达结果共有 $2^r$ 个。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：可选数 $[1,2,3]$ 的向量秩为 2，因为 $1\oplus2=3$。8 种下标选择映到 4 种结果，每个结果恰有 2 种原像；XOR 为 0 的是空集与三个全选。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：这里的加法是 XOR，不是 OR；若要求恰选 $k$ 个，线性方程的解数不能直接套用。单数 $B$ 位的增量线性基 $O(nB)$；一般 $m\times n$ 系统朴素 $O(mn\min(m,n))$，bitset 可并行异或。秩/无解返回语义见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/SolveLinearBinary.h&quot;&gt;KACTL SolveLinearBinary&lt;/a&gt;，实现见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;32. 连通选边方案：Matrix-Tree 把树数变成行列式&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：在给定无向图里选 $n-1$ 条边保持连通；数生成树或其权值乘积之和，边数无法子集枚举。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：构造拉普拉斯矩阵 $L$：一条权为 $w$ 的非自环边 $(u,v)$，给 $L_{uu},L_{vv}$ 加 $w$，给 $L_{uv},L_{vu}$ 减 $w$。删去同一个顶点的行列后求行列式。结果等于每棵生成树中边权乘积的总和；全为 1 时就是树数。定理与多重边实例见 &lt;a href=&quot;https://math.mit.edu/~apost/courses/18.212_2021/lectures/18212_lecture19.pdf&quot;&gt;MIT 18.212 Lecture 19&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：三角形的约化矩阵为 $\begin{pmatrix}2&amp;amp;-1\-1&amp;amp;2\end{pmatrix}$，行列式 $4-1=3$，对应删去三条边中的任一条。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：无向图、允许平行边并累加，自环无贡献；不连通时行列式为 0。模素数可消元 $O(n^3)$、空间 $O(n^2)$，换行要变号，零主元必须找行交换。合数模不能对所有非零主元求逆。带方向的树有朝向约定，不能直接套这份无向构造；代码入口见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;33. 大范围求和但答案低次：插值与有限差分&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：求 $1^k+\cdots+N^k$，$k$ 小而 $N$ 极大；答案随参数像一个固定次数多项式。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先证明次数上界。因为离散差分 $F(N)-F(N-1)=N^k$，$F$ 在有理数上次数至多 $k+1$；求出 $F(0),\ldots,F(k+1)$ 后插值。等距点可用拉格朗日式&lt;/p&gt;
&lt;p&gt;$$F(t)=\sum_{i=0}^d y_i\prod_{j\ne i}\frac{t-j}{i-j}.$$&lt;/p&gt;
&lt;p&gt;一般点插值的作者实现与 $O(d^2)$ 基线见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/PolyInterpolate.h&quot;&gt;KACTL PolyInterpolate&lt;/a&gt;；该文件用浮点，模数题应另用域上的运算。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：平方和前四项 $F(0..3)=[0,1,5,14]$；一阶差 $1,4,9$，二阶差 $3,5$，三阶差 2。延伸下一项得二阶差 7、一阶差 16，$F(4)=30$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：有限数据“看起来多项式”不是证明；取模后采样点必须互异且分母可逆。素数模数 $P$ 下使用本方法求幂和，常规安全条件是 $k+1&amp;lt;P$。等距节点配前后缀积可 $O(d)$ 求一次值，预处理样本费用另计；已有样本点应直接返回其值。&lt;/p&gt;
&lt;h3&gt;34. 固定规则重复巨大次：矩阵、递推与幺半群快速幂&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：步数 $10^{18}$，每一步的线性转移相同；线性递推第 $N$ 项；等比和不能安全做除法。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把状态写成列向量 $v_{t+1}=Tv_t$，答案是 $T^Nv_0$。若是 $s_{t+1}=As_t+1$，增添常数 1 维，转移为 $\begin{pmatrix}A&amp;amp;1\0&amp;amp;1\end{pmatrix}$；&lt;a href=&quot;https://atcoder.jp/contests/abc293/editorial/5955?lang=ja&quot;&gt;ABC293 E 官方题解&lt;/a&gt; 给出了这个应用。&lt;/p&gt;
&lt;p&gt;也可直接维护 $(P_n,S_n)=(A^n,\sum_{i&amp;lt;n}A^i)$，连接长度 $a,b$ 的块：$(P_aP_b,S_a+P_aS_b)$。此结合运算可快速幂，不需要 $A-1$ 可逆。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$A=3,N=4,M=7$，$S_4=1+3+9+27\equiv5$。Fibonacci 初值 $0,1$、递推系数 $1,1$，$F_{10}=55$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：转移若依赖时刻，需先合成周期或增广状态。$d$ 维普通矩阵为 $O(d^3\log N)$；已知 $d$ 阶递推可按特征多项式约化到 $O(d^2\log N)$，见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/LinearRecurrence.h&quot;&gt;KACTL LinearRecurrence&lt;/a&gt;。BM 需要域且已知递推阶数上界，足够多前缀才能保证恢复；有限项拟合不能替代后续递推存在性的证明，见 &lt;a href=&quot;https://raw.githubusercontent.com/kth-competitive-programming/kactl/main/content/numerical/BerlekampMassey.h&quot;&gt;作者 BM 接口&lt;/a&gt;。&lt;/p&gt;
&lt;h3&gt;35. 置换反复执行：循环决定周期与交换次数&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：一次操作是位置重排且可逆；问执行 $k$ 次后的结果、最少交换数或恢复原样的最早时间。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：把置换拆成互不相交的有向循环。长度 $\ell$ 的循环上，执行 $k$ 次等于前进 $k\bmod\ell$；所有位置一起恢复的周期是各循环长度的 LCM。长度 $\ell$ 的循环用任意两点交换拆成单点最少需 $\ell-1$ 次，故总计 $n-c$ 次，$c$ 为循环数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：置换由 $(1\ 2\ 3)(4\ 5)$ 构成，周期 $\operatorname{lcm}(3,2)=6$，任意交换复原最少 $(3-1)+(2-1)=3$ 次；执行 4 次后，前三点前进 1 格、后两点不变。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：必须是双射；一般函数图还有入环树与前导段。相邻交换的最少次数是逆序对，不能用 $n-c$。拆环 $O(n)$；LCM 可能溢出，需按题意用大整数或质因子最大指数。用循环数统计对称固定点的进一步应用见 20；结构背景见 &lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;四、概率期望：拆事件、拆贡献、拆等待阶段&lt;/h2&gt;
&lt;h3&gt;15. 精确最大值概率：CDF 做差&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：很多独立随机数的最大值/最小值；“恰好等于 $k$”不好计，所有值都不超过 $k$ 容易计。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：独立均匀 $X_i\in{1,\ldots,m}$，$Y=\max X_i$，则&lt;/p&gt;
&lt;p&gt;$$P(Y\le k)=(k/m)^n,\quad P(Y=k)=(k/m)^n-((k-1)/m)^n.$$&lt;/p&gt;
&lt;p&gt;再用 $E[Y]=\sum_k kP(Y=k)$，或尾和 $E[Y]=\sum_{k=1}^m[1-((k-1)/m)^n]$。独立但不同分布时把幂改成各 CDF 乘积。&lt;a href=&quot;https://cses.fi/problemset/task/1727&quot;&gt;CSES Candy Lottery&lt;/a&gt; 可直接练习。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$n=2,m=3$，最大值的概率是 $1/9,3/9,5/9$，期望 $(1+6+15)/9=22/9$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：精确最大值不是“指定某一个位置等于 $k$、其余不超过 $k$”，后者会因并列最大重复计数。$n\ge1$；不独立时不能乘 CDF。按 $m$ 个取值枚举，通用快速幂 $O(m\log n)$，浮点幂可按误差要求使用；模概率须分母可逆。&lt;/p&gt;
&lt;h3&gt;16. 顺序统计量：先区分连续与离散&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：第 $j$ 小的期望、保留最小若干个样本的期望；动态过程可证明始终只保留历史的前几个小值。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：对 $N\ge1$ 个独立连续均匀 $[0,m]$ 样本（$m&amp;gt;0,1\le j\le r\le N$），排序后 $X_{(j)}$ 满足&lt;/p&gt;
&lt;p&gt;$$E[X_{(j)}]=\frac{jm}{N+1},\qquad E[\sum_{j=1}^r X_{(j)}]=\frac{mr(r+1)}{2(N+1)}.$$&lt;/p&gt;
&lt;p&gt;可以把两端点也加入，$N+1$ 段间距由对称性具有相同期望；正式分布推导见 &lt;a href=&quot;https://ocw.mit.edu/courses/18-443-statistics-for-applications-spring-2015/06daf6d78e7eb0465d6bb53e8f96b2ff_MIT18_443S15_LEC11.pdf&quot;&gt;MIT 18.443 顺序统计讲义&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：3 个 $[0,8]$ 样本最小两个的期望和是 $8(1+2)/4=6$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：离散分布会并列，不能照搬均匀间距。整数 $[1,m]$ 中第 $j$ 小值可用尾和：$P(X_{(j)}&amp;gt;t)=\sum_{h=0}^{j-1}\binom Nh(t/m)^h(1-t/m)^{N-h}$。例 $N=2,m=2$ 的最小值期望是 $5/4$，不是连续公式 $2/3$。先证明“历史样本中第几小”的不变量、数清已生成样本总数，再套公式；连续闭式 $O(1)$，离散直接枚举约 $O(mj)$。&lt;/p&gt;
&lt;h3&gt;17. 期望 DP：自环移项前先问是否有限&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：随机重复操作直到终止；某次尝试可能不改变状态；问平均操作次数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：令 $E_s$ 为从 $s$ 到结束的未来期望代价，一步费用 $c_s$，终态为 0：&lt;/p&gt;
&lt;p&gt;$$E_s=c_s+p_0E_s+\sum_{t\ne s}p_{st}E_t,
\qquad E_s=\frac{c_s+\sum_{t\ne s}p_{st}E_t}{1-p_0}.$$&lt;/p&gt;
&lt;p&gt;先确认除自环外有拓扑顺序，再 DP；无自环的“每次增加一个计数”模型见 &lt;a href=&quot;https://atcoder.jp/contests/abc184/editorial/371?lang=ja&quot;&gt;ABC184 D 官方题解&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：每次一半概率成功终止、一半留在原状态，$E=1+E/2$，故 $E=2$。若从 A 一步必到 B，B 一半结束、一半回 A，则 $E_A=1+E_B,E_B=1+E_A/2$，得 $E_A=4$；这已经不能只移掉局部自环。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：$p_0=1$ 的正费用状态期望无穷；有限状态吸收链也要排除可达的非终止闭类。一般 SCC 可建立线性方程，$s$ 个状态朴素 $O(s^3)$，有向无环依赖则 $O(#状态+#转移)$。若求终止概率，常数项与边界不同，不能套步数方程。&lt;/p&gt;
&lt;h3&gt;22. 分类期望：不要漏掉被状态改变的另一类&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：随机排列中，达到第 $a$ 个特殊对象后规则改变；“在阈值之前/之后”的对象贡献不同。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先固定一个对象，计算它位于阈值之后的概率，再把同类权重求和。设有 $c\ge a\ge1$ 个特殊对象和若干普通对象，均匀随机排列，到第 $a$ 个特殊对象时屏障消失，该对象本身仍被屏障挡住。特殊权重和 $S$ 中，只有后 $c-a$ 个起作用，期望 $S(c-a)/c$。&lt;/p&gt;
&lt;p&gt;某个普通对象与 $c$ 个特殊对象的相对次序均匀，所在 $c+1$ 个间隙等概率；屏障后有 $c-a+1$ 个间隙，所以其作用概率为 $(c-a+1)/(c+1)$，普通权重和 $W$ 贡献 $W(c-a+1)/(c+1)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$c=a=1$，特殊权重 10，普通权重 4。两种相对次序中只有“特殊、普通”产生 4 的贡献，期望 2；特殊自身贡献为 0。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：阈值对象是否生效、未达到阈值如何处理、排列是否等概率，都会改变式子；$a=0$ 应全量生效而不是套原分类；$c&amp;lt;a$ 时本模型屏障始终存在。分类计数 $O(n)$，按阈值有多次询问时可排序、前缀和。思想与 36 的指示变量一致，不能把此特定规则当成通用伤害公式。&lt;/p&gt;
&lt;h3&gt;36. 期望的贡献法：相关事件也能逐项求和&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：问不同颜色数、空盒数、逆序对数、被覆盖点数；整体分布很大，但一个对象是否被计入容易求概率。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：给每个对象定义 $I_i=[\text{它被计入}]$，则 $E[\sum I_i]=\sum P(I_i=1)$，不要求 $I_i$ 之间独立。独立投入 $m$ 个球、每球等概率选 $n$ 个盒子，空盒期望 $n(1-1/n)^m$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：3 球入 2 盒，期望空盒数 $2(1/2)^3=1/4$；两个盒子的空事件不独立，线性求和仍正确。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;应用与前提&lt;/strong&gt;：&lt;a href=&quot;https://cses.fi/problemset/task/1726&quot;&gt;CSES Moving Robots&lt;/a&gt; 可先对每个起点做随机游走 DP 得到终点概率 $p_{s,t}$，再算空格概率 $\prod_s(1-p_{s,t})$，最后对格子 $t$ 求和。这个乘积要求不同机器人的游走独立，而最后一层求和不要求各格子独立。$V$ 格、$E$ 条可走边、$k$ 步，逐起点计算为 $O(VkE+V^2)$；不能用“进入格子的期望个数为 0”代替“格子为空的概率”。&lt;/p&gt;
&lt;h3&gt;37. 收集和等待：按“下一次取得进展”分阶段&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：重复抽样直到见到新种类、集齐全部、凑够若干次成功；无效尝试会原地停留。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：独立同分布试验成功概率为 $p&amp;gt;0$，包含最终成功的一共尝试次数期望为 $1/p$。如果目前已集齐 $k$ 种、总共 $n$ 种等概率，那么下一次新种类概率是 $(n-k)/n$，该阶段等待期望 $n/(n-k)$，总计 $nH_n$。分阶段推导见 &lt;a href=&quot;https://ocw.mit.edu/courses/6-856j-randomized-algorithms-fall-2002/2e00cd3ccdd9e9e9aa3f4b8305a6abef_n4.pdf&quot;&gt;MIT 6.856 Coupon collecting 讲义&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：3 种等概率卡片，收集齐期望 $1+3/2+3=11/2$ 次。成功概率 $1/4$ 时，成功前失败次数期望为 3，包含成功则为 4。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：若种类不等概率，仅知道“已收集多少种”不能决定下一次进展概率，可能要记录具体集合；试验概率随失败变化也不再是固定几何分布。等概率求和 $O(n)$，重复 $r$ 次固定成功且每次条件不变为 $r/p$。几何变量从 0 还是 1 开始取值必须写清。&lt;/p&gt;
&lt;h2&gt;五、优化：用差分证明最优点在哪里&lt;/h2&gt;
&lt;h3&gt;18. 绝对值：拆方向、找中位数、看顺序&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：把所有数改成同一个数的代价是绝对差；一维移动、相邻交换聚拢、两两距离求和。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：$F(x)=\sum_i|a_i-x|$ 的斜率是左侧数量减右侧数量，故中位数处最小；有正权重时换成左右权重，取加权中位数。固定 $x$ 还可排序加前缀和求值。&lt;a href=&quot;https://cses.fi/problemset/task/1074&quot;&gt;CSES Stick Lengths&lt;/a&gt; 是直接应用。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,2,2,3,5]$ 取 $x=2$，代价 $1+0+0+1+3=5$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;扩展与前提&lt;/strong&gt;：保持顺序的位置 $p_1&amp;lt;\cdots&amp;lt;p_k$ 要移成连续格 $x+1,\ldots,x+k$，先令 $b_i=p_i-i$，再找 $b$ 的中位数。例 $p=[1,4,6]$，$b=[0,2,3]$，选 $x=2$，目标 $[3,4,5]$，代价 3。移动费用是平方差时最优点是均值附近，不能用中位数。排序 $O(n\log n)$，选择中位数可期望 $O(n)$。&lt;/p&gt;
&lt;h3&gt;19. 分段线性函数：扫断点，不猜单峰&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：代价有 $\max(0,x-a)$、$\min(x,b)$、截断区间长度，参数是一维整数或实数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：每一项只在少数断点改变斜率，排序事件后维护当前值与斜率。对&lt;/p&gt;
&lt;p&gt;$$F(t)=x t+y\sum_i\max(0,r_i-\max(l_i,t)),\quad t\ge0,$$&lt;/p&gt;
&lt;p&gt;在不含端点的开区间里，斜率 $x-y\cdot#{i:l_i&amp;lt;t&amp;lt;r_i}$。在 $l_i$ 处减 $y$，在 $r_i$ 处加 $y$，区间内线性，故只需检查端点及定义域边界。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$x=1,y=2,[l,r]=[2,5]$，$F(0)=6,F(2)=8,F(5)=5$。先增、再减、再增，不能仅凭 &lt;code&gt;max&lt;/code&gt; 就断言凸或直接三分。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：接口 &lt;code&gt;cp::clipped_cost_min(x,y,intervals)&lt;/code&gt; 对应以上精确公式，要求 $x,y\ge0$，端点合法，返回整数 $t$ 的最优值和位置。一次排序 $O(n\log n)$，用 i128 推进 $value+=slope\cdot\Delta t$。换一个式子须重推每个事件的斜率增量；同坐标事件合并处理。&lt;/p&gt;
&lt;h3&gt;38. 排列怎样配对最优：计算一次交换的差&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：两个序列可重排配对，目标是乘积和或某种总惩罚；直觉是“大配大”但缺证明。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先比较两个位置的两种配法。若 $a\le b,c\le d$，有&lt;/p&gt;
&lt;p&gt;$$ac+bd-(ad+bc)=(b-a)(d-c)\ge0.$$&lt;/p&gt;
&lt;p&gt;所以乘积和同向排序最大、反向排序最小；反复消去逆序配对就得到全局证明。实数可含负数，关键是两个差同号。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,4]$ 与 $[2,7]$，同向和为 30，反向为 15，差 $(4-1)(7-2)=15$。若最小化平方差，展开 $\sum(a_i-b_{\pi(i)})^2$ 后只有 $-2\sum a_ib_{\pi(i)}$ 受排列影响，所以同向配对最小。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：只适用于目标可按成对交换比较且任意配对合法。存在禁配边、额外跨位置项时，排序结论未必成立，可能回到匹配/DP。通常排序 $O(n\log n)$。上面的等式就是独立完整证明，使用前先写出自己题目的交换差，不能只记“大配大”。&lt;/p&gt;
&lt;h3&gt;39. 总量固定如何分配：凸性等价于边际费用递增&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：固定总和，最小化平方和、负载惩罚、分配资源；每多分配一个单位代价会改变。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：对整数费用 $f$ 定义边际 $\Delta f(x)=f(x+1)-f(x)$。若边际随 $x$ 非降，将一个单位从较大负载移向较小负载不会变差；同一种凸费用、无额外约束时，最优各份最多差 1。不同凸费用 $f_i$ 可从满足下界的配置出发，每次选择最便宜的下一单位，用堆维护边际。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$x+y+z=8,x,y,z\ge0$，最小平方和在 $[2,3,3]$，为 22。若某两项相差至少 2，$a^2+b^2-(a-1)^2-(b+1)^2=2(a-b-1)&amp;gt;0$，因此一定还能改进。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：异权费用并不要求负载尽量相等；取整、容量上下界要进入可行域。边际不单调时，逐单位堆贪心可能错。相同费用直接均分 $O(n)$；分配 $K$ 个增量的堆法 $O((n+K)\log n)$。本条采用显式交换证明，不需要浮点求二阶导数。&lt;/p&gt;
&lt;h2&gt;六、结构与不变量：先决定历史能压缩成什么&lt;/h2&gt;
&lt;h3&gt;7. 分组 DP：余数能算出来就不存&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：选完一个集合之后分组，组目标和相同；DP 同时记录已选 &lt;code&gt;mask&lt;/code&gt; 和当前桶内和。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：在每组和固定为 $T&amp;gt;0$、非负数装桶且当前组和不超过 $T$ 的模型中，当前余数由&lt;/p&gt;
&lt;p&gt;$$rem(mask)=\left(\sum_{i\in mask}a_i\right)\bmod T$$&lt;/p&gt;
&lt;p&gt;唯一决定。只记录 &lt;code&gt;reachable[mask]&lt;/code&gt;；尝试加入未选元素时检查 $rem+a_i\le T$。可预处理子集和，或者递推到达时携带唯一余数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[1,1,2,2]$ 分成两个和为 3 的组。选过一个 1、一个 2 时总和 3，余数 0；不同加入次序不需要不同状态，下一组从空桶开始。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：还要有总和是 $T$ 的倍数、目标组数一致等整体条件；负数时不能用“不超桶容量”剪枝。零元素与非空组要求单独核对。若还有组大小、顺序、颜色限制，余数仍可推导但其他信息可能不能删除。复杂度 $O(n2^n)$、空间 $O(2^n)$；这里的删维来自公式，不代表所有分组问题都能这么转移。&lt;/p&gt;
&lt;h3&gt;23. 区间数量比较 → 前缀差 → 多维偏序&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：一个区间里 A 的数量至少 B、同时至少 C；求若干不交合法区间的总长最大。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：定义 $X_i=#A-#B,Y_i=#A-#C$ 的前缀值，则 $(j,i]$ 合法当且仅当 $X_j\le X_i,Y_j\le Y_i$。若 $dp[i]$ 为前 $i$ 个位置的最优覆盖总长，&lt;/p&gt;
&lt;p&gt;$$dp[i]=\max\bigl(dp[i-1],\ i+\max_{j&amp;lt;i,X_j\le X_i,Y_j\le Y_i}(dp[j]-j)\bigr).$$&lt;/p&gt;
&lt;p&gt;按时间从左到右，用二维前缀最大值保存坐标 $(X_j,Y_j)$、权 $dp[j]-j$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：字符串 ABB 的前缀坐标为 $(0,0),(1,1),(0,1),(-1,1)$。AB 合法，ABB 因 A 少于 B 不合法，最大覆盖为 2。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：接口 &lt;code&gt;cp::Fenwick2DMax&lt;/code&gt;，提前提供所有可能更新坐标，单次更新/查询 $O(\log^2 n)$、总空间 $O(n\log n)$。先查询再插入当前点以保持 $j&amp;lt;i$；严格不等改压缩下标边界。只支持 &lt;code&gt;chmax&lt;/code&gt;，不能删点或把权值降低。若允许重叠区间，以上 DP 的含义需要改变。&lt;/p&gt;
&lt;h3&gt;24. 树上端点差分：用割证明方向&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：树上给很多条路径，问每条边经过次数或奇偶；逐路径走太慢。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：固定树边，删去后树分成两块。一条路径经过此边，当且仅当其端点分别在两块。因此奇偶模型对每条路径做 $d_u\mathrel{\char94}=1,d_v\mathrel{\char94}=1$，自底向上异或子树，边 $(fa,v)$ 的答案就是汇总后的 $d_v$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：路径树 $1-2-3$ 上加入 $(1,3)$ 与 $(1,2)$ 两条路径，边 $1-2$ 被过两次，奇偶为 0；边 $2-3$ 一次，奇偶为 1。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：这是边覆盖；若数实际次数，使用 $d_u++,d_v++,d_{lca}-=2$ 再子树求和。点覆盖则为 $d_u++,d_v++,d_{lca}--,d_{fa(lca)}--$，根父亲为虚点；模型不同，修正点不同。奇偶接口 &lt;code&gt;cp::tree_path_xor_edges&lt;/code&gt; 不需要 LCA，$O(n+q)$；实际计数加 LCA 预处理约 $O((n+q)\log n)$。&lt;/p&gt;
&lt;h3&gt;40. 不变量与势能：证明不可能，再界定操作次数&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：要求构造操作序列或证明无法到达；每步只改少数位置，直接搜索的状态过大。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：先求一个在操作下保持的量，如总和、奇偶、棋盘染色差、置换符号；这给出必要条件。若要证明过程会停止，找非负整数势能 $\Phi$，证明每步至少下降 1。必要条件不自动是充分条件，仍需构造能达到目标。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：黑白染色棋盘上每块多米诺覆盖一黑一白，因此黑白数量不同必不能铺满；数量相同也未必能铺满带洞棋盘。排序时每次交换一对相邻逆序，逆序数恰减 1，所以最多初始逆序数次停止。$[3,1,2]$ 有 2 个逆序，恰需 2 次相邻交换。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：计数势能应保证有下界；实数严格下降但每次降幅可能趋于 0，不足以推出有限步终止。多米诺的标准完整矩形模型可练 &lt;a href=&quot;https://cses.fi/problemset/task/2181&quot;&gt;CSES Counting Tilings&lt;/a&gt;，不要把必要染色条件当完整计数算法。逆序数可树状数组 $O(n\log n)$；势能还可用于证明摊还复杂度，而不是要求实际模拟全部操作。&lt;/p&gt;
&lt;h3&gt;41. 非单调也能找零点：离散介值保持的是异号括区&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;识别&lt;/strong&gt;：要求找到某个平衡位置；函数可能反复波动，但每移动一个位置只变 $-1,0,1$，两端一负一正。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;转化与应用&lt;/strong&gt;：设整数函数满足 $|f(i+1)-f(i)|\le1$，已知 $f(L)&amp;lt;0&amp;lt;f(R)$。取中点 $M$，若为 0 立即返回；若负，保留 $[M,R]$；若正，保留 $[L,M]$。每次只维护两端异号，离散介值保证区间内仍有一个 0，不要求全局单调。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;小例&lt;/strong&gt;：$[-2,-1,0,-1,0,1,2]$ 不单调。两端异号，中点值 $-1$，保留右半；新中点可取值 0 的位置，找到一个解。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;前提与代价&lt;/strong&gt;：只能保证找“某个”零点，不能保证最早零点；若相邻可从 $-1$ 跳到 $+1$，零点不再必然存在。要严格证明每次相邻变化界，以及一个已知异号初始区间。本段是根据相邻变化界直接给出的证明；评估一次函数为 $T$，查询复杂度 $O(T\log(R-L))$。&lt;/p&gt;
&lt;h2&gt;21. 赛时落地的五步&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;写量&lt;/strong&gt;：明确元素、位置、下标集合、概率事件分别是什么；先把题意变成一个等式或不等式。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;找宽条件&lt;/strong&gt;：精确 GCD 改成倍数条件，最大值改成 CDF，复杂选择改成固定对象的贡献。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;证明压缩&lt;/strong&gt;：说明删掉的信息为什么不影响后续决策；对不变量用归纳，对最优策略用交换差或上下界。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;匹配计算规模&lt;/strong&gt;：值域能否筛、状态能否 $2^B$、卷积长度能否容纳、模数是否允许求逆；再选择接口。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;算一个小例&lt;/strong&gt;：至少独立手算一个能区分模型的例子，再核对程序的初始化、计数对象与边界。&lt;/li&gt;
&lt;/ol&gt;
</content:encoded></item><item><title>算法竞赛整理索引</title><link>https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B4%E7%90%86%E7%B4%A2%E5%BC%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B4%E7%90%86%E7%B4%A2%E5%BC%95/</guid><description>- 算法竞赛模板增补：带前提、复杂度和调用例子的自包含C++17代码。 - 模拟退火的适用情形与分类模板：用具体场景解释方案、评分和随机改动，附中文注释单文件模板。 - 算法竞赛编译器预处理：宏、条件编译、LOCAL调试、断言、GCC pragma与编译命令。 - 树状数组维护区间和：双树状数组区间加、区间求和，含推导</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛整理索引&lt;/h1&gt;
&lt;h2&gt;比赛时从这里查&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;：带前提、复杂度和调用例子的自包含C++17代码。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E6%A8%A1%E6%8B%9F%E9%80%80%E7%81%AB%E7%9A%84%E9%80%82%E7%94%A8%E6%83%85%E5%BD%A2%E4%B8%8E%E5%88%86%E7%B1%BB%E6%A8%A1%E6%9D%BF/&quot;&gt;模拟退火的适用情形与分类模板&lt;/a&gt;：用具体场景解释方案、评分和随机改动，附中文注释单文件模板。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E7%BC%96%E8%AF%91%E5%99%A8%E9%A2%84%E5%A4%84%E7%90%86/&quot;&gt;算法竞赛编译器预处理&lt;/a&gt;：宏、条件编译、LOCAL调试、断言、GCC pragma与编译命令。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84%E7%BB%B4%E6%8A%A4%E5%8C%BA%E9%97%B4%E5%92%8C/&quot;&gt;树状数组维护区间和&lt;/a&gt;：双树状数组区间加、区间求和，含推导、配图与离线矩形计数。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%BB%8F%E5%85%B8trick/&quot;&gt;经典Trick&lt;/a&gt;：按题面信号找转化。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;：计数、概率、不变量、偏序、卷积与反演。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;：三个月复盘、最小反例、提交检查、十题二刷验收。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E6%8A%BD%E8%B1%A1%E4%BB%A3%E6%95%B0%E7%9A%84%E7%AB%9E%E8%B5%9B%E7%94%A8%E6%B3%95/&quot;&gt;抽象代数的竞赛用法&lt;/a&gt;：循环、置换、核与像、状态压缩、群作用与有限域。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A4%A7%E5%85%A8/&quot;&gt;算法竞赛模板大全&lt;/a&gt;：模板、Trick、数学套路与抽象代数的完整正文，个人易错点为唯一附录。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A0%A1%E8%AE%A2%E5%90%88%E8%AE%A2%E6%9C%AC.pdf&quot;&gt;算法竞赛校订合订本.pdf&lt;/a&gt;：带目录书签的合订 PDF。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;相关专题&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/fft%E4%B8%8Entt%E7%AE%97%E6%B3%95%E7%AC%94%E8%AE%B0/&quot;&gt;FFT与NTT算法笔记&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/dirichlet%E5%8D%B7%E7%A7%AF%E4%BB%A5%E5%8F%8A%E8%8E%AB%E6%AF%94%E4%B9%8C%E6%96%AF%E5%8F%8D%E6%BC%94/&quot;&gt;DIRICHLET卷积以及莫比乌斯反演&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E6%9C%9F%E6%9C%9Bdp/&quot;&gt;期望DP&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E8%99%9A%E6%A0%91/&quot;&gt;虚树&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E5%B7%A6%E5%81%8F%E6%A0%91/&quot;&gt;左偏树&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E5%8F%AF%E6%8C%81%E4%B9%85%E5%8C%96%E5%B7%A6%E5%81%8F%E6%A0%91/&quot;&gt;可持久化左偏树&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E8%B4%A1%E7%8C%AE%E6%B3%95%E5%BA%94%E7%94%A8/&quot;&gt;贡献法应用&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/cses-dp%E5%90%88%E9%9B%86/&quot;&gt;CSES  DP合集&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/cses-geometry/&quot;&gt;CSES Geometry&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/cses-graph%E5%90%88%E9%9B%86/&quot;&gt;CSES Graph合集&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/cses-mathmatics%E5%90%88%E9%9B%86/&quot;&gt;CSES Mathmatics合集&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%B4%A2%E5%BC%95/&quot;&gt;抽象代数索引&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;本地代码与更新方式&lt;/h2&gt;
&lt;p&gt;完整头文件：&lt;code&gt;/home/sanzenin/algo_templates/ready/cp_ready.hpp&lt;/code&gt;，示例及验证程序在同目录。使用GNU C++17，不依赖第三方算法库。&lt;/p&gt;
&lt;p&gt;经典Trick与抽象代数专题在vault里维护，整理稿在本地notes目录维护。修改代码后先运行 &lt;code&gt;python3 refresh_notes.py&lt;/code&gt;，再运行 &lt;code&gt;bash compile_pdf.sh&lt;/code&gt; 重建并同步全集与 PDF。&lt;/p&gt;
</content:encoded></item><item><title>算法竞赛板子检查报告</title><link>https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%9D%BF%E5%AD%90%E6%A3%80%E6%9F%A5%E6%8A%A5%E5%91%8A/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%9D%BF%E5%AD%90%E6%A3%80%E6%9F%A5%E6%8A%A5%E5%91%8A/</guid><description>本轮检查的是《算法竞赛模板大全》的全部第一至八章主代码与其中的专题代码，外加上轮新增的自包含模板。结论：旧板子存在可复现的逻辑错误、编译损坏、越界以及标题与代码不符；已在手册生成层修订，原刷题文件和Neovim全局配置没有批量改写。 | 章节 | 原问题 | 修订与验证 | | --- | --- | --- | |</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛板子检查报告&lt;/h1&gt;
&lt;p&gt;本轮检查的是《算法竞赛模板大全》的全部第一至八章主代码与其中的专题代码，外加上轮新增的自包含模板。结论：旧板子存在可复现的逻辑错误、编译损坏、越界以及标题与代码不符；已在手册生成层修订，原刷题文件和Neovim全局配置没有批量改写。&lt;/p&gt;
&lt;h2&gt;先记住这些明确错误&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;章节&lt;/th&gt;
&lt;th&gt;原问题&lt;/th&gt;
&lt;th&gt;修订与验证&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;2.7 动态线段树&lt;/td&gt;
&lt;td&gt;vector扩容后使用父节点子字段引用；已有节点整段查询漏祖先tag&lt;/td&gt;
&lt;td&gt;返回节点编号；查询补carry；随机区间加和对照数组&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.11 扫描线&lt;/td&gt;
&lt;td&gt;y编号从0开始却维护从1开始的树，依赖-999哨兵，x用int&lt;/td&gt;
&lt;td&gt;去哨兵、统一0-based、128位面积，单位格覆盖对照&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.18/2.19 左偏树&lt;/td&gt;
&lt;td&gt;DSU初始化写到fa[N]；持久化版本宏被换行破坏&lt;/td&gt;
&lt;td&gt;边界修复；独立持久化堆接口，多版本不可变性检查&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.22/2.23 Splay&lt;/td&gt;
&lt;td&gt;插入0误认空哨兵；根上重复插入size不更新；kth使用cnt代替size&lt;/td&gt;
&lt;td&gt;与multiset对照5000轮插删和kth&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4.5 Trie&lt;/td&gt;
&lt;td&gt;插入减&apos;a&apos;，查询减&apos;0&apos;&lt;/td&gt;
&lt;td&gt;统一字符映射，按需分配节点&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.7 严格次小MST&lt;/td&gt;
&lt;td&gt;等权环把不存在的次大边当成可替换边&lt;/td&gt;
&lt;td&gt;初始化缺失值；用所有小图生成树权值集合对照&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.18 割点&lt;/td&gt;
&lt;td&gt;混入城市删除整题，未真正删除城市且状态残留&lt;/td&gt;
&lt;td&gt;换成真正的割点/桥接口，逐点/逐边删除检查连通分量&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.21 Hall&lt;/td&gt;
&lt;td&gt;一般区间邻域不能只检查连续左部编号片段；最大子段和无建模&lt;/td&gt;
&lt;td&gt;给出反例；改为右部区间条件与有证明的区间匹配贪心&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.27 0-1 BFS&lt;/td&gt;
&lt;td&gt;三桶实现未及时处理当前桶新进入的0权边&lt;/td&gt;
&lt;td&gt;改deque，边权严格0/1；对照Floyd&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.11 高斯&lt;/td&gt;
&lt;td&gt;跳过零主元后仍回代除0&lt;/td&gt;
&lt;td&gt;显式返回无解/唯一/无穷多解&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.14 BSGS&lt;/td&gt;
&lt;td&gt;baby/giant方向与答案指数不一致，逆元默认费马&lt;/td&gt;
&lt;td&gt;规范baby表、巨步与一般逆元；小模数完全穷举&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.16 EXCRT&lt;/td&gt;
&lt;td&gt;缺差值能否被gcd整除的判定&lt;/td&gt;
&lt;td&gt;无解nullopt、负余数归一化、lcm越界抛异常&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.25 康托&lt;/td&gt;
&lt;td&gt;upper_bound后删了下一元素&lt;/td&gt;
&lt;td&gt;lower_bound与0-based序位；穷举n&amp;lt;=7全部排列正逆&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.9/7.16 点在多边形&lt;/td&gt;
&lt;td&gt;用有限远端点射线且不处理顶点重数&lt;/td&gt;
&lt;td&gt;半开纵向交叉、128位叉积，边界单独判断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.13 直线圆交&lt;/td&gt;
&lt;td&gt;沿垂直向量找交点，结果不在原直线上&lt;/td&gt;
&lt;td&gt;改原直线方向，补相切和退化点检查&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.5 哈密顿路径&lt;/td&gt;
&lt;td&gt;换行字符被写成两行，无法编译&lt;/td&gt;
&lt;td&gt;修复字面量，和小图排列枚举核对&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.6 斜率DP&lt;/td&gt;
&lt;td&gt;整数除法截断斜率、dp用int、重复横坐标epsilon代替证明&lt;/td&gt;
&lt;td&gt;128位离散Li Chao；正负/重复前缀对照二重循环&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.7 树背包&lt;/td&gt;
&lt;td&gt;默认两个儿子，son[1]可越界&lt;/td&gt;
&lt;td&gt;一般树逐子树合并，负边和恰选数量对照子集枚举&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;几个最小复现：动态线段树先整段+5，再对子段更新/查询；等权三角形不存在严格次小树；插入字符串az后查询az；直线y=0与单位圆的交点必须是(-1,0)、(1,0)；同余x=0 mod2和x=1 mod2无解；排列(2,1)的1-based排名应为2。&lt;/p&gt;
&lt;h2&gt;两类误收不再混用&lt;/h2&gt;
&lt;p&gt;原“最小圆覆盖”文件是角度扫描整题，现换成经过小规模最优支持圆枚举对照的二维最小圆覆盖。原“三维最小球”文件没有z坐标，亦为二维圆扫描，已隔离并移出可复制代码；本书不宣称已经提供可用的三维最小球实现。&lt;/p&gt;
&lt;p&gt;可持久化数组与区间第k小、单模与双模哈希、隐式Treap与Splay、所有递增子序列与最长递增子序列计数，也已纠正名称和适用范围。&lt;/p&gt;
&lt;p&gt;半平面交改为&lt;strong&gt;与给定边界方框求交的裁剪版&lt;/strong&gt;，最坏O(k²)，不是原先声称的O(k log k)通用半平面交；不能用它推断原问题无界性。&lt;/p&gt;
&lt;h2&gt;验证证据与范围&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;第一至八章的&lt;strong&gt;129段代码&lt;/strong&gt;均按GNU C++17语法检查：125个主代码块及专题中的4段。片段补足原有骨架中的n、m、Point等依赖，不代表每段都可脱离依赖直接运行。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;checked/verify_checked.cpp&lt;/code&gt;：&lt;strong&gt;707000项检查&lt;/strong&gt;，开启ASan/UBSan；用独立暴力、数学不等式、最优DP或另一套算法比较结果。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;ready/verify.cpp&lt;/code&gt;：&lt;strong&gt;97881项检查&lt;/strong&gt;，开启ASan/UBSan，覆盖上轮新增模板。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;audit/verify_programs.py&lt;/code&gt;：&lt;strong&gt;16039项程序输入输出检查&lt;/strong&gt;，包括康托全部排列、Hall枚举匹配、课程DP、权值线段树、左偏堆、哈密顿路径。&lt;/li&gt;
&lt;li&gt;合计&lt;strong&gt;820920项检查&lt;/strong&gt;，不是820920道题或远程AC数；没有进行远程判题。&lt;/li&gt;
&lt;li&gt;PDF由Pandoc与XeLaTeX在WSL ext4生成，检查中文、公式、图片、页码、目录/书签、内部链接与代码自动折行；源文件支持重建。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;编译通过不等于所有算法在任意题意下都正确。保留整题的输入限制、静态数组上界、非负权、递归栈、哈希碰撞和几何精度仍需按题目审查。浮点几何不是任意尺度的精确计算；所有“128位安全”均以中间值未超出128位范围为前提。&lt;/p&gt;
&lt;h2&gt;复现命令&lt;/h2&gt;
&lt;p&gt;在 &lt;code&gt;/home/sanzenin/algo_templates&lt;/code&gt; 运行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;python3 audit/compile_handbook.py
g++ -std=c++17 -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer \
  -Wno-return-type -Wno-unused-result checked/verify_checked.cpp -o /tmp/checked-verify
/tmp/checked-verify
python3 audit/verify_programs.py
bash compile_pdf.sh
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;全部校订清单&lt;/h2&gt;
&lt;p&gt;以下包含算法修复、边界/前提补充和名称校订，不能把条目数理解为相同数量的独立算法错误。修订代码位于本项目checked目录，清单来自checked/corrections.json，生成器按章节号替换，可追溯原来源。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;章节&lt;/th&gt;
&lt;th&gt;名称&lt;/th&gt;
&lt;th&gt;校订原因&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1.6&lt;/td&gt;
&lt;td&gt;双向分层搜索（梦魇专用实例）&lt;/td&gt;
&lt;td&gt;先检查坐标再访问地图，并注明这是3:1速度和扩散危险区的专用实例。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;1.7&lt;/td&gt;
&lt;td&gt;八数码 A*（曼哈顿启发式）&lt;/td&gt;
&lt;td&gt;原双向搜索未按层扩展，遇不可达状态可能对空队列front且无返回；替换带奇偶判无解的A*。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.6&lt;/td&gt;
&lt;td&gt;线段树上二分 (Segment Tree Walk)&lt;/td&gt;
&lt;td&gt;修正递归lambda调用示例中漏传自身参数；计数须非负且1&amp;lt;=k&amp;lt;=总数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.7&lt;/td&gt;
&lt;td&gt;动态开点线段树 (Dynamic Segment Tree)&lt;/td&gt;
&lt;td&gt;修复vector扩容导致子节点引用悬空；完整覆盖查询补上祖先懒标记。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.9&lt;/td&gt;
&lt;td&gt;权值线段树 (Weight Segment Tree)&lt;/td&gt;
&lt;td&gt;空前缀区间[1,0]会无限递归，补上区间无交检查。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.10&lt;/td&gt;
&lt;td&gt;李超线段树（项目收益实例）&lt;/td&gt;
&lt;td&gt;明确原代码默认0收益，不是支持任意负直线的通用最大值初始化。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.11&lt;/td&gt;
&lt;td&gt;矩形面积并（0-based离散化，128位面积）&lt;/td&gt;
&lt;td&gt;修复y离散化哨兵依赖、0-based区间遗漏、x坐标int截断；同x事件合并，零面积忽略。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.12&lt;/td&gt;
&lt;td&gt;可持久化数组（历史版本单点修改/查询）&lt;/td&gt;
&lt;td&gt;修正标题/说明与实际代码用途不一致。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.16&lt;/td&gt;
&lt;td&gt;单调栈 (Monotone Stack)&lt;/td&gt;
&lt;td&gt;注释中&amp;gt;=弹栈得到的是右侧首个不大于元素，不能称严格更小。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.17&lt;/td&gt;
&lt;td&gt;二叉堆（C++动态数组）&lt;/td&gt;
&lt;td&gt;原演示固定pop十次，小输入会空堆下溢；改完整动态二叉堆接口。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.18&lt;/td&gt;
&lt;td&gt;可并堆：左偏树 (Leftist Tree / Mergable Heap)&lt;/td&gt;
&lt;td&gt;修复初始化写越界fa[N]，设置新叶子dist=1。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.19&lt;/td&gt;
&lt;td&gt;可持久化左偏树 (Persistent Leftist Tree)&lt;/td&gt;
&lt;td&gt;原代码宏被换行破坏且误混入整题；改为可独立使用的持久化左偏堆。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.20&lt;/td&gt;
&lt;td&gt;笛卡尔树构造与特定 XOR 子树检查实例&lt;/td&gt;
&lt;td&gt;修正标题/说明与实际代码用途不一致。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.21&lt;/td&gt;
&lt;td&gt;Treap 平衡树（FHQ 分裂合并版本）&lt;/td&gt;
&lt;td&gt;修正标题/说明与实际代码用途不一致。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.22&lt;/td&gt;
&lt;td&gt;Splay 伸展树 (Standard Splay)&lt;/td&gt;
&lt;td&gt;修复插入0命中空哨兵、根上重复计数后size未更新；第二版kth比较cnt改size。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.23&lt;/td&gt;
&lt;td&gt;Splay 伸展树 (第二实现版本)&lt;/td&gt;
&lt;td&gt;修复插入0命中空哨兵、根上重复计数后size未更新；第二版kth比较cnt改size。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2.24&lt;/td&gt;
&lt;td&gt;隐式 FHQ Treap（区间翻转）&lt;/td&gt;
&lt;td&gt;修正标题/说明与实际代码用途不一致。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3.4&lt;/td&gt;
&lt;td&gt;PBDS 哈希表 (gp_hash_table)&lt;/td&gt;
&lt;td&gt;gp_hash_table的Hash_Fn是第三模板参数，原注释写第四。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4.3&lt;/td&gt;
&lt;td&gt;单模哈希应用：对称分块&lt;/td&gt;
&lt;td&gt;修正标题/说明与实际代码用途不一致。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4.4&lt;/td&gt;
&lt;td&gt;Manacher 最长回文子串算法&lt;/td&gt;
&lt;td&gt;原哨兵扩展无显式边界，改为奇/偶半径数组，支持任意普通字符及空串函数调用。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4.5&lt;/td&gt;
&lt;td&gt;字典树 Trie（小写字母，动态节点）&lt;/td&gt;
&lt;td&gt;修复插入减&apos;a&apos;而查询减&apos;0&apos;的不一致；改按实际节点分配。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4.6&lt;/td&gt;
&lt;td&gt;01-Trie 最大异或对（uint32_t）&lt;/td&gt;
&lt;td&gt;完整uint32位宽，移位使用无符号值，节点数按实际分配。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.1&lt;/td&gt;
&lt;td&gt;单源最短路 Dijkstra&lt;/td&gt;
&lt;td&gt;竞赛骨架同时using std和PBDS时priority_queue歧义；明确std命名空间。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.4&lt;/td&gt;
&lt;td&gt;带权并查集 (完整题解版)&lt;/td&gt;
&lt;td&gt;同堆合并会自连成环；自身查询距离不应为-1。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.7&lt;/td&gt;
&lt;td&gt;严格次小生成树 (Strict Second Minimum Spanning Tree)&lt;/td&gt;
&lt;td&gt;原严格次小MST把缺失次大值当真实边，等权环可输出不存在的答案；修复不同最大/次大值与不连通处理。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.11&lt;/td&gt;
&lt;td&gt;树的直径完整实现 (带权与距离维护)&lt;/td&gt;
&lt;td&gt;修复pair&amp;lt;ll,int&amp;gt;与pair&amp;lt;ll,ll&amp;gt;比较不能编译，删除重复输出0。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.18&lt;/td&gt;
&lt;td&gt;无向图割点与桥（重边/非连通）&lt;/td&gt;
&lt;td&gt;原整题没有真正删除城市且cut残留，不能当通用割点板；换成按边id的割点与桥函数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.21&lt;/td&gt;
&lt;td&gt;Hall 婚姻定理 (Hall&apos;s Marriage Theorem)&lt;/td&gt;
&lt;td&gt;旧稿将一般区间邻域错误归结为连续左部片段，且最大子段和代码缺少建模；给出反例与正确区间贪心。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.23&lt;/td&gt;
&lt;td&gt;网络流：Dinic 独立实现版&lt;/td&gt;
&lt;td&gt;add参数使用int会截断64位容量；点数数组按n分配。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.24&lt;/td&gt;
&lt;td&gt;网络流：Edmonds-Karp (EK 增广路算法)&lt;/td&gt;
&lt;td&gt;add参数使用int会截断容量；边数组静态上界保留，须满足2m&amp;lt;N。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.25&lt;/td&gt;
&lt;td&gt;第 K 短路 A*（允许重复点边的 walk）&lt;/td&gt;
&lt;td&gt;把起点与时间上限比较误写为s==t；改s==e，并限制每点弹出次数与不可达扩展。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5.27&lt;/td&gt;
&lt;td&gt;0-1 BFS（边权仅0或1）&lt;/td&gt;
&lt;td&gt;原三桶队列没有在当前距离处理完新加入的0权边，访问顺序可能错误；换成严格0/1 deque。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.4&lt;/td&gt;
&lt;td&gt;扩展欧几里得算法 (EXGCD)&lt;/td&gt;
&lt;td&gt;修正递归lambda调用示例；该有符号版本按a,b非负使用。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.8&lt;/td&gt;
&lt;td&gt;扩展欧拉降幂（十进制大指数）&lt;/td&gt;
&lt;td&gt;模数1与0次幂返回错误，phi和大指数缩减存在窄类型溢出；用128位中间值。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.11&lt;/td&gt;
&lt;td&gt;高斯普通消元法 (Gauss-Jordan Elimination)&lt;/td&gt;
&lt;td&gt;原稿遇零主元仍回代除零；现在区分无解、唯一解与无穷多解。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.13&lt;/td&gt;
&lt;td&gt;Miller-Rabin 素性测试 (大素数判定)&lt;/td&gt;
&lt;td&gt;实现参数是signed long long，原注释误声称覆盖完整unsigned范围。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.14&lt;/td&gt;
&lt;td&gt;BSGS 离散对数算法 (Baby-step Giant-step)&lt;/td&gt;
&lt;td&gt;修复baby/giant步方向、指数符号和复合模数逆元；最小解用穷举验证。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.15&lt;/td&gt;
&lt;td&gt;中国剩余定理 CRT (Chinese Remainder Theorem)&lt;/td&gt;
&lt;td&gt;统一为可检查无解的CRT接口，避免大乘积公式中间溢出；lcm限制64位。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.16&lt;/td&gt;
&lt;td&gt;扩展中国剩余定理 EXCRT (Extended CRT)&lt;/td&gt;
&lt;td&gt;补上(r2-r1)%g可解性检查，规范化负余数，检查lcm溢出。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.17&lt;/td&gt;
&lt;td&gt;莫比乌斯反演与数论分块 (P3455 ZAP-Queries)&lt;/td&gt;
&lt;td&gt;线性筛循环访问下标N，原bitset&amp;lt;N&amp;gt;越界。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.20&lt;/td&gt;
&lt;td&gt;K 个数的异或最大/特定统计&lt;/td&gt;
&lt;td&gt;rank=63时1ll&amp;lt;&amp;lt;63会产生错误的有符号比较；改无符号位宽。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.22&lt;/td&gt;
&lt;td&gt;高精度乘法（幂的数位统计实例）&lt;/td&gt;
&lt;td&gt;注明这是乘法类的题目应用，主程序输出a^n各数位的奇偶数量差，不能当乘积输出。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.23&lt;/td&gt;
&lt;td&gt;有界生成函数计数（滑动窗口DP）&lt;/td&gt;
&lt;td&gt;原d[j+k]没有限制总次数，固定数组可越界；改滑动窗口DP和大整数精确计数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.24&lt;/td&gt;
&lt;td&gt;卡特兰与括号前缀补全&lt;/td&gt;
&lt;td&gt;修复损坏头文件，并以组合数反射原理代替每项两次快速幂的低效递推。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.25&lt;/td&gt;
&lt;td&gt;康托展开与逆康托展开 (Cantor Expansion / Obsidian / 知乎)&lt;/td&gt;
&lt;td&gt;康托排名应删除当前值而非其upper_bound位置；改lower_bound与0-based序位。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6.27&lt;/td&gt;
&lt;td&gt;错排问题 (Derangement)&lt;/td&gt;
&lt;td&gt;原截取缺少f、mod定义且n=0无限递归；改完整迭代错排函数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.2&lt;/td&gt;
&lt;td&gt;整数点极角排序（128位叉积）&lt;/td&gt;
&lt;td&gt;浮点版本误称无浮点误差，原点等价关系破坏严格弱序；改整数128位比较并处理零向量。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.5&lt;/td&gt;
&lt;td&gt;二维凸包 (CSES g_andrew.cpp 实战版)&lt;/td&gt;
&lt;td&gt;去重，补空集/单点/全共线退化；避免共线点往返重复输出。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.6&lt;/td&gt;
&lt;td&gt;半平面交（有界多边形裁剪）&lt;/td&gt;
&lt;td&gt;原半平面交未处理平行/重合线，可能除零；提供明确有界的多边形裁剪版。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.7&lt;/td&gt;
&lt;td&gt;线段相交判定 (CSES Line Segment Intersection)&lt;/td&gt;
&lt;td&gt;改用128位几何谓词；点在多边形用半开纵向交叉，避免有限射线端点与顶点重数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.8&lt;/td&gt;
&lt;td&gt;多边形面积计算 (CSES Polygon Area)&lt;/td&gt;
&lt;td&gt;改用128位几何谓词；点在多边形用半开纵向交叉，避免有限射线端点与顶点重数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.9&lt;/td&gt;
&lt;td&gt;点在多边形内部判定 (CSES Point in Polygon)&lt;/td&gt;
&lt;td&gt;改用128位几何谓词；点在多边形用半开纵向交叉，避免有限射线端点与顶点重数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.10&lt;/td&gt;
&lt;td&gt;二维最小圆覆盖（随机增量）&lt;/td&gt;
&lt;td&gt;原文件是二维角度扫描整题，与最小圆覆盖不符；换成随机增量最小圆。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.11&lt;/td&gt;
&lt;td&gt;三维最小球覆盖（误收代码已隔离）&lt;/td&gt;
&lt;td&gt;原文件是二维圆交角度扫描，误标三维最小球，已从可用代码中移除。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.12&lt;/td&gt;
&lt;td&gt;两直线交点计算 (Line Intersection)&lt;/td&gt;
&lt;td&gt;平行/退化直线显式返回nullopt。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.13&lt;/td&gt;
&lt;td&gt;直线与圆的交点计算 (Line-Circle Intersection)&lt;/td&gt;
&lt;td&gt;原交点沿法向偏移，改沿直线方向；补退化点与相切处理。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.14&lt;/td&gt;
&lt;td&gt;平面最近点对 (Closest Pair of Points / 分治法)&lt;/td&gt;
&lt;td&gt;128位距离平方转回long long再开方会截断；扩大无穷大并直接转long double。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.15&lt;/td&gt;
&lt;td&gt;Pick 定理与多边形格点 (Pick&apos;s Theorem &amp;amp; Polygon Area)&lt;/td&gt;
&lt;td&gt;改用128位几何谓词；点在多边形用半开纵向交叉，避免有限射线端点与顶点重数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7.16&lt;/td&gt;
&lt;td&gt;光线投射算法 (Point in Polygon / 射线法判定点在多边形内部)&lt;/td&gt;
&lt;td&gt;改用128位几何谓词；点在多边形用半开纵向交叉，避免有限射线端点与顶点重数。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.4&lt;/td&gt;
&lt;td&gt;树状数组统计所有严格递增子序列&lt;/td&gt;
&lt;td&gt;修正标题/说明与实际代码用途不一致。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.5&lt;/td&gt;
&lt;td&gt;状压 DP 求解哈密顿路径 (CSES Hamiltonian Flights)&lt;/td&gt;
&lt;td&gt;修复生成器把换行字符字面量写成两行，导致无法编译。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.6&lt;/td&gt;
&lt;td&gt;二次代价 DP（离散李超树优化）&lt;/td&gt;
&lt;td&gt;原斜率先整数除法再转double，DP用int会溢出；改用128位整数离散Li Chao，支持重复/非单调前缀。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.7&lt;/td&gt;
&lt;td&gt;树形背包（恰选q条与根连通的边）&lt;/td&gt;
&lt;td&gt;原稿默认恰有两个孩子并直接访问son[1]，一条边的树即失效；改一般树子树背包。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.8&lt;/td&gt;
&lt;td&gt;树形背包 DP (DFS 序展开优化版)&lt;/td&gt;
&lt;td&gt;恰选m课程时不可达状态不能初始化0，否则负学分会少选冒充可行。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.10&lt;/td&gt;
&lt;td&gt;集合 Nim 博弈与 SG 函数 (Sprague-Grundy)&lt;/td&gt;
&lt;td&gt;补cstring头文件、SG枚举上界和EOF退出条件。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8.12&lt;/td&gt;
&lt;td&gt;剪纸博弈 (Cutting Game)&lt;/td&gt;
&lt;td&gt;固定bitset无法容纳两子游戏SG异或结果，改set收集可达SG。&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;9.2&lt;/td&gt;
&lt;td&gt;贡献法应用&lt;/td&gt;
&lt;td&gt;组合数补非法参数返回0，避免k&amp;lt;2的负下标；模答案规范化。&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B4%E7%90%86%E7%B4%A2%E5%BC%95/&quot;&gt;算法竞赛整理索引&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A4%A7%E5%85%A8/&quot;&gt;算法竞赛模板大全&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E5%A2%9E%E8%A1%A5%E6%A0%B8%E5%AF%B9%E8%AE%B0%E5%BD%95/&quot;&gt;算法竞赛增补核对记录&lt;/a&gt;。&lt;/p&gt;
</content:encoded></item><item><title>算法竞赛模板增补</title><link>https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/</guid><description>[!tip] 直接使用 下方第一份代码是完整自包含头文件，GNU C++17、无需第三方库；第二份是完整调用示例。提交单文件时，将第一份放到 main 前，再去掉第二份中的本地 include。不要只复制函数调用而遗漏依赖。 本页提供与题面无关的自包含接口。先从下表确认模型、数据范围与复杂度，再复制对应代码。 | 接口</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛模板增补&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;[!tip] 直接使用
下方第一份代码是完整自包含头文件，GNU C++17、无需第三方库；第二份是完整调用示例。提交单文件时，将第一份放到 main 前，再去掉第二份中的本地 include。不要只复制函数调用而遗漏依赖。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;本页提供与题面无关的自包含接口。先从下表确认模型、数据范围与复杂度，再复制对应代码。&lt;/p&gt;
&lt;h2&gt;模板选用与前提&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;接口&lt;/th&gt;
&lt;th&gt;用于什么&lt;/th&gt;
&lt;th&gt;时间 / 空间&lt;/th&gt;
&lt;th&gt;必须满足&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;floor_div / ceil_div / to_string128&lt;/td&gt;
&lt;td&gt;带符号数学整除与128位输出&lt;/td&gt;
&lt;td&gt;O(1) / O(1)，输出按位数&lt;/td&gt;
&lt;td&gt;整除参数64位，除数非0；返回128位&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;norm / pow_mod / inv_mod&lt;/td&gt;
&lt;td&gt;模归一化、模幂、一般模数逆元&lt;/td&gt;
&lt;td&gt;幂O(log e)，逆元O(log m)&lt;/td&gt;
&lt;td&gt;模数正；逆元m&amp;gt;=2且互质，否则nullopt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Comb&amp;lt;MOD&amp;gt;&lt;/td&gt;
&lt;td&gt;阶乘组合数&lt;/td&gt;
&lt;td&gt;预处理O(N)，查询O(1) / O(N)&lt;/td&gt;
&lt;td&gt;MOD为素数、0&amp;lt;=N&amp;lt;MOD，n不超过预处理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;floor_sum_nonnegative&lt;/td&gt;
&lt;td&gt;线性分子整除和&lt;/td&gt;
&lt;td&gt;O(log m) / O(1)&lt;/td&gt;
&lt;td&gt;n,a,b&amp;gt;=0,m&amp;gt;0，精确答案可放有符号128位&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;sos(f,super,inverse)&lt;/td&gt;
&lt;td&gt;子集/超集zeta及逆变换&lt;/td&gt;
&lt;td&gt;O(B2^B) / 原地&lt;/td&gt;
&lt;td&gt;长度是非零2次幂；不是模运算，中间和可放64位&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;subset_witness&lt;/td&gt;
&lt;td&gt;为每个mask找一个输入子掩码&lt;/td&gt;
&lt;td&gt;O(B2^B+n) / O(2^B)&lt;/td&gt;
&lt;td&gt;0&amp;lt;=B&amp;lt;=24，值在[0,2^B)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;count_and_zero&lt;/td&gt;
&lt;td&gt;非空下标子集AND为0计数&lt;/td&gt;
&lt;td&gt;O(n+B2^B) / O(n+2^B)&lt;/td&gt;
&lt;td&gt;0&amp;lt;=B&amp;lt;=24，计数取模；相同值下标可分别选&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;exact_gcd_pairs&lt;/td&gt;
&lt;td&gt;i&amp;lt;j的GCD恰好值频数&lt;/td&gt;
&lt;td&gt;O(n+V log V) / O(V)&lt;/td&gt;
&lt;td&gt;a_i&amp;gt;0，V=max(a)可开数组，n为int规模&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;count_subarray_gcd&lt;/td&gt;
&lt;td&gt;所有连续区间GCD为target&lt;/td&gt;
&lt;td&gt;每轮O(log V)个状态，各调用gcd / O(log V)&lt;/td&gt;
&lt;td&gt;非负64位输入；0额外占一个状态，空输入返回0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;z_function&lt;/td&gt;
&lt;td&gt;字符串每个后缀与原串的LCP&lt;/td&gt;
&lt;td&gt;O(n) / O(n)&lt;/td&gt;
&lt;td&gt;0-based，z[0]=n；空串返回空&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;tree_path_xor_edges&lt;/td&gt;
&lt;td&gt;批量路径对每条边覆盖奇偶&lt;/td&gt;
&lt;td&gt;O(n+q) / O(n)&lt;/td&gt;
&lt;td&gt;连通树，顶点0-based；结果按输入边顺序&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fenwick2DMax&lt;/td&gt;
&lt;td&gt;x&amp;lt;=X且y&amp;lt;=Y的历史点最大值&lt;/td&gt;
&lt;td&gt;单次O(log² n) / O(n log n)&lt;/td&gt;
&lt;td&gt;预先收集所有更新坐标；仅chmax，不支持删点/降值&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;convolution / ntt&lt;/td&gt;
&lt;td&gt;998244353模数多项式乘法&lt;/td&gt;
&lt;td&gt;O(L log L) / O(L)&lt;/td&gt;
&lt;td&gt;L为&amp;gt;=长度和-1的2次幂，L&amp;lt;=2^23；直接ntt的输入需先归一化&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;offline_cache_misses&lt;/td&gt;
&lt;td&gt;单项访问序列的最少缓存缺失&lt;/td&gt;
&lt;td&gt;O(n log n) / O(n)&lt;/td&gt;
&lt;td&gt;容量非负、初始空、等载入代价；不适用整批共存模型&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;clipped_cost_min&lt;/td&gt;
&lt;td&gt;非负参数截断区间代价最小值&lt;/td&gt;
&lt;td&gt;O(n log n) / O(n)&lt;/td&gt;
&lt;td&gt;精确模型见数学套路；x,y&amp;gt;=0,0&amp;lt;=l&amp;lt;=r，128位不溢出&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;固定约定与内存&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;SOS数组长度是&lt;code&gt;1&amp;lt;&amp;lt;B&lt;/code&gt;，位外层；子集默认 &lt;code&gt;super=false&lt;/code&gt;，超集传 &lt;code&gt;true&lt;/code&gt;。逆变换传第三个参数 &lt;code&gt;true&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;subset_witness&lt;/code&gt;无解返回-1；存在值0时不能把0当无解。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;inv_mod&lt;/code&gt;可能无解，先判断optional；组合数模板不自动检查MOD是否为素数。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Fenwick2DMax::NEG=-(1LL&amp;lt;&amp;lt;60)&lt;/code&gt;，插入值必须大于NEG，查询无点返回NEG；不要直接拿NEG加代价。&lt;/li&gt;
&lt;li&gt;NTT模数固定，不能随意改常量。循环卷积需再按目标周期折叠。&lt;/li&gt;
&lt;li&gt;有符号128位也有上界，不是任意精度整数。乘法前先提升操作数。&lt;/li&gt;
&lt;li&gt;B=22：int数组约16 MiB，long long数组约32 MiB；B=24时分别约64/128 MiB。先估峰值再选B。&lt;/li&gt;
&lt;li&gt;所有assert表示使用前提，不能代替审题；关闭assert后也必须满足前提。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;完整头文件&lt;/h2&gt;
&lt;p&gt;本地同源文件：&lt;a href=&quot;/home/sanzenin/algo_templates/ready/cp_ready.hpp:1&quot;&gt;cp_ready.hpp&lt;/a&gt;。下面内容与文件逐字一致。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#pragma once
#include &amp;lt;bits/stdc++.h&amp;gt;

// GNU C++17. All public indices below are zero-based unless stated otherwise.
namespace cp {
using i64 = long long;
using i128 = __int128_t;

// Inputs are signed 64-bit; output is widened (LLONG_MIN / -1 is supported).
inline i128 floor_div(i64 a, i64 b) {
    assert(b != 0);
    i128 x = a, y = b, q = x / y, r = x % y;
    return q - (r != 0 &amp;amp;&amp;amp; ((r &amp;lt; 0) != (y &amp;lt; 0)));
}
inline i128 ceil_div(i64 a, i64 b) {
    assert(b != 0);
    i128 x = a, y = b, q = x / y, r = x % y;
    return q + (r != 0 &amp;amp;&amp;amp; ((r &amp;lt; 0) == (y &amp;lt; 0)));
}
inline std::string to_string128(i128 x) {
    bool neg = x &amp;lt; 0;
    __uint128_t y = neg ? __uint128_t(-(x + 1)) + 1 : __uint128_t(x);
    std::string s;
    do { s.push_back(char(&apos;0&apos; + y % 10)); y /= 10; } while (y);
    if (neg) s.push_back(&apos;-&apos;);
    std::reverse(s.begin(), s.end());
    return s;
}
inline i64 norm(i64 a, i64 m) {
    assert(m &amp;gt; 0);
    a %= m;
    return a &amp;lt; 0 ? a + m : a;
}
inline i64 pow_mod(i64 a, i64 e, i64 m) {
    assert(e &amp;gt;= 0 &amp;amp;&amp;amp; m &amp;gt; 0);
    a = norm(a, m);
    i64 r = 1 % m;
    while (e) {
        if (e &amp;amp; 1) r = i128(r) * a % m;
        a = i128(a) * a % m;
        e &amp;gt;&amp;gt;= 1;
    }
    return r;
}
// m &amp;gt;= 2; works for composite moduli too. nullopt means gcd(a,m) != 1.
inline std::optional&amp;lt;i64&amp;gt; inv_mod(i64 a, i64 m) {
    assert(m &amp;gt;= 2);
    i128 r0 = norm(a, m), r1 = m, s0 = 1, s1 = 0;
    while (r1) {
        i128 q = r0 / r1;
        i128 nr = r0 - q * r1, ns = s0 - q * s1;
        r0 = r1; r1 = nr; s0 = s1; s1 = ns;
    }
    if (r0 != 1) return std::nullopt;
    s0 %= m;
    if (s0 &amp;lt; 0) s0 += m;
    return i64(s0);
}

// Prime modulus ONLY; 0 &amp;lt;= prepared N &amp;lt; MOD. No Lucas in this class.
template&amp;lt;int MOD = 998244353&amp;gt; struct Comb {
    std::vector&amp;lt;i64&amp;gt; fac, ifac;
    explicit Comb(int n) : fac(n + 1, 1), ifac(n + 1, 1) {
        assert(0 &amp;lt;= n &amp;amp;&amp;amp; n &amp;lt; MOD);
        for (int i = 1; i &amp;lt;= n; ++i) fac[i] = fac[i - 1] * i % MOD;
        ifac[n] = pow_mod(fac[n], MOD - 2, MOD);
        for (int i = n; i; --i) ifac[i - 1] = ifac[i] * i % MOD;
    }
    i64 C(int n, int k) const {
        if (n &amp;lt; 0 || k &amp;lt; 0 || k &amp;gt; n) return 0;
        assert(n &amp;lt; int(fac.size()));
        return fac[n] * ifac[k] % MOD * ifac[n - k] % MOD;
    }
};

// Sum_{i=0}^{n-1} floor((a*i+b)/m). Nonnegative signed-64 inputs, m &amp;gt; 0.
// The exact answer MUST fit signed __int128. Time O(log m).
inline i128 floor_sum_nonnegative(i64 nn, i64 mm, i64 aa, i64 bb) {
    assert(nn &amp;gt;= 0 &amp;amp;&amp;amp; mm &amp;gt; 0 &amp;amp;&amp;amp; aa &amp;gt;= 0 &amp;amp;&amp;amp; bb &amp;gt;= 0);
    i128 n = nn, m = mm, a = aa, b = bb, ans = 0;
    while (true) {
        if (a &amp;gt;= m) { ans += (n * (n - 1) / 2) * (a / m); a %= m; }
        if (b &amp;gt;= m) { ans += n * (b / m); b %= m; }
        i128 y = a * n + b;
        if (y &amp;lt; m) break;
        n = y / m; b = y % m;
        std::swap(a, m);
    }
    return ans;
}

// f.size() must be a nonzero power of two, with size &amp;lt;= INT_MAX.
// All intermediate sums/differences MUST fit i64; these are not modular sums.
inline void sos(std::vector&amp;lt;i64&amp;gt;&amp;amp; f, bool super = false, bool inverse = false) {
    int n = int(f.size());
    assert(n &amp;gt; 0 &amp;amp;&amp;amp; (n &amp;amp; (n - 1)) == 0);
    for (int bit = 1; bit &amp;lt; n; bit &amp;lt;&amp;lt;= 1)
        for (int mask = 0; mask &amp;lt; n; ++mask)
            if (bool(mask &amp;amp; bit) != super) {
                if (inverse) f[mask] -= f[mask ^ bit];
                else f[mask] += f[mask ^ bit];
            }
}
// Return one input submask for each mask, -1 if absent. 0 &amp;lt;= B &amp;lt;= 24.
inline std::vector&amp;lt;int&amp;gt; subset_witness(const std::vector&amp;lt;int&amp;gt;&amp;amp; a, int B) {
    assert(0 &amp;lt;= B &amp;amp;&amp;amp; B &amp;lt;= 24);
    int n = 1 &amp;lt;&amp;lt; B;
    std::vector&amp;lt;int&amp;gt; f(n, -1);
    for (int x : a) { assert(0 &amp;lt;= x &amp;amp;&amp;amp; x &amp;lt; n); f[x] = x; }
    for (int bit = 1; bit &amp;lt; n; bit &amp;lt;&amp;lt;= 1)
        for (int mask = 0; mask &amp;lt; n; ++mask)
            if (mask &amp;amp; bit) f[mask] = std::max(f[mask], f[mask ^ bit]);
    return f;
}
// Count NONEMPTY index-subsets with bitwise AND == 0, modulo MOD.
// Equal values at different input indices are distinct choices. 0 &amp;lt;= B &amp;lt;= 24.
template&amp;lt;int MOD = 1000000007&amp;gt;
int count_and_zero(const std::vector&amp;lt;int&amp;gt;&amp;amp; a, int B) {
    static_assert(MOD &amp;gt;= 2);
    assert(0 &amp;lt;= B &amp;amp;&amp;amp; B &amp;lt;= 24);
    int n = 1 &amp;lt;&amp;lt; B;
    std::vector&amp;lt;i64&amp;gt; cnt(n);
    for (int x : a) { assert(0 &amp;lt;= x &amp;amp;&amp;amp; x &amp;lt; n); ++cnt[x]; }
    sos(cnt, true);
    std::vector&amp;lt;int&amp;gt; pow2(a.size() + 1, 1);
    for (size_t i = 1; i &amp;lt; pow2.size(); ++i) pow2[i] = 2LL * pow2[i - 1] % MOD;
    i64 ans = 0;
    for (int mask = 0; mask &amp;lt; n; ++mask) {
        i64 ways = (pow2[cnt[mask]] + i64(MOD) - 1) % MOD;
        ans += (__builtin_popcount(unsigned(mask)) &amp;amp; 1) ? -ways : ways;
        ans %= MOD;
    }
    return int((ans + MOD) % MOD);
}

// Positive a[i] &amp;lt;= V; pairs of indices i &amp;lt; j. Empty input returns {0}.
inline std::vector&amp;lt;i64&amp;gt; exact_gcd_pairs(const std::vector&amp;lt;int&amp;gt;&amp;amp; a) {
    if (a.empty()) return {0};
    int V = *std::max_element(a.begin(), a.end());
    assert(V &amp;gt;= 1);
    std::vector&amp;lt;i64&amp;gt; cnt(V + 1), exact(V + 1);
    for (int x : a) { assert(x &amp;gt; 0); ++cnt[x]; }
    for (int d = V; d &amp;gt;= 1; --d) {
        i64 c = 0;
        for (int k = d; k &amp;lt;= V; k += d) c += cnt[k];
        exact[d] = c * (c - 1) / 2;
        for (int k = d + d; k &amp;lt;= V; k += d) exact[d] -= exact[k];
    }
    return exact;
}
// Nonnegative a[i]; all zeros are supported. Answer fits i64 for int-sized n.
inline i64 count_subarray_gcd(const std::vector&amp;lt;i64&amp;gt;&amp;amp; a, i64 target) {
    assert(target &amp;gt;= 0);
    std::vector&amp;lt;std::pair&amp;lt;i64, i64&amp;gt;&amp;gt; cur, nxt;
    i64 ans = 0;
    for (i64 x : a) {
        assert(x &amp;gt;= 0);
        nxt.clear(); nxt.push_back({x, 1});
        for (auto [g, c] : cur) {
            i64 ng = std::gcd(g, x);
            if (nxt.back().first == ng) nxt.back().second += c;
            else nxt.push_back({ng, c});
        }
        cur.swap(nxt);
        for (auto [g, c] : cur) if (g == target) ans += c;
    }
    return ans;
}

// z[0] = n. For i &amp;gt; 0, z[i] = LCP(s, s.substr(i)); half-open [l,r).
inline std::vector&amp;lt;int&amp;gt; z_function(const std::string&amp;amp; s) {
    int n = int(s.size());
    std::vector&amp;lt;int&amp;gt; z(n);
    if (n) z[0] = n;
    for (int i = 1, l = 0, r = 0; i &amp;lt; n; ++i) {
        if (i &amp;lt; r) z[i] = std::min(r - i, z[i - l]);
        while (i + z[i] &amp;lt; n &amp;amp;&amp;amp; s[z[i]] == s[i + z[i]]) ++z[i];
        if (i + z[i] &amp;gt; r) { l = i; r = i + z[i]; }
    }
    return z;
}

// Connected tree, n&amp;gt;=1, zero-based vertices. Edge answers follow input order.
// Each (u,v) path toggles all its edges; no LCA is needed for XOR parity.
inline std::vector&amp;lt;int&amp;gt; tree_path_xor_edges(
        int n, const std::vector&amp;lt;std::pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;amp; edges,
        const std::vector&amp;lt;std::pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;amp; paths) {
    assert(n &amp;gt;= 1 &amp;amp;&amp;amp; int(edges.size()) == n - 1);
    std::vector&amp;lt;std::vector&amp;lt;std::pair&amp;lt;int,int&amp;gt;&amp;gt;&amp;gt; adj(n);
    for (int i = 0; i &amp;lt; n - 1; ++i) {
        auto [u,v] = edges[i];
        assert(0 &amp;lt;= u &amp;amp;&amp;amp; u &amp;lt; n &amp;amp;&amp;amp; 0 &amp;lt;= v &amp;amp;&amp;amp; v &amp;lt; n);
        adj[u].push_back({v,i}); adj[v].push_back({u,i});
    }
    std::vector&amp;lt;int&amp;gt; parent(n, -2), pe(n, -1), order{0}, d(n), ans(n - 1);
    parent[0] = -1;
    for (size_t i = 0; i &amp;lt; order.size(); ++i) {
        int u = order[i];
        for (auto [v,e] : adj[u]) if (parent[v] == -2) {
            parent[v] = u; pe[v] = e; order.push_back(v);
        }
    }
    assert(int(order.size()) == n);
    for (auto [u,v] : paths) {
        assert(0 &amp;lt;= u &amp;amp;&amp;amp; u &amp;lt; n &amp;amp;&amp;amp; 0 &amp;lt;= v &amp;amp;&amp;amp; v &amp;lt; n);
        d[u] ^= 1; d[v] ^= 1;
    }
    for (int i = n - 1; i &amp;gt; 0; --i) {
        int u = order[i];
        ans[pe[u]] = d[u];
        d[parent[u]] ^= d[u];
    }
    return ans;
}

// All potential update coordinates must be supplied at construction.
// Incremental point chmax; query max over x&amp;lt;=X AND y&amp;lt;=Y, including ties.
// Updates never delete or decrease values. O(log^2 n) per operation.
struct Fenwick2DMax {
    static constexpr i64 NEG = -(1LL &amp;lt;&amp;lt; 60);
    std::vector&amp;lt;i64&amp;gt; xs;
    std::vector&amp;lt;std::vector&amp;lt;i64&amp;gt;&amp;gt; ys, bit;
    explicit Fenwick2DMax(const std::vector&amp;lt;std::pair&amp;lt;i64,i64&amp;gt;&amp;gt;&amp;amp; points) {
        for (auto [x,y] : points) xs.push_back(x);
        std::sort(xs.begin(), xs.end());
        xs.erase(std::unique(xs.begin(), xs.end()), xs.end());
        int n = int(xs.size()); ys.resize(n + 1); bit.resize(n + 1);
        for (auto [x,y] : points) {
            int p = int(std::lower_bound(xs.begin(), xs.end(), x) - xs.begin()) + 1;
            for (int i = p; i &amp;lt;= n; i += i &amp;amp; -i) ys[i].push_back(y);
        }
        for (int i = 1; i &amp;lt;= n; ++i) {
            auto&amp;amp; v = ys[i]; std::sort(v.begin(), v.end());
            v.erase(std::unique(v.begin(), v.end()), v.end());
            bit[i].assign(v.size() + 1, NEG);
        }
    }
    void update(i64 x, i64 y, i64 value) {
        assert(value &amp;gt; NEG);
        int p = int(std::lower_bound(xs.begin(), xs.end(), x) - xs.begin());
        assert(p &amp;lt; int(xs.size()) &amp;amp;&amp;amp; xs[p] == x);
        for (int i = p + 1; i &amp;lt;= int(xs.size()); i += i &amp;amp; -i) {
            int j = int(std::lower_bound(ys[i].begin(), ys[i].end(), y) - ys[i].begin());
            assert(j &amp;lt; int(ys[i].size()) &amp;amp;&amp;amp; ys[i][j] == y);
            for (++j; j &amp;lt; int(bit[i].size()); j += j &amp;amp; -j) bit[i][j] = std::max(bit[i][j], value);
        }
    }
    i64 query(i64 X, i64 Y) const {
        i64 ans = NEG;
        int p = int(std::upper_bound(xs.begin(), xs.end(), X) - xs.begin());
        for (int i = p; i; i -= i &amp;amp; -i) {
            int j = int(std::upper_bound(ys[i].begin(), ys[i].end(), Y) - ys[i].begin());
            for (; j; j -= j &amp;amp; -j) ans = std::max(ans, bit[i][j]);
        }
        return ans;
    }
};

// NTT specifically for 998244353, primitive root 3. No external ACL needed.
inline void ntt(std::vector&amp;lt;int&amp;gt;&amp;amp; a, bool inverse) {
    constexpr int P = 998244353;
    int n = int(a.size());
    assert(n &amp;gt;= 1 &amp;amp;&amp;amp; n &amp;lt;= (1 &amp;lt;&amp;lt; 23) &amp;amp;&amp;amp; (n &amp;amp; (n - 1)) == 0);
    for (int i = 1, j = 0; i &amp;lt; n; ++i) {
        int bit = n &amp;gt;&amp;gt; 1;
        for (; j &amp;amp; bit; bit &amp;gt;&amp;gt;= 1) j ^= bit;
        j ^= bit;
        if (i &amp;lt; j) std::swap(a[i], a[j]);
    }
    for (int len = 2; len &amp;lt;= n; len &amp;lt;&amp;lt;= 1) {
        i64 wlen = pow_mod(3, (P - 1) / len, P);
        if (inverse) wlen = pow_mod(wlen, P - 2, P);
        for (int l = 0; l &amp;lt; n; l += len) {
            i64 w = 1;
            for (int j = 0; j &amp;lt; len / 2; ++j) {
                int u = a[l + j], v = a[l + j + len / 2] * w % P;
                a[l + j] = u + v &amp;lt; P ? u + v : u + v - P;
                a[l + j + len / 2] = u - v &amp;gt;= 0 ? u - v : u - v + P;
                w = w * wlen % P;
            }
        }
    }
    if (inverse) {
        i64 inv = pow_mod(n, P - 2, P);
        for (int&amp;amp; x : a) x = x * inv % P;
    }
}
inline std::vector&amp;lt;int&amp;gt; convolution(std::vector&amp;lt;int&amp;gt; a, std::vector&amp;lt;int&amp;gt; b) {
    constexpr int P = 998244353;
    if (a.empty() || b.empty()) return {};
    size_t need = a.size() + b.size() - 1;
    assert(need &amp;lt;= (1 &amp;lt;&amp;lt; 23));
    int n = 1;
    while (size_t(n) &amp;lt; need) n &amp;lt;&amp;lt;= 1;
    for (int&amp;amp; x : a) x = int(norm(x, P));
    for (int&amp;amp; x : b) x = int(norm(x, P));
    a.resize(n); b.resize(n);
    ntt(a, false); ntt(b, false);
    for (int i = 0; i &amp;lt; n; ++i) a[i] = i64(a[i]) * b[i] % P;
    ntt(a, true); a.resize(need);
    return a;
}

// Standard SINGLE-item cache requests. Initially empty; any int item IDs.
// A cache miss loads this item; after each access &amp;lt;= capacity items may remain.
// Lazy heap: O(n log n) time / O(n) space, NOT O(n log capacity).
inline i64 offline_cache_misses(const std::vector&amp;lt;int&amp;gt;&amp;amp; seq, int capacity) {
    assert(capacity &amp;gt;= 0);
    int n = int(seq.size());
    if (!capacity) return n;
    std::vector&amp;lt;int&amp;gt; next(n, n);
    std::unordered_map&amp;lt;int, int&amp;gt; last, in;
    for (int i = n - 1; i &amp;gt;= 0; --i) {
        auto it = last.find(seq[i]);
        if (it != last.end()) next[i] = it-&amp;gt;second;
        last[seq[i]] = i;
    }
    std::priority_queue&amp;lt;std::pair&amp;lt;int, int&amp;gt;&amp;gt; q;
    i64 misses = 0;
    for (int i = 0; i &amp;lt; n; ++i) {
        if (!in.count(seq[i])) {
            ++misses;
            if (int(in.size()) == capacity) {
                while (!q.empty()) {
                    auto [pos, x] = q.top(); q.pop();
                    auto it = in.find(x);
                    if (it != in.end() &amp;amp;&amp;amp; it-&amp;gt;second == pos) { in.erase(it); break; }
                }
            }
        }
        in[seq[i]] = next[i];
        q.push({next[i], seq[i]});
    }
    return misses;
}

// Minimize F(t)=x*t+y*sum(max(0,r_i-max(l_i,t))) for integer t&amp;gt;=0.
// x,y&amp;gt;=0 and 0&amp;lt;=l_i&amp;lt;=r_i, all i64. Returns {minimum, one minimizer}.
// Maximum intermediate absolute value must fit signed __int128.
inline std::pair&amp;lt;i128, i64&amp;gt; clipped_cost_min(
        i64 x, i64 y, const std::vector&amp;lt;std::pair&amp;lt;i64, i64&amp;gt;&amp;gt;&amp;amp; intervals) {
    assert(x &amp;gt;= 0 &amp;amp;&amp;amp; y &amp;gt;= 0);
    std::vector&amp;lt;std::pair&amp;lt;i64, int&amp;gt;&amp;gt; ev;
    i128 value = 0;
    for (auto [l, r] : intervals) {
        assert(0 &amp;lt;= l &amp;amp;&amp;amp; l &amp;lt;= r);
        value += i128(y) * (i128(r) - l);
        if (l &amp;lt; r) { ev.push_back({l, 1}); ev.push_back({r, -1}); }
    }
    std::sort(ev.begin(), ev.end());
    i128 best = value;
    i64 arg = 0, prev = 0, active = 0;
    for (size_t i = 0; i &amp;lt; ev.size();) {
        i64 pos = ev[i].first;
        value += (i128(pos) - prev) * (i128(x) - i128(y) * active);
        if (value &amp;lt; best) { best = value; arg = pos; }
        while (i &amp;lt; ev.size() &amp;amp;&amp;amp; ev[i].first == pos) active += ev[i++].second;
        prev = pos;
    }
    return {best, arg};
}
} // namespace cp
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;完整调用示例&lt;/h2&gt;
&lt;p&gt;本地编译：&lt;code&gt;g++ -std=c++17 -O2 ready/example.cpp -o /tmp/cp-example&lt;/code&gt;，在 &lt;code&gt;/home/sanzenin/algo_templates&lt;/code&gt; 运行。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &quot;cp_ready.hpp&quot;
using namespace std;

int main() {
    cout &amp;lt;&amp;lt; cp::to_string128(cp::floor_div(-3, 2)) &amp;lt;&amp;lt; &apos;\n&apos;; // -2
    cp::Comb&amp;lt;&amp;gt; C(100);
    cout &amp;lt;&amp;lt; C.C(5, 2) &amp;lt;&amp;lt; &apos;\n&apos;; // 10
    cout &amp;lt;&amp;lt; cp::count_and_zero(vector&amp;lt;int&amp;gt;{1, 2, 3}, 2) &amp;lt;&amp;lt; &apos;\n&apos;; // 2
    cout &amp;lt;&amp;lt; cp::count_subarray_gcd({2, 4, 6}, 2) &amp;lt;&amp;lt; &apos;\n&apos;; // 4
    auto poly = cp::convolution({1, 2}, {3, 4});
    for (int x : poly) cout &amp;lt;&amp;lt; x &amp;lt;&amp;lt; &apos; &apos;; // 3 10 8
    cout &amp;lt;&amp;lt; &apos;\n&apos;;
    cout &amp;lt;&amp;lt; cp::offline_cache_misses({1, 2, 3, 1, 2, 3}, 2) &amp;lt;&amp;lt; &apos;\n&apos;; // 4
    auto parity = cp::tree_path_xor_edges(3, {{0, 1}, {1, 2}}, {{0, 2}, {1, 2}});
    for (int x : parity) cout &amp;lt;&amp;lt; x &amp;lt;&amp;lt; &apos; &apos;; // 1 0
    cout &amp;lt;&amp;lt; &apos;\n&apos;;

    // Model: maximize total length of disjoint RGB-balanced segments, gaps allowed.
    string s = &quot;RGB&quot;;
    vector&amp;lt;pair&amp;lt;long long,long long&amp;gt;&amp;gt; prefix{{0,0}};
    for (char c : s) {
        auto [x,y] = prefix.back();
        if (c == &apos;R&apos;) ++x, ++y;
        if (c == &apos;G&apos;) --x;
        if (c == &apos;B&apos;) --y;
        prefix.push_back({x,y});
    }
    cp::Fenwick2DMax ft(prefix);
    ft.update(0, 0, 0);
    long long dp = 0;
    for (int i = 1; i &amp;lt;= int(s.size()); ++i) {
        auto [x,y] = prefix[i];
        auto best = ft.query(x,y); // BEFORE insertion: j &amp;lt; i
        if (best != cp::Fenwick2DMax::NEG) dp = max(dp, i + best);
        ft.update(x,y,dp-i);
    }
    cout &amp;lt;&amp;lt; dp &amp;lt;&amp;lt; &apos;\n&apos;; // 3
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;预期逐行输出：&lt;code&gt;-2&lt;/code&gt;、&lt;code&gt;10&lt;/code&gt;、&lt;code&gt;2&lt;/code&gt;、&lt;code&gt;4&lt;/code&gt;、&lt;code&gt;3 10 8&lt;/code&gt;、&lt;code&gt;4&lt;/code&gt;、&lt;code&gt;1 0&lt;/code&gt;、&lt;code&gt;3&lt;/code&gt;（行末空格无影响）。RGB示例的目标是选不交合法段的最大总长度，允许跳过位置；其他目标需改DP，不能只套数据结构。&lt;/p&gt;
&lt;h2&gt;复制依赖表&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Comb&lt;/code&gt;依赖&lt;code&gt;pow_mod&lt;/code&gt;，后者依赖&lt;code&gt;norm&lt;/code&gt;和i64/i128别名。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;count_and_zero&lt;/code&gt;依赖&lt;code&gt;sos&lt;/code&gt;；&lt;code&gt;convolution&lt;/code&gt;依赖&lt;code&gt;ntt&lt;/code&gt;、&lt;code&gt;pow_mod&lt;/code&gt;、&lt;code&gt;norm&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;其余函数依赖公共头文件和类型别名。省事时直接复制整个namespace cp。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B0%E5%AD%A6%E5%A5%97%E8%B7%AF/&quot;&gt;算法竞赛数学套路&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%BB%8F%E5%85%B8trick/&quot;&gt;经典Trick&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%95%B4%E7%90%86%E7%B4%A2%E5%BC%95/&quot;&gt;算法竞赛整理索引&lt;/a&gt;。&lt;/p&gt;
</content:encoded></item><item><title>算法竞赛编译器预处理</title><link>https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E7%BC%96%E8%AF%91%E5%99%A8%E9%A2%84%E5%A4%84%E7%90%86/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E7%BC%96%E8%AF%91%E5%99%A8%E9%A2%84%E5%A4%84%E7%90%86/</guid><description>这里整理 C++17 的预处理指令和常见 GCC 编译选项。预处理解决“哪些源代码交给编译器、宏怎样替换”；优化选项控制编译器生成什么代码；筛法、阶乘等算法预计算属于算法章节。 | 需要解决的问题 | 使用什么 | 应用边界 | | --- | --- | --- | | 本地打印中间状态，提交时删除 | LOCAL</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;算法竞赛编译器预处理&lt;/h1&gt;
&lt;p&gt;这里整理 C++17 的预处理指令和常见 GCC 编译选项。预处理解决“哪些源代码交给编译器、宏怎样替换”；优化选项控制编译器生成什么代码；筛法、阶乘等算法预计算属于算法章节。&lt;/p&gt;
&lt;h2&gt;1. 按用途选板子&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;需要解决的问题&lt;/th&gt;
&lt;th&gt;使用什么&lt;/th&gt;
&lt;th&gt;应用边界&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;本地打印中间状态，提交时删除&lt;/td&gt;
&lt;td&gt;&lt;code&gt;LOCAL&lt;/code&gt; 条件编译与 &lt;code&gt;CP_DBG&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;关闭时参数完全不求值，必要操作不能写在日志参数里&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;常量、类型别名、更新最优值&lt;/td&gt;
&lt;td&gt;&lt;code&gt;constexpr&lt;/code&gt;、&lt;code&gt;using&lt;/code&gt;、函数模板&lt;/td&gt;
&lt;td&gt;交给类型系统，避免文字替换改变含义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;同一头文件被重复包含&lt;/td&gt;
&lt;td&gt;include guard 或 &lt;code&gt;#pragma once&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;防同一翻译单元重复定义，不自动解决跨文件链接冲突&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;针对某个语言标准或编译器选代码&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#if&lt;/code&gt;、&lt;code&gt;defined&lt;/code&gt;、特性检测&lt;/td&gt;
&lt;td&gt;&lt;code&gt;constexpr&lt;/code&gt; 变量不能直接参与预处理表达式&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;给日志打印表达式、生成标识符&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#&lt;/code&gt;、&lt;code&gt;##&lt;/code&gt; 的二层宏&lt;/td&gt;
&lt;td&gt;宏专长是处理 token；别用它代替普通数值函数&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;编译后仍慢，想试优化&lt;/td&gt;
&lt;td&gt;先用命令行 &lt;code&gt;-O2&lt;/code&gt;，再实测局部 &lt;code&gt;O3&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;不改变算法复杂度，性能不保证单调提升&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;想启用 AVX2 等指令&lt;/td&gt;
&lt;td&gt;架构限定的函数版本及运行时分派&lt;/td&gt;
&lt;td&gt;目标 CPU 必须支持，基线入口不能先使用该指令集&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;2. 默认竞赛框架：LOCAL 日志、类型与常量&lt;/h2&gt;
&lt;p&gt;下面是完整单文件板子，输入 &lt;code&gt;n&lt;/code&gt; 和 &lt;code&gt;n&lt;/code&gt; 个整数，输出总和。数值前提为 &lt;code&gt;n&amp;gt;=0&lt;/code&gt; 且所有前缀和能放进 &lt;code&gt;int64_t&lt;/code&gt;。日志只写 &lt;code&gt;stderr&lt;/code&gt;，正式答案只写 &lt;code&gt;stdout&lt;/code&gt;。&lt;code&gt;CP_DBG&lt;/code&gt; 支持已经定义 &lt;code&gt;operator&amp;lt;&amp;lt;&lt;/code&gt; 的类型；打印容器时自行提供输出函数，不假定 &lt;code&gt;vector&lt;/code&gt; 可以直接流输出。&lt;/p&gt;
&lt;p&gt;文件同源：&lt;code&gt;ready/preprocessor_example.cpp&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;cassert&amp;gt;
#include &amp;lt;cstdint&amp;gt;
#include &amp;lt;iostream&amp;gt;
#include &amp;lt;type_traits&amp;gt;

#if __cplusplus &amp;lt; 201703L
#error This template requires C++17 or later.
#endif

using i64 = std::int64_t;
[[maybe_unused]] constexpr i64 MOD = 1000000007;

#define CP_STRING_IMPL(x) #x
#define CP_STRING(x) CP_STRING_IMPL(x)
#define CP_JOIN_IMPL(a, b) a##b
#define CP_JOIN(a, b) CP_JOIN_IMPL(a, b)

#ifdef LOCAL
namespace cp_debug {
struct Line {
    const char* file;
    int line;
    const char* expressions;
    template&amp;lt;class... Ts&amp;gt;
    void operator()(const Ts&amp;amp;... values) const {
        std::cerr &amp;lt;&amp;lt; &apos;[&apos; &amp;lt;&amp;lt; file &amp;lt;&amp;lt; &apos;:&apos; &amp;lt;&amp;lt; line &amp;lt;&amp;lt; &quot;] &quot; &amp;lt;&amp;lt; expressions &amp;lt;&amp;lt; &quot; =&quot;;
        ((std::cerr &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt; values), ...);
        std::cerr &amp;lt;&amp;lt; &apos;\n&apos;;
    }
};
} // namespace cp_debug
#define CP_DBG(...) ::cp_debug::Line{__FILE__, __LINE__, #__VA_ARGS__}(__VA_ARGS__)
#else
#define CP_DBG(...) ((void)0)
#endif

template&amp;lt;class T&amp;gt;
bool chmin(T&amp;amp; current, const T&amp;amp; candidate) {
    if (candidate &amp;lt; current) {
        current = candidate;
        return true;
    }
    return false;
}

void solve() {
    int n;
    if (!(std::cin &amp;gt;&amp;gt; n)) return;
    assert(n &amp;gt;= 0);
    i64 sum = 0;
    for (int i = 0; i &amp;lt; n; ++i) {
        i64 x;
        std::cin &amp;gt;&amp;gt; x;
        sum += x;
    }
    CP_DBG(n, sum);
    std::cout &amp;lt;&amp;lt; sum &amp;lt;&amp;lt; &apos;\n&apos;;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如输入 &lt;code&gt;4 -3 2 7 9&lt;/code&gt;（空白分隔），标准输出为 &lt;code&gt;15&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;启用本地模式时 &lt;code&gt;CP_DBG(n, sum)&lt;/code&gt; 打印文件、行号、表达式文字和对应值；关闭后展开成 &lt;code&gt;((void)0)&lt;/code&gt;，没有参数求值。虽然这种隔离对日志方便，&lt;strong&gt;不要写 &lt;code&gt;CP_DBG(++cnt)&lt;/code&gt; 并依赖它推进算法&lt;/strong&gt;：本地和提交的行为会不同。多个参数的求值先后也不要依赖，例如不要在一条日志里同时修改并读取同一个变量。&lt;code&gt;__FILE__&lt;/code&gt;、&lt;code&gt;__LINE__&lt;/code&gt; 的语义见 &lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html&quot;&gt;GCC 标准预定义宏&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;chmin&lt;/code&gt; 用模板函数表达“比较并赋值”；类型别名使用 &lt;code&gt;using i64=...&lt;/code&gt;，常量使用 &lt;code&gt;constexpr&lt;/code&gt;。不把 &lt;code&gt;#define int long long&lt;/code&gt; 当默认配置，它会改写第三方声明、函数签名和本来需要 &lt;code&gt;int&lt;/code&gt; 的位置。&lt;/p&gt;
&lt;h2&gt;3. 宏是 token 替换，不是函数&lt;/h2&gt;
&lt;p&gt;下面这种宏即使加足括号，也会把参数复制两遍：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#define CP_BAD_SQUARE(x) ((x) * (x))
// CP_BAD_SQUARE(++i) 会展开为 ((++i) * (++i))，不能这样调用。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;若只写成 &lt;code&gt;#define CP_BAD_SQUARE(x) x*x&lt;/code&gt;，&lt;code&gt;CP_BAD_SQUARE(a+b)&lt;/code&gt; 还会产生运算优先级问题。算术函数用模板或 &lt;code&gt;inline&lt;/code&gt;；&lt;code&gt;inline&lt;/code&gt; 不是承诺“必须机器码内联”，是否内联由编译器决定。&lt;/p&gt;
&lt;p&gt;多个语句的宏若确有必要，用 &lt;code&gt;do { ... } while (0)&lt;/code&gt; 包成一个语句，调用者在最后写分号，才能正常接 &lt;code&gt;if (...) MACRO(...); else ...&lt;/code&gt;。括号解决结合方式，&lt;code&gt;do/while&lt;/code&gt; 解决语句边界；两者都不能自动消除重复求值。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Operator-Precedence-Problems.html&quot;&gt;GCC 宏优先级说明&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Duplication-of-Side-Effects.html&quot;&gt;重复副作用&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Swallowing-the-Semicolon.html&quot;&gt;宏与分号&lt;/a&gt;分别解释这三种问题。&lt;/p&gt;
&lt;h2&gt;4. 条件编译：存在性与数值判断分开&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;#ifdef LOCAL&lt;/code&gt;：只检查宏是否存在，&lt;code&gt;-DLOCAL=0&lt;/code&gt; 也会进入。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;#if defined(CP_DEBUG_LEVEL) &amp;amp;&amp;amp; CP_DEBUG_LEVEL &amp;gt;= 2&lt;/code&gt;：检查存在性和整数值。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;#if __cplusplus &amp;gt;= 201703L&lt;/code&gt;：选择 C++17 或以上分支。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;#error ...&lt;/code&gt;：不满足必要编译条件时直接给出诊断。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;code&gt;LOCAL&lt;/code&gt;、&lt;code&gt;DEBUG&lt;/code&gt;、&lt;code&gt;ONLINE_JUDGE&lt;/code&gt; 都是约定名称，不是 C++ 标准保证的环境开关。不要假定某个 OJ 一定定义 &lt;code&gt;ONLINE_JUDGE&lt;/code&gt;；自己掌控的本地开关用 &lt;code&gt;-DLOCAL&lt;/code&gt; 最直观。&lt;code&gt;-Dname&lt;/code&gt; 等价于预定义为 1，&lt;code&gt;-Uname&lt;/code&gt; 撤销定义。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Preprocessor-Options.html&quot;&gt;GCC 命令行预处理选项&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;预处理器不理解 C++ 的类型、&lt;code&gt;sizeof&lt;/code&gt;、&lt;code&gt;constexpr&lt;/code&gt; 变量。&lt;code&gt;#if LIMIT &amp;gt; 10&lt;/code&gt; 中，若 LIMIT 只是 C++ 变量而不是宏，预处理时它通常被当成 0；&lt;code&gt;-Wundef&lt;/code&gt; 能帮助发现未定义标识符。分支类型检查应使用 C++17 的 &lt;code&gt;if constexpr&lt;/code&gt;，但它不能无条件屏蔽任意非法代码：模板中不依赖模板参数的错误仍可能提前诊断，模板外的丢弃分支也不是随意放未声明名字的地方。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/If.html&quot;&gt;GCC #if 规则&lt;/a&gt;、&lt;a href=&quot;https://timsong-cpp.github.io/cppwp/n4659/stmt.if&quot;&gt;C++17 if constexpr 草案&lt;/a&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#ifndef CP_DEBUG_LEVEL
#define CP_DEBUG_LEVEL 0
#endif
#if CP_DEBUG_LEVEL &amp;gt;= 2
// 只有该配置会进入后续编译阶段。
#endif
constexpr int LIMIT = 20;
static_assert(LIMIT &amp;gt; 10, &quot;LIMIT must exceed 10&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;预处理条件是编译时选择，不随输入变化；题目分支仍用普通 &lt;code&gt;if&lt;/code&gt;。&lt;/p&gt;
&lt;h2&gt;5. assert 与 NDEBUG：检查不能承担算法工作&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;assert(condition)&lt;/code&gt; 用于检查程序内部不变量；&lt;code&gt;-DNDEBUG&lt;/code&gt; 可以关闭它。不要写 &lt;code&gt;assert(read_input())&lt;/code&gt;、&lt;code&gt;assert(++ptr&amp;lt;n)&lt;/code&gt; 并指望其中的读取或自增仍会发生。先执行必要工作，再断言结果。&lt;code&gt;NDEBUG&lt;/code&gt; 必须在定义 &lt;code&gt;assert&lt;/code&gt; 的头文件被处理时生效，最简单是编译命令传 &lt;code&gt;-DNDEBUG&lt;/code&gt;。&lt;a href=&quot;https://timsong-cpp.github.io/cppwp/n4659/assertions&quot;&gt;C++17 断言章节&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;含模板逗号的表达式可用额外括号包住，例如 &lt;code&gt;assert((std::is_same_v&amp;lt;int, int&amp;gt;));&lt;/code&gt;，因为预处理器不会把尖括号当作宏参数的括号。静态条件使用 &lt;code&gt;static_assert&lt;/code&gt;；它不受 &lt;code&gt;NDEBUG&lt;/code&gt; 关闭。需要在正式程序处理的“无解”“输入允许的越界状态”等分支，写正常判断并返回错误结果，不仅依赖断言。&lt;/p&gt;
&lt;h2&gt;6. 字符串化、token 拼接与可变参数&lt;/h2&gt;
&lt;p&gt;默认框架里保留四个小宏：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#define CP_STRING_IMPL(x) #x
#define CP_STRING(x) CP_STRING_IMPL(x)
#define CP_JOIN_IMPL(a, b) a##b
#define CP_JOIN(a, b) CP_JOIN_IMPL(a, b)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如先 &lt;code&gt;#define CP_LIMIT 24&lt;/code&gt;：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;写法&lt;/th&gt;
&lt;th&gt;展开结果&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CP_STRING_IMPL(CP_LIMIT)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;字符串 &lt;code&gt;&quot;CP_LIMIT&quot;&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CP_STRING(CP_LIMIT)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;字符串 &lt;code&gt;&quot;24&quot;&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CP_JOIN_IMPL(value_, CP_LIMIT)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;标识符 &lt;code&gt;value_CP_LIMIT&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CP_JOIN(value_, CP_LIMIT)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;标识符 &lt;code&gt;value_24&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;直接遇到 &lt;code&gt;#&lt;/code&gt; 或 &lt;code&gt;##&lt;/code&gt; 的宏参数不会先按普通规则展开，所以外层用于先展开、内层用于字符串化或拼接。拼接后必须是合法 token，不能用它拼出任意语法。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Stringizing.html&quot;&gt;GCC 字符串化&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Concatenation.html&quot;&gt;GCC token 拼接&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;__VA_ARGS__&lt;/code&gt; 用于可变参数宏。C++17 不以 &lt;code&gt;__VA_OPT__&lt;/code&gt; 为标准特性；GNU 的 &lt;code&gt;, ##__VA_ARGS__&lt;/code&gt; 是扩展，别把它当跨编译器的标准 C++17 逗号处理方案。默认框架采用“构造日志对象后再调用”的写法，&lt;code&gt;CP_DBG()&lt;/code&gt; 也会形成合法的空参数函数调用，不会遗留逗号。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html&quot;&gt;GCC 可变参数宏说明&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;7. 头文件与特性检测&lt;/h2&gt;
&lt;p&gt;自写头文件可以使用唯一的 include guard：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#ifndef SANZENIN_CP_EXTRA_HPP_INCLUDED
#define SANZENIN_CP_EXTRA_HPP_INCLUDED
// 在这里放声明、inline 函数或模板。
#endif
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也可以在文件开头写 &lt;code&gt;#pragma once&lt;/code&gt;；它受 GCC、Clang 等支持，但不是 ISO C++ 的标准指令。二选一通常足够。宏名包含项目与文件信息，避免两个头文件误用同一个 guard。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Once-Only-Headers.html&quot;&gt;GCC 头文件保护&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Alternatives-to-Wrapper-_0023ifndef.html&quot;&gt;pragma once&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;检测头文件时先判是否支持检测操作：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#if defined(__has_include)
#  if __has_include(&amp;lt;bits/stdc++.h&amp;gt;)
#    include &amp;lt;bits/stdc++.h&amp;gt;
#  else
#    include &amp;lt;algorithm&amp;gt;
#    include &amp;lt;iostream&amp;gt;
#    include &amp;lt;vector&amp;gt;
#  endif
#else
#  include &amp;lt;algorithm&amp;gt;
#  include &amp;lt;iostream&amp;gt;
#  include &amp;lt;vector&amp;gt;
#endif
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个示例的回退只包含列出的三个标准头；真实代码用了什么就补什么。&lt;code&gt;__has_include&lt;/code&gt; 在 C++17 中已有标准依据，但头文件存在不等于其全部接口可在当前模式使用。&lt;code&gt;bits/stdc++.h&lt;/code&gt; 是实现提供的汇总头，不是标准头。&lt;a href=&quot;https://timsong-cpp.github.io/cppwp/n4659/cpp.cond&quot;&gt;C++17 条件包含草案&lt;/a&gt;、&lt;a href=&quot;https://clang.llvm.org/docs/LanguageExtensions.html#include-file-checking-macros&quot;&gt;Clang 头文件检测&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;区分编译器时，先检查 Clang，再检查 GCC 兼容宏：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#if defined(__clang__)
// Clang 路径
#elif defined(__GNUC__)
// GCC 或其他声明兼容 GNU 的编译器路径
#else
// 其他编译器路径
#endif
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;仅有 &lt;code&gt;__GNUC__&lt;/code&gt; 不能证明“这就是 GCC”。要探测某个内建函数，可先判 &lt;code&gt;defined(__has_builtin)&lt;/code&gt; 再调用 &lt;code&gt;__has_builtin(函数名)&lt;/code&gt;；不要因为版本号看起来够大就假定扩展存在。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html&quot;&gt;GCC 兼容宏定义&lt;/a&gt;、&lt;a href=&quot;https://clang.llvm.org/docs/LanguageExtensions.html#feature-checking-macros&quot;&gt;Clang 特性检测&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;8. GCC 优化与 target：按需求启用&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;写法&lt;/th&gt;
&lt;th&gt;实际控制什么&lt;/th&gt;
&lt;th&gt;何时使用&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;命令行 &lt;code&gt;-O2&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;常见优化等级&lt;/td&gt;
&lt;td&gt;竞赛提交的常用起点，最终以 OJ 命令为准&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;命令行 &lt;code&gt;-O3&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;更多优化尝试&lt;/td&gt;
&lt;td&gt;对热点实测，代码膨胀等因素可能让它更慢&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;#pragma GCC optimize(&quot;O3&quot;)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;后续定义函数的优化选项&lt;/td&gt;
&lt;td&gt;需要局部试验时，使用 push/pop 限定范围&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;#pragma GCC target(&quot;avx2&quot;)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;后续函数可使用的指令集&lt;/td&gt;
&lt;td&gt;限定架构，并确保运行 CPU 支持&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;-Ofast&lt;/code&gt; / &lt;code&gt;fast-math&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;放宽浮点及其他语义限制&lt;/td&gt;
&lt;td&gt;只有明确允许这些变化的计算才考虑&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;&lt;code&gt;Ofast&lt;/code&gt; 包含 &lt;code&gt;fast-math&lt;/code&gt;，后者允许重关联等变换，并可假定没有 NaN/无穷。几何精度判定、模拟退火能量的 &lt;code&gt;isfinite&lt;/code&gt; 检查、依赖浮点特殊值的代码不应套一个全局“极限优化”开头；优化不能修复越界、有符号溢出或错误算法。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html&quot;&gt;GCC 优化选项&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;target(&quot;avx2&quot;)&lt;/code&gt; 不是“检测并开启 AVX2”，而是允许生成对应指令。&lt;code&gt;-march=native&lt;/code&gt; 也是针对当前编译机器，不保证换到评测机器还能运行。需要通用可执行文件时保留基线版本，用函数级 target 加运行时检测分派；包含检测逻辑的入口也要按基线指令集编译。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html&quot;&gt;GCC x86 选项&lt;/a&gt;、&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/x86-Built-in-Functions.html&quot;&gt;CPU 检测内建函数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;下面完整程序演示局部 O3、可选 AVX2 版本和回退。默认不编译 AVX2 特化；使用 GCC 且传 &lt;code&gt;-DCP_ENABLE_AVX2&lt;/code&gt; 时才产生该版本，运行时仍检查是否支持。Clang 路径保留普通函数。数据本身只有四个元素，不用于宣称 AVX2 更快；实际热点应另行测量。&lt;code&gt;push_options/pop_options&lt;/code&gt; 保存与恢复当前函数选项，避免设置影响后续函数及头文件。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Function-Specific-Option-Pragmas.html&quot;&gt;GCC 函数选项 pragma&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;文件同源：&lt;code&gt;ready/preprocessor_pragmas.cpp&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;cstddef&amp;gt;
#include &amp;lt;cstdint&amp;gt;
#include &amp;lt;iostream&amp;gt;
#include &amp;lt;vector&amp;gt;

// GCC-only function options; Clang uses the baseline implementation below.
#if defined(__GNUC__) &amp;amp;&amp;amp; !defined(__clang__)
#pragma GCC push_options
#pragma GCC optimize(&quot;O3&quot;)
#endif
std::uint64_t sum_words(const std::vector&amp;lt;std::uint32_t&amp;gt;&amp;amp; a) {
    std::uint64_t answer = 0;
    for (std::uint32_t x : a) answer += x;
    return answer;
}
#if defined(__GNUC__) &amp;amp;&amp;amp; !defined(__clang__)
#pragma GCC pop_options
#endif

// Optional x86 specialization: opt in at compile time, then dispatch at runtime.
#if defined(CP_ENABLE_AVX2) &amp;amp;&amp;amp; defined(__GNUC__) &amp;amp;&amp;amp; !defined(__clang__) &amp;amp;&amp;amp; \
    (defined(__x86_64__) || defined(__i386__))
#define CP_HAS_AVX2_VARIANT 1
#pragma GCC push_options
#pragma GCC optimize(&quot;O3&quot;)
#pragma GCC target(&quot;avx2&quot;)
std::uint64_t sum_words_avx2(const std::vector&amp;lt;std::uint32_t&amp;gt;&amp;amp; a) {
    std::uint64_t answer = 0;
    for (std::uint32_t x : a) answer += x;
    return answer;
}
#pragma GCC pop_options
#else
#define CP_HAS_AVX2_VARIANT 0
#endif

int main() {
    const std::vector&amp;lt;std::uint32_t&amp;gt; a{1, 2, 3, 4};
    std::uint64_t answer;
#if CP_HAS_AVX2_VARIANT
    // main and the fallback must themselves be compiled for the baseline CPU.
    if (__builtin_cpu_supports(&quot;avx2&quot;)) answer = sum_words_avx2(a);
    else answer = sum_words(a);
#else
    answer = sum_words(a);
#endif
    std::cout &amp;lt;&amp;lt; answer &amp;lt;&amp;lt; &apos;\n&apos;;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;程序输出 &lt;code&gt;10&lt;/code&gt;。启用参数：&lt;code&gt;g++ -std=c++17 -O2 -DCP_ENABLE_AVX2 ready/preprocessor_pragmas.cpp -o /tmp/cp-pragmas&lt;/code&gt;。不要同时全局加 &lt;code&gt;-march=native&lt;/code&gt; 再把运行时检测当成跨 CPU 兼容保证。&lt;/p&gt;
&lt;h2&gt;9. 本地调试与提交命令&lt;/h2&gt;
&lt;p&gt;在模板目录运行，源文件换成你的提交文件即可：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 本地定位越界、悬空访问和一部分未定义行为；LOCAL 日志写 stderr。
g++ -std=c++17 -O1 -g -Wall -Wextra -Wshadow -Wundef \
  -DLOCAL -fsanitize=address,undefined -fno-omit-frame-pointer \
  ready/preprocessor_example.cpp -o /tmp/cp-debug
/tmp/cp-debug &amp;lt; input.txt &amp;gt; output.txt 2&amp;gt; debug.txt

# 贴近通常的优化提交环境；断言默认保留，不额外定义 LOCAL。
g++ -std=c++17 -O2 -Wall -Wextra \
  ready/preprocessor_example.cpp -o /tmp/cp-submit
/tmp/cp-submit &amp;lt; input.txt &amp;gt; output.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;-O2&lt;/code&gt; 本身不会自动定义 &lt;code&gt;NDEBUG&lt;/code&gt;。只有明确决定关闭断言时再加 &lt;code&gt;-DNDEBUG&lt;/code&gt;。Sanitizer 用于查错，会改变时间和内存开销，不能拿它测比赛极限性能；相关检测范围见 &lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html&quot;&gt;GCC 插桩选项&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;要查 STL 迭代器和部分容器前提，可另外用 &lt;code&gt;-D_GLIBCXX_DEBUG&lt;/code&gt; 编译本地单文件。它属于 libstdc++ 模式，不是标准 C++，会改变部分容器类型的大小与行为；跨编译单元传容器时需保持配置一致。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/libstdc++/manual/debug_mode_using.html&quot;&gt;libstdc++ Debug Mode&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;10. 看预处理结果：宏出问题时直接展开&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;# 展开 include 和宏，查看实际交给编译器的 C++。
g++ -std=c++17 -E -P ready/preprocessor_example.cpp -o /tmp/cp-expanded.cpp

# 查看当前编译器/标准模式预定义了哪些宏。
g++ -std=c++17 -dM -E -x c++ /dev/null &amp;gt; /tmp/cp-macros.txt
rg &apos;__cplusplus|__GNUC__|__clang__|ONLINE_JUDGE|LOCAL&apos; /tmp/cp-macros.txt

# 查看包含了哪些头文件，缩进反映包含深度。
g++ -std=c++17 -H -fsyntax-only ready/preprocessor_example.cpp 2&amp;gt; /tmp/cp-includes.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;-E&lt;/code&gt; 只做预处理，&lt;code&gt;-P&lt;/code&gt; 去掉输出中的行标记；&lt;code&gt;-dM -E&lt;/code&gt; 列出宏定义，&lt;code&gt;-H&lt;/code&gt; 输出包含层次。它们帮助判断 LOCAL 分支是否出现、某个名字是否被宏污染、头文件搜索是否符合预期。&lt;a href=&quot;https://gcc.gnu.org/onlinedocs/gcc/Preprocessor-Options.html&quot;&gt;GCC 预处理命令文档&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;相关：&lt;a href=&quot;/posts/obsidian/%E6%A8%A1%E6%8B%9F%E9%80%80%E7%81%AB%E7%9A%84%E9%80%82%E7%94%A8%E6%83%85%E5%BD%A2%E4%B8%8E%E5%88%86%E7%B1%BB%E6%A8%A1%E6%9D%BF/&quot;&gt;模拟退火的适用情形与分类模板&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A2%9E%E8%A1%A5/&quot;&gt;算法竞赛模板增补&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E4%B8%AA%E4%BA%BA%E6%98%93%E9%94%99%E7%82%B9/&quot;&gt;算法竞赛个人易错点&lt;/a&gt;。&lt;/p&gt;
</content:encoded></item><item><title>AtCoder Beginner Contest 477 F：Count Cells in a Window</title><link>https://sanzenin.top/posts/obsidian/%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84%E7%BB%B4%E6%8A%A4%E5%8C%BA%E9%97%B4%E5%92%8C/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84%E7%BB%B4%E6%8A%A4%E5%8C%BA%E9%97%B4%E5%92%8C/</guid><description>给定一个 行 列的网格。第 行中，第 列到第 列的格子为黑色，其余格子为白色。 每次查询给出 ，求矩形区域 内黑色格子的数量。 约束为 ，且 。 固定扫描到前 行，令 cover[x] 表示第 列在这些行中出现的黑格数量，则查询前缀行区间 对列区间 的答案就是 加入第 行时，需要对整个区间 加 ；查询时需要求列区间和。</description><pubDate>Sun, 04 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84%E7%BB%B4%E6%8A%A4%E5%8C%BA%E9%97%B4%E5%92%8C-1791116082410.webp&quot; alt=&quot;树状数组维护区间和-1791116082410&quot; /&gt;&lt;/p&gt;
&lt;h1&gt;AtCoder Beginner Contest 477 F：Count Cells in a Window&lt;/h1&gt;
&lt;h2&gt;题目重述&lt;/h2&gt;
&lt;p&gt;给定一个 $N$ 行 $M$ 列的网格。第 $i$ 行中，第 $L_i$ 列到第 $R_i$ 列的格子为黑色，其余格子为白色。&lt;/p&gt;
&lt;p&gt;每次查询给出 $A,B,C,D$，求矩形区域&lt;/p&gt;
&lt;p&gt;$$
[A,B]\times[C,D]
$$&lt;/p&gt;
&lt;p&gt;内黑色格子的数量。&lt;/p&gt;
&lt;p&gt;约束为 $1\le N,M,Q\le 2\times 10^5$，且 $1\le L_i\le R_i\le M$。&lt;/p&gt;
&lt;h2&gt;关键观察&lt;/h2&gt;
&lt;p&gt;固定扫描到前 $i$ 行，令 &lt;code&gt;cover[x]&lt;/code&gt; 表示第 $x$ 列在这些行中出现的黑格数量，则查询前缀行区间 $[1,i]$ 对列区间 $[C,D]$ 的答案就是&lt;/p&gt;
&lt;p&gt;$$
\sum_{x=C}^{D}\text{cover}[x].
$$&lt;/p&gt;
&lt;p&gt;加入第 $i$ 行时，需要对整个区间 $[L_i,R_i]$ 加 $1$；查询时需要求列区间和。因此问题转化为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;区间加：对 $[L_i,R_i]$ 中每个位置加 $1$；&lt;/li&gt;
&lt;li&gt;区间求和：求 $[C,D]$ 的元素和。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;单棵树状数组适合“单点修改、前缀和查询”，不能直接同时完成区间加和区间求和。使用两棵树状数组维护差分数组即可支持这两种操作。&lt;/p&gt;
&lt;h2&gt;解析&lt;/h2&gt;
&lt;h3&gt;两棵树状数组维护区间加、区间和&lt;/h3&gt;
&lt;p&gt;设对差分数组在位置 $l$ 加上 $k$、在位置 $r+1$ 加上 $-k$。令第一棵树状数组维护这些差分值，第二棵树状数组维护差分值乘以位置偏移后的结果：&lt;/p&gt;
&lt;p&gt;$$
\begin{aligned}
\text{tr}_1[l]&amp;amp;\mathrel{+}=k, &amp;amp;\text{tr}_1[r+1]&amp;amp;\mathrel{-}=k,\
\text{tr}_2[l]&amp;amp;\mathrel{+}=k(l-1), &amp;amp;\text{tr}_2[r+1]&amp;amp;\mathrel{-}=kr.
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;记两棵树状数组在位置 $x$ 的前缀和分别为 $S_1(x)$、$S_2(x)$，则原数组的前缀和为&lt;/p&gt;
&lt;p&gt;$$
\operatorname{prefix}(x)=xS_1(x)-S_2(x).
$$&lt;/p&gt;
&lt;p&gt;所以区间和可以写成&lt;/p&gt;
&lt;p&gt;$$
\operatorname{sum}(l,r)=\operatorname{prefix}(r)-\operatorname{prefix}(l-1).
$$&lt;/p&gt;
&lt;p&gt;代码中的 &lt;code&gt;modify(l, r, k)&lt;/code&gt; 实现区间加，&lt;code&gt;query_interval(l, r)&lt;/code&gt; 实现区间求和。&lt;/p&gt;
&lt;h3&gt;按行编号离线处理查询&lt;/h3&gt;
&lt;p&gt;设一个查询为 $(A,B,C,D)$。扫描行编号 $i$ 时：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在处理第 $A$ 行之前，树状数组维护的是第 $1$ 到第 $A-1$ 行，因此记录一次负贡献；&lt;/li&gt;
&lt;li&gt;加入第 $A$ 行到第 $B$ 行后，树状数组维护的是第 $1$ 到第 $B$ 行，因此记录一次正贡献。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;两次前缀状态之差恰好只保留第 $A$ 到第 $B$ 行的贡献。代码使用 &lt;code&gt;enter[A]&lt;/code&gt; 保存负贡献事件，使用 &lt;code&gt;settle[B]&lt;/code&gt; 保存正贡献事件：&lt;/p&gt;
&lt;p&gt;$$
\text{answer}(A,B,C,D)
=F(B,C,D)-F(A-1,C,D),
$$&lt;/p&gt;
&lt;p&gt;其中 $F(i,C,D)$ 表示前 $i$ 行在列区间 $[C,D]$ 中的黑格数。&lt;/p&gt;
&lt;h3&gt;正确性说明&lt;/h3&gt;
&lt;p&gt;在扫描到第 $i$ 行后，树状数组中每一列的值等于前 $i$ 行该列黑格的数量，因为每行只在自己的黑色区间 $[L_i,R_i]$ 上加 $1$。因此 &lt;code&gt;query_interval(C, D)&lt;/code&gt; 等于前 $i$ 行在列区间 $[C,D]$ 内的黑格总数。&lt;/p&gt;
&lt;p&gt;对于查询 $(A,B,C,D)$，负事件发生在加入第 $A$ 行前，得到 $F(A-1,C,D)$；正事件发生在加入第 $B$ 行后，得到 $F(B,C,D)$。两者相减后，编号不在 $[A,B]$ 内的行贡献完全抵消，剩余值正是目标矩形中的黑格数量。&lt;/p&gt;
&lt;p&gt;每次区间修改或区间查询需要 $O(\log M)$ 时间，所有行和查询的总复杂度为&lt;/p&gt;
&lt;p&gt;$$
O((N+Q)\log M),
$$&lt;/p&gt;
&lt;p&gt;空间复杂度为 $O(N+Q+M)$。&lt;/p&gt;
&lt;h2&gt;代码&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define tii tuple&amp;lt;int, int, int&amp;gt;
#define tll tuple&amp;lt;ll, ll, ll&amp;gt;
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
#define inf 0x3f3f3f3f3f3f3f3f
#define N 100005
#define M 1000005
#define lc p &amp;lt;&amp;lt; 1
#define rc p &amp;lt;&amp;lt; 1 | 1
#define lowbit(x) (x &amp;amp; -x)
using namespace std;

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

    auto solve = [&amp;amp;]() {
        ll n, m, q;
        cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m &amp;gt;&amp;gt; q;
        vector&amp;lt;ll&amp;gt; tr1(m + 5, 0);
        vector&amp;lt;ll&amp;gt; tr2(m + 5, 0);
        vector&amp;lt;pr&amp;gt; block(n + 5);
        for (int i = 1; i &amp;lt;= n; i++) {
            cin &amp;gt;&amp;gt; block[i].first &amp;gt;&amp;gt; block[i].second;
        }
        vector&amp;lt;vector&amp;lt;tuple&amp;lt;ll, ll, ll&amp;gt;&amp;gt;&amp;gt; enter(n + 5); //
        vector&amp;lt;vector&amp;lt;tuple&amp;lt;ll, ll, ll&amp;gt;&amp;gt;&amp;gt; settle(n + 5);
        for (int i = 1; i &amp;lt;= q; i++) {
            ll a, b, c, d;
            cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b &amp;gt;&amp;gt; c &amp;gt;&amp;gt; d;
            enter[a].push_back({i, c, d});
            settle[b].push_back({i, c, d});
        }
        auto add = [&amp;amp;](vector&amp;lt;ll&amp;gt; &amp;amp;tr, ll x, ll add) {
            for (; x &amp;lt;= m; x += lowbit(x))
                tr[x] += add;
        };
        auto query = [&amp;amp;](vector&amp;lt;ll&amp;gt; &amp;amp;tr, ll x) {
            ll res = 0;
            for (; x; x -= lowbit(x))
                res += tr[x];
            return res;
        };
        auto modify = [&amp;amp;](ll l, ll r, ll k) {
            add(tr1, l, k);
            add(tr1, r + 1, -k);
            add(tr2, l, k * (l - 1));
            add(tr2, r + 1, -k * r);
        };
        auto query_interval = [&amp;amp;](ll l, ll r) {
            return (query(tr1, r) * r - query(tr2, r) - (query(tr1, l - 1) * (l - 1) - query(tr2, l - 1)));
        };
        vector&amp;lt;ll&amp;gt; ans(q + 5, 0);
        for (int i = 1; i &amp;lt;= n; i++) {
            for (auto [id, l, r] : enter[i]) {
                ans[id] -= query_interval(l, r);
            }
            modify(block[i].first, block[i].second, 1);
            for (auto [id, l, r] : settle[i]) {
                ans[id] += query_interval(l, r);
            }
        }
        for (int i = 1; i &amp;lt;= q; i++)
            cout &amp;lt;&amp;lt; ans[i] &amp;lt;&amp;lt; &apos;\n&apos;;
    };

    solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>笛卡尔树</title><link>https://sanzenin.top/posts/obsidian/%E7%AC%9B%E5%8D%A1%E5%B0%94%E6%A0%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%AC%9B%E5%8D%A1%E5%B0%94%E6%A0%91/</guid><description>笛卡尔树是一种特殊的二叉树，由一系列键值对 构成。它同时满足以下两个特性： 1. 二叉搜索树（BST）性质：节点的左子树中所有节点的 值均小于根节点的 值，右子树中所有节点的 值均大于根节点的 值。 2. 堆（Heap）性质：节点的 值满足堆的性质（大根堆或小根堆）。通常在算法竞赛中，默认 满足小根堆性质，即父节点的</description><pubDate>Sun, 04 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h2&gt;1. 简介&lt;/h2&gt;
&lt;p&gt;笛卡尔树是一种特殊的&lt;strong&gt;二叉树&lt;/strong&gt;，由一系列键值对 $(k, w)$ 构成。它同时满足以下两个特性：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;二叉搜索树（BST）性质&lt;/strong&gt;：节点的左子树中所有节点的 $k$ 值均小于根节点的 $k$ 值，右子树中所有节点的 $k$ 值均大于根节点的 $k$ 值。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;堆（Heap）性质&lt;/strong&gt;：节点的 $w$ 值满足堆的性质（大根堆或小根堆）。通常在算法竞赛中，默认 $w$ 满足小根堆性质，即父节点的 $w$ 值小于其子节点。&lt;/li&gt;
&lt;/ol&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;核心结论&lt;/strong&gt;：如果一棵树的所有 $k$ 互不相同，且所有 $w$ 也互不相同，那么这棵笛卡尔树的结构是&lt;strong&gt;唯一&lt;/strong&gt;的。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 基本性质&lt;/h2&gt;
&lt;p&gt;以数组 $A$ 为例，通常将&lt;strong&gt;数组下标&lt;/strong&gt;作为 $k$，&lt;strong&gt;数组元素值&lt;/strong&gt;作为 $w$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;中序遍历&lt;/strong&gt;：笛卡尔树的中序遍历结果即为原序列（按 $k$ 排序）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;区间最值&lt;/strong&gt;：在小根堆性质下，一段区间 $[l, r]$ 的最小值对应笛卡尔树中下标 $l$ 和下标 $r$ 两个节点的&lt;strong&gt;最近公共祖先（LCA）&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子树区间性&lt;/strong&gt;：笛卡尔树中，以节点 $i$ 为根的子树，其所有节点在原数组中构成一个连续的区间。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 线性构建算法 ($O(n)$)&lt;/h2&gt;
&lt;p&gt;利用&lt;strong&gt;单调栈&lt;/strong&gt;可以在 $O(n)$ 时间内完成构建。&lt;/p&gt;
&lt;h3&gt;构建原理&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;按 $k$（下标）从小到大的顺序依次插入节点。&lt;/li&gt;
&lt;li&gt;新插入的节点必然位于当前树的&lt;strong&gt;右链&lt;/strong&gt;（从根节点出发一直往右走的路径）上。&lt;/li&gt;
&lt;li&gt;使用单调栈维护这条右链：
&lt;ul&gt;
&lt;li&gt;比较栈顶节点与当前节点的 $w$ 值。&lt;/li&gt;
&lt;li&gt;如果栈顶 $w &amp;gt;$ 当前 $w$，说明栈顶节点应该成为当前节点的左孩子（满足堆性质和 $k$ 的顺序）。&lt;/li&gt;
&lt;li&gt;不断弹出直到找到一个 $w &amp;lt;$ 当前 $w$ 的节点，将当前节点设为其右孩子。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;blockquote&gt;
&lt;p&gt;复制于oiwiki的建树图
&lt;img src=&quot;/obsidian/Pasted%20image%2020260124185416.png&quot; alt=&quot;Pasted image 20260124185416&quot; /&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/3314&quot;&gt;CSES  Mountain Range&lt;/a&gt;
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#define N 1000005
#define ll long long
#define inf 100000000000
using namespace std;
ll n, m, ans;
ll c[N];
const ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    vector&amp;lt;ll&amp;gt; s(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++) {
        cin &amp;gt;&amp;gt; s[i];
    }
    stack&amp;lt;int&amp;gt; sta;
    int root = 0;
    vector&amp;lt;int&amp;gt; rs(n + 5, 0);
    vector&amp;lt;int&amp;gt; ls(n + 5, 0);
    auto build = [&amp;amp;]() {
        for (int i = 1; i &amp;lt;= n; i++) {
            int pre = -1;
            while (sta.size() &amp;amp;&amp;amp; s[sta.top()] &amp;lt; s[i]) {
                pre = sta.top();
                sta.pop();
            }
            if (sta.size())
                rs[sta.top()] = i;
            else
                root = i;
            if (pre != -1)
                ls[i] = pre;
            sta.push(i);
        }
    };
#define lc ls[x]
#define rc rs[x]
    build();
    vector&amp;lt;int&amp;gt; dis(n + 5, 0);
    auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; int {
        if (!x)
            return dis[x] = 0;
        int res = 1;
        if (lc) {
            self(self, lc);
            if (s[x] == s[lc])
                res = max(dis[lc], res);
            else
                res = max(dis[lc] + 1, res);
        }
        if (rc) {
            self(self, rc);
            if (s[x] == s[rc])
                res = max(dis[rc], res);
            else
                res = max(dis[rc] + 1, res);
        }
        return dis[x] = res;
    };
    cout &amp;lt;&amp;lt; dfs(dfs, root);
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;4. Codeforces 2269E：KiaKio and Energy Intervals&lt;/h2&gt;
&lt;h3&gt;题目重述&lt;/h3&gt;
&lt;p&gt;给定长度为 $n$ 的数组 $a$。选择一个满足 $l&amp;lt;r$ 的区间 $[l,r]$，令&lt;/p&gt;
&lt;p&gt;$$
m=\max(a_l,a_{l+1},\ldots,a_r).
$$&lt;/p&gt;
&lt;p&gt;区间的能量定义为&lt;/p&gt;
&lt;p&gt;$$
\operatorname{val}(l,r)=\bigoplus_{i=l}^{r}(a_i\mathbin{&amp;amp;}m).
$$&lt;/p&gt;
&lt;p&gt;求所有合法区间中的最大能量。&lt;/p&gt;
&lt;p&gt;约束为 $1\le t\le 10^4$、$2\le n\le 2\cdot 10^5$，所有测试用例的 $n$ 之和不超过 $2\cdot 10^5$，且 $0\le a_i&amp;lt;2^{18}$。&lt;/p&gt;
&lt;h3&gt;关键观察&lt;/h3&gt;
&lt;h4&gt;按位贪心转化为可行性判定&lt;/h4&gt;
&lt;p&gt;设 $M$ 是当前希望强制出现在答案中的位掩码。定义 &lt;code&gt;check(M)&lt;/code&gt;：是否存在一个区间，使其能量的所有 $M$ 中的位均为 $1$。&lt;/p&gt;
&lt;p&gt;若该区间的最大值为 $a_x$，则必须满足&lt;/p&gt;
&lt;p&gt;$$
(a_x\mathbin{&amp;amp;}M)=M,
$$&lt;/p&gt;
&lt;p&gt;否则能量中不可能出现 $M$ 的某个高位。满足该条件后，令 $b_i=a_i\mathbin{&amp;amp;}M$，则每个 $b_i$ 都只包含 $M$ 中的位，因此区间异或包含全部 $M$ 中的位，当且仅当&lt;/p&gt;
&lt;p&gt;$$
\bigoplus_{i=l}^{r}b_i=M.
$$&lt;/p&gt;
&lt;p&gt;记前缀异或&lt;/p&gt;
&lt;p&gt;$$
p_i=b_1\oplus b_2\oplus\cdots\oplus b_i,
$$&lt;/p&gt;
&lt;p&gt;则判定条件变成 $p_{l-1}\oplus p_r=M$。&lt;/p&gt;
&lt;p&gt;从最高位到最低位依次尝试加入一位：若 &lt;code&gt;check(ans | (1 &amp;lt;&amp;lt; bit))&lt;/code&gt; 成立，就保留该位。因为数值比较首先由最高不同位决定，该过程得到所有可行能量中的最大值。&lt;/p&gt;
&lt;h4&gt;用最大笛卡尔树确定区间最大值&lt;/h4&gt;
&lt;p&gt;以数组下标为键、$a_i$ 为权值建立最大笛卡尔树。代码在建树时仅弹出严格更小的栈顶，因此相同最大值保留在左侧节点的右子树中；于是每个区间的树根可视为该区间最大值最左侧的出现位置。&lt;/p&gt;
&lt;p&gt;设节点 $x$ 的子树对应数组区间 $[L_x,R_x]$。节点 $x$ 是某个区间的笛卡尔树根，当且仅当&lt;/p&gt;
&lt;p&gt;$$
L_x\le l\le x\le r\le R_x.
$$&lt;/p&gt;
&lt;p&gt;这是因为子树区间内的元素都不大于 $a_x$，而区间一旦越过子树边界，就会包含笛卡尔树中位于 $x$ 上方的更大（或按相同值规则优先的）节点。&lt;/p&gt;
&lt;h4&gt;跨过根节点的区间等价于前缀异或配对&lt;/h4&gt;
&lt;p&gt;固定节点 $x$，只考虑其根为 $x$ 的区间。左端点对应的前缀下标 $l-1$ 位于 $[L_x-1,x-1]$，右端点对应的前缀下标 $r$ 位于 $[x,R_x]$，因此需要寻找&lt;/p&gt;
&lt;p&gt;$$
p_i\oplus p_j=M,
\quad i\in[L_x-1,x-1],\quad j\in[x,R_x].
$$&lt;/p&gt;
&lt;p&gt;代码的 &lt;code&gt;dfs(x, l, r)&lt;/code&gt; 使用前缀下标约定表示节点 $x$ 的子树数组区间 $[l+1,r]$。所以两个待配对集合正好是 &lt;code&gt;l..x-1&lt;/code&gt; 与 &lt;code&gt;x..r&lt;/code&gt;。&lt;/p&gt;
&lt;h4&gt;启发式合并与非法单点区间&lt;/h4&gt;
&lt;p&gt;在节点 $x$ 处，将较大一侧的 &lt;code&gt;pre&lt;/code&gt; 值加入频次数组 &lt;code&gt;cnt&lt;/code&gt;，枚举较小一侧的每个 $p_i$，查询 &lt;code&gt;cnt[p_i ^ M]&lt;/code&gt;。较小一侧的元素只会被重新加入到更大的集合中，因此一次 &lt;code&gt;check&lt;/code&gt; 的复杂度为 $O(n\log n)$。&lt;/p&gt;
&lt;p&gt;上述配对会额外包含 $i=x-1,j=x$，它对应区间 $[x,x]$，但题目要求 $l&amp;lt;r$。若&lt;/p&gt;
&lt;p&gt;$$
p_{x-1}\oplus p_x=M,
$$&lt;/p&gt;
&lt;p&gt;则代码在对应的小集合位置上减去这一个频次，排除该非法配对；这正是变量 &lt;code&gt;bad&lt;/code&gt; 与 &lt;code&gt;badid&lt;/code&gt; 的作用。&lt;/p&gt;
&lt;h3&gt;解析&lt;/h3&gt;
&lt;p&gt;对每个测试用例执行以下步骤：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;使用单调栈在线性时间内建立最大笛卡尔树。栈中维护当前右链；新节点弹出所有权值更小的节点，最后一个被弹出的节点成为新节点的左孩子，栈顶成为新节点的父节点的右孩子。&lt;/li&gt;
&lt;li&gt;枚举答案的二进制位。对每个候选掩码 $M$，先计算 $p_i$。&lt;/li&gt;
&lt;li&gt;在笛卡尔树上进行启发式合并 DFS。递归处理左右子树后，使用 &lt;code&gt;cnt&lt;/code&gt; 检查所有跨过当前节点 $x$ 的前缀异或配对；仅当 $(a_x\mathbin{&amp;amp;}M)=M$ 时才进行检查。&lt;/li&gt;
&lt;li&gt;如果存在合法配对，则当前位可以加入答案。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;正确性来自三点：笛卡尔树将每个区间唯一归类到其最大值根节点；前缀异或将固定根节点下的区间条件准确转换为两个集合间的异或配对；&lt;code&gt;check(M)&lt;/code&gt; 判定的正是“存在一个能量包含掩码 $M$ 的区间”。因此按位贪心在每一位都保留了数值最优的可行前缀，最终得到全局最大能量。&lt;/p&gt;
&lt;p&gt;设 $B=21$ 为代码枚举的位数。建树复杂度为 $O(n)$，每次判定复杂度为 $O(n\log n)$，总复杂度为&lt;/p&gt;
&lt;p&gt;$$
O(Bn\log n)，
$$&lt;/p&gt;
&lt;p&gt;空间复杂度为&lt;/p&gt;
&lt;p&gt;$$
O(n+2^B)。
$$&lt;/p&gt;
&lt;h3&gt;代码&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/extc++.h&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
#define tii tuple&amp;lt;int, int, int&amp;gt;
#define tll tuple&amp;lt;ll, ll, ll&amp;gt;
#define sp &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt;
#define inf 0x3f3f3f3f3f3f3f3f
#define N 100005
using namespace std;
using namespace __gnu_pbds;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);

    vector&amp;lt;ll&amp;gt; cnt(1 &amp;lt;&amp;lt; 21, 0);
    auto solve = [&amp;amp;]() {
        ll n, root;
        cin &amp;gt;&amp;gt; n;
        vector&amp;lt;array&amp;lt;int, 2&amp;gt;&amp;gt; tr(n + 5, {0, 0});
        stack&amp;lt;int&amp;gt; sta;
        vector&amp;lt;int&amp;gt; s(n + 5, 0);
        vector&amp;lt;int&amp;gt; pre(n + 5, 0);
        for (int i = 1; i &amp;lt;= n; i++) {
            cin &amp;gt;&amp;gt; s[i];
            int pre = -1;
            while (sta.size() &amp;amp;&amp;amp; s[sta.top()] &amp;lt; s[i])
                pre = sta.top(), sta.pop();
            if (sta.size())
                tr[sta.top()][1] = i;
            else
                root = i;
            if (pre != -1)
                tr[i][0] = pre;
            sta.push(i);
        }
        ll ans = 0;
        auto check = [&amp;amp;](int M) -&amp;gt; bool {
            for (int i = 1; i &amp;lt;= n; i++) {
                pre[i] = pre[i - 1] ^ (s[i] &amp;amp; M);
            }
            bool found = false;
            auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int l, int r, bool keep) -&amp;gt; void {
                if (l == r) {
                    if (keep)
                        cnt[pre[l]]++;
                    return;
                }
                int lc = tr[x][0], rc = tr[x][1];
                bool leftSmall = x - 1 - l &amp;lt;= r - x;
                int sl = leftSmall ? l : x, sr = leftSmall ? x - 1 : r;
                if (leftSmall)
                    self(self, lc, l, x - 1, false), self(self, rc, x, r, true);
                else
                    self(self, rc, x, r, false), self(self, lc, l, x - 1, true);
                if ((s[x] &amp;amp; M) == M) {
                    bool bad = (pre[x - 1] ^ pre[x]) == M;
                    int badid = leftSmall ? x - 1 : x;
                    for (int i = sl; i &amp;lt;= sr; i++) {
                        if (cnt[pre[i] ^ M] - (bad &amp;amp;&amp;amp; badid == i) &amp;gt; 0)
                            found = true;
                    }
                }
                for (int i = sl; i &amp;lt;= sr; i++)
                    cnt[pre[i]]++;
                if (!keep)
                    for (int i = l; i &amp;lt;= r; i++)
                        cnt[pre[i]]--;
            };
            dfs(dfs, root, 0, n, false);
            return found;
        };
        for (int i = 20; i &amp;gt;= 0; i--) {
            if (check(ans | (1 &amp;lt;&amp;lt; i)))
                ans |= (1 &amp;lt;&amp;lt; i);
        }
        cout &amp;lt;&amp;lt; ans &amp;lt;&amp;lt; &apos;\n&apos;;
    };
    ll t;
    cin &amp;gt;&amp;gt; t;
    while (t--)
        solve();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>03-陪集-Lagrange-正规子群</title><link>https://sanzenin.top/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/</guid><description>设 是群 的子群。对于任意 ： 1. 左陪集（Left Coset）：集合 称为子群 在 中关于代表元 的左陪集。 2. 右陪集（Right Coset）：集合 称为子群 在 中关于代表元 的右陪集。 元素 称为该陪集的代表元（Representative）。 陪集是用子群 作为基准结构对全群 进行的平移划分。陪集本身</description><pubDate>Thu, 24 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;03-陪集-Lagrange-正规子群&lt;/h1&gt;
&lt;h2&gt;1. 陪集的严格定义与性质&lt;/h2&gt;
&lt;h3&gt;1.1 严格表述&lt;/h3&gt;
&lt;p&gt;设 $H$ 是群 $G$ 的子群。对于任意 $a \in G$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;左陪集（Left Coset）&lt;/strong&gt;：集合 $aH := {ah \mid h \in H}$ 称为子群 $H$ 在 $G$ 中关于代表元 $a$ 的左陪集。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;右陪集（Right Coset）&lt;/strong&gt;：集合 $Ha := {ha \mid h \in H}$ 称为子群 $H$ 在 $G$ 中关于代表元 $a$ 的右陪集。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;元素 $a$ 称为该陪集的&lt;strong&gt;代表元（Representative）&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;1.2 数学直觉&lt;/h3&gt;
&lt;p&gt;陪集是用子群 $H$ 作为基准结构对全群 $G$ 进行的平移划分。陪集本身通常不包含单位元，因而不是子群；当且仅当代表元属于 $H$ 时，陪集才等于 $H$ 本身。&lt;/p&gt;
&lt;h3&gt;1.3 陪集的核心性质及其证明&lt;/h3&gt;
&lt;h4&gt;定理 3.1（代表元包含性与平凡陪集）&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;$\forall a \in G$，$a \in aH$ 且 $a \in Ha$；&lt;/li&gt;
&lt;li&gt;$eH = H = He$；&lt;/li&gt;
&lt;li&gt;$a \in H \iff aH = H$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;因 $H \le G$，单位元 $e \in H$。故 $a = ae \in aH$，$a = ea \in Ha$。&lt;/li&gt;
&lt;li&gt;$eH = {eh \mid h \in H} = {h \mid h \in H} = H$。&lt;/li&gt;
&lt;li&gt;若 $a \in H$，对任意 $h \in H$，由封闭性 $ah \in H \implies aH \subseteq H$；又对任意 $h \in H$，$h = a(a^{-1}h) \in aH \implies H \subseteq aH$，故 $aH = H$。反之，若 $aH = H$，由 $a \in aH$ 得 $a \in H$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;定理 3.2（陪集相等的充要判定准则）&lt;/h4&gt;
&lt;p&gt;设 $H \le G$，$a, b \in G$。下列命题等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$aH = bH$；&lt;/li&gt;
&lt;li&gt;$aH \cap bH \ne \emptyset$；&lt;/li&gt;
&lt;li&gt;$b \in aH$；&lt;/li&gt;
&lt;li&gt;$a^{-1}b \in H$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;$1 \implies 2$&lt;/strong&gt;：若 $aH = bH$，由 $b = be \in bH = aH$，交集非空。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$2 \implies 3$&lt;/strong&gt;：设 $x \in aH \cap bH$。存在 $h_1, h_2 \in H$ 使得 $x = ah_1 = bh_2$。
两边右乘 $h_2^{-1}$，得 $b = a(h_1 h_2^{-1})$。因为 $H \le G$，故 $h_1 h_2^{-1} \in H$，所以 $b \in aH$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$3 \implies 4$&lt;/strong&gt;：若 $b \in aH$，存在 $h \in H$ 使得 $b = ah$。两边左乘 $a^{-1}$，得 $a^{-1}b = h \in H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$4 \implies 1$&lt;/strong&gt;：若 $a^{-1}b \in H$，设 $h_0 = a^{-1}b \in H$，则 $b = ah_0$。
对任意 $bh \in bH$，有 $bh = (ah_0)h = a(h_0 h) \in aH \implies bH \subseteq aH$。
同理，由 $a^{-1}b \in H \implies (a^{-1}b)^{-1} = b^{-1}a \in H$，推得 $aH \subseteq bH$。
因此 $aH = bH$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!NOTE] 代数直觉
$a^{-1}b \in H$ 表示 $a$ 与 $b$ 的代数差异落在了子群 $H$ 内部。在加法群中，该条件对应于差值 $b - a \in H$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h4&gt;定理 3.3（模 $H$ 同余与等价划分）&lt;/h4&gt;
&lt;p&gt;定义群 $G$ 上的二元关系 $\equiv_L$ 为：
$$a \equiv_L b \pmod H \iff a^{-1}b \in H$$
则 $\equiv_L$ 是群 $G$ 上的一个&lt;strong&gt;等价关系&lt;/strong&gt;。其等价类集合正是子群 $H$ 在 $G$ 中的全体左陪集：
$$[a] = aH$$
因此，所有互不相交的左陪集构成群 $G$ 的一个严格无缝划分：
$$G = \bigcup_{i \in I} a_i H, \quad \text{且 } a_i H \cap a_j H = \emptyset\ (i \ne j)$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;自反性&lt;/strong&gt;：$\forall a \in G$，$a^{-1}a = e \in H \implies a \equiv_L a$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;对称性&lt;/strong&gt;：若 $a \equiv_L b$，则 $a^{-1}b \in H$。由子群对求逆封闭，$(a^{-1}b)^{-1} = b^{-1}a \in H \implies b \equiv_L a$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;传递性&lt;/strong&gt;：若 $a \equiv_L b$ 且 $b \equiv_L c$，则 $a^{-1}b \in H$ 且 $b^{-1}c \in H$。
由子群对乘法封闭：$(a^{-1}b)(b^{-1}c) = a^{-1}(bb^{-1})c = a^{-1}c \in H \implies a \equiv_L c$。
由集合论基本定理，等价关系唯一确定集合划分，等价类 $[a] = {x \in G \mid a^{-1}x \in H} = {ah \mid h \in H} = aH$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 陪集的等势性与拉格朗日定理（Lagrange）&lt;/h2&gt;
&lt;h3&gt;2.1 陪集大小的等势性&lt;/h3&gt;
&lt;h4&gt;定理 3.4&lt;/h4&gt;
&lt;p&gt;设 $H \le G$。对任意 $a \in G$，左陪集 $aH$ 与子群 $H$ 等势，即：
$$|aH| = |H|$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
构造映射 $f: H \to aH$，定义为 $f(h) = ah$（$\forall h \in H$）。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;单射性&lt;/strong&gt;：设 $h_1, h_2 \in H$。若 $f(h_1) = f(h_2)$，即 $ah_1 = ah_2$。
根据群的左消去律，两边左乘 $a^{-1}$ 得出 $h_1 = h_2$。故 $f$ 是单射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：任取 $y \in aH$，由左陪集定义，存在 $h \in H$ 使得 $y = ah = f(h)$。故 $f$ 是满射。
因此 $f$ 是双射，集合 $aH$ 与 $H$ 具有相同的基数。对于有限群，必然有 $|aH| = |H|$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;2.2 拉格朗日定理（Lagrange&apos;s Theorem）&lt;/h3&gt;
&lt;h4&gt;定理 3.5（Lagrange 定理）&lt;/h4&gt;
&lt;p&gt;设 $G$ 是有限群，$H$ 是 $G$ 的任意子群。则子群的阶 $|H|$ 必定整除大群的阶 $|G|$，且有：
$$|G| = [G : H] \cdot |H|$$
其中 $[G : H]$ 称为子群 $H$ 在群 $G$ 中的&lt;strong&gt;指数（Index）&lt;/strong&gt;，即群 $G$ 中互不相交的左陪集总数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
由定理 3.3，群 $G$ 可以无重叠、无遗漏地划分成有限个互不相同的左陪集：
$$G = a_1 H \cup a_2 H \cup \cdots \cup a_k H$$
其中 $k = [G : H]$，且对任意 $i \ne j$ 有 $a_i H \cap a_j H = \emptyset$。
对划分两边的元素个数求和：
$$|G| = \sum_{i=1}^k |a_i H|$$
由定理 3.4，每一个陪集的大小均严格等于 $|H|$：
$$|G| = \sum_{i=1}^k |H| = k \cdot |H| = [G : H] \cdot |H|$$
两边除以 $|H|$，得出 $[G : H] = \frac{|G|}{|H|}$ 为正整数，故 $|H| \mid |G|$。 $\blacksquare$&lt;/p&gt;
&lt;h3&gt;2.3 核心推论&lt;/h3&gt;
&lt;h4&gt;推论 3.6（元素的阶整除群阶）&lt;/h4&gt;
&lt;p&gt;设 $G$ 是有限群。对任意元素 $a \in G$：
$$\operatorname{ord}(a) \mid |G|$$
从而：
$$a^{|G|} = e$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
考察由元素 $a$ 生成的循环子群 $H = \langle a \rangle$。
由定义，$|H| = \operatorname{ord}(a)$。
根据 Lagrange 定理，$|H| \mid |G|$，即 $\operatorname{ord}(a) \mid |G|$。
设 $|G| = q \cdot \operatorname{ord}(a)$，则 $a^{|G|} = (a^{\operatorname{ord}(a)})^q = e^q = e$。 $\blacksquare$&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;数论应用&lt;/strong&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;欧拉定理&lt;/strong&gt;：在模 $m$ 简化剩余系乘法群 $(\mathbb{Z}_m^\times, \times)$ 中，群阶为 $\phi(m)$。对任意与 $m$ 互质的整数 $a$，由该推论立得 $a^{\phi(m)} \equiv 1 \pmod m$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;费马小定理&lt;/strong&gt;：当 $m = p$ 为素数时，$\phi(p) = p - 1$，立得 $a^{p-1} \equiv 1 \pmod p$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;h4&gt;推论 3.7（素数阶群必为循环群）&lt;/h4&gt;
&lt;p&gt;若有限群 $G$ 的阶 $|G| = p$ 是一个素数，则 $G$ 必为循环群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
任取非单位元 $a \in G$（$a \ne e$）。
考察其阶 $\operatorname{ord}(a)$。由推论 3.6，$\operatorname{ord}(a) \mid p$。
因为 $p$ 是素数，其正因数仅有 $1$ 和 $p$。
又因 $a \ne e$，$\operatorname{ord}(a) &amp;gt; 1$，所以只能是 $\operatorname{ord}(a) = p$。
由此，由 $a$ 生成的循环子群包含 $p$ 个元素，即 $\langle a \rangle = G$。
群 $G$ 由单元素生成，故必为循环群。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 拉格朗日定理逆命题的反思与反例&lt;/h2&gt;
&lt;h3&gt;3.1 逆命题的不成立性&lt;/h3&gt;
&lt;p&gt;Lagrange 定理给出了子群阶数的&lt;strong&gt;必要条件&lt;/strong&gt;（必须是因数），但并不构成&lt;strong&gt;充分条件&lt;/strong&gt;：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;若 $d \mid |G|$，群 $G$ 中&lt;strong&gt;不一定&lt;/strong&gt;存在阶为 $d$ 的子群。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;3.2 经典反例：交代群 $A_4$ 没有 6 阶子群&lt;/h3&gt;
&lt;h4&gt;定理 3.8&lt;/h4&gt;
&lt;p&gt;4 次交代群 $A_4$ 的阶数为 $|A_4| = \frac{4!}{2} = 12$。虽然 $6 \mid 12$，但 $A_4$ 内部不存在任何 6 阶子群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;形式化证明（反证法）：&lt;/strong&gt;
假设 $A_4$ 存在一个 6 阶子群 $H$（$|H| = 6$）。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;子群的指数与正规性&lt;/strong&gt;：
$$[A_4 : H] = \frac{|A_4|}{|H|} = \frac{12}{6} = 2$$
由后续定理 3.10（指数为 2 的子群必正规），必有 $H \triangleleft A_4$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;商群平方性质&lt;/strong&gt;：
既然 $H$ 正规，商群 $A_4 / H$ 存在且阶为 2：
$$|A_4 / H| = [A_4 : H] = 2$$
二阶群中的任何元素其平方必为单位元（商群的单位元即陪集 $H$）。
因此，对全群中任意元素 $g \in A_4$，在商群中均有：
$$(gH)^2 = H \implies g^2 H = H \implies g^2 \in H$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;引入 3-轮换导出矛盾&lt;/strong&gt;：
任取 $A_4$ 中的任意一个 3-轮换 $\tau = (a\ b\ c)$。
由上述推导，必有 $\tau^2 \in H$。
根据 3-轮换的运算性质，$\tau^3 = (1) \implies \tau^2 = \tau^{-1}$。
因此 $\tau^{-1} \in H$。因为 $H$ 是子群，对求逆封闭，所以：
$$\tau = (\tau^{-1})^{-1} \in H$$
这表明：$A_4$ 中的所有 3-轮换都必须属于子群 $H$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;元素计数矛盾&lt;/strong&gt;：
在 $A_4$ 中，3-轮换一共有 $\binom{4}{3} \times 2 = 8$ 个。
加上单位元 $(1)$，$H$ 中至少必须包含 $8 + 1 = 9$ 个互不相同的元素：
$$|H| \ge 9$$
这与假设 $|H| = 6$ 矛盾。
因此假设不成立，$A_4$ 绝无 6 阶子群。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 正规子群（Normal Subgroup）&lt;/h2&gt;
&lt;h3&gt;4.1 严格定义&lt;/h3&gt;
&lt;p&gt;设 $N$ 是群 $G$ 的子群。如果对任意 $g \in G$，都有：
$$g N g^{-1} = N$$
（或者等价地：$\forall g \in G, \forall n \in N \implies g n g^{-1} \in N$），
则称 $N$ 是群 $G$ 的&lt;strong&gt;正规子群（Normal Subgroup，或不变子群）&lt;/strong&gt;，记作：
$$N \triangleleft G$$&lt;/p&gt;
&lt;h3&gt;4.2 等价判据定理&lt;/h3&gt;
&lt;h4&gt;定理 3.9&lt;/h4&gt;
&lt;p&gt;设 $N \le G$。下列条件等价：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$N \triangleleft G$；&lt;/li&gt;
&lt;li&gt;$\forall g \in G$，$g N g^{-1} \subseteq N$；&lt;/li&gt;
&lt;li&gt;$\forall g \in G$，$gN = Ng$（左陪集等于右陪集）；&lt;/li&gt;
&lt;li&gt;$\forall g \in G$，$gN g^{-1} = N$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$1 \iff 2$：若 $\forall g \in G, gNg^{-1} \subseteq N$。任取 $g \in G$，以 $g^{-1}$ 代替 $g$，有 $g^{-1}N(g^{-1})^{-1} \subseteq N \implies g^{-1}Ng \subseteq N$。
两边左乘 $g$、右乘 $g^{-1}$，得 $N \subseteq gNg^{-1}$。结合两式即得 $gNg^{-1} = N$。&lt;/li&gt;
&lt;li&gt;$1 \iff 3$：在 $gNg^{-1} = N$ 两边右乘 $g$，由结合律直接化为 $gN = Ng$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;4.3 指数为 2 的正规性定理&lt;/h3&gt;
&lt;h4&gt;定理 3.10&lt;/h4&gt;
&lt;p&gt;若子群 $H \le G$ 满足指数 $[G : H] = 2$，则 $H$ 必为 $G$ 的正规子群（$H \triangleleft G$）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
验证左陪集是否等于右陪集：
任取 $g \in G$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $g \in H$：由子群封闭性，$gH = H = Hg$。&lt;/li&gt;
&lt;li&gt;若 $g \notin H$：因为指数 $[G : H] = 2$，全群只能划分成两个互不相交的左陪集，其中一个是平凡陪集 $H$。因此另一个左陪集必为补集：
$$gH = G \setminus H$$
同理，全群也只能划分成两个互不相交的右陪集，故右陪集也必为补集：
$$Hg = G \setminus H$$
两者完全相同：
$$gH = Hg$$
综上，对一切 $g \in G$ 均有 $gH = Hg$，故 $H \triangleleft G$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 群的作用与轨道-稳定子定理&lt;/h2&gt;
&lt;h3&gt;5.1 严格表述&lt;/h3&gt;
&lt;p&gt;设 $G$ 是群，$X$ 是非空集合。群 $G$ 在集合 $X$ 上的一个**作用（Group Action）**是指一个映射 $\cdot: G \times X \to X$，满足：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$\forall x \in X$，$e \cdot x = x$；&lt;/li&gt;
&lt;li&gt;$\forall g_1, g_2 \in G, \forall x \in X$，$(g_1 g_2) \cdot x = g_1 \cdot (g_2 \cdot x)$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;在此作用下，定义两个核心对象：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;轨道（Orbit）&lt;/strong&gt;：点 $x$ 在群操作下能达到的全体目标点集合：
$$\operatorname{Orb}(x) = {g \cdot x \mid g \in G} \subseteq X$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;稳定子（Stabilizer）&lt;/strong&gt;：所有保持点 $x$ 保持不动的群元素集合：
$$\operatorname{Stab}(x) = {g \in G \mid g \cdot x = x} \subseteq G$$&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;引理 3.11&lt;/h4&gt;
&lt;p&gt;对任意 $x \in X$，$\operatorname{Stab}(x)$ 是群 $G$ 的子群（$\operatorname{Stab}(x) \le G$）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$e \cdot x = x \implies e \in \operatorname{Stab}(x)$，非空。&lt;/li&gt;
&lt;li&gt;任取 $a, b \in \operatorname{Stab}(x)$。则 $a \cdot x = x, b \cdot x = x$。
在 $b \cdot x = x$ 两边作用 $b^{-1}$，得 $b^{-1} \cdot x = x$。
则 $(ab^{-1}) \cdot x = a \cdot (b^{-1} \cdot x) = a \cdot x = x$。
故 $ab^{-1} \in \operatorname{Stab}(x)$。由一步判定法，$\operatorname{Stab}(x) \le G$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;5.2 轨道-稳定子定理（Orbit-Stabilizer Theorem）&lt;/h3&gt;
&lt;h4&gt;定理 3.12&lt;/h4&gt;
&lt;p&gt;设有限群 $G$ 作用在集合 $X$ 上。对于任意 $x \in X$：
$$|G| = |\operatorname{Orb}(x)| \times |\operatorname{Stab}(x)|$$
即：轨道的大小等于稳定子群在 $G$ 中的指数：
$$|\operatorname{Orb}(x)| = [G : \operatorname{Stab}(x)]$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
记 $H = \operatorname{Stab}(x)$。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;特别说明&lt;/strong&gt;：记号 $G/H = {gH \mid g \in G}$ 在此处&lt;strong&gt;仅表示子群 $H$ 在 $G$ 中的左陪集集合&lt;/strong&gt;。因为 $H$ 不一定是正规子群，所以此处 $G/H$ &lt;strong&gt;不是商群&lt;/strong&gt;，只作为一个普通的商集合。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;构造从左陪集集合 $G/H$ 到轨道 $\operatorname{Orb}(x)$ 的映射：
$$\Psi: G/H \to \operatorname{Orb}(x), \quad \Psi(gH) = g \cdot x$$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;良定性与单射性&lt;/strong&gt;：
设 $g_1, g_2 \in G$。根据定理 3.2：
$$g_1 H = g_2 H \iff g_1^{-1} g_2 \in H = \operatorname{Stab}(x)$$
$$\iff (g_1^{-1} g_2) \cdot x = x \iff g_2 \cdot x = g_1 \cdot x \iff \Psi(g_1 H) = \Psi(g_2 H)$$
正向推导证明了映射 $\Psi$ 的&lt;strong&gt;良定性&lt;/strong&gt;（取值与代表元选取无关）；
逆向推导证明了 $\Psi$ 的&lt;strong&gt;单射性&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满射性&lt;/strong&gt;：
任取轨道中的点 $y \in \operatorname{Orb}(x)$，由轨道定义，存在 $g \in G$ 使得 $g \cdot x = y$。
从而 $\Psi(gH) = g \cdot x = y$。故 $\Psi$ 是满射。
综上，$\Psi$ 是双射。因此：
$$|\operatorname{Orb}(x)| = |G/H| = [G : \operatorname{Stab}(x)]$$
再由 Lagrange 定理 $|G| = [G : H] \cdot |H|$，代入即得：
$$|G| = |\operatorname{Orb}(x)| \times |\operatorname{Stab}(x)| \quad \blacksquare$$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 核心易错点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;陪集判定的左逆次序&lt;/strong&gt;：左陪集相等是 $a^{-1}b \in H$，而非 $ab^{-1} \in H$（后者对应右陪集相等 $Ha = Hb$）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;陪集与子群的区别&lt;/strong&gt;：陪集 $aH$ 通常不含单位元，因而通常不是子群；当且仅当 $a \in H$ 时，$aH = H$ 才是子群。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;正规子群判定的左右颠倒&lt;/strong&gt;：$gN = Ng$ 并不要求群元素满足逐点交换 $gn = ng$；它表示的是集合相等，即对任意 $n \in N$，存在 $n&apos; \in N$ 使得 $gn = n&apos;g$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;拉格朗日逆命题误区&lt;/strong&gt;：不能认为只要 $d$ 整除群阶就一定存在 $d$ 阶子群，例如 $A_4$ 没有 6 阶子群。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 前后知识连接&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：集合等价关系与划分（&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;）、子群一步判定、阿贝尔群交换性（&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/&quot;&gt;01-群与子群.md&lt;/a&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;正规子群是构造商群（&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态.md&lt;/a&gt;）的先决条件。&lt;/li&gt;
&lt;li&gt;$a^{-1}b \in N$ 是证明商群乘法良定性与第一同构定理双射性（&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理.md&lt;/a&gt;）的核心工具。&lt;/li&gt;
&lt;li&gt;轨道-稳定子定理是后续证明 Cayley 定理与内自同构群（&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley.md&lt;/a&gt;）的理论基石。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与证明套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（易错点 8 Lagrange 逆命题反例、模板 5 指数为 2 子群必正规证明法）。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>04-商群与同态</title><link>https://sanzenin.top/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/</guid><description>设 是群 的正规子群（ ）。定义集合： 为 关于 的全体左（右）陪集构成的集合。 在集合 上定义二元运算（陪集乘法）： 代数系统 称为群 关于正规子群 的商群（Quotient Group）。 商群是通过忽略正规子群 内部差异而构造的同余类系统。由于陪集是用其中的代表元来写出的，必须保证选取的代表元不同时，陪集相乘的结</description><pubDate>Thu, 24 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;04-商群与同态&lt;/h1&gt;
&lt;h2&gt;1. 商群的构造与良定性&lt;/h2&gt;
&lt;h3&gt;1.1 严格表述&lt;/h3&gt;
&lt;p&gt;设 $N$ 是群 $G$ 的&lt;strong&gt;正规子群&lt;/strong&gt;（$N \triangleleft G$）。定义集合：
$$G/N := {aN \mid a \in G}$$
为 $G$ 关于 $N$ 的全体左（右）陪集构成的集合。
在集合 $G/N$ 上定义二元运算（陪集乘法）：
$$(aN)(bN) := (ab)N, \quad \forall aN, bN \in G/N$$
代数系统 $(G/N, \cdot)$ 称为群 $G$ 关于正规子群 $N$ 的&lt;strong&gt;商群（Quotient Group）&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;1.2 数学直觉&lt;/h3&gt;
&lt;p&gt;商群是通过忽略正规子群 $N$ 内部差异而构造的同余类系统。由于陪集是用其中的代表元来写出的，必须保证选取的代表元不同时，陪集相乘的结果仍然落在同一个陪集中，这一前提由 $N$ 的正规性（$gN = Ng$）所保证。&lt;/p&gt;
&lt;h3&gt;1.3 商群乘法的良定性（Well-definedness）证明&lt;/h3&gt;
&lt;h4&gt;定理 4.1（良定性充要定理）&lt;/h4&gt;
&lt;p&gt;运算 $(aN)(bN) = (ab)N$ 在陪集集合 $G/N$ 上是良定的，当且仅当 $N$ 是群 $G$ 的正规子群（$N \triangleleft G$）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;严格形式化证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;充分性（$N \triangleleft G \implies$ 运算良定）&lt;/strong&gt;：
设 $a_1 N = a_2 N$ 且 $b_1 N = b_2 N$。
由定理 3.2，存在 $n_a, n_b \in N$，使得：
$$a_2 = a_1 n_a, \quad b_2 = b_1 n_b$$
计算两个新代表元的乘积：
$$a_2 b_2 = (a_1 n_a)(b_1 n_b) = a_1 (n_a b_1) n_b$$
因为 $N \triangleleft G$，由左陪集等于右陪集（$N b_1 = b_1 N$），存在 $n&apos;_a \in N$ 使得：
$$n_a b_1 = b_1 n&apos;_a$$
将此式代入乘积中：
$$a_2 b_2 = a_1 (b_1 n&apos;_a) n_b = (a_1 b_1)(n&apos;_a n_b)$$
因为 $N$ 是子群，对运算封闭，故 $n&apos;_a n_b \in N$。
因此：
$$(a_1 b_1)^{-1}(a_2 b_2) = n&apos;_a n_b \in N$$
由定理 3.2，得：
$$(a_2 b_2)N = (a_1 b_1)N$$
这证明了运算结果与代表元的选择无关，商群乘法良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必要性（运算良定 $\implies N \triangleleft G$）&lt;/strong&gt;：
设运算良定。任取 $g \in G, n \in N$。
因为 $n \in N$，故 $nN = eN = N$。
由良定性，陪集乘法 $(gN)(nN)(g^{-1}N)$ 的结果与代表元选取无关：
$$(gN)(nN)(g^{-1}N) = (gN)(eN)(g^{-1}N) = (g e g^{-1})N = eN = N$$
直接按运算定义计算左边：
$$(gN)(nN)(g^{-1}N) = (g n g^{-1})N$$
因此必有 $(g n g^{-1})N = N \implies g n g^{-1} \in N$。
由定义，$N \triangleleft G$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!CAUTION] 非正规子群的反例
在 3 次对称群 $S_3$ 中，取 2 阶子群 $H = {(1), (1\ 2)}$。$H$ 不是正规子群。
$H$ 在 $S_3$ 中的全部左陪集为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$H = {(1), (1\ 2)}$；&lt;/li&gt;
&lt;li&gt;$(1\ 3)H = {(1\ 3)(1), (1\ 3)(1\ 2)} = {(1\ 3), (1\ 2\ 3)}$；&lt;/li&gt;
&lt;li&gt;$(2\ 3)H = {(2\ 3)(1), (2\ 3)(1\ 2)} = {(2\ 3), (1\ 3\ 2)}$。
考虑左陪集 $A = (1\ 3)H = {(1\ 3), (1\ 2\ 3)}$ 与 $B = (2\ 3)H = {(2\ 3), (1\ 3\ 2)}$ 的乘法：&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;若选代表元 $(1\ 3) \in A$ 与 $(2\ 3) \in B$：乘积为 $(1\ 3)(2\ 3) = (1\ 3\ 2)$，其所在左陪集为 $(1\ 3\ 2)H = (2\ 3)H = {(2\ 3), (1\ 3\ 2)}$；&lt;/li&gt;
&lt;li&gt;若选代表元 $(1\ 2\ 3) \in A$ 与 $(2\ 3) \in B$：乘积为 $(1\ 2\ 3)(2\ 3) = (1\ 2)$，其所在左陪集为 $(1\ 2)H = H = {(1), (1\ 2)}$。
两种代表元选取给出了完全不同的左陪集 $(2\ 3)H \ne H$。这证明了非正规子群无法良定陪集乘法。&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;
&lt;h3&gt;1.4 商群公理的形式化验证&lt;/h3&gt;
&lt;h4&gt;定理 4.2&lt;/h4&gt;
&lt;p&gt;设 $N \triangleleft G$，则 $(G/N, \cdot)$ 构成一个群。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;封闭性&lt;/strong&gt;：由定理 4.1，对任意 $aN, bN \in G/N$，乘积 $(ab)N \in G/N$ 且良定。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结合律&lt;/strong&gt;：任取 $aN, bN, cN \in G/N$：
$$((aN)(bN))(cN) = ((ab)N)(cN) = ((ab)c)N$$
由群 $G$ 的结合律 $(ab)c = a(bc)$：
$$= (a(bc))N = (aN)((bc)N) = (aN)((bN)(cN))$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单位元&lt;/strong&gt;：$N = eN$ 为单位元。对任意 $aN \in G/N$：
$$(eN)(aN) = (ea)N = aN, \quad (aN)(eN) = (ae)N = aN$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;逆元&lt;/strong&gt;：对任意 $aN \in G/N$，其逆元为 $a^{-1}N$：
$$(aN)(a^{-1}N) = (a a^{-1})N = eN = N, \quad (a^{-1}N)(aN) = (a^{-1}a)N = eN = N$$
综上，$(G/N, \cdot)$ 构成一个群。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 商群的阶与塔式法则&lt;/h2&gt;
&lt;h3&gt;2.1 商群的阶&lt;/h3&gt;
&lt;h4&gt;定理 4.3&lt;/h4&gt;
&lt;p&gt;设 $G$ 是有限群，$N \triangleleft G$，则商群 $G/N$ 的阶为：
$$|G/N| = [G : N] = \frac{|G|}{|N|}$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
商群 $G/N$ 的元素即为 $N$ 在 $G$ 中的全体左陪集。由 Lagrange 定理（定理 3.5），互不相交的陪集总数恰为 $[G : N] = \frac{|G|}{|N|}$。 $\blacksquare$&lt;/p&gt;
&lt;h3&gt;2.2 塔式法则（指数乘法公式）&lt;/h3&gt;
&lt;h4&gt;定理 4.4（子群链指数公式）&lt;/h4&gt;
&lt;p&gt;设 $K \le H \le G$ 是群 $G$ 的子群链（无需正规性假设）。则：
$$[G : K] = [G : H][H : K]$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;
设 $H$ 在 $G$ 中的互不相交左陪集划分为：
$$G = \bigcup_{i \in I} g_i H, \quad |I| = [G : H]$$
设 $K$ 在 $H$ 中的互不相交左陪集划分为：
$$H = \bigcup_{j \in J} h_j K, \quad |J| = [H : K]$$
将 $H$ 的划分代入 $G$ 中：
$$G = \bigcup_{i \in I} g_i \left( \bigcup_{j \in J} h_j K \right) = \bigcup_{i \in I, j \in J} (g_i h_j) K$$
需证明所有陪集 $(g_i h_j) K$ 两两互不相交：
设 $(g_i h_j) K = (g_{i&apos;} h_{j&apos;}) K$。
两边同时右乘 $H$（因为 $K \subseteq H \implies KH = H$）：
$$g_i h_j H = g_{i&apos;} h_{j&apos;} H$$
因为 $h_j, h_{j&apos;} \in H$，故 $h_j H = H = h_{j&apos;} H$。
因此：
$$g_i H = g_{i&apos;} H$$
由于 ${g_i H}&lt;em&gt;{i \in I}$ 是互不相同的左陪集，必有 $i = i&apos;$。
将 $i = i&apos;$ 代入原式，两边左乘 $g_i^{-1}$：
$$(g_i h_j)K = (g_i h&lt;/em&gt;{j&apos;})K \implies h_j K = h_{j&apos;} K$$
由于 ${h_j K}_{j \in J}$ 是互不相同的左陪集，必有 $j = j&apos;$。
因此，指标对 $(i, j) \in I \times J$ 唯一确定 $G$ 关于 $K$ 的一个左陪集，无遗漏且两两不交。
其总个数为 $|I| \times |J|$，即 $[G : K] = [G : H][H : K]$。 $\blacksquare$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 群同态与群同构&lt;/h2&gt;
&lt;h3&gt;3.1 严格定义&lt;/h3&gt;
&lt;p&gt;设 $(G, \cdot)$ 与 $(G&apos;, *)$ 是群，$f: G \to G&apos;$ 是一个映射。
如果对任意 $a, b \in G$，均有：
$$f(ab) = f(a) * f(b)$$
则称 $f$ 是群 $G$ 到群 $G&apos;$ 的&lt;strong&gt;群同态（Homomorphism）&lt;/strong&gt;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;单同态（Monomorphism）&lt;/strong&gt;：$f$ 是单射；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;满同态（Epimorphism）&lt;/strong&gt;：$f$ 是满射；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同构（Isomorphism）&lt;/strong&gt;：$f$ 是双射（既单又满），称群 $G$ 与 $G&apos;$ 同构，记作 $G \cong G&apos;$；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;自同态 / 自同构&lt;/strong&gt;：目标群 $G&apos; = G$ 时的同态 / 同构。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3.2 群同态的保持性质&lt;/h3&gt;
&lt;h4&gt;定理 4.5&lt;/h4&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态，$e, e&apos;$ 分别为 $G, G&apos;$ 的单位元。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$f(e) = e&apos;$；&lt;/li&gt;
&lt;li&gt;$\forall a \in G$，$f(a^{-1}) = (f(a))^{-1}$；&lt;/li&gt;
&lt;li&gt;$\forall a \in G, \forall k \in \mathbb{Z}$，$f(a^k) = (f(a))^k$；&lt;/li&gt;
&lt;li&gt;若 $\operatorname{ord}(a) = m &amp;lt; \infty$，则 $\operatorname{ord}(f(a))$ 有限且 $\operatorname{ord}(f(a)) \mid \operatorname{ord}(a)$；&lt;/li&gt;
&lt;li&gt;若 $f$ 是同构（或单同态），则对任意有限阶元素 $a \in G$，$\operatorname{ord}(f(a)) = \operatorname{ord}(a)$（同构严格保阶）。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;在群 $G$ 中 $ee = e$。施加映射 $f(ee) = f(e) \implies f(e)f(e) = f(e) = f(e)e&apos;$。
在 $G&apos;$ 中两边左乘 $(f(e))^{-1}$，得 $f(e) = e&apos;$。&lt;/li&gt;
&lt;li&gt;$f(a)f(a^{-1}) = f(a a^{-1}) = f(e) = e&apos;$，且 $f(a^{-1})f(a) = f(a^{-1}a) = f(e) = e&apos;$。
由逆元唯一性，$f(a^{-1}) = (f(a))^{-1}$。&lt;/li&gt;
&lt;li&gt;当 $k &amp;gt; 0$ 时，对 $k$ 施加数学归纳法：$f(a^{k+1}) = f(a^k a) = f(a^k)f(a) = (f(a))^k f(a) = (f(a))^{k+1}$；当 $k = 0$ 时由第 1 条成立；当 $k &amp;lt; 0$ 时，令 $k = -m$（$m &amp;gt; 0$），$f(a^k) = f((a^m)^{-1}) = (f(a^m))^{-1} = ((f(a))^m)^{-1} = (f(a))^{-m} = (f(a))^k$。&lt;/li&gt;
&lt;li&gt;设 $\operatorname{ord}(a) = m$，即 $a^m = e$。
$(f(a))^m = f(a^m) = f(e) = e&apos;$。
由定理 1.6（阶整除引理），必有 $\operatorname{ord}(f(a)) \mid m$。&lt;/li&gt;
&lt;li&gt;若 $f$ 是同构，逆映射 $f^{-1}: G&apos; \to G$ 也是同构。
由第 4 条，$\operatorname{ord}(f(a)) \mid \operatorname{ord}(a)$，且 $\operatorname{ord}(a) = \operatorname{ord}(f^{-1}(f(a))) \mid \operatorname{ord}(f(a))$。
两个正整数互相整除，必有 $\operatorname{ord}(f(a)) = \operatorname{ord}(a)$。若 $f$ 仅为单同态，记 $d = \operatorname{ord}(f(a))$，则 $f(a^d) = (f(a))^d = e&apos;$，故 $a^d \in \operatorname{Ker}f = {e} \implies a^d = e \implies \operatorname{ord}(a) \mid d$，同理得 $\operatorname{ord}(a) = \operatorname{ord}(f(a))$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 同态像、同态核与单同态判定&lt;/h2&gt;
&lt;h3&gt;4.1 严格定义&lt;/h3&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;同态像（Image）&lt;/strong&gt;：
$$\operatorname{Im}f := f(G) = {f(x) \mid x \in G} \subseteq G&apos;$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态核（Kernel）&lt;/strong&gt;：
$$\operatorname{Ker}f := f^{-1}(e&apos;) = {x \in G \mid f(x) = e&apos;} \subseteq G$$&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;4.2 核心结构定理：同态核的正规性&lt;/h3&gt;
&lt;h4&gt;定理 4.6&lt;/h4&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态。则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$\operatorname{Im}f$ 是 $G&apos;$ 的子群（$\operatorname{Im}f \le G&apos;$）；&lt;/li&gt;
&lt;li&gt;$\operatorname{Ker}f$ 是 $G$ 的&lt;strong&gt;正规子群&lt;/strong&gt;（$\operatorname{Ker}f \triangleleft G$）。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;证明 $\operatorname{Im}f \le G&apos;$&lt;/strong&gt;：
$e&apos; = f(e) \in \operatorname{Im}f \implies \operatorname{Im}f \ne \emptyset$。
任取 $y_1, y_2 \in \operatorname{Im}f$，存在 $x_1, x_2 \in G$ 使得 $f(x_1) = y_1, f(x_2) = y_2$。
则 $y_1 y_2^{-1} = f(x_1)(f(x_2))^{-1} = f(x_1)f(x_2^{-1}) = f(x_1 x_2^{-1})$。
由于 $x_1 x_2^{-1} \in G$，故 $y_1 y_2^{-1} \in \operatorname{Im}f$。由一步判定法，$\operatorname{Im}f \le G&apos;$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;证明 $\operatorname{Ker}f \triangleleft G$&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;先证 $\operatorname{Ker}f \le G$：$f(e) = e&apos; \implies e \in \operatorname{Ker}f$。
任取 $a, b \in \operatorname{Ker}f$，即 $f(a) = e&apos;, f(b) = e&apos;$。
$f(ab^{-1}) = f(a)(f(b))^{-1} = e&apos;(e&apos;)^{-1} = e&apos; \implies ab^{-1} \in \operatorname{Ker}f$。故 $\operatorname{Ker}f \le G$。&lt;/li&gt;
&lt;li&gt;再证正规性：任取 $g \in G, k \in \operatorname{Ker}f$。
检验共轭元素 $g k g^{-1}$ 在 $f$ 下的像：
$$f(g k g^{-1}) = f(g) f(k) f(g^{-1}) = f(g) e&apos; (f(g))^{-1} = f(g)(f(g))^{-1} = e&apos;$$
根据同态核定义，映射结果为 $e&apos;$，必有：
$$g k g^{-1} \in \operatorname{Ker}f$$
因此 $\operatorname{Ker}f \triangleleft G$。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;4.3 单同态判定准则&lt;/h3&gt;
&lt;h4&gt;定理 4.7&lt;/h4&gt;
&lt;p&gt;设 $f: G \to G&apos;$ 是群同态。则：
$$f \text{ 是单同态（单射）} \iff \operatorname{Ker}f = {e}$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;必要性（$\implies$）&lt;/strong&gt;：设 $f$ 是单射。
已知 $f(e) = e&apos;$，故 $e \in \operatorname{Ker}f$。
若 $x \in \operatorname{Ker}f$，则 $f(x) = e&apos; = f(e)$。由单射定义，必有 $x = e$。
因此 $\operatorname{Ker}f = {e}$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;充分性（$\impliedby$）&lt;/strong&gt;：设 $\operatorname{Ker}f = {e}$。
任取 $x, y \in G$，设 $f(x) = f(y)$。
两边右乘 $(f(y))^{-1}$：
$$f(x)(f(y))^{-1} = e&apos; \implies f(x)f(y^{-1}) = e&apos; \implies f(x y^{-1}) = e&apos;$$
由同态核定义：
$$x y^{-1} \in \operatorname{Ker}f$$
因为已知 $\operatorname{Ker}f = {e}$，故必有 $x y^{-1} = e \implies x = y$。
这证明了 $f$ 必定是单射。 $\blacksquare$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 自然同态（Canonical Homomorphism）&lt;/h2&gt;
&lt;h3&gt;5.1 严格表述与定理&lt;/h3&gt;
&lt;h4&gt;定理 4.8&lt;/h4&gt;
&lt;p&gt;设 $N \triangleleft G$。定义映射：
$$\pi: G \to G/N, \quad \pi(a) = aN \quad (\forall a \in G)$$
则：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;$\pi$ 是满同态，称为 $G$ 到商群 $G/N$ 的&lt;strong&gt;自然同态（规范同态）&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;自然同态的核恰好等于子群 $N$，即 $\operatorname{Ker}\pi = N$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;证明：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;任取 $a, b \in G$。根据商群乘法定义：
$$\pi(ab) = (ab)N = (aN)(bN) = \pi(a)\pi(b)$$
故 $\pi$ 是群同态。
对任意陪集 $aN \in G/N$，均有 $a \in G$ 使得 $\pi(a) = aN$，故 $\pi$ 是满射。&lt;/li&gt;
&lt;li&gt;考察商群 $G/N$ 的单位元为 $N = eN$。由核的定义：
$$\operatorname{Ker}\pi = {x \in G \mid \pi(x) = N} = {x \in G \mid xN = N}$$
由定理 3.1，陪集 $xN = N \iff x \in N$。
因此 $\operatorname{Ker}\pi = N$。 $\blacksquare$&lt;/li&gt;
&lt;/ol&gt;
&lt;blockquote&gt;
&lt;p&gt;[!NOTE] 结构联系
定理 4.6 与定理 4.8 确立了如下对应：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;任何群同态的核都是正规子群；&lt;/li&gt;
&lt;li&gt;任何正规子群 $N \triangleleft G$ 都必然是某个从 $G$ 出发的群同态（即自然同态 $\pi: G \to G/N$）的核。&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 核心易错点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;商群良定性前提&lt;/strong&gt;：构造商群乘法时，必须以 $N \triangleleft G$ 为前提并严格验证良定性，不可直接默认“封闭性显然”。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态与同构的保阶差异&lt;/strong&gt;：一般同态下仅有像的阶整除原像的阶（$\operatorname{ord}(f(a)) \mid \operatorname{ord}(a)$）；只有在同构（或单同态）下阶才严格不变。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射判定化简&lt;/strong&gt;：验证群同态为单射时，无需验证 $f(x)=f(y) \implies x=y$，只需计算同态核 $\operatorname{Ker}f$，确认其只有单位元 ${e}$ 即可。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;塔式法则适用条件&lt;/strong&gt;：在子群链 $K \le H \le G$ 中，指数公式 $[G:K] = [G:H][H:K]$ 对任意子群均成立，不需要 $K$ 或 $H$ 正规。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 前后知识连接&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;前置依赖&lt;/strong&gt;：映射单射/满射等价性质（&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;）、陪集相等充要条件、正规子群判据（&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群.md&lt;/a&gt;）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;向后驱动&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;商群与同态核是建立三大同构定理（&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理.md&lt;/a&gt;）的核心载体。&lt;/li&gt;
&lt;li&gt;自然同态 $\pi$ 是诱导同态基本定理双射映射的原型。&lt;/li&gt;
&lt;li&gt;单同态核判据是后续证明 Cayley 定理单射性（&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley.md&lt;/a&gt;）的核心工具。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;易错与证明套路&lt;/strong&gt;：参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路.md&lt;/a&gt;（易错点 7 商群良定性前提、易错点 10 塔式法则、模板 3 核判单射法）。&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>抽象代数索引</title><link>https://sanzenin.top/posts/obsidian/%E7%B4%A2%E5%BC%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%B4%A2%E5%BC%95/</guid><description>本索引包含群论笔记的章节目录、依赖关系、定理速查、概念索引与符号表。 | 编号 | 笔记文件 | 主要内容 | 涉及定理 | |:---:|---|---|---| | 00 | 00-集合论与映射 | 集合、等价关系、划分、映射、选择公理、商集与良定性 | 定理 0.1 ~ 0.8 | | 01 | 01-群与子群</description><pubDate>Thu, 24 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;抽象代数索引&lt;/h1&gt;
&lt;p&gt;本索引包含群论笔记的章节目录、依赖关系、定理速查、概念索引与符号表。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 章节列表&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;编号&lt;/th&gt;
&lt;th&gt;笔记文件&lt;/th&gt;
&lt;th&gt;主要内容&lt;/th&gt;
&lt;th&gt;涉及定理&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;00&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;集合、等价关系、划分、映射、选择公理、商集与良定性&lt;/td&gt;
&lt;td&gt;定理 0.1 ~ 0.8&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;01&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/&quot;&gt;01-群与子群&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;群公理、交换群判定、元素的阶、子群判定、中心&lt;/td&gt;
&lt;td&gt;定理 1.1 ~ 1.14&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;02&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/&quot;&gt;02-循环群与生成元&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;循环群分类、生成元判定、子群结构、自同构群&lt;/td&gt;
&lt;td&gt;定理 2.1 ~ 2.10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;03&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;陪集划分、Lagrange 定理、正规子群判据、群作用&lt;/td&gt;
&lt;td&gt;定理 3.1 ~ 3.12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;04&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;商群构造、良定性、指数乘法、群同态、同态核与像&lt;/td&gt;
&lt;td&gt;定理 4.1 ~ 4.8&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;05&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;第一同构定理、第二同构定理、第三同构定理、正规性保持&lt;/td&gt;
&lt;td&gt;定理 5.1, 第二同构, 第三同构, 定理 5.2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;06&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;对称群 $S_n$、轮换分解、对换奇偶性、交代群 $A_n$、共轭型、内自同构、Cayley 定理&lt;/td&gt;
&lt;td&gt;定理 6.1 ~ 6.15&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;90&lt;/td&gt;
&lt;td&gt;&lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;概念易错点复盘、常用证明模板&lt;/td&gt;
&lt;td&gt;易错点 1~10、模板 1~6&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 章节依赖关系&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    M0[&quot;00 集合论与映射&amp;lt;br/&amp;gt;等价划分 / 映射消去律 / 商集良定性&quot;] --&amp;gt; G1[&quot;01 群与子群&amp;lt;br/&amp;gt;群公理 / 元素的阶 / 子群判定 / 中心&quot;]
    M0 --&amp;gt; G3[&quot;03 陪集-Lagrange-正规子群&amp;lt;br/&amp;gt;陪集划分 / Lagrange定理 / 正规子群&quot;]
    M0 --&amp;gt; G4[&quot;04 商群与同态&amp;lt;br/&amp;gt;商群良定性 / 同态核与像&quot;]
    G1 --&amp;gt; G2[&quot;02 循环群与生成元&amp;lt;br/&amp;gt;循环群分类 / 生成元 / 子群结构&quot;]
    G1 --&amp;gt; G3
    G1 --&amp;gt; G6[&quot;06 置换群-内自同构-Cayley&amp;lt;br/&amp;gt;对称群 / 轮换 / Cayley定理&quot;]
    G3 --&amp;gt; G4
    G4 --&amp;gt; G5[&quot;05 三大同构定理&amp;lt;br/&amp;gt;第一 / 第二 / 第三同构定理&quot;]
    G3 --&amp;gt; G6
    G5 --&amp;gt; G6
    G1 -.-&amp;gt; G90[&quot;90 易错点与证明套路&quot;]
    G3 -.-&amp;gt; G90
    G4 -.-&amp;gt; G90
    G5 -.-&amp;gt; G90
    G6 -.-&amp;gt; G90
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;主线发展脉络：
$$
\text{集合与等价划分}
\longrightarrow
\text{群与子群}
\longrightarrow
\text{陪集与正规子群}
\longrightarrow
\text{商群与同态}
\longrightarrow
\text{同构定理与变换群}.
$$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 定理速查&lt;/h2&gt;
&lt;h3&gt;00 集合论与映射&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-1-%E7%AD%89%E4%BB%B7%E7%B1%BB%E7%9B%B8%E4%BA%A4%E5%8D%B3%E5%85%A8%E5%90%8C&quot;&gt;定理 0.1（等价类相交即全同）&lt;/a&gt;：$a \sim b \iff [a] \cap [b] \neq \emptyset \iff [a] = [b]$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-2-%E7%AD%89%E4%BB%B7%E5%85%B3%E7%B3%BB%E4%B8%8E%E9%9B%86%E5%90%88%E5%88%92%E5%88%86%E7%9A%84%E5%AF%B9%E5%BA%94&quot;&gt;定理 0.2（等价划分对应定理）&lt;/a&gt;：等价关系与集合划分一一对应。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-3-%E5%8E%9F%E5%83%8F%E5%AF%B9%E9%9B%86%E5%90%88%E8%BF%90%E7%AE%97%E7%9A%84%E4%BF%9D%E6%8C%81%E6%80%A7%E8%B4%A8&quot;&gt;定理 0.3（原像保持交并补）&lt;/a&gt;：$f^{-1}$ 完全保持任意交、并、差与补。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-4-%E5%83%8F%E7%9A%84%E8%BF%90%E7%AE%97%E6%80%A7%E8%B4%A8%E4%B8%8E%E5%8D%95%E5%B0%84%E5%88%A4%E5%AE%9A&quot;&gt;定理 0.4（像保持交的充要条件）&lt;/a&gt;：$f(S_1 \cap S_2) = f(S_1) \cap f(S_2)$ 恒成立 $\iff f$ 是单射。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-5-%E5%8D%95%E5%B0%84%E7%AD%89%E4%BB%B7%E5%AE%9A%E7%90%86&quot;&gt;定理 0.5（单射等价定理）&lt;/a&gt;：单射 $\iff$ 存在左逆 $\iff$ 映射左可消。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-6-%E6%BB%A1%E5%B0%84%E7%AD%89%E4%BB%B7%E5%AE%9A%E7%90%86&quot;&gt;定理 0.6（满射等价定理）&lt;/a&gt;：满射 $\iff$ 存在右逆（需选择公理） $\iff$ 映射右可消。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-7-%E5%8F%8C%E5%B0%84%E4%B8%8E%E5%8F%AF%E9%80%86%E6%80%A7%E5%85%85%E8%A6%81%E6%9D%A1%E4%BB%B6&quot;&gt;定理 0.7（双射与可逆性充要条件）&lt;/a&gt;：双射 $\iff$ 存在唯一双边逆映射；求逆反序 $(g \circ f)^{-1} = f^{-1} \circ g^{-1}$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-8-%E5%95%86%E9%9B%86%E8%AF%B1%E5%AF%BC%E6%98%A0%E5%B0%84%E5%AE%9A%E7%90%86&quot;&gt;定理 0.8（商集诱导映射定理）&lt;/a&gt;：商集映射良定性与分解：$A \xrightarrow{\pi} A/{\sim} \xrightarrow{\bar{f}} \operatorname{Im} f \hookrightarrow B$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;01 群与子群&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-1-%E5%8D%95%E4%BD%8D%E5%85%83%E4%B8%8E%E9%80%86%E5%85%83%E7%9A%84%E5%94%AF%E4%B8%80%E6%80%A7&quot;&gt;定理 1.1（单位元与逆元唯一性）&lt;/a&gt;：群中单位元与任意元素逆元均唯一。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-2-%E7%BE%A4%E7%9A%84%E6%B6%88%E5%8E%BB%E5%BE%8B&quot;&gt;定理 1.2（群消去律）&lt;/a&gt;：$ab = ac \implies b = c$；$ba = ca \implies b = c$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-3-%E6%B1%82%E9%80%86%E8%BF%90%E7%AE%97%E6%80%A7%E8%B4%A8&quot;&gt;定理 1.3（求逆反序性质）&lt;/a&gt;：$(ab)^{-1} = b^{-1}a^{-1}$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-4-%E5%B9%B3%E6%96%B9%E4%B9%98%E7%A7%AF%E5%88%A4%E5%AE%9A%E5%87%86%E5%88%99&quot;&gt;定理 1.4（平方乘积判定准则）&lt;/a&gt;：$G$ 交换 $\iff \forall a, b \in G, (ab)^2 = a^2 b^2$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-5-%E9%AB%98%E9%98%B6%E5%B9%82%E6%AC%A1%E5%88%A4%E5%AE%9A%E5%87%86%E5%88%99&quot;&gt;定理 1.5（高阶幂次判定准则）&lt;/a&gt;：$G$ 交换 $\iff \forall t \in \mathbb{Z}^+, (ab)^t = a^t b^t$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-6-%E9%98%B6%E6%95%B4%E9%99%A4%E5%BC%95%E7%90%86&quot;&gt;定理 1.6（阶整除引理）&lt;/a&gt;：设 $\operatorname{ord}(a) = m$，则 $a^k = e \iff m \mid k$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-7-%E4%B8%A4%E6%AD%A5%E5%88%A4%E5%AE%9A%E6%B3%95&quot;&gt;定理 1.7（子群两步判定法）&lt;/a&gt;：$H \le G \iff$ 运算封闭且求逆封闭。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-8-%E4%B8%80%E6%AD%A5%E5%88%A4%E5%AE%9A%E6%B3%95&quot;&gt;定理 1.8（子群一步判定法）&lt;/a&gt;：$H \le G \iff \forall a, b \in H, ab^{-1} \in H$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-9-%E6%9C%89%E9%99%90%E5%AD%90%E9%9B%86%E7%9A%84%E5%88%A4%E5%AE%9A%E6%B3%95&quot;&gt;定理 1.9（有限子集判定法）&lt;/a&gt;：$H$ 有限非空，则 $H \le G \iff H$ 运算封闭。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-10&quot;&gt;定理 1.10（子群交集性质）&lt;/a&gt;：$\bigcap_{i \in I} H_i \le G$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-11&quot;&gt;定理 1.11（真子群并集定理）&lt;/a&gt;：若 $H_1, H_2 &amp;lt; G$，则 $G \neq H_1 \cup H_2$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-12&quot;&gt;定理 1.12（子群乘积集封闭定理）&lt;/a&gt;：$H_1 H_2 \le G \iff H_1 H_2 = H_2 H_1$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-14&quot;&gt;定理 1.14（中心子群性质）&lt;/a&gt;：群的中心 $Z(G) \le G$ 且为交换群。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;02 循环群与生成元&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-1&quot;&gt;定理 2.1（循环群交换性）&lt;/a&gt;：任何循环群都是交换群。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-2-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E5%88%86%E7%B1%BB%E5%AE%9A%E7%90%86&quot;&gt;定理 2.2（循环群分类定理）&lt;/a&gt;：无限循环群同构于 $(\mathbb{Z}, +)$；$m$ 阶有限循环群同构于 $(\mathbb{Z}_m, +)$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-3-%E5%85%83%E7%B4%A0%E9%98%B6%E5%85%AC%E5%BC%8F&quot;&gt;定理 2.3（元素阶公式）&lt;/a&gt;：设 $\operatorname{ord}(a) = m$，则 $\operatorname{ord}(a^k) = \frac{m}{\gcd(k, m)}$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-4&quot;&gt;定理 2.4（有限循环群生成元）&lt;/a&gt;：$a^k$ 是 $\langle a \rangle$ 生成元 $\iff \gcd(k, m) = 1$，共有 $\phi(m)$ 个生成元。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-5&quot;&gt;定理 2.5（无限循环群生成元）&lt;/a&gt;：无限循环群 $\langle a \rangle$ 的生成元仅有 $a$ 与 $a^{-1}$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-6&quot;&gt;定理 2.6（循环群子群性质）&lt;/a&gt;：循环群的任意子群必为循环群。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-7&quot;&gt;定理 2.7（因数子群对应定理）&lt;/a&gt;：设 $|G|=m$ 是循环群，对 $m$ 的每个正因数 $d$，$G$ 存在唯一的 $d$ 阶子群 $\langle a^{m/d} \rangle$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-8&quot;&gt;定理 2.8（循环群同态像）&lt;/a&gt;：循环群的同态像必为循环群。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-9&quot;&gt;定理 2.9（有限循环群满同态条件）&lt;/a&gt;：存在 $\mathbb{Z}_m \to \mathbb{Z}_n$ 满同态 $\iff n \mid m$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-10&quot;&gt;定理 2.10（循环群自同构群）&lt;/a&gt;：$\operatorname{Aut}(\mathbb{Z}) \cong \mathbb{Z}_2$；$\operatorname{Aut}(\mathbb{Z}_m) \cong \mathbb{Z}_m^\times$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;03 陪集-Lagrange-正规子群&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-1-%E4%BB%A3%E8%A1%A8%E5%85%83%E5%8C%85%E5%90%AB%E6%80%A7%E4%B8%8E%E5%B9%B3%E5%87%A1%E9%99%AA%E9%9B%86&quot;&gt;定理 3.1（代表元包含性）&lt;/a&gt;：$a \in aH$；$aH = H \iff a \in H$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-2-%E9%99%AA%E9%9B%86%E7%9B%B8%E7%AD%89%E7%9A%84%E5%85%85%E8%A6%81%E5%88%A4%E5%AE%9A%E5%87%86%E5%88%99&quot;&gt;定理 3.2（陪集相等判定）&lt;/a&gt;：$aH = bH \iff a^{-1}b \in H \iff b \in aH$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-3-%E6%A8%A1-h-%E5%90%8C%E4%BD%99%E4%B8%8E%E7%AD%89%E4%BB%B7%E5%88%92%E5%88%86&quot;&gt;定理 3.3（模 $H$ 同余与划分）&lt;/a&gt;：左陪集族形成群 $G$ 的一个划分。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-4&quot;&gt;定理 3.4（陪集大小等势性）&lt;/a&gt;：对任意 $a \in G$，$|aH| = |H| = |Ha|$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-5-lagrange-%E5%AE%9A%E7%90%86&quot;&gt;定理 3.5（Lagrange 定理）&lt;/a&gt;：若 $G$ 有限，$H \le G$，则 $|G| = [G : H] \cdot |H|$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E6%8E%A8%E8%AE%BA-3-6-%E5%85%83%E7%B4%A0%E7%9A%84%E9%98%B6%E6%95%B4%E9%99%A4%E7%BE%A4%E9%98%B6&quot;&gt;推论 3.6（元素阶整除群阶）&lt;/a&gt;：$\forall a \in G, \operatorname{ord}(a) \mid |G|$，且 $a^{|G|} = e$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E6%8E%A8%E8%AE%BA-3-7-%E7%B4%A0%E6%95%B0%E9%98%B6%E7%BE%A4%E5%BF%85%E4%B8%BA%E5%BE%AA%E7%8E%AF%E7%BE%A4&quot;&gt;推论 3.7（素数阶群性质）&lt;/a&gt;：素数阶群必为循环群。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-8&quot;&gt;定理 3.8（Lagrange 逆命题反例）&lt;/a&gt;：12 阶交错群 $A_4$ 没有 6 阶子群。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-9&quot;&gt;定理 3.9（正规子群判定条件）&lt;/a&gt;：$N \triangleleft G \iff \forall g \in G, gNg^{-1} = N \iff \forall g \in G, gN = Ng$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-10&quot;&gt;定理 3.10（指数为 2 的子群性质）&lt;/a&gt;：若 $[G : H] = 2$，则 $H \triangleleft G$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%BC%95%E7%90%86-3-11&quot;&gt;引理 3.11（稳定子子群性质）&lt;/a&gt;：群作用下 $\operatorname{Stab}(x) \le G$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#5-2-%E8%BD%A8%E9%81%93-%E7%A8%B3%E5%AE%9A%E5%AD%90%E5%AE%9A%E7%90%86-orbit-stabilizer-theorem&quot;&gt;定理 3.12（轨道-稳定子定理）&lt;/a&gt;：$|G \cdot x| = [G : \operatorname{Stab}(x)]$。若 $G$ 有限，则 $|G| = |G \cdot x| \cdot |\operatorname{Stab}(x)|$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;04 商群与同态&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-1-%E8%89%AF%E5%AE%9A%E6%80%A7%E5%85%85%E8%A6%81%E5%AE%9A%E7%90%86&quot;&gt;定理 4.1（商群乘法良定性）&lt;/a&gt;：$(aN)(bN) = (ab)N$ 良定 $\iff N \triangleleft G$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-2&quot;&gt;定理 4.2（商群成群性质）&lt;/a&gt;：若 $N \triangleleft G$，则 $(G/N, \cdot)$ 构成群。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-3&quot;&gt;定理 4.3（商群的阶）&lt;/a&gt;：$|G/N| = [G : N] = \frac{|G|}{|N|}$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-4-%E5%AD%90%E7%BE%A4%E9%93%BE%E6%8C%87%E6%95%B0%E5%85%AC%E5%BC%8F&quot;&gt;定理 4.4（子群链指数公式）&lt;/a&gt;：若 $K \le H \le G$，则 $[G : K] = [G : H][H : K]$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-5&quot;&gt;定理 4.5（群同态基本性质）&lt;/a&gt;：$f(e) = e&apos;$，$f(a^{-1}) = f(a)^{-1}$，$\operatorname{ord}(f(a)) \mid \operatorname{ord}(a)$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-6&quot;&gt;定理 4.6（同态核与像）&lt;/a&gt;：$\operatorname{Ker}f \triangleleft G$，$\operatorname{Im}f \le G&apos;$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-7&quot;&gt;定理 4.7（单同态判定准则）&lt;/a&gt;：同态 $f$ 是单同态 $\iff \operatorname{Ker}f = {e}$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-8&quot;&gt;定理 4.8（自然同态性质）&lt;/a&gt;：$\pi: G \to G/N, g \mapsto gN$ 是满同态，且 $\operatorname{Ker}\pi = N$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;05 三大同构定理&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#1-%E7%BE%A4%E5%90%8C%E6%80%81%E5%9F%BA%E6%9C%AC%E5%AE%9A%E7%90%86-%E7%AC%AC%E4%B8%80%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86&quot;&gt;定理 5.1（第一同构定理）&lt;/a&gt;：设 $f: G \to G&apos;$ 是群同态，则 $G/\operatorname{Ker}f \cong \operatorname{Im}f$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#2-%E7%AC%AC%E4%BA%8C%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86-%E8%8F%B1%E5%BD%A2%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86-diamond-isomorphism-theorem&quot;&gt;第二同构定理（菱形同构）&lt;/a&gt;：设 $H \le G, N \triangleleft G$，则 $HN/N \cong H/(H \cap N)$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#3-%E7%AC%AC%E4%B8%89%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86-%E5%95%86%E7%BE%A4%E7%BA%A6%E5%88%86%E5%AE%9A%E7%90%86&quot;&gt;第三同构定理（商群约分）&lt;/a&gt;：设 $K \triangleleft G, N \triangleleft G$ 且 $K \le N$，则 $(G/K)/(N/K) \cong G/N$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#%E5%AE%9A%E7%90%86-5-2&quot;&gt;定理 5.2（正规性保持定理）&lt;/a&gt;：若 $f: G \to G&apos;$ 是满同态，$N \triangleleft G$，则 $f(N) \triangleleft G&apos;$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;06 置换群-内自同构-Cayley&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-1&quot;&gt;定理 6.1（一一变换群）&lt;/a&gt;：集合 $A$ 上全体一一变换在复合下成群。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-2&quot;&gt;定理 6.2（不相交轮换交换性）&lt;/a&gt;：不相交循环置换乘积可交换。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-3-%E4%B8%8D%E7%9B%B8%E4%BA%A4%E8%BD%AE%E6%8D%A2%E5%88%86%E8%A7%A3%E5%AE%9A%E7%90%86&quot;&gt;定理 6.3（不相交轮换分解）&lt;/a&gt;：有限置换可唯一分解为不相交轮换之积。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-4-%E7%BD%AE%E6%8D%A2%E6%B1%82%E9%98%B6%E5%85%AC%E5%BC%8F&quot;&gt;定理 6.4（置换求阶公式）&lt;/a&gt;：置换的阶等于各不相交轮换长度的最小公倍数。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-5&quot;&gt;定理 6.5（对换分解定理）&lt;/a&gt;：任一置换均可分解为对换之积；$r$-轮换可分解为 $r-1$ 个对换。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-6-%E5%AF%B9%E6%8D%A2%E5%A5%87%E5%81%B6%E6%80%A7%E4%B8%8D%E5%8F%98%E9%87%8F%E5%AE%9A%E7%90%86&quot;&gt;定理 6.6（对换奇偶性不变量）&lt;/a&gt;：同一置换分解为对换之积时，对换个数的奇偶性不变。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-8-%E4%BA%A4%E4%BB%A3%E7%BE%A4%E7%9A%84%E5%AD%90%E7%BE%A4%E6%80%A7%E8%B4%A8%E4%B8%8E%E9%98%B6%E6%95%B0&quot;&gt;定理 6.8（交代群性质与阶数）&lt;/a&gt;：$A_n \triangleleft S_n$，且 $|A_n| = \frac{n!}{2}$（$n \ge 2$）。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-9&quot;&gt;定理 6.9（3-轮换生成交代群）&lt;/a&gt;：对任意 $n \ge 3$，$A_n$ 由全体 3-轮换生成。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-10-%E7%BD%AE%E6%8D%A2%E5%85%B1%E8%BD%AD%E5%85%AC%E5%BC%8F&quot;&gt;定理 6.10（置换共轭公式）&lt;/a&gt;：$\tau (i_1\ i_2\ \dots\ i_r) \tau^{-1} = (\tau(i_1)\ \tau(i_2)\ \dots\ \tau(i_r))$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-11-%E5%85%B1%E8%BD%AD%E7%B1%BB%E4%B8%8E%E5%BE%AA%E7%8E%AF%E5%9E%8B%E5%85%85%E8%A6%81%E6%9D%A1%E4%BB%B6&quot;&gt;定理 6.11（共轭类与循环型）&lt;/a&gt;：$S_n$ 中两置换共轭 $\iff$ 具有相同的循环型。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E7%BB%93%E8%AE%BA-6-12&quot;&gt;结论 6.12（$A_5$ 单群性质）&lt;/a&gt;：$A_5$ 是最小的非交换单群。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-13&quot;&gt;定理 6.13（内自同构群性质）&lt;/a&gt;：共轭映射是群自同构，$\operatorname{Inn}(G) \le \operatorname{Aut}(G)$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-14&quot;&gt;定理 6.14（内自同构与中心）&lt;/a&gt;：$G/Z(G) \cong \operatorname{Inn}(G)$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-15-cayley-%E5%AE%9A%E7%90%86&quot;&gt;定理 6.15（Cayley 定理）&lt;/a&gt;：任何群均同构于某个集合上的置换群；$n$ 阶群可嵌入 $S_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 概念索引&lt;/h2&gt;
&lt;h3&gt;集合与映射&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;等价关系&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#2-2-%E7%AD%89%E4%BB%B7%E5%85%B3%E7%B3%BB%E4%B8%8E%E7%AD%89%E4%BB%B7%E7%B1%BB&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-2-%E7%AD%89%E4%BB%B7%E5%85%B3%E7%B3%BB%E4%B8%8E%E9%9B%86%E5%90%88%E5%88%92%E5%88%86%E7%9A%84%E5%AF%B9%E5%BA%94&quot;&gt;划分对应定理 0.2&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;等价类&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#2-2-%E7%AD%89%E4%BB%B7%E5%85%B3%E7%B3%BB%E4%B8%8E%E7%AD%89%E4%BB%B7%E7%B1%BB&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-1-%E7%AD%89%E4%BB%B7%E7%B1%BB%E7%9B%B8%E4%BA%A4%E5%8D%B3%E5%85%A8%E5%90%8C&quot;&gt;相交即全同定理 0.1&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;商集&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#2-2-%E7%AD%89%E4%BB%B7%E5%85%B3%E7%B3%BB%E4%B8%8E%E7%AD%89%E4%BB%B7%E7%B1%BB&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-8-%E5%95%86%E9%9B%86%E8%AF%B1%E5%AF%BC%E6%98%A0%E5%B0%84%E5%AE%9A%E7%90%86&quot;&gt;诱导映射定理 0.8&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;单射 / 满射 / 双射&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#4-1-%E5%9F%BA%E6%9C%AC%E5%AE%9A%E4%B9%89%E4%B8%8E%E6%9C%89%E9%99%90%E9%9B%86%E5%90%88%E6%80%A7%E8%B4%A8&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-5-%E5%8D%95%E5%B0%84%E7%AD%89%E4%BB%B7%E5%AE%9A%E7%90%86&quot;&gt;单射判定定理 0.5&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-6-%E6%BB%A1%E5%B0%84%E7%AD%89%E4%BB%B7%E5%AE%9A%E7%90%86&quot;&gt;满射判定定理 0.6&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-7-%E5%8F%8C%E5%B0%84%E4%B8%8E%E5%8F%AF%E9%80%86%E6%80%A7%E5%85%85%E8%A6%81%E6%9D%A1%E4%BB%B6&quot;&gt;可逆性定理 0.7&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;像与原像&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#3-1-%E6%98%A0%E5%B0%84%E5%AE%9A%E4%B9%89%E4%B8%8E%E5%9F%BA%E6%9C%AC%E6%A6%82%E5%BF%B5&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-3-%E5%8E%9F%E5%83%8F%E5%AF%B9%E9%9B%86%E5%90%88%E8%BF%90%E7%AE%97%E7%9A%84%E4%BF%9D%E6%8C%81%E6%80%A7%E8%B4%A8&quot;&gt;原像保持性质定理 0.3&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#%E5%AE%9A%E7%90%86-0-4-%E5%83%8F%E7%9A%84%E8%BF%90%E7%AE%97%E6%80%A7%E8%B4%A8%E4%B8%8E%E5%8D%95%E5%B0%84%E5%88%A4%E5%AE%9A&quot;&gt;像与单射定理 0.4&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;选择公理&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#5-1-%E9%80%89%E6%8B%A9%E5%85%AC%E7%90%86%E7%9A%84%E4%B8%89%E7%A7%8D%E7%AD%89%E4%BB%B7%E8%A1%A8%E8%BF%B0&quot;&gt;表述&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#5-3-%E5%B8%B8%E8%A7%81%E7%AD%89%E4%BB%B7%E5%91%BD%E9%A2%98%E4%B8%8E-zorn-%E5%BC%95%E7%90%86&quot;&gt;等价命题与 Zorn 引理&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;良定性&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/#6-1-%E8%89%AF%E5%AE%9A%E6%80%A7%E8%A6%81%E6%B1%82&quot;&gt;商集映射定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#1-3-%E5%95%86%E7%BE%A4%E4%B9%98%E6%B3%95%E7%9A%84%E8%89%AF%E5%AE%9A%E6%80%A7-well-definedness-%E8%AF%81%E6%98%8E&quot;&gt;商群乘法良定性定理 4.1&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;群、子群与阶&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;群公理&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#1-%E7%BE%A4%E7%9A%84%E5%85%AC%E7%90%86%E4%B8%8E%E5%88%9D%E7%AD%89%E6%80%A7%E8%B4%A8&quot;&gt;四条公理&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-1-%E5%8D%95%E4%BD%8D%E5%85%83%E4%B8%8E%E9%80%86%E5%85%83%E7%9A%84%E5%94%AF%E4%B8%80%E6%80%A7&quot;&gt;消去律与逆元唯一&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;交换群（阿贝尔群）&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#1-%E7%BE%A4%E7%9A%84%E5%85%AC%E7%90%86%E4%B8%8E%E5%88%9D%E7%AD%89%E6%80%A7%E8%B4%A8&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-4-%E5%B9%B3%E6%96%B9%E4%B9%98%E7%A7%AF%E5%88%A4%E5%AE%9A%E5%87%86%E5%88%99&quot;&gt;平方乘积判定&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-5-%E9%AB%98%E9%98%B6%E5%B9%82%E6%AC%A1%E5%88%A4%E5%AE%9A%E5%87%86%E5%88%99&quot;&gt;高阶幂次判定&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;元素的阶&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#3-%E5%85%83%E7%B4%A0%E7%9A%84%E9%98%B6-order&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-6-%E9%98%B6%E6%95%B4%E9%99%A4%E5%BC%95%E7%90%86&quot;&gt;阶整除引理&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-3-%E5%85%83%E7%B4%A0%E9%98%B6%E5%85%AC%E5%BC%8F&quot;&gt;幂元素求阶公式&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子群判定&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#4-%E5%AD%90%E7%BE%A4-subgroup-%E5%8F%8A%E5%85%B6%E5%88%A4%E5%AE%9A&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-7-%E4%B8%A4%E6%AD%A5%E5%88%A4%E5%AE%9A%E6%B3%95&quot;&gt;两步判定&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-8-%E4%B8%80%E6%AD%A5%E5%88%A4%E5%AE%9A%E6%B3%95&quot;&gt;一步判定&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-9-%E6%9C%89%E9%99%90%E5%AD%90%E9%9B%86%E7%9A%84%E5%88%A4%E5%AE%9A%E6%B3%95&quot;&gt;有限子群判定&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;群中心&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#5-4-%E7%BE%A4%E7%9A%84%E4%B8%AD%E5%BF%83-center&quot;&gt;定义与性质&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-14&quot;&gt;中心商群同构&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子群运算&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-10&quot;&gt;交集仍为子群&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-11&quot;&gt;真子群并集不全覆&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-1-12&quot;&gt;乘积集成群充要条件&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;循环群&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;循环群与生成元&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#1-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E7%9A%84%E5%AE%9A%E4%B9%89%E4%B8%8E%E8%A1%A8%E7%A4%BA&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-2-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E5%88%86%E7%B1%BB%E5%AE%9A%E7%90%86&quot;&gt;分类定理&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-4&quot;&gt;生成元个数&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;循环群子群&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-6&quot;&gt;子群必为循环群&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-7&quot;&gt;因数子群唯一性&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;循环群自同构&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/#%E5%AE%9A%E7%90%86-2-10&quot;&gt;自同构群结构&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;陪集与正规子群&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;陪集&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#1-%E9%99%AA%E9%9B%86%E7%9A%84%E4%B8%A5%E6%A0%BC%E5%AE%9A%E4%B9%89%E4%B8%8E%E6%80%A7%E8%B4%A8&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-2-%E9%99%AA%E9%9B%86%E7%9B%B8%E7%AD%89%E7%9A%84%E5%85%85%E8%A6%81%E5%88%A4%E5%AE%9A%E5%87%86%E5%88%99&quot;&gt;相等判定&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-4&quot;&gt;等势性&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Lagrange 定理&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-5-lagrange-%E5%AE%9A%E7%90%86&quot;&gt;定理证明&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E6%8E%A8%E8%AE%BA-3-6-%E5%85%83%E7%B4%A0%E7%9A%84%E9%98%B6%E6%95%B4%E9%99%A4%E7%BE%A4%E9%98%B6&quot;&gt;阶整除群阶&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E6%8E%A8%E8%AE%BA-3-7-%E7%B4%A0%E6%95%B0%E9%98%B6%E7%BE%A4%E5%BF%85%E4%B8%BA%E5%BE%AA%E7%8E%AF%E7%BE%A4&quot;&gt;素数阶群&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-8&quot;&gt;逆命题反例&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;正规子群&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#4-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4-normal-subgroup&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-9&quot;&gt;判定条件&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#%E5%AE%9A%E7%90%86-3-10&quot;&gt;指数 2 必正规&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;群作用&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#5-%E7%BE%A4%E7%9A%84%E4%BD%9C%E7%94%A8%E4%B8%8E%E8%BD%A8%E9%81%93-%E7%A8%B3%E5%AE%9A%E5%AD%90%E5%AE%9A%E7%90%86&quot;&gt;定义与稳定子&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/#5-2-%E8%BD%A8%E9%81%93-%E7%A8%B3%E5%AE%9A%E5%AD%90%E5%AE%9A%E7%90%86-orbit-stabilizer-theorem&quot;&gt;轨道-稳定子定理&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;商群与同态&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;商群&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#1-%E5%95%86%E7%BE%A4%E7%9A%84%E6%9E%84%E9%80%A0%E4%B8%8E%E8%89%AF%E5%AE%9A%E6%80%A7&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-1-%E8%89%AF%E5%AE%9A%E6%80%A7%E5%85%85%E8%A6%81%E5%AE%9A%E7%90%86&quot;&gt;乘法良定性&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-3&quot;&gt;商群的阶&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;塔式法则&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-4-%E5%AD%90%E7%BE%A4%E9%93%BE%E6%8C%87%E6%95%B0%E5%85%AC%E5%BC%8F&quot;&gt;子群链指数公式&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;群同态与同构&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#3-%E7%BE%A4%E5%90%8C%E6%80%81%E4%B8%8E%E7%BE%A4%E5%90%8C%E6%9E%84&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-5&quot;&gt;保持性质&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;同态核与像&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#4-%E5%90%8C%E6%80%81%E5%83%8F-%E5%90%8C%E6%80%81%E6%A0%B8%E4%B8%8E%E5%8D%95%E5%90%8C%E6%80%81%E5%88%A4%E5%AE%9A&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-6&quot;&gt;核正规性&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-7&quot;&gt;单同态核判据&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/#%E5%AE%9A%E7%90%86-4-8&quot;&gt;自然同态&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;同构定理&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;第一同构定理&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#1-%E7%BE%A4%E5%90%8C%E6%80%81%E5%9F%BA%E6%9C%AC%E5%AE%9A%E7%90%86-%E7%AC%AC%E4%B8%80%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86&quot;&gt;定理与证明&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#1-4-%E4%BA%94%E5%A4%A7%E7%BB%8F%E5%85%B8%E5%BA%94%E7%94%A8%E5%AE%9E%E4%BE%8B&quot;&gt;应用实例&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第二同构定理&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#2-%E7%AC%AC%E4%BA%8C%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86-%E8%8F%B1%E5%BD%A2%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86-diamond-isomorphism-theorem&quot;&gt;定理与证明&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第三同构定理&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#3-%E7%AC%AC%E4%B8%89%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86-%E5%95%86%E7%BE%A4%E7%BA%A6%E5%88%86%E5%AE%9A%E7%90%86&quot;&gt;定理与证明&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;正规性保持&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/#%E5%AE%9A%E7%90%86-5-2&quot;&gt;满同态保持正规性&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;置换群与 Cayley 定理&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;对称群 $S_n$&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#1-%E5%AF%B9%E7%A7%B0%E7%BE%A4-s-n-%E4%B8%8E%E4%B8%80%E4%B8%80%E5%8F%98%E6%8D%A2%E7%BE%A4&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#1-2-%E8%BF%90%E7%AE%97%E6%96%B9%E5%90%91%E7%BA%A6%E5%AE%9A&quot;&gt;运算方向&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;不相交轮换&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#2-1-%E5%BE%AA%E7%8E%AF%E7%BD%AE%E6%8D%A2%E7%9A%84%E5%AE%9A%E4%B9%89&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-2&quot;&gt;交换性&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-3-%E4%B8%8D%E7%9B%B8%E4%BA%A4%E8%BD%AE%E6%8D%A2%E5%88%86%E8%A7%A3%E5%AE%9A%E7%90%86&quot;&gt;分解定理&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-4-%E7%BD%AE%E6%8D%A2%E6%B1%82%E9%98%B6%E5%85%AC%E5%BC%8F&quot;&gt;求阶&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;对换与奇偶置换&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-5&quot;&gt;对换分解&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-6-%E5%AF%B9%E6%8D%A2%E5%A5%87%E5%81%B6%E6%80%A7%E4%B8%8D%E5%8F%98%E9%87%8F%E5%AE%9A%E7%90%86&quot;&gt;奇偶性不变量&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;交代群 $A_n$&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#3-3-%E5%A5%87%E5%81%B6%E7%BD%AE%E6%8D%A2%E4%B8%8E%E4%BA%A4%E4%BB%A3%E7%BE%A4-a-n&quot;&gt;定义与阶数&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-9&quot;&gt;3-轮换生成&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;共轭与循环型&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-10-%E7%BD%AE%E6%8D%A2%E5%85%B1%E8%BD%AD%E5%85%AC%E5%BC%8F&quot;&gt;共轭计算&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-11-%E5%85%B1%E8%BD%AD%E7%B1%BB%E4%B8%8E%E5%BE%AA%E7%8E%AF%E5%9E%8B%E5%85%85%E8%A6%81%E6%9D%A1%E4%BB%B6&quot;&gt;循环型充要条件&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;内自同构&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-13&quot;&gt;定义&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-14&quot;&gt;商群同构&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Cayley 定理&lt;/strong&gt;：&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#%E5%AE%9A%E7%90%86-6-15-cayley-%E5%AE%9A%E7%90%86&quot;&gt;定理与证明&lt;/a&gt;、&lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/#8-3-%E5%B7%A6%E4%B9%98%E4%B8%8E%E5%8F%B3%E4%B9%98%E7%9A%84%E5%8C%BA%E5%88%AB&quot;&gt;左乘右乘区别&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 符号表&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;符号&lt;/th&gt;
&lt;th&gt;含义&lt;/th&gt;
&lt;th&gt;说明&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;$a \in A, A \subseteq B$&lt;/td&gt;
&lt;td&gt;属于、包含&lt;/td&gt;
&lt;td&gt;集合基础记号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$A \setminus B, A^c$&lt;/td&gt;
&lt;td&gt;差集、补集&lt;/td&gt;
&lt;td&gt;$A^c = U \setminus A$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$A \times B$&lt;/td&gt;
&lt;td&gt;笛卡尔积&lt;/td&gt;
&lt;td&gt;有序对集合&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$[a]$&lt;/td&gt;
&lt;td&gt;等价类&lt;/td&gt;
&lt;td&gt;${x \mid x \sim a}$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$A/\sim$&lt;/td&gt;
&lt;td&gt;商集&lt;/td&gt;
&lt;td&gt;所有等价类构成的集合&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$f^{-1}(T)$&lt;/td&gt;
&lt;td&gt;原像&lt;/td&gt;
&lt;td&gt;${x \mid f(x) \in T}$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\operatorname{ord}(a)$&lt;/td&gt;
&lt;td&gt;元素的阶&lt;/td&gt;
&lt;td&gt;满足 $a^m = e$ 的最小正整数 $m$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$&lt;/td&gt;
&lt;td&gt;G&lt;/td&gt;
&lt;td&gt;$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$H \le G, H &amp;lt; G$&lt;/td&gt;
&lt;td&gt;子群、真子群&lt;/td&gt;
&lt;td&gt;$H$ 在原运算下成群&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$Z(G)$&lt;/td&gt;
&lt;td&gt;群中心&lt;/td&gt;
&lt;td&gt;与全群元素均交换的元素集&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\langle a \rangle, \langle S \rangle$&lt;/td&gt;
&lt;td&gt;生成子群&lt;/td&gt;
&lt;td&gt;包含指定元素的最小子群&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$aH, Ha$&lt;/td&gt;
&lt;td&gt;左陪集、右陪集&lt;/td&gt;
&lt;td&gt;${ah \mid h \in H}$ 与 ${ha \mid h \in H}$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$[G : H]$&lt;/td&gt;
&lt;td&gt;子群指数&lt;/td&gt;
&lt;td&gt;左陪集的个数&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$N \triangleleft G$&lt;/td&gt;
&lt;td&gt;正规子群&lt;/td&gt;
&lt;td&gt;$\forall g \in G, gNg^{-1} = N$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$G/N$&lt;/td&gt;
&lt;td&gt;商群&lt;/td&gt;
&lt;td&gt;陪集构成的群&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\operatorname{Ker}f, \operatorname{Im}f$&lt;/td&gt;
&lt;td&gt;同态核、同态像&lt;/td&gt;
&lt;td&gt;$\operatorname{Ker}f = f^{-1}({e&apos;})$，$\operatorname{Im}f = f(G)$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$G \cong G&apos;$&lt;/td&gt;
&lt;td&gt;群同构&lt;/td&gt;
&lt;td&gt;存在保持运算的双射&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$S_n, A_n$&lt;/td&gt;
&lt;td&gt;对称群、交代群&lt;/td&gt;
&lt;td&gt;$n$ 元置换群与偶置换群&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$(i_1\ i_2\ \dots\ i_r)$&lt;/td&gt;
&lt;td&gt;轮换（循环置换）&lt;/td&gt;
&lt;td&gt;长度为 $r$ 的置换&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\operatorname{Aut}(G), \operatorname{Inn}(G)$&lt;/td&gt;
&lt;td&gt;自同构群、内自同构群&lt;/td&gt;
&lt;td&gt;$G$ 到自身的同构映射构成的群&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$G \cdot x, \operatorname{Stab}(x)$&lt;/td&gt;
&lt;td&gt;轨道、稳定子&lt;/td&gt;
&lt;td&gt;群作用中的轨迹与保持元&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 证明模板速查&lt;/h2&gt;
&lt;p&gt;参见 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路&lt;/a&gt; 中的推导步骤：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/#%E6%A8%A1%E6%9D%BF-1-%E5%AD%90%E7%BE%A4%E4%B8%80%E6%AD%A5%E5%88%A4%E5%AE%9A%E6%B3%95&quot;&gt;子群一步判定法&lt;/a&gt;：验证非空，对任取元素算 $ab^{-1}$ 并在子集中。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/#%E6%A8%A1%E6%9D%BF-2-%E7%AC%AC%E4%B8%80%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86%E6%9E%84%E5%BB%BA%E5%95%86%E7%BE%A4%E5%90%8C%E6%9E%84&quot;&gt;第一同构定理构建商群同构&lt;/a&gt;：构造满同态并求核。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/#%E6%A8%A1%E6%9D%BF-3-%E5%8D%95%E5%90%8C%E6%80%81%E5%88%A4%E5%AE%9A-%E9%80%9A%E8%BF%87%E5%90%8C%E6%80%81%E6%A0%B8&quot;&gt;单同态核判据&lt;/a&gt;：假设 $x \in \operatorname{Ker}f$ 推出 $x = e$。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/#%E6%A8%A1%E6%9D%BF-4-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E5%AD%90%E7%BE%A4%E8%AF%81%E6%98%8E-%E6%9C%80%E5%B0%8F%E6%AD%A5%E9%95%BF%E4%B8%8E%E5%B8%A6%E4%BD%99%E9%99%A4%E6%B3%95&quot;&gt;循环群子群证明&lt;/a&gt;：良序公理取正指数最小元，带余除法证余数为 0。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/#%E6%A8%A1%E6%9D%BF-5-%E6%8C%87%E6%95%B0%E4%B8%BA-2-%E7%9A%84%E5%AD%90%E7%BE%A4%E5%BF%85%E6%AD%A3%E8%A7%84&quot;&gt;指数为 2 子群必正规&lt;/a&gt;：两块划分互补直接导出左右陪集相等。&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/#%E6%A8%A1%E6%9D%BF-6-%E6%9C%89%E9%99%90%E5%AD%90%E7%BE%A4%E5%B0%81%E9%97%AD%E6%80%A7%E5%88%A4%E5%AE%9A-%E6%8A%BD%E5%B1%89%E5%8E%9F%E7%90%86%E6%9E%84%E9%80%A0%E9%80%86%E5%85%83&quot;&gt;有限子群抽屉原理逆元构造&lt;/a&gt;：有限幂次必重合推导逆元存在。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 阅读建议&lt;/h2&gt;
&lt;p&gt;按章节顺序阅读：
&lt;a href=&quot;/posts/obsidian/00-%E9%9B%86%E5%90%88%E8%AE%BA%E4%B8%8E%E6%98%A0%E5%B0%84/&quot;&gt;00-集合论与映射&lt;/a&gt; → &lt;a href=&quot;/posts/obsidian/01-%E7%BE%A4%E4%B8%8E%E5%AD%90%E7%BE%A4/&quot;&gt;01-群与子群&lt;/a&gt; → &lt;a href=&quot;/posts/obsidian/02-%E5%BE%AA%E7%8E%AF%E7%BE%A4%E4%B8%8E%E7%94%9F%E6%88%90%E5%85%83/&quot;&gt;02-循环群与生成元&lt;/a&gt; → &lt;a href=&quot;/posts/obsidian/03-%E9%99%AA%E9%9B%86-lagrange-%E6%AD%A3%E8%A7%84%E5%AD%90%E7%BE%A4/&quot;&gt;03-陪集-Lagrange-正规子群&lt;/a&gt; → &lt;a href=&quot;/posts/obsidian/04-%E5%95%86%E7%BE%A4%E4%B8%8E%E5%90%8C%E6%80%81/&quot;&gt;04-商群与同态&lt;/a&gt; → &lt;a href=&quot;/posts/obsidian/05-%E4%B8%89%E5%A4%A7%E5%90%8C%E6%9E%84%E5%AE%9A%E7%90%86/&quot;&gt;05-三大同构定理&lt;/a&gt; → &lt;a href=&quot;/posts/obsidian/06-%E7%BD%AE%E6%8D%A2%E7%BE%A4-%E5%86%85%E8%87%AA%E5%90%8C%E6%9E%84-cayley/&quot;&gt;06-置换群-内自同构-Cayley&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;复习与做题时结合 &lt;a href=&quot;/posts/obsidian/90-%E6%98%93%E9%94%99%E7%82%B9%E4%B8%8E%E8%AF%81%E6%98%8E%E5%A5%97%E8%B7%AF/&quot;&gt;90-易错点与证明套路&lt;/a&gt; 查阅易错点与模板。&lt;/p&gt;
</content:encoded></item><item><title>现代 CMake 实用笔记（面向 C++ 与 AI Infra）</title><link>https://sanzenin.top/posts/obsidian/%E7%8E%B0%E4%BB%A3-cmake-%E5%AE%9E%E7%94%A8%E7%AC%94%E8%AE%B0/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%8E%B0%E4%BB%A3-cmake-%E5%AE%9E%E7%94%A8%E7%AC%94%E8%AE%B0/</guid><description>这份笔记总结自小彭老师的课程及实际工程经验，删掉了冷门复杂的语法，只保留做 C++ 开发和 AI Infra（算子、推理引擎、CUDA 开发）必须掌握的核心内容。 很多人初学时容易把 CMake 和编译器搞混： - g++ / clang++ / nvcc 才是真正的编译器，负责把代码编译成汇编和机器码。 - CMak</description><pubDate>Wed, 16 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;现代 CMake 实用笔记（面向 C++ 与 AI Infra）&lt;/h1&gt;
&lt;p&gt;这份笔记总结自小彭老师的课程及实际工程经验，删掉了冷门复杂的语法，只保留做 C++ 开发和 AI Infra（算子、推理引擎、CUDA 开发）必须掌握的核心内容。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;0. 搞懂 CMake 的角色：它到底在干什么？&lt;/h2&gt;
&lt;p&gt;很多人初学时容易把 CMake 和编译器搞混：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;g++ / clang++ / nvcc&lt;/strong&gt; 才是真正的编译器，负责把代码编译成汇编和机器码。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;CMake 本身不编译任何代码&lt;/strong&gt;。它是一个“生成配置的工具”。你写一份跨平台的 &lt;code&gt;CMakeLists.txt&lt;/code&gt;，在 Linux 上它帮你生成 Makefile 或 &lt;code&gt;build.ninja&lt;/code&gt;，在 Windows 上它生成 VS 工程，然后再调用底层的 &lt;code&gt;make&lt;/code&gt;、&lt;code&gt;ninja&lt;/code&gt; 或 &lt;code&gt;cl.exe&lt;/code&gt; 去真正编译。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;从 CMake 3.x 开始，官方推崇所谓的 &lt;strong&gt;“现代 CMake”（Modern CMake）&lt;/strong&gt;。核心区别只有一句话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;别再用全局变量了，一切围绕目标（Target）来配置。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;每个可执行文件（exe）或库（lib）就是一个 Target。头文件路径、宏定义、编译选项都是绑定在具体 Target 上的属性，通过 &lt;code&gt;PUBLIC&lt;/code&gt; / &lt;code&gt;PRIVATE&lt;/code&gt; 控制要不要传给别人。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 标准构建命令：别再手动 mkdir build 了&lt;/h2&gt;
&lt;p&gt;老教程经常教这种写法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mkdir build &amp;amp;&amp;amp; cd build
cmake ..
make -j
cd ..
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这种写法既繁琐，又容易污染目录。&lt;strong&gt;现代 CMake 推荐统一使用 &lt;code&gt;-B&lt;/code&gt; 和 &lt;code&gt;--build&lt;/code&gt;：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 1. 配置阶段：自动创建 build 目录并生成构建文件
cmake -B build -DCMAKE_BUILD_TYPE=Release

# 2. 编译阶段：跨平台通用，自动调用底层 make 或 ninja，自动多核编译
cmake --build build -j$(nproc)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;无论在 Linux、macOS 还是 Windows 下，这两条命令完全一致。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 最基础的项目怎么写？&lt;/h2&gt;
&lt;p&gt;新建一个项目，根目录下放一个 &lt;code&gt;CMakeLists.txt&lt;/code&gt;，最小可用骨架如下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 声明最低版本要求（建议 &amp;gt;= 3.18，对 CUDA 和新特性的支持比较完善）
cmake_minimum_required(VERSION 3.18)

# 声明项目名字和用到的语言（纯 C++ 项目指明 CXX）
project(my_project LANGUAGES CXX)

# 设置 C++ 标准
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)  # 必须加上，防止编译器默默降级到旧标准
set(CMAKE_CXX_EXTENSIONS OFF)        # 关掉 GCC 专有的 gnu++17 扩展，保证代码跨平台

# 生成可执行文件
add_executable(my_app main.cpp other.cpp)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 源文件怎么组织？&lt;/h2&gt;
&lt;h3&gt;推荐：直接列出文件名&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;add_executable(my_app
    main.cpp
    utils.cpp
    utils.h
)
&lt;/code&gt;&lt;/pre&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;提示&lt;/strong&gt;：头文件 &lt;code&gt;.h&lt;/code&gt; 虽然不参与编译，但也写进 target 里，这样在 VS Code / CLion / Visual Studio 的左侧工程树里能直接看到头文件，跳转更方便。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;偷懒写法：通配符的坑&lt;/h3&gt;
&lt;p&gt;很多人喜欢用 &lt;code&gt;file(GLOB ...)&lt;/code&gt; 自动搜集目录下所有文件：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# ⚠️ 错误示范：千万别这么写
file(GLOB sources *.cpp *.h)
add_executable(my_app ${sources})
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;坑在哪里？&lt;/strong&gt;
当你新建或删除了一个 &lt;code&gt;.cpp&lt;/code&gt; 文件，因为 &lt;code&gt;CMakeLists.txt&lt;/code&gt; 本身没变，执行 &lt;code&gt;cmake --build build&lt;/code&gt; 时 CMake 不会感知到新文件，导致新代码根本没编进去。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;正确写法：加上 &lt;code&gt;CONFIGURE_DEPENDS&lt;/code&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;file(GLOB sources CONFIGURE_DEPENDS *.cpp *.h)
add_executable(my_app ${sources})
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;加了这个参数，底层构建系统每次编译前都会去扫一眼文件系统，发现文件增删会自动重新跑一遍 CMake。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 拆分模块与构建库（Library）&lt;/h2&gt;
&lt;p&gt;做稍大一点的工程，一般把核心代码编成库，上层应用去链接它。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 编译静态库（Linux 下出 .a，Windows 下出 .lib）
add_library(tensor_lib STATIC src/tensor.cpp)

# 编译动态库（Linux 下出 .so，Windows 下出 .dll）
add_library(tensor_lib SHARED src/tensor.cpp)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;技巧 1：让外部决定编静态库还是动态库&lt;/h3&gt;
&lt;p&gt;不写 &lt;code&gt;STATIC&lt;/code&gt; 也不写 &lt;code&gt;SHARED&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add_library(tensor_lib src/tensor.cpp)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CMake 会根据变量 &lt;code&gt;BUILD_SHARED_LIBS&lt;/code&gt; 自动判断。在命令行执行时可以灵活切换：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cmake -B build -DBUILD_SHARED_LIBS=ON   # 编出 .so
cmake -B build -DBUILD_SHARED_LIBS=OFF  # 编出 .a
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;技巧 2：静态库被动态库链接时的 &lt;code&gt;-fPIC&lt;/code&gt; 报错&lt;/h3&gt;
&lt;p&gt;如果静态库 &lt;code&gt;A&lt;/code&gt; 后续要被链接进动态库 &lt;code&gt;B&lt;/code&gt;（或者给 Python 做 &lt;code&gt;.so&lt;/code&gt; 扩展），Linux 链接器会报错要求用 &lt;code&gt;-fPIC&lt;/code&gt;。
在 CMake 里给静态库加上这一行即可：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;set_property(TARGET A PROPERTY POSITION_INDEPENDENT_CODE ON)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 最核心的概念：PUBLIC、PRIVATE、INTERFACE&lt;/h2&gt;
&lt;p&gt;这是初学 CMake 最容易懵的地方。其实它的本质就是&lt;strong&gt;定义属性传递的范围&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;当你给一个库配置头文件目录、链接依赖或编译选项时，用这三个关键字控制：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;关键字&lt;/th&gt;
&lt;th&gt;自己编译时用不用？&lt;/th&gt;
&lt;th&gt;别人链接我时能拿到吗？&lt;/th&gt;
&lt;th&gt;通俗理解&lt;/th&gt;
&lt;th&gt;常见场景&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;&lt;code&gt;PRIVATE&lt;/code&gt;&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;用&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;不给别人&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;内部自用，关起门来自己用&lt;/td&gt;
&lt;td&gt;内部实现代码、最终的可执行程序&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;&lt;code&gt;INTERFACE&lt;/code&gt;&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;不用&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;专门给别人&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;纯接口转发，自己不编&lt;/td&gt;
&lt;td&gt;纯头文件库（Header-only）、导入目标&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;&lt;code&gt;PUBLIC&lt;/code&gt;&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;用&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;也给别人&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;对外公开接口，一人一份&lt;/td&gt;
&lt;td&gt;你的公共头文件引用了外部依赖&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;实际案例：头文件路径自动传递&lt;/h3&gt;
&lt;p&gt;假设目录结构如下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;tensor_lib/
├── include/
│   └── tensor.h    # 对外暴露的头文件
└── src/
    └── tensor.cpp  # 具体实现
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在配置 &lt;code&gt;tensor_lib&lt;/code&gt; 时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add_library(tensor_lib STATIC src/tensor.cpp)

# 设置为 PUBLIC：告诉 CMake，不仅我编译要搜 include 目录，谁链接我，谁也自动搜 include 目录
target_include_directories(tensor_lib PUBLIC &quot;${CMAKE_CURRENT_SOURCE_DIR}/include&quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在可执行程序里：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add_executable(bench_app main.cpp)
target_link_libraries(bench_app PRIVATE tensor_lib)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这时候在 &lt;code&gt;main.cpp&lt;/code&gt; 里直接写 &lt;code&gt;#include &quot;tensor.h&quot;&lt;/code&gt; 就能通过编译！
你不需要再给 &lt;code&gt;bench_app&lt;/code&gt; 重复配置路径，CMake 会把 &lt;code&gt;tensor_lib&lt;/code&gt; 上标为 &lt;code&gt;PUBLIC&lt;/code&gt; 的属性一路传染给 &lt;code&gt;bench_app&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 如何引入第三方库？&lt;/h2&gt;
&lt;p&gt;日常开发中碰到的第三方库主要有三类引入方式：&lt;/p&gt;
&lt;h3&gt;方式 1：纯头文件库（Header-only，比如 glm、nlohmann/json）&lt;/h3&gt;
&lt;p&gt;这种库不需要编译，直接把它的 &lt;code&gt;include&lt;/code&gt; 路径挂到你的 Target 上就行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;target_include_directories(my_app PRIVATE &quot;${CMAKE_CURRENT_SOURCE_DIR}/third_party/glm/include&quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;方式 2：源码作为子目录引入（比如 fmt）&lt;/h3&gt;
&lt;p&gt;把第三方库源码放到项目的子目录里（通常通过 git submodule），然后用 &lt;code&gt;add_subdirectory&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add_subdirectory(third_party/fmt)

add_executable(my_app main.cpp)
target_link_libraries(my_app PRIVATE fmt::fmt)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;方式 3：系统安装好的库（使用 &lt;code&gt;find_package&lt;/code&gt;）&lt;/h3&gt;
&lt;p&gt;系统或者包管理器里装好的库，用 &lt;code&gt;find_package&lt;/code&gt; 寻找：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;find_package(TBB REQUIRED)
target_link_libraries(my_app PRIVATE TBB::tbb)
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;REQUIRED&lt;/code&gt; 表示如果找不到就直接报错停下来，不要继续。&lt;/li&gt;
&lt;li&gt;像 &lt;code&gt;TBB::tbb&lt;/code&gt; 这种带双冒号的名字叫 &lt;strong&gt;Imported Target（导入目标）&lt;/strong&gt;。它把 &lt;code&gt;.so&lt;/code&gt; 路径、头文件路径、编译参数全打包在一起了，只要 link 它，所有依赖全自动配齐。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;7. find_package 的两种模式：Module 还是 Config？&lt;/h2&gt;
&lt;p&gt;很多人被 &lt;code&gt;FindXXX.cmake&lt;/code&gt; 和 &lt;code&gt;XXXConfig.cmake&lt;/code&gt; 搞晕过，区别其实很简单：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Module 模式（默认）&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;找的是 &lt;code&gt;Find&amp;lt;Name&amp;gt;.cmake&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;这是 CMake 官方或你自己写的一个探测脚本，负责满系统乱翻找路径。&lt;/li&gt;
&lt;li&gt;相当于“找外面的私家侦探帮你去翻系统目录”。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Config 模式（推荐，加 &lt;code&gt;CONFIG&lt;/code&gt; 关键字）&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;找的是 &lt;code&gt;&amp;lt;Name&amp;gt;Config.cmake&lt;/code&gt; 或 &lt;code&gt;&amp;lt;name&amp;gt;-config.cmake&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;这是第三方库自己安装到系统里的，库作者最清楚库的位置和参数。&lt;/li&gt;
&lt;li&gt;相当于“直接读该库官方提供的说明书”。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;# 优先推荐指定 CONFIG（如果该库提供了的话）
find_package(TBB CONFIG REQUIRED)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;搭配包管理器（vcpkg / Conan）&lt;/h3&gt;
&lt;p&gt;如果用 vcpkg 安装了库，执行 CMake 时带上它的工具链参数即可，CMake 脚本本身一行都不用改：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cmake -B build -DCMAKE_TOOLCHAIN_FILE=&quot;/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;8. 变量、Cache 与 option 开关&lt;/h2&gt;
&lt;h3&gt;普通变量 vs 缓存变量&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;set(MY_VAR &quot;123&quot;)&lt;/code&gt;：普通局部变量，CMake 退出后就没了。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;set(MY_VAR &quot;123&quot; CACHE STRING &quot;说明&quot;)&lt;/code&gt;：写进 &lt;code&gt;build/CMakeCache.txt&lt;/code&gt; 里的缓存变量，下次执行 CMake 依然在，可以在命令行用 &lt;code&gt;-DMY_VAR=xxx&lt;/code&gt; 覆盖。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;制作命令行开关：&lt;code&gt;option()&lt;/code&gt;&lt;/h3&gt;
&lt;p&gt;这是给项目做配置项的标准方式：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;option(ENABLE_TESTS &quot;是否编译测试程序&quot; ON)
option(WITH_CUDA    &quot;是否开启 CUDA 加速&quot; OFF)

if (ENABLE_TESTS)
    add_subdirectory(tests)
endif()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;用户在命令行就能很方便地开关功能：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cmake -B build -DENABLE_TESTS=OFF -DWITH_CUDA=ON
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;9. AI Infra 核心：OpenMP 与 CUDA 异构编译&lt;/h2&gt;
&lt;p&gt;在做深度学习推理框架、算子优化时，最常打交道的就是 CPU 多线程与 GPU 编译。&lt;/p&gt;
&lt;h3&gt;9.1 OpenMP 并行支持（CPU 算子加速）&lt;/h3&gt;
&lt;p&gt;别再去手动写 &lt;code&gt;-fopenmp&lt;/code&gt;，现代 CMake 写法极其干净：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;find_package(OpenMP REQUIRED)

add_executable(vec_bench main.cpp)
# 只要链接这一行，编译参数、运行库依赖全部自动补齐
target_link_libraries(vec_bench PRIVATE OpenMP::OpenMP_CXX)

# 配合 CPU 算子极限优化：开启 O3 和本地 CPU 架构向量化（AVX2/AVX-512）
target_compile_options(vec_bench PRIVATE -O3 -march=native)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;9.2 原生 CUDA 支持（GPU 算子开发）&lt;/h3&gt;
&lt;blockquote&gt;
&lt;p&gt;⚠️ &lt;strong&gt;警告&lt;/strong&gt;：老旧教程里教的 &lt;code&gt;find_package(CUDA)&lt;/code&gt; 和 &lt;code&gt;cuda_add_executable&lt;/code&gt; 早在 CMake 3.10+ 就被&lt;strong&gt;废弃&lt;/strong&gt;了，新项目绝对不要用。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;现代做法是把 CUDA 当成原生语言：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cmake_minimum_required(VERSION 3.18)

# 1. 声明开启 CXX 和 CUDA 语言（CMake 会自动检测系统的 nvcc）
project(cuda_ops LANGUAGES CXX CUDA)

# 2. 保证 C++ 与 CUDA 语言标准一致
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CUDA_STANDARD 17)

# 3. 混合添加 .cpp 和 .cu 文件
add_library(attn_ops SHARED
    src/interface.cpp
    src/kernel.cu
)

# 4. 指定目标 GPU 架构（计算能力）
# 本地调试用 native 自动识别本机显卡（如 4060 会自动识别为 89）：
set_property(TARGET attn_ops PROPERTY CUDA_ARCHITECTURES native)

# 如果要发布库支持多种显卡（fatbin），显式指定多个算力：
# 80(A100), 89(4090/4060), 90(H100)
# set_property(TARGET attn_ops PROPERTY CUDA_ARCHITECTURES 80 89 90)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CMake 会自动把 &lt;code&gt;.cpp&lt;/code&gt; 给 GCC 编，把 &lt;code&gt;.cu&lt;/code&gt; 给 nvcc 编，最后把它们和 CUDA 运行时（&lt;code&gt;libcudart&lt;/code&gt;）自动链接在一起。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;10. 常见报错快速排查套路&lt;/h2&gt;
&lt;h3&gt;1. &lt;code&gt;fatal error: xxx.h: No such file or directory&lt;/code&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;原因&lt;/strong&gt;：找不到头文件。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;排查&lt;/strong&gt;：
&lt;ol&gt;
&lt;li&gt;看提供头文件的库有没有写 &lt;code&gt;target_include_directories(库名 PUBLIC 路径)&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;看你的目标有没有通过 &lt;code&gt;target_link_libraries(你的目标 PRIVATE 库名)&lt;/code&gt; 连上去。&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;2. &lt;code&gt;undefined reference to &apos;xxx&apos;&lt;/code&gt; 或 &lt;code&gt;LNK2019&lt;/code&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;原因&lt;/strong&gt;：头文件找到了（函数声明有了），但链接器找不到函数实现的机器码。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;排查&lt;/strong&gt;：
&lt;ol&gt;
&lt;li&gt;实现这个函数的 &lt;code&gt;.cpp&lt;/code&gt; 是不是忘了写进 &lt;code&gt;add_library&lt;/code&gt; 或 &lt;code&gt;add_executable&lt;/code&gt;？&lt;/li&gt;
&lt;li&gt;是不是只包含了头文件，忘了用 &lt;code&gt;target_link_libraries&lt;/code&gt; 链接第三方库的 &lt;code&gt;.a&lt;/code&gt; / &lt;code&gt;.so&lt;/code&gt;？&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;3. &lt;code&gt;error while loading shared libraries: libxxx.so&lt;/code&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;原因&lt;/strong&gt;：编译链接都成功了，但程序&lt;strong&gt;运行时&lt;/strong&gt;动态链接器找不到 &lt;code&gt;.so&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;排查&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;临时解决：&lt;code&gt;export LD_LIBRARY_PATH=/path/to/lib:$LD_LIBRARY_PATH&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;CMake 优雅解决：设置 RPATH，把库路径写进二进制文件：&lt;pre&gt;&lt;code&gt;set_target_properties(my_app PROPERTIES BUILD_RPATH &quot;${CMAKE_CURRENT_BINARY_DIR}&quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;4. &lt;code&gt;No CUDA toolchain found&lt;/code&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;原因&lt;/strong&gt;：CMake 找不到 &lt;code&gt;nvcc&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;排查&lt;/strong&gt;：检查环境变量 &lt;code&gt;export PATH=/usr/local/cuda/bin:$PATH&lt;/code&gt;，确认终端里敲 &lt;code&gt;nvcc --version&lt;/code&gt; 能正常输出。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;总结：牢记这 5 条守则&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;构建只用两行：&lt;code&gt;cmake -B build&lt;/code&gt; 和 &lt;code&gt;cmake --build build&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;尽量少用全局变量，属性都挂到具体 &lt;strong&gt;Target&lt;/strong&gt; 上（&lt;code&gt;target_*&lt;/code&gt; 系列命令）。&lt;/li&gt;
&lt;li&gt;区分好 &lt;strong&gt;&lt;code&gt;PUBLIC&lt;/code&gt;&lt;/strong&gt;（别人要用）和 &lt;strong&gt;&lt;code&gt;PRIVATE&lt;/code&gt;&lt;/strong&gt;（仅自己用）。&lt;/li&gt;
&lt;li&gt;搜源文件用 &lt;code&gt;file(GLOB ... CONFIGURE_DEPENDS)&lt;/code&gt; 防止新增文件无法感知。&lt;/li&gt;
&lt;li&gt;引入外部依赖优先认准带双冒号的 &lt;strong&gt;Imported Target&lt;/strong&gt;（如 &lt;code&gt;OpenMP::OpenMP_CXX&lt;/code&gt;、&lt;code&gt;TBB::tbb&lt;/code&gt;），省去手动配参数的麻烦。&lt;/li&gt;
&lt;/ol&gt;
</content:encoded></item><item><title>0-1BFS扩展</title><link>https://sanzenin.top/posts/obsidian/0-1bfs%E6%89%A9%E5%B1%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/0-1bfs%E6%89%A9%E5%B1%95/</guid><description>给定一张无向图，起点为 ，终点为 。每条边的权值表示经过该道路所需时间，题目语境下普通道路耗时为 ，若需要聊天则额外耗时 ，因此边权只会落在小整数集合 中。图中可能存在重边，要求输出从 到 的最短路长度。 数据范围为 ， 。若直接使用堆优化 Dijkstra，复杂度为 ，在该规模下常数和对数因子都较重；边权范围很小，应</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;0-1BFS扩展&lt;/h1&gt;
&lt;h2&gt;题目重述&lt;/h2&gt;
&lt;p&gt;给定一张无向图，起点为 $1$，终点为 $t$。每条边的权值表示经过该道路所需时间，题目语境下普通道路耗时为 $1$，若需要聊天则额外耗时 $1$，因此边权只会落在小整数集合 ${1,2}$ 中。图中可能存在重边，要求输出从 $1$ 到 $t$ 的最短路长度。&lt;/p&gt;
&lt;p&gt;数据范围为 $n \le 5,000,000$，$m \le 10,000,000$。若直接使用堆优化 Dijkstra，复杂度为 $O(m \log n)$，在该规模下常数和对数因子都较重；边权范围很小，应利用这一结构。&lt;/p&gt;
&lt;h2&gt;关键观察&lt;/h2&gt;
&lt;p&gt;0-1 BFS 适用于边权集合 ${0,1}$：当前点距离为 $d$，松弛后新距离只可能为 $d$ 或 $d+1$，因此用双端队列即可维持非降序出队。&lt;/p&gt;
&lt;p&gt;本题边权集合为 ${1,2}$，松弛后新距离只可能为 $d+1$ 或 $d+2$。这不能直接等价为 0-1 BFS，因为把每条边权减去 $1$ 会使路径代价额外依赖边数，而不同路径的边数不一定相同。正确的推广方式是使用循环桶：维护 $3$ 个队列，队列编号为距离对 $3$ 取模的结果。&lt;/p&gt;
&lt;p&gt;选择 $3$ 个桶的原因是最大边权为 $2$。当正在处理距离 $d$ 的点时，新产生的候选距离不会超过 $d+2$；在距离指针依次移动到 $d+1,d+2,d+3$ 前，编号为 $d \bmod 3$ 的桶已经被清空，可以重新存放距离为 $d+3$ 的点。因为所有边权均为正，已经弹出并确认的最小距离不会再被更小距离更新，所以每个点第一次被确认时即得到最短路。&lt;/p&gt;
&lt;h2&gt;解析&lt;/h2&gt;
&lt;p&gt;建图时使用链式前向星存储无向边。对于输入边 $(u,v,w)$，分别加入 $u \to v$ 和 $v \to u$。由于 $m$ 可达 $10^7$，链式前向星比 &lt;code&gt;vector&amp;lt;vector&amp;lt;...&amp;gt;&amp;gt;&lt;/code&gt; 更容易控制内存。&lt;/p&gt;
&lt;p&gt;设 &lt;code&gt;dis[x]&lt;/code&gt; 表示当前已知的从 $1$ 到 $x$ 的最短距离，&lt;code&gt;vis[x]&lt;/code&gt; 表示该点是否已经被确认。维护三个普通队列 &lt;code&gt;q[0]&lt;/code&gt;、&lt;code&gt;q[1]&lt;/code&gt;、&lt;code&gt;q[2]&lt;/code&gt;，变量 &lt;code&gt;cur&lt;/code&gt; 表示当前要处理的距离模 $3$ 的桶。初始令 &lt;code&gt;dis[1]=0&lt;/code&gt;，将 $1$ 放入 &lt;code&gt;q[0]&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;每轮从 &lt;code&gt;q[cur]&lt;/code&gt; 中取出当前批次的点。若点已经被确认，则跳过；否则标记为确认，并枚举其所有出边。对于边 $x \to v$，权值为 $w$，若&lt;/p&gt;
&lt;p&gt;$$
\text{dis}[v] &amp;gt; \text{dis}[x] + w,
$$&lt;/p&gt;
&lt;p&gt;则更新&lt;/p&gt;
&lt;p&gt;$$
\text{dis}[v] = \text{dis}[x] + w,
$$&lt;/p&gt;
&lt;p&gt;并将 $v$ 放入 &lt;code&gt;q[dis[v] % 3]&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;该过程是 Dial 算法在最大边权为 $2$ 时的特化形式，也可以看作 0-1 BFS 从两个优先级扩展到三个循环优先级。0-1 BFS 用“队首”和“队尾”区分距离 $d$ 与 $d+1$；本题用 $3$ 个桶区分当前窗口内的距离 $d,d+1,d+2$。由于边权不超过 $2$，任何从当前最小距离点松弛出的新状态都不会跳出这个窗口，因此循环桶始终能够按照距离非降序确认点。&lt;/p&gt;
&lt;p&gt;代码中在弹出点后若发现 &lt;code&gt;x==t&lt;/code&gt; 即返回。此时 &lt;code&gt;t&lt;/code&gt; 是从当前最小距离桶中取出的点；根据上述非降序性质，之后不可能出现距离更小的 $t$，所以可以提前终止。&lt;/p&gt;
&lt;p&gt;复杂度方面，每条边在端点被确认时被扫描一次，入队可能因松弛发生多次，但每次成功松弛对应一次距离下降，整体在小整数正权的桶式 Dijkstra 框架下为线性级实现。对于本题代码的常见分析，可记为 $O(n+m)$；存储图和辅助数组的空间复杂度为 $O(n+m)$。&lt;/p&gt;
&lt;h2&gt;代码&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#define ll long long
#define N 10000005
#define pr pair&amp;lt;int, int&amp;gt;
using namespace std;
ll ans;
int n, m;
int t, cnt;
struct edge {
    int to, nxt, w;
} edges[N];
int head[N];
int main() {
    ios::sync_with_stdio(0);
    scanf(&quot;%d %d %d&quot;, &amp;amp;n, &amp;amp;m, &amp;amp;t);
    memset(head, -1, sizeof head);
    auto add = [&amp;amp;](int a, int b, int c) {
        cnt++;
        edges[cnt] = {b, head[a], c};
        head[a] = cnt;
    };
    for (int i = 1; i &amp;lt;= m; i++) {
        int a, b, c;
        // cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b&amp;gt;&amp;gt;c;
        scanf(&quot;%d %d %d&quot;, &amp;amp;a, &amp;amp;b, &amp;amp;c);
        add(a, b, c);
        add(b, a, c);
    }
    vector&amp;lt;int&amp;gt; dis(n + 5, 1e9);
    vector&amp;lt;bool&amp;gt; vis(n + 5, 0);
    auto bfs = [&amp;amp;]() {
        queue&amp;lt;int&amp;gt; q[3];
        q[0].push(1);
        dis[1] = 0;
        int cur = 0;
        while (q[0].size() || q[1].size() || q[2].size()) {
            int siz = q[cur].size();
            for (int i = 1; i &amp;lt;= siz; i++) {
                auto x = q[cur].front();
                q[cur].pop();
                if (x == t)
                    return;
                if (vis[x])
                    continue;
                vis[x] = 1;
                for (int i = head[x]; ~i; i = edges[i].nxt) {
                    int v = edges[i].to, w = edges[i].w;
                    if (dis[v] &amp;gt; dis[x] + w) {
                        dis[v] = dis[x] + w;
                        q[dis[v] % 3].push(v);
                    }
                }
            }
            cur = (cur + 1) % 3;
        }
    };
    bfs();
    cout &amp;lt;&amp;lt; dis[t];
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>2-SAT</title><link>https://sanzenin.top/posts/obsidian/2-sat/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/2-sat/</guid><description>有 个布尔变量 ，另有 个需要满足的条件，每个条件的形式都是「 为 true / false 或 为 true / false」。比如「 为真或 为假」、「 为假或 为假」。 2-SAT 问题的目标是给每个变量赋值使得所有条件得到满足。 成立 或 成立，等价于：若 不成立，则 必成立；且 若 不成立，则 必成立。 注意</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;有 $n$ 个布尔变量 $x_1 \sim x_n$，另有 $m$ 个需要满足的条件，每个条件的形式都是「$x_i$ 为 &lt;code&gt;true&lt;/code&gt; / &lt;code&gt;false&lt;/code&gt; 或 $x_j$ 为 &lt;code&gt;true&lt;/code&gt; / &lt;code&gt;false&lt;/code&gt;」。比如「$x_1$ 为真或 $x_3$ 为假」、「$x_7$ 为假或 $x_2$ 为假」。&lt;/p&gt;
&lt;p&gt;2-SAT 问题的目标是给每个变量赋值使得所有条件得到满足。&lt;/p&gt;
&lt;h3&gt;算法流程&lt;/h3&gt;
&lt;h4&gt;1. 逻辑关系：把 或关系 转化为 蕴含关系&lt;/h4&gt;
&lt;p&gt;$$a \lor b \iff (\neg a \to b) \land (\neg b \to a)$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$a$ 成立 或 $b$ 成立，等价于：若 $a$ 不成立，则 $b$ 必成立；且 若 $b$ 不成立，则 $a$ 必成立。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;注意：&lt;/strong&gt; 蕴含关系具有&lt;strong&gt;传递性&lt;/strong&gt;：若 $a \to b \land b \to c$，则 $a \to c$。蕴含关系通常是不可逆的。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;2. 拆点建图&lt;/h4&gt;
&lt;p&gt;把每个变量看成点，把 $n$ 个点拆成 $2n$ 个点，即把 $x_i$ 拆成 $i$ 和 $i+n$：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$i$ 对应 $x_i = 1$&lt;/li&gt;
&lt;li&gt;$i+n$ 对应 $x_i = 0$&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;建图就是连有向边，例如：$x_i = a \lor x_j = b$，其中 $a \in {0, 1}, b \in {0, 1}$。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;蕴含关系 $\neg(x_i = a) \to x_j = b$ 可以表示为：从 $i + (!a) \times n$ 到 $j + b \times n$ 的有向边。&lt;/li&gt;
&lt;li&gt;蕴含关系 $\neg(x_j = b) \to x_i = a$ 可以表示为：从 $j + (!b) \times n$ 到 $i + a \times n$ 的有向边。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;3. Tarjan 缩点&lt;/h4&gt;
&lt;p&gt;先跑 Tarjan 缩点，缩点后判断：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;如果 $i$ 和 $i+n$ 在同一 SCC 里&lt;/strong&gt;（即在一个环内），那么显然&lt;strong&gt;无解&lt;/strong&gt;。因为 $x_i$ 不能既取 0 又取 1。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;否则&lt;/strong&gt;，$i$ 和 $i+n$ 可能在一条链上或无关，那么&lt;strong&gt;一定存在可行解&lt;/strong&gt;。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;如何构造答案?&lt;/h3&gt;
&lt;h4&gt;1. 核心构造规则&lt;/h4&gt;
&lt;p&gt;在完成 Tarjan 缩点并判定无解（即不存在 $x_i$ 与 $\neg x_i$ 在同一 SCC）后，变量的赋值规则为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 &lt;strong&gt;&lt;code&gt;scc[x] &amp;lt; scc[not_x]&lt;/code&gt;&lt;/strong&gt;，则令 &lt;strong&gt;$x = \text{True}$&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;若 &lt;strong&gt;&lt;code&gt;scc[x] &amp;gt; scc[not_x]&lt;/code&gt;&lt;/strong&gt;，则令 &lt;strong&gt;$x = \text{False}$&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;关键背景：&lt;/strong&gt; Tarjan 算法得到的 SCC 编号是 &lt;strong&gt;反拓扑序&lt;/strong&gt;。编号越小，在拓扑序中越靠后（越接近推导链的终点/汇点）。&lt;/p&gt;
&lt;hr /&gt;
&lt;h4&gt;2. 为什么这样是对的&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;推导性质：&lt;/strong&gt; 若存在推导 $A \to B$，则 $A$ 为真时 $B$ 必为真。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;拓扑逻辑：&lt;/strong&gt; 越靠近汇点（拓扑序后）的点，其约束越少。将汇点设为真，不会通过边传递“必须为真”的压力给其他点；而将源点（拓扑序前）设为真，会引发连锁反应。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;对称性：&lt;/strong&gt; 蕴含图是对称的。如果 $x$ 在拓扑序后端，其否定点 $\neg x$ 必然在拓扑序前端。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h4&gt;3. 正确性证明（反证法）&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;目标：&lt;/strong&gt; 证明对于任意边 $u \to v$，不存在 $u = \text{True}$ 且 $v = \text{False}$ 的情况。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明过程：&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;前提条件：&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;有向边 $u \to v \implies$ 图中必有逆否边 $\neg v \to \neg u$。&lt;/li&gt;
&lt;li&gt;根据 Tarjan 序性质：&lt;code&gt;scc[u] &amp;gt;= scc[v]&lt;/code&gt; 且 &lt;code&gt;scc[not_v] &amp;gt;= scc[not_u]&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;假设冲突发生：&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;$u = \text{True} \implies$ &lt;code&gt;scc[u] &amp;lt; scc[not_u]&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;$v = \text{False} \implies$ &lt;code&gt;scc[not_v] &amp;lt; scc[v]&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;链条推导：&lt;/strong&gt;
将上述四个不等式连立：
$$scc[u] &amp;lt; scc[not_u] \le scc[not_v] &amp;lt; scc[v] \le scc[u]$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论：&lt;/strong&gt;
推导出 $scc[u] &amp;lt; scc[u]$，矛盾。因此，该赋值规则下逻辑恒自洽。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h4&gt;4. 有点难理解的地方&lt;/h4&gt;
&lt;h4&gt;Q1：路径 $x \to \neg x$ 为什么不导致矛盾？&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;误区：&lt;/strong&gt; 认为存在路径就会矛盾。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;真相：&lt;/strong&gt; 只有 &lt;strong&gt;环&lt;/strong&gt; ($x \leftrightarrow \neg x$) 才矛盾。
&lt;ul&gt;
&lt;li&gt;$x \to \neg x$ 仅表示一种&lt;strong&gt;强约束&lt;/strong&gt;：若 $x$ 为真则产生矛盾，所以 &lt;strong&gt;$x$ 只能取假&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;在算法中，$\neg x$ 在 $x$ 的下游，&lt;code&gt;scc[not_x]&lt;/code&gt; 较小，规则会正确地将 $\neg x$ 设为真，即 $x$ 设为假。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;Q2：假设 $a, b$ 都为真，但存在 $b \to \neg a$，怎么办？&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;真相：&lt;/strong&gt; 这种情况&lt;strong&gt;在数学上不存在&lt;/strong&gt;。
&lt;ul&gt;
&lt;li&gt;如果 $b \to \neg a$，那么在全局拓扑序中，$b$ 必须排在 $\neg a$ 的前面。&lt;/li&gt;
&lt;li&gt;如果你选了 $a$ 为真（即 $\neg a$ 为假），那么根据推导链，$b$ 必须也被迫为假。&lt;/li&gt;
&lt;li&gt;算法通过 &lt;code&gt;scc&lt;/code&gt; 编号的大小关系，强制保证了这种全局序。如果 $a, b$ 都被赋为真，它们之间的所有路径（包括 $b \to \neg a$）都不会违背逻辑。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;常见命题约束的建图方式&lt;/h3&gt;
&lt;p&gt;2-SAT 建图的核心是把题面条件翻译成蕴含关系。对任意蕴含 $P\to Q$，需要同时加入其逆否命题 $\neg Q\to\neg P$。原因是二者在命题逻辑中等价：若 $P$ 成立时 $Q$ 必须成立，那么当 $Q$ 不成立时，$P$ 也不可能成立。&lt;/p&gt;
&lt;p&gt;蕴含 $P\to Q$ 的实际含义是“禁止 $P$ 为真且 $Q$ 为假”。当前提 $P$ 为假时，该限制没有被触发，所以 $P=false,Q=true$ 是合法的。这也是一般的 $P\to Q$ 不能直接用并查集合并 $P$ 与 $Q$ 的原因：并查集合并表示 $P=Q$，会错误排除 $P=false,Q=true$。&lt;/p&gt;
&lt;p&gt;常见建图模板如下：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;约束&lt;/th&gt;
&lt;th&gt;逻辑形式&lt;/th&gt;
&lt;th&gt;建边&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;$P$ 必须为真&lt;/td&gt;
&lt;td&gt;$\neg P\to P$&lt;/td&gt;
&lt;td&gt;加 $\neg P\to P$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$P$ 必须为假&lt;/td&gt;
&lt;td&gt;$P\to \neg P$&lt;/td&gt;
&lt;td&gt;加 $P\to\neg P$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$P\to Q$&lt;/td&gt;
&lt;td&gt;蕴含&lt;/td&gt;
&lt;td&gt;加 $P\to Q$ 与 $\neg Q\to\neg P$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$P\lor Q$&lt;/td&gt;
&lt;td&gt;至少一个为真&lt;/td&gt;
&lt;td&gt;加 $\neg P\to Q$ 与 $\neg Q\to P$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$P,Q$ 不能同时为真&lt;/td&gt;
&lt;td&gt;$\neg(P\land Q)$&lt;/td&gt;
&lt;td&gt;加 $P\to\neg Q$ 与 $Q\to\neg P$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$P,Q$ 必须相同&lt;/td&gt;
&lt;td&gt;$P\Leftrightarrow Q$&lt;/td&gt;
&lt;td&gt;加 $P\to Q$、$Q\to P$，并补逆否&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$P,Q$ 必须不同&lt;/td&gt;
&lt;td&gt;$P\Leftrightarrow\neg Q$&lt;/td&gt;
&lt;td&gt;加 $P\to\neg Q$、$Q\to\neg P$，并补逆否&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;若使用 $x$ 与 $x\oplus 1$ 表示互为否定的两个状态，可以把加边封装成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto rev = [&amp;amp;](int x) { return x ^ 1; };
auto add_imp = [&amp;amp;](int u, int v) {
    g[u].push_back(v);
    g[rev(v)].push_back(rev(u));
};
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中 &lt;code&gt;add_imp(u, v)&lt;/code&gt; 表示加入 $u\to v$，并自动补上 $\neg v\to\neg u$。&lt;/p&gt;
&lt;h3&gt;例题：公司搬迁&lt;/h3&gt;
&lt;h4&gt;题目重述&lt;/h4&gt;
&lt;p&gt;给定 $n$ 个互不相同的员工工号 $p_1,p_2,\ldots,p_n$，每名员工必须被分配到 $A$ 座或 $B$ 座。若工号为 $x$ 的员工在 $A$ 座，则工号为 $a-x$ 的员工也必须存在并在 $A$ 座；若工号为 $x$ 的员工在 $B$ 座，则工号为 $b-x$ 的员工也必须存在并在 $B$ 座。判断是否存在一种分配方案。&lt;/p&gt;
&lt;p&gt;约束为 $1\le n\le 10^5$，$1\le p_i,a,b\le 10^9$，测试组数 $T\le 10$。&lt;/p&gt;
&lt;h4&gt;关键观察&lt;/h4&gt;
&lt;p&gt;每名员工只有两种互斥状态，令&lt;/p&gt;
&lt;p&gt;$$
A_i:\text{员工 }i\text{ 在 }A\text{ 座},\qquad B_i:\text{员工 }i\text{ 在 }B\text{ 座}.
$$&lt;/p&gt;
&lt;p&gt;由于每名员工必须且只能选择一栋楼，$A_i$ 与 $B_i$ 互为否定命题。&lt;/p&gt;
&lt;p&gt;若存在员工 $j$ 满足 $p_j=a-p_i$，则题意给出&lt;/p&gt;
&lt;p&gt;$$
A_i\to A_j.
$$&lt;/p&gt;
&lt;p&gt;若不存在这样的员工，则 $A_i$ 这个状态不合法，等价于&lt;/p&gt;
&lt;p&gt;$$
A_i\to B_i.
$$&lt;/p&gt;
&lt;p&gt;$B$ 座约束同理。若存在员工 $j$ 满足 $p_j=b-p_i$，则&lt;/p&gt;
&lt;p&gt;$$
B_i\to B_j,
$$&lt;/p&gt;
&lt;p&gt;否则&lt;/p&gt;
&lt;p&gt;$$
B_i\to A_i.
$$&lt;/p&gt;
&lt;p&gt;因此本题可以直接按 2-SAT 建图并跑 SCC。&lt;/p&gt;
&lt;p&gt;但本题还可以用并查集判断。原因在于函数 $f_a(x)=a-x$ 满足 $f_a(f_a(x))=x$。若 $p_j=a-p_i$ 存在，则遍历到 $i$ 时得到 $A_i\to A_j$，遍历到 $j$ 时又得到 $A_j\to A_i$，二者合起来是&lt;/p&gt;
&lt;p&gt;$$
A_i\Leftrightarrow A_j.
$$&lt;/p&gt;
&lt;p&gt;这已经不是一般 2-SAT 的单向约束，而是等价约束。等价关系可以用并查集合并维护。$B$ 座对应的函数 $f_b(x)=b-x$ 同样满足该性质。&lt;/p&gt;
&lt;h4&gt;解析&lt;/h4&gt;
&lt;p&gt;标准 2-SAT 做法可以令&lt;/p&gt;
&lt;p&gt;$$
\text{node}(A_i)=2i,\qquad \text{node}(B_i)=2i+1,
$$&lt;/p&gt;
&lt;p&gt;且 $\text{rev}(x)=x\oplus 1$。按以下方式建图：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $a-p_i$ 存在且对应员工为 $j$，添加 $A_i\to A_j$；否则添加 $A_i\to B_i$。&lt;/li&gt;
&lt;li&gt;若 $b-p_i$ 存在且对应员工为 $j$，添加 $B_i\to B_j$；否则添加 $B_i\to A_i$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;跑 SCC 后检查是否存在 $A_i$ 与 $B_i$ 同属一个强连通分量。&lt;/p&gt;
&lt;p&gt;并查集做法利用“存在搭档时状态等价”的特殊性。若 $a-p_i$ 存在且对应员工为 $j$，合并：&lt;/p&gt;
&lt;p&gt;$$
A_i=A_j,\qquad B_i=B_j.
$$&lt;/p&gt;
&lt;p&gt;若 $b-p_i$ 存在且对应员工为 $j$，合并：&lt;/p&gt;
&lt;p&gt;$$
B_i=B_j,\qquad A_i=A_j.
$$&lt;/p&gt;
&lt;p&gt;若 $a-p_i$ 不存在，员工 $i$ 不能在 $A$ 座，即 $A_i$ 为假、$B_i$ 为真。引入两个特殊集合 $T$ 与 $F$ 表示状态被强制为真或假，则合并：&lt;/p&gt;
&lt;p&gt;$$
A_i=F,\qquad B_i=T.
$$&lt;/p&gt;
&lt;p&gt;若 $b-p_i$ 不存在，则合并：&lt;/p&gt;
&lt;p&gt;$$
B_i=F,\qquad A_i=T.
$$&lt;/p&gt;
&lt;p&gt;处理完所有约束后，若 $T$ 与 $F$ 被合并，说明某个状态被同时强制为真和假，无解。若存在某个员工满足 $A_i$ 与 $B_i$ 被合并，说明该员工被要求同时在两栋楼，也无解。否则存在可行方案。&lt;/p&gt;
&lt;p&gt;使用哈希表存储工号到员工下标的映射，可以在均摊 $O(1)$ 时间内判断搭档是否存在。每个员工只进行常数次并查集合并与查询，单组复杂度为 $O(n\alpha(n))$，空间复杂度为 $O(n)$。&lt;/p&gt;
&lt;h4&gt;代码&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;array&amp;gt;
#include &amp;lt;bits/extc++.h&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cctype&amp;gt;
#include &amp;lt;functional&amp;gt;
#define ll long long
#define N 1005
using namespace std;
using namespace __gnu_pbds;
ll ans;
ll n, m, a, b;
ll t;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; t;
    while (t--) {
        auto solve = [&amp;amp;]() {
            cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b;
            vector&amp;lt;ll&amp;gt; s(n + 5, 0);
            unordered_map&amp;lt;ll, ll&amp;gt; id;
            for (int i = 1; i &amp;lt;= n; i++) {
                cin &amp;gt;&amp;gt; s[i];
                id[s[i]] = i;
            }
            auto toa = [&amp;amp;](int x) { return x * 2; };
            auto tob = [&amp;amp;](int x) { return x * 2 + 1; };
            auto rev = [&amp;amp;](int x) { return x ^ 1; };
            vector&amp;lt;int&amp;gt; fa(2 * n + 10, 0);
            for (int i = 1; i &amp;lt;= 2 * n + 4; i++)
                fa[i] = i;
            auto find = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; int {
                return fa[x] = (fa[x] == x ? fa[x] : self(self, fa[x]));
            };
            auto merge = [&amp;amp;](int x, int y) {
                auto rx = find(find, x);
                auto ry = find(find, y);
                if (rx == ry)
                    return;
                fa[rx] = ry;
            };
            auto add = [&amp;amp;](int x, int y) {
                merge(x, y);
                merge(rev(x), rev(y));
            };
#define F 2 * n + 2
#define T 2 * n + 3
            for (int i = 1; i &amp;lt;= n; i++) {
                if (id.count(a - s[i])) {
                    add(toa(i), toa(id[a - s[i]]));
                } else {
                    merge(toa(i), F);
                    merge(tob(i), T);
                }
                if (id.count(b - s[i])) {
                    add(tob(i), tob(id[b - s[i]]));
                } else {
                    merge(tob(i), F);
                    merge(toa(i), T);
                }
            }
            if (find(find, T) == find(find, F)) {
                cout &amp;lt;&amp;lt; &quot;NO\n&quot;;
                return;
            }
            for (int i = 1; i &amp;lt;= n; i++) {
                if (find(find, tob(i)) == find(find, toa(i))) {
                    cout &amp;lt;&amp;lt; &quot;NO\n&quot;;
                    return;
                }
            }
            cout &amp;lt;&amp;lt; &quot;YES\n&quot;;
        };
        solve();
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/1684&quot;&gt;CSES  Giant Pizza&lt;/a&gt;
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iterator&amp;gt;
#include &amp;lt;queue&amp;gt;
#include &amp;lt;set&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#define N 100005
#define inf 0x3f3f3f3f3f3f3f3f
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
int n, m, q, ma, block;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; map1;
vector&amp;lt;ll&amp;gt; scc;
const ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; m &amp;gt;&amp;gt; n;
    map1.assign(2 * n + 5, {});
    scc.assign(2 * n + 5, 0);
    auto rev = [&amp;amp;](int x) { return x &amp;gt; n ? x - n : x + n; };
    for (int i = 1; i &amp;lt;= m; i++) {
        char op1, op2;
        ll a, b;
        cin &amp;gt;&amp;gt; op1 &amp;gt;&amp;gt; a &amp;gt;&amp;gt; op2 &amp;gt;&amp;gt; b;
        if (op1 == &apos;-&apos;)
            a += n;
        if (op2 == &apos;-&apos;)
            b += n;
        map1[rev(a)].push_back(b);
        map1[rev(b)].push_back(a);
    }
    vector&amp;lt;ll&amp;gt; dfn(2 * n + 5, 0);
    vector&amp;lt;ll&amp;gt; low(2 * n + 5, 0);
    int tim = 0;
    stack&amp;lt;int&amp;gt; sta;
    vector&amp;lt;bool&amp;gt; insta(2 * n + 5, 0);
    auto tarjan = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void {
        dfn[x] = low[x] = ++tim;
        sta.push(x);
        insta[x] = 1;
        for (auto v : map1[x]) {
            if (!dfn[v]) {
                self(self, v);
                low[x] = min(low[x], low[v]);
            } else if (insta[v])
                low[x] = min(low[x], dfn[v]);
        }
        if (low[x] == dfn[x]) {
            int y = -1;
            block++;
            while (y != x) {
                y = sta.top(), sta.pop();
                insta[y] = 0;
                scc[y] = block;
            }
        }
    };
    for (int i = 1; i &amp;lt;= 2 * n; i++) {
        if (!dfn[i])
            tarjan(tarjan, i);
    }
    vector&amp;lt;bool&amp;gt; ans(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++) {
        if (scc[i] == scc[i + n]) {
            cout &amp;lt;&amp;lt; &quot;IMPOSSIBLE&quot;;
            return 0;
        }
        if (scc[i] &amp;lt; scc[i + n]) {
            ans[i] = 1;
        }
    }
    for (int i = 1; i &amp;lt;= n; i++) {
        if (ans[i] == 1)
            cout &amp;lt;&amp;lt; &apos;+&apos; &amp;lt;&amp;lt; &apos; &apos;;
        else
            cout &amp;lt;&amp;lt; &apos;-&apos; &amp;lt;&amp;lt; &apos; &apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Hall 婚姻定理 (Hall&apos;s Marriage Theorem)</title><link>https://sanzenin.top/posts/obsidian/hall%E5%AE%9A%E7%90%86/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/hall%E5%AE%9A%E7%90%86/</guid><description>设二分图 ， 。 中存在包含 中所有顶点的完全匹配（即最大匹配为 ）的充要条件是： 对于 的任意子集 ，其在 中的邻域集合 均满足： 若二分图不一定存在完美匹配，则 的最大匹配数为： 即我们只需要最小化亏损 。 如果 中的每个点 连向 中下标在某个区间 内的点，若区间满足连续包含性，根据 Hall 定理，只需检验所有连</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Hall 婚姻定理 (Hall&apos;s Marriage Theorem)&lt;/h1&gt;
&lt;h2&gt;1. 定理内容与充要条件&lt;/h2&gt;
&lt;p&gt;设二分图 $G = (V_1, V_2, E)$，$|V_1| \le |V_2|$。$G$ 中存在包含 $V_1$ 中所有顶点的完全匹配（即最大匹配为 $|V_1|$）的&lt;strong&gt;充要条件&lt;/strong&gt;是：
对于 $V_1$ 的任意子集 $S \subseteq V_1$，其在 $V_2$ 中的邻域集合 $N(S) = {v \in V_2 \mid \exists u \in S, (u, v) \in E}$ 均满足：
$$
|N(S)| \ge |S|
$$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 广义最大匹配公式 (Hall 极值定理)&lt;/h2&gt;
&lt;p&gt;若二分图不一定存在完美匹配，则 $G$ 的最大匹配数为：
$$
\text{MaxMatch} = |V_1| - \max_{S \subseteq V_1} \bigl( |S| - |N(S)| \bigr)
$$
即我们只需要最小化亏损 $\max(|S| - |N(S)|)$。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 竞赛常见建模与算法化应用&lt;/h2&gt;
&lt;h3&gt;(1) 区间连边模型 + 线段树维护 (最常见考法，如 POI / CF 题)&lt;/h3&gt;
&lt;p&gt;如果 $V_1$ 中的每个点 $i$ 连向 $V_2$ 中下标在某个区间 $[L_i, R_i]$ 内的点，若区间满足连续包含性，根据 Hall 定理，只需检验所有&lt;strong&gt;连续区间的子集&lt;/strong&gt; $S = [l, r]$ 是否满足：
$$
|N([l, r])| \ge \sum_{i \in [l, r]} cnt_i
$$
移项后可得：
$$
|N([l, r])| - \sum_{i \in [l, r]} cnt_i \ge 0
$$
这可以用&lt;strong&gt;线段树维护区间最大子段和&lt;/strong&gt;或&lt;strong&gt;区间前缀/后缀最值&lt;/strong&gt;，在 $O(N \log N)$ 时间内完成动态插入与合法性判定，彻底避开跑 $O(V \sqrt{E})$ 网络流的复杂度瓶颈。&lt;/p&gt;
&lt;h3&gt;(2) 贪心可匹配性判定&lt;/h3&gt;
&lt;p&gt;按某种权值贪心选择匹配对象时，每加入一个元素，判断剩余未匹配集合是否依然满足 Hall 条件。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;4. 竞赛实战模板：Hall 定理 + 线段树动态区间维护&lt;/h2&gt;
&lt;p&gt;以下模板演示当左右部连边具有区间连续性质时，使用线段树动态维护 $\min(|N(S)| - |S|)$ 以快速判定是否存在完全匹配：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;
const int N = 200005;
struct Node {
    ll lmax, rmax, sum, max_val;
} tr[N &amp;lt;&amp;lt; 2];
// 线段树维护区间最大子段和 / 亏损值
void pushup(int u) {
    tr[u].sum = tr[u &amp;lt;&amp;lt; 1].sum + tr[u &amp;lt;&amp;lt; 1 | 1].sum;
    tr[u].lmax = max(tr[u &amp;lt;&amp;lt; 1].lmax, tr[u &amp;lt;&amp;lt; 1].sum + tr[u &amp;lt;&amp;lt; 1 | 1].lmax);
    tr[u].rmax = max(tr[u &amp;lt;&amp;lt; 1 | 1].rmax, tr[u &amp;lt;&amp;lt; 1 | 1].sum + tr[u &amp;lt;&amp;lt; 1].rmax);
    tr[u].max_val =
        max({tr[u &amp;lt;&amp;lt; 1].max_val, tr[u &amp;lt;&amp;lt; 1 | 1].max_val, tr[u &amp;lt;&amp;lt; 1].rmax + tr[u &amp;lt;&amp;lt; 1 | 1].lmax});
}
void build(int u, int l, int r, ll k) {
    if (l == r) {
        tr[u] = {-k, -k, -k, -k};
        return;
    }
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    build(u &amp;lt;&amp;lt; 1, l, mid, k);
    build(u &amp;lt;&amp;lt; 1 | 1, mid + 1, r, k);
    pushup(u);
}
void update(int u, int l, int r, int pos, ll val) {
    if (l == r) {
        tr[u].sum += val;
        tr[u].lmax += val;
        tr[u].rmax += val;
        tr[u].max_val += val;
        return;
    }
    int mid = (l + r) &amp;gt;&amp;gt; 1;
    if (pos &amp;lt;= mid)
        update(u &amp;lt;&amp;lt; 1, l, mid, pos, val);
    else
        update(u &amp;lt;&amp;lt; 1 | 1, mid + 1, r, pos, val);
    pushup(u);
}
// 检查是否存在完全匹配：要求所有子集的亏损不超过容许上限 limit
bool check_hall(ll limit) {
    return tr[1].max_val &amp;lt;= limit;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>KMP算法</title><link>https://sanzenin.top/posts/obsidian/kmp%E7%AE%97%E6%B3%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/kmp%E7%AE%97%E6%B3%95/</guid><description>KMP（Knuth-Morris-Pratt）算法是一种高效的字符串匹配算法。其核心精髓在于：当匹配失败时，能够利用已匹配的信息，避免模式串指针的回溯，实现“原地”跳跃。 next[i] 的定义是：模式串 P 从第 1 位到第 i 位组成的字符串中，最长公共前后缀的长度。 为何会有 j = ne[j]？ 当 P[i]</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;KMP（Knuth-Morris-Pratt）算法是一种高效的字符串匹配算法。其核心精髓在于：&lt;strong&gt;当匹配失败时，能够利用已匹配的信息，避免模式串指针的回溯，实现“原地”跳跃。&lt;/strong&gt;&lt;/p&gt;
&lt;h2&gt;1. 核心逻辑：&lt;code&gt;next&lt;/code&gt; 数组（前缀函数）&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;next[i]&lt;/code&gt; 的定义是：&lt;strong&gt;模式串 &lt;code&gt;P&lt;/code&gt; 从第 1 位到第 &lt;code&gt;i&lt;/code&gt; 位组成的字符串中，最长公共前后缀的长度。&lt;/strong&gt;&lt;/p&gt;
&lt;h3&gt;代码实现&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;// 模式串 P 从 1 开始，长度为 n
ne[1] = 0;
for (int i = 2, j = 0; i &amp;lt;= n; i++) {
    // 如果当前字符不匹配，j 持续回退到 ne[j]
    while (j &amp;amp;&amp;amp; P[i] != P[j + 1]) j = ne[j];
    // 如果匹配，最长公共前后缀长度 j 加 1
    if (P[i] == P[j + 1]) j++;
    // 记录结果
    ne[i] = j;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;为何会有 &lt;code&gt;j = ne[j]&lt;/code&gt;？&lt;/strong&gt; 当 &lt;code&gt;P[i] != P[j+1]&lt;/code&gt; 时，说明以 &lt;code&gt;i&lt;/code&gt; 结尾的匹配串出现了失配，我们需要找一个比当前 &lt;code&gt;j&lt;/code&gt; 更短的、已经处理过的后缀能与之重合的部分前缀。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 复杂度证明&lt;/h2&gt;
&lt;p&gt;这里KMP计算next数组的复杂度直观上很难分析,我们可以考虑j的贡献来分析整体的复杂度。
我们可以考虑j的总增加次数和减少次数：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;增加次数&lt;/strong&gt;：在整个 &lt;code&gt;for&lt;/code&gt; 循环中，&lt;code&gt;i&lt;/code&gt; 从 2 到 $n$。&lt;code&gt;j&lt;/code&gt; 只有在 &lt;code&gt;P[i] == P[j + 1]&lt;/code&gt; 时才会执行 &lt;code&gt;j++&lt;/code&gt;，这意味着 &lt;code&gt;j&lt;/code&gt; 在整个生命周期中&lt;strong&gt;最多增加 $n-1$ 次&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;减少次数&lt;/strong&gt;：&lt;code&gt;while&lt;/code&gt; 循环中的 &lt;code&gt;j = ne[j]&lt;/code&gt; 操作会使 &lt;code&gt;j&lt;/code&gt; 减小。因为 &lt;code&gt;j&lt;/code&gt; 的值始终大于等于 0，&lt;strong&gt;&lt;code&gt;j&lt;/code&gt; 减少的总次数不可能超过它增加的总次数&lt;/strong&gt;。
因此，总的操作开销 = $O(N) + O(N) = \mathbf{O(N)}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P16231&quot;&gt;例题 P16231 [蓝桥杯 2026 省 A] 基因研究&lt;/a&gt;
dp[i][j]的意义是第i位匹配到易感基因第j位的概率,匹配失败时需要用next数组,提前预处理出来在dp时使用&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
int n, m, cnt, vv;
const ll mod = 998244353;
int main() {
    ios::sync_with_stdio(0);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    string s;
    map&amp;lt;char, int&amp;gt; mp;
    mp[&apos;A&apos;] = 0;
    mp[&apos;T&apos;] = 1;
    mp[&apos;G&apos;] = 2;
    mp[&apos;C&apos;] = 3;
    cin &amp;gt;&amp;gt; s;
    vector&amp;lt;int&amp;gt; gene;
    gene.push_back(0);
    for (auto x : s) {
        gene.push_back(mp[x]);
    }
    vector&amp;lt;int&amp;gt; next(m + 5, 0);
    next[1] = 0;
    for (int i = 2, j = 0; i &amp;lt;= m; i++) {
        while (j &amp;amp;&amp;amp; gene[i] != gene[j + 1])
            j = next[j];
        if (gene[i] == gene[j + 1])
            j++;
        next[i] = j;
    }
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; to(m + 5, vector&amp;lt;int&amp;gt;(5, 0));
    for (int j = 0; j &amp;lt; m; j++) {
        for (int ch = 0; ch &amp;lt; 4; ch++) {
            int now = j;
            while (now &amp;amp;&amp;amp; gene[now + 1] != ch)
                now = next[now];
            if (gene[now + 1] == ch)
                now++;
            to[j][ch] = now;
        }
    }
    vector&amp;lt;ll&amp;gt; p(5, 0);
    vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt; dp(n + 5, vector&amp;lt;ll&amp;gt;(m + 5, 0));
    dp[0][0] = 1;
    for (int i = 1; i &amp;lt;= n; i++) {
        for (int j = 0; j &amp;lt; 4; j++) {
            cin &amp;gt;&amp;gt; p[j];
        }
        for (int j = 0; j &amp;lt;= min(i - 1, m - 1); j++) {
            for (int ch = 0; ch &amp;lt; 4; ch++) {
                dp[i][to[j][ch]] = (dp[i][to[j][ch]] + dp[i - 1][j] * p[ch]) % mod;
            }
        }
    }
    ll res = 0;
    for (int j = 0; j &amp;lt; m; j++)
        res = (res + dp[n][j]) % mod;
    cout &amp;lt;&amp;lt; (1 - res + mod) % mod;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Miller-Rabin 素数判定算法整理</title><link>https://sanzenin.top/posts/obsidian/miller-rabin%E7%AE%97%E6%B3%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/miller-rabin%E7%AE%97%E6%B3%95/</guid><description>Miller-Rabin 素数判定算法是可以快速判定质数的一个概率性算法,时间复杂度约为 ,远远快于试除法的 Miller-Rabin 算法是费马小定理与二次探测定理的结合，通过寻找“非平凡平方根”来从概率上判定一个数是否为合数。 如果 是素数，对于任意整数 ( )，满足： 局限性：存在“卡迈克尔数”（伪素数），它们是</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;Miller-Rabin 素数判定算法是可以快速判定质数的一个概率性算法,时间复杂度约为$O(klog(n))$,远远快于试除法的$O(\sqrt{n})$&lt;/p&gt;
&lt;h1&gt;Miller-Rabin 素数判定算法整理&lt;/h1&gt;
&lt;h2&gt;1. 核心原理&lt;/h2&gt;
&lt;p&gt;Miller-Rabin 算法是&lt;strong&gt;费马小定理&lt;/strong&gt;与&lt;strong&gt;二次探测定理&lt;/strong&gt;的结合，通过寻找“非平凡平方根”来从概率上判定一个数是否为合数。&lt;/p&gt;
&lt;h3&gt;A. 费马小定理 (基础检测)&lt;/h3&gt;
&lt;p&gt;如果 $n$ 是素数，对于任意整数 $a$ ($1 &amp;lt; a &amp;lt; n$)，满足：
$$a^{n-1} \equiv 1 \pmod n$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;局限性&lt;/strong&gt;：存在“卡迈克尔数”（伪素数），它们是合数但能通过此测试。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;B. 二次探测定理 (核心检测)&lt;/h3&gt;
&lt;p&gt;如果 $p$ 是素数，且 $x^2 \equiv 1 \pmod p$，则 $x$ 的解只有两种可能：
$$x \equiv 1 \pmod p \quad \text{或} \quad x \equiv p-1 \pmod p$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;推论&lt;/strong&gt;：如果在模 $n$ 的运算中，发现了一个数 $x$，它的平方是 1，但它自己既不是 1 也不是 $n-1$，则 $n$ &lt;strong&gt;必然是合数&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 证明&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;命题&lt;/strong&gt;：若存在 $x$ 满足 $x^2 \equiv 1 \pmod n$，且 $x \not\equiv \pm 1 \pmod n$，则 $n$ 为合数。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明步骤&lt;/strong&gt;：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;由 $x^2 \equiv 1 \pmod n$，移项得 $x^2 - 1 \equiv 0 \pmod n$。&lt;/li&gt;
&lt;li&gt;即 $n$ 整除 $(x-1)(x+1)$，记作 $n \mid (x-1)(x+1)$。&lt;/li&gt;
&lt;li&gt;根据&lt;strong&gt;欧几里得引理 (Euclid&apos;s Lemma)&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;如果 $n$ 是素数，它必须整除 $(x-1)$ 或者整除 $(x+1)$。&lt;/li&gt;
&lt;li&gt;即 $x \equiv 1 \pmod n$ 或 $x \equiv -1 \pmod n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;反证&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;如果我们发现 $x \not\equiv 1$ 且 $x \not\equiv n-1$（即 $-1$），说明 $n$ 虽然整除乘积，却无法整除任何一个因子。&lt;/li&gt;
&lt;li&gt;这违背了素数的性质（素数不可拆分）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：$n$ 必然是合数。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 算法流程&lt;/h2&gt;
&lt;p&gt;假设要判定奇数 $n$ 是否为素数。&lt;/p&gt;
&lt;h3&gt;第一步：拆解指数&lt;/h3&gt;
&lt;p&gt;将 $n-1$ 提取出所有的因子 2，表示为：
$$n - 1 = d \times 2^r$$
其中 $d$ 是奇数，$r$ 是非负整数。这一步是为了构建可以不断“开平方”的序列。&lt;/p&gt;
&lt;h3&gt;第二步：选取底数 (Witness)&lt;/h3&gt;
&lt;p&gt;选取一个（或多个）底数 $a$ ($1 &amp;lt; a &amp;lt; n$) 进行测试。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;em&gt;注：在long long范围内 ($&amp;lt; 2^{64}$)，选取固定的 {2, 3, 5, 7,11,17,37} 这一组底数可实现百分百正确判定。&lt;/em&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;第三步：序列测试 (针对每一个 $a$)&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;计算起点&lt;/strong&gt;：算出 $x = a^d \pmod n$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;初步判断&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;如果 $x = 1$ 或 $x = n-1$，则该底数测试通过（可能是素数），跳过后续步骤。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;平方探测循环&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;重复执行 $r-1$ 次平方操作：$x \leftarrow x^2 \pmod n$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;在每次平方后检查&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;若结果为 $n-1$：测试通过（找到了 -1），停止本轮，判定为“可能是素数”。&lt;/li&gt;
&lt;li&gt;若结果为 $1$：&lt;strong&gt;判定为合数&lt;/strong&gt;（触发二次探测定理，发现了非平凡平方根）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;最终审判&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;如果循环结束，$x$ 仍未变成 $n-1$，说明最终 $a^{n-1} \not\equiv 1 \pmod n$ 或者无法在最后一步前匹配到 -1。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;判定为合数&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;模板题&lt;/h3&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/3396&quot;&gt;CSES  Next Prime&lt;/a&gt;
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cin &amp;gt;&amp;gt; n;
auto mul = [&amp;amp;](ll a, ll b, ll mod) { return (ll)((__int128)a * b % mod); };
auto qp = [&amp;amp;](ll x, ll n, ll mod) {
    ll res = 1;
    while (n) {
        if (n &amp;amp; 1)
            res = mul(res, x, mod);
        x = mul(x, x, mod);
        n &amp;gt;&amp;gt;= 1;
    }
    return res;
};
auto MR = [&amp;amp;](ll x, ll d, ll r, ll p) -&amp;gt; bool {
    ll now = qp(p, d, x);
    for (int i = 0; i &amp;lt; r; i++) {
        ll tem = mul(now, now, x);
        if (tem == 1 &amp;amp;&amp;amp; now != 1 &amp;amp;&amp;amp; now != x - 1)
            return 0; // 最容易理解的写法 乘完变成1且原本不是1或-1
        now = tem;
    }
    return now == 1;
};
vector&amp;lt;ll&amp;gt; primes = {2, 3, 5, 7, 11, 13, 17, 37};
auto is_prime = [&amp;amp;](ll x) -&amp;gt; bool {
    if (x &amp;lt;= 3)
        return x == 2 || x == 3;
    if (x % 2 == 0)
        return 0;
    ll d = x - 1, r = 0;
    while (d % 2 == 0) {
        d &amp;gt;&amp;gt;= 1;
        r++;
    }
    for (auto p : primes) {
        if (p &amp;gt; x)
            continue;
        if (x == p)
            return 1;
        if (x % p == 0)
            return 0;
        if (!MR(x, d, r, p))
            return 0;
    }
    return 1;
};
while (n--) {
    ll x;
    cin &amp;gt;&amp;gt; x;
    while (x++) {
        if (is_prime(x)) {
            cout &amp;lt;&amp;lt; x &amp;lt;&amp;lt; &apos;\n&apos;;
            break;
        }
    }
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Pick定理</title><link>https://sanzenin.top/posts/obsidian/pick%E5%AE%9A%E7%90%86/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/pick%E5%AE%9A%E7%90%86/</guid><description>平面上简单多边形的面积S,其内部位于整数坐标点上点数目I,以及在边上的整点书目b,满足 1. 首先证明可加性.由假设有两个多边形 均满足Pick定理.且两个多边形有一条公共边,公共边上的点为 .我们设 .由假设得合并后多边形的内部点 ,边界点 ,带入Pick公式得 2. 首先易证得平面上的矩形都满足Pick定理,由可加</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h3&gt;Pick定理&lt;/h3&gt;
&lt;p&gt;平面上简单多边形的面积S,其内部位于整数坐标点上点数目I,以及在边上的整点书目b,满足$$S=I+\frac{b}{2}-1$$&lt;/p&gt;
&lt;h3&gt;证明(不是那么严谨)&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;首先证明可加性.由假设有两个多边形$A_1,A_2$均满足Pick定理.且两个多边形有一条公共边,公共边上的点为$k$.我们设$A=A_1 \bigcup A_2$.由假设得合并后多边形的内部点$I=I_1+I_2+k-2$,边界点$b=b_1+b_2-2&lt;em&gt;k+2$,带入Pick公式得$$S_1+S_2=I_1+\frac{b_1}{2}-1+I_2+\frac{b_2}{2}-1=(I_1+I_2+k-2)+\frac{b_1+b_2-2&lt;/em&gt;k+2}{2}-1=S$$&lt;/li&gt;
&lt;li&gt;首先易证得平面上的矩形都满足Pick定理,由可加性可得矩形的一半即直角三角形也满足Pick定理,任意三角形均可以通过矩形去掉若干直角三角形得到,则任意三角形也满足Pick定理,那么任意多边形均能划分为若干三角形,也满足Pick定理&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/2193/&quot;&gt;CSES Polygon Lattice Points&lt;/a&gt;
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 1000005
#define pr pair&amp;lt;ll, ll&amp;gt;
#define ll long long
#define inf 100000000000
using namespace std;
ll n, m, ans, x;
const ll mod = 1e9 + 7;
class Point {
  public:
    ll x = 0, y = 0;
    ll operator*(const Point &amp;amp;oth) const { return x * oth.x + y * oth.y; }
    ll mul(const Point &amp;amp;oth) const { return x * oth.y - y * oth.x; }
    Point operator+(const Point &amp;amp;oth) const { return {x + oth.x, y + oth.y}; }
    Point operator-(const Point &amp;amp;oth) { return {x - oth.x, y - oth.y}; }
};
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    vector&amp;lt;Point&amp;gt; s;
    for (int i = 1; i &amp;lt;= n; i++) {
        ll x, y;
        cin &amp;gt;&amp;gt; x &amp;gt;&amp;gt; y;
        s.push_back({x, y});
    }
    ll res1 = 0;
    ll res2 = 0;
    for (int i = 0; i &amp;lt; n; i++) {
        res1 += s[i].mul(s[(i - 1 + n) % n]);
        auto x = s[i] - s[(i - 1 + n) % n];
        res2 += gcd(abs(x.x), abs(x.y));
    }
    cout &amp;lt;&amp;lt; (abs(res1) - res2 + 2) / 2 &amp;lt;&amp;lt; &apos; &apos; &amp;lt;&amp;lt; res2;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>光线投射算法</title><link>https://sanzenin.top/posts/obsidian/%E5%85%89%E7%BA%BF%E6%8A%95%E5%B0%84%E7%AE%97%E6%B3%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%85%89%E7%BA%BF%E6%8A%95%E5%B0%84%E7%AE%97%E6%B3%95/</guid><description>如何快速判断一个点是否在一个多边形内部? 这是一个很显然的定理(但很难证明),这条定理指出,每条平面上的简单封闭曲线总是将封面划分为两个部分. 我们考虑从一个点引出一条射线,显然射线一定会到达无穷远处,即对于任意的封闭曲线,射线的终点总是会在曲线外部. 我们考虑这条从曲线内部的一点引射线穿过这条封闭曲线的次数,显然每穿</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h4&gt;引入&lt;/h4&gt;
&lt;p&gt;如何快速判断一个点是否在一个多边形内部?&lt;/p&gt;
&lt;h3&gt;若当曲线定理(Jordan Curve Theorem)&lt;/h3&gt;
&lt;p&gt;这是一个很显然的定理(但很难证明),这条定理指出,每条平面上的简单封闭曲线总是将封面划分为两个部分.&lt;/p&gt;
&lt;h4&gt;光线投射算法(Ray casting algorithm)&lt;/h4&gt;
&lt;p&gt;我们考虑从一个点引出一条射线,显然射线一定会到达无穷远处,即对于任意的封闭曲线,射线的终点总是会在曲线外部.
我们考虑这条从曲线内部的一点引射线穿过这条封闭曲线的次数,显然每穿过曲线一次,射线都会由曲线内部/曲线外部-&amp;gt;曲线外部/曲线内部.因此我们只需要判断这条射线穿过曲线的次数即可,次数为奇数则当前点在多边形内,否则在多边形外.&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/2192&quot;&gt;CSES Point in Polygon&lt;/a&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;type_traits&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#include &amp;lt;utility&amp;gt;
#define N 1000005
#define pr pair&amp;lt;ll, ll&amp;gt;
#define ll long long
#define inf 100000000000
using namespace std;
ll n, m, ans, x;
const ll mod = 1e9 + 7;
class Point {
  public:
    ll x = 0, y = 0;
    ll operator*(const Point &amp;amp;oth) const { return x * oth.x + y * oth.y; }
    ll mul(const Point &amp;amp;oth) const { return x * oth.y - y * oth.x; }
    Point operator+(const Point &amp;amp;oth) const { return {x + oth.x, y + oth.y}; }
    Point operator-(const Point &amp;amp;oth) { return {x - oth.x, y - oth.y}; }
};
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    vector&amp;lt;Point&amp;gt; pol;
    for (int i = 1; i &amp;lt;= n; i++) {
        ll a, b;
        cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b;
        pol.push_back({a, b});
    }
    auto sgn = [](ll x) {
        if (!x)
            return 0;
        return x &amp;lt; 0 ? -1 : 1;
    };
    auto check = [&amp;amp;](Point x) {
        auto check = [&amp;amp;](Point &amp;amp;a, Point &amp;amp;b, Point &amp;amp;c, Point d) {
            auto seg1 = b - a;
            auto seg2 = d - c;
            if (sgn(seg1.mul(c - a)) * sgn(seg1.mul(d - a)) &amp;lt;= 0 &amp;amp;&amp;amp;
                sgn(seg2.mul(a - c)) * sgn(seg2.mul(b - c)) &amp;lt;= 0)
                return 1;
            return 0;
        };
        Point tmp = {0, (ll)2e9 + 1000};
        int cnt = 0;
        for (int i = 0; i &amp;lt; pol.size(); i++) {
            int pre = (i - 1 + n) % n;
            if ((pol[i] - pol[pre]).mul(pol[pre] - x) == 0 &amp;amp;&amp;amp; (pol[i] - x) * (x - pol[pre]) &amp;gt;= 0)
                return -1; // 点在线段上
            if (check(x, tmp, pol[i], pol[pre]))
                cnt++;
            ;
        }
        return cnt % 2;
    };
    for (int i = 1; i &amp;lt;= m; i++) {
        ll x, y;
        cin &amp;gt;&amp;gt; x &amp;gt;&amp;gt; y;
        auto flag = check({x, y});
        if (flag == -1)
            cout &amp;lt;&amp;lt; &quot;BOUNDARY\n&quot;;
        else if (!flag)
            cout &amp;lt;&amp;lt; &quot;OUTSIDE\n&quot;;
        else
            cout &amp;lt;&amp;lt; &quot;INSIDE\n&quot;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>二维凸包 (Convex Hull - Andrew 算法)</title><link>https://sanzenin.top/posts/obsidian/%E5%87%B8%E5%8C%85/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%87%B8%E5%8C%85/</guid><description>在二维平面点集中，凸包是能够包含所有点的最小凸多边形。其顶点集是平面点集的子集，多边形内部角均小于 180 度。 Andrew 算法是 Graham 扫描法的变种，常数更优、鲁棒性更强： 1. 坐标排序：优先按 升序排序，若 相同则按 升序排序。 2. 构建下凸壳：从左往右扫描点，用单调栈维护向量叉积 （向左拐）。若出</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;二维凸包 (Convex Hull - Andrew 算法)&lt;/h1&gt;
&lt;h2&gt;1. 概念与性质&lt;/h2&gt;
&lt;p&gt;在二维平面点集中，凸包是能够包含所有点的最小凸多边形。其顶点集是平面点集的子集，多边形内部角均小于 180 度。&lt;/p&gt;
&lt;h2&gt;2. Andrew 算法流程&lt;/h2&gt;
&lt;p&gt;Andrew 算法是 Graham 扫描法的变种，常数更优、鲁棒性更强：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;坐标排序&lt;/strong&gt;：优先按 $x$ 升序排序，若 $x$ 相同则按 $y$ 升序排序。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;构建下凸壳&lt;/strong&gt;：从左往右扫描点，用单调栈维护向量叉积 $\vec{v_1} \times \vec{v_2} &amp;gt; 0$（向左拐）。若出现顺时针拐弯或共线（视是否严格凸包而定），则弹出栈顶。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;构建上凸壳&lt;/strong&gt;：从右往左倒序扫描剩余点，同样用单调栈维护左拐关系。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;闭合多边形&lt;/strong&gt;：合并上下凸壳，注意去重起点与终点。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;时间复杂度：排序 $O(N \log N)$，单调栈扫描 $O(N)$，总复杂度 $O(N \log N)$。&lt;/p&gt;
&lt;h2&gt;3. 核心模板代码 (C++)&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
using namespace std;
struct Point {
    ll x, y;
    Point operator-(const Point &amp;amp;o) const { return {x - o.x, y - o.y}; }
    ll operator^(const Point &amp;amp;o) const { return x * o.y - y * o.x; } // 叉积
    bool operator&amp;lt;(const Point &amp;amp;o) const { return x == o.x ? y &amp;lt; o.y : x &amp;lt; o.x; }
};
ll cross(Point a, Point b, Point c) {
    return (b - a) ^ (c - a);
}
vector&amp;lt;Point&amp;gt; get_convex_hull(vector&amp;lt;Point&amp;gt; &amp;amp;pts) {
    int n = pts.size();
    if (n &amp;lt;= 1)
        return pts;
    sort(pts.begin(), pts.end());
    vector&amp;lt;Point&amp;gt; hull;
    // 下凸壳
    for (int i = 0; i &amp;lt; n; i++) {
        while (hull.size() &amp;gt;= 2 &amp;amp;&amp;amp; cross(hull[hull.size() - 2], hull.back(), pts[i]) &amp;lt;= 0) {
            hull.pop_back();
        }
        hull.push_back(pts[i]);
    }
    // 上凸壳
    int t = hull.size();
    for (int i = n - 2; i &amp;gt;= 0; i--) {
        while ((int)hull.size() &amp;gt; t &amp;amp;&amp;amp; cross(hull[hull.size() - 2], hull.back(), pts[i]) &amp;lt;= 0) {
            hull.pop_back();
        }
        hull.push_back(pts[i]);
    }
    hull.pop_back(); // 起点重复计算一次
    return hull;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>半平面交 (Half-Plane Intersection)</title><link>https://sanzenin.top/posts/obsidian/%E5%8D%8A%E5%B9%B3%E9%9D%A2%E4%BA%A4/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%8D%8A%E5%B9%B3%E9%9D%A2%E4%BA%A4/</guid><description>每条有向直线左侧（或右侧）定义一个半平面。所有半平面的公共交集是一个凸多边形（或空集、无界区域）。 常用 Sutherland-Hodgman / 极角排序增量法 (双端队列) 在 内求解。 1. 极角排序：计算每条有向直线的极角 atan2(dy, dx)，按极角排序。同极角平行向量保留最靠内侧的一条。 2. 双端队</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;半平面交 (Half-Plane Intersection)&lt;/h1&gt;
&lt;h2&gt;1. 核心思想&lt;/h2&gt;
&lt;p&gt;每条有向直线左侧（或右侧）定义一个半平面。所有半平面的公共交集是一个凸多边形（或空集、无界区域）。
常用 &lt;strong&gt;Sutherland-Hodgman / 极角排序增量法 (双端队列)&lt;/strong&gt; 在 $O(N \log N)$ 内求解。&lt;/p&gt;
&lt;h2&gt;2. 算法步骤&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;极角排序&lt;/strong&gt;：计算每条有向直线的极角 &lt;code&gt;atan2(dy, dx)&lt;/code&gt;，按极角排序。同极角平行向量保留最靠内侧的一条。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;双端队列维护&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;依次考虑每条直线，若队列尾部两直线的交点在该直线右侧（外侧），弹出队尾。&lt;/li&gt;
&lt;li&gt;同样检查队首两直线的交点是否在当前直线外侧，弹出队首。&lt;/li&gt;
&lt;li&gt;当前直线入队。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;闭合收尾&lt;/strong&gt;：用队首约束更新队尾，最后计算相邻直线两两交点即得凸多边形顶点。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;3. 核心模板代码 (C++)&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
const double EPS = 1e-9;
struct Point {
    double x, y;
    Point operator+(const Point &amp;amp;o) const { return {x + o.x, y + o.y}; }
    Point operator-(const Point &amp;amp;o) const { return {x - o.x, y - o.y}; }
    Point operator*(double k) const { return {x * k, y * k}; }
};
double cross(Point a, Point b) {
    return a.x * b.y - a.y * b.x;
}
double cross3(Point a, Point b, Point c) {
    return cross(b - a, c - a);
}
struct Line {
    Point p, v; // p + t * v
    double ang;
    Line() {}
    Line(Point p, Point v) : p(p), v(v), ang(atan2(v.y, v.x)) {}
    bool operator&amp;lt;(const Line &amp;amp;o) const { return ang &amp;lt; o.ang; }
};
Point line_intersection(Line a, Line b) {
    Point u = a.p - b.p;
    double t = cross(b.v, u) / cross(a.v, b.v);
    return a.p + a.v * t;
}
bool on_right(Line l, Point p) {
    return cross(l.v, p - l.p) &amp;lt; -EPS;
}
vector&amp;lt;Point&amp;gt; half_plane_intersection(vector&amp;lt;Line&amp;gt; &amp;amp;lines) {
    sort(lines.begin(), lines.end());
    vector&amp;lt;Line&amp;gt; q(lines.size() + 5);
    int head = 0, tail = 0;
    q[0] = lines[0];
    for (int i = 1; i &amp;lt; (int)lines.size(); i++) {
        while (head &amp;lt; tail &amp;amp;&amp;amp; on_right(lines[i], line_intersection(q[tail], q[tail - 1])))
            tail--;
        while (head &amp;lt; tail &amp;amp;&amp;amp; on_right(lines[i], line_intersection(q[head], q[head + 1])))
            head++;
        q[++tail] = lines[i];
    }
    while (head &amp;lt; tail &amp;amp;&amp;amp; on_right(q[head], line_intersection(q[tail], q[tail - 1])))
        tail--;
    while (head &amp;lt; tail &amp;amp;&amp;amp; on_right(q[tail], line_intersection(q[head], q[head + 1])))
        head++;
    if (tail - head + 1 &amp;lt; 3)
        return {}; // 空集或退化
    vector&amp;lt;Point&amp;gt; poly;
    for (int i = head; i &amp;lt; tail; i++)
        poly.push_back(line_intersection(q[i], q[i + 1]));
    poly.push_back(line_intersection(q[tail], q[head]));
    return poly;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>卡特兰数</title><link>https://sanzenin.top/posts/obsidian/%E5%8D%A1%E7%89%B9%E5%85%B0%E6%95%B0/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%8D%A1%E7%89%B9%E5%85%B0%E6%95%B0/</guid><description>更详细的内容可以参考[[Tutorial] Catalan Numbers and Catalan Convolution](https://codeforces.com/blog/entry/87585) 以走网格为例，从格点 走到格点 ，只能向右或向上走，并且不能越过对角线的路径的条数，就是卡特兰数，记为 。 (1</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;更详细的内容可以参考&lt;a href=&quot;https://codeforces.com/blog/entry/87585&quot;&gt;[Tutorial] Catalan Numbers and Catalan Convolution&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;卡特兰数 (Catalan)&lt;/h3&gt;
&lt;p&gt;以走网格为例，从格点 $(0,0)$ 走到格点 $(n, n)$，只能&lt;strong&gt;向右或向上&lt;/strong&gt;走，并且不能越过对角线的路径的条数，就是卡特兰数，记为 $H_n$。&lt;/p&gt;
&lt;h4&gt;通项公式&lt;/h4&gt;
&lt;p&gt;(1) $H_n = C_{2n}^n - C_{2n}^{n-1}$
(2) $H_n = \frac{1}{n+1} C_{2n}^n$
(3) $H_n = \frac{4n-2}{n+1} H_{n-1}$&lt;/p&gt;
&lt;h4&gt;证明(1)式&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;先求路径总数&lt;/strong&gt;：在 $2n$ 次移动中选 $n$ 次向右移动，即 $C_{2n}^n$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;再求非法路径&lt;/strong&gt;：即越过对角线的路径。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;反射原理&lt;/strong&gt;：把 $y = x + 1$ 这条线画出来，碰到即说明是一条非法路径。
所有的非法路径与这条线有至少一个交点，把第一个交点设为 $(a, a+1)$，把 $(a, a+1)$ 之后的路径全部按照 $y = x + 1$ 这条线对称过去。这样，最后的终点就会变成 $(n-1, n+1)$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：所有非法路径对称后都唯一对应着一条到 $(n-1, n+1)$ 的路径，所以非法路径数就是 $C_{2n}^{n-1}$，合法路径数就是 $C_{2n}^n - C_{2n}^{n-1}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;证明(2)式&lt;/h4&gt;
&lt;p&gt;$$
\begin{aligned}
H_n &amp;amp;= C_{2n}^n - C_{2n}^{n-1} = \frac{(2n)!}{n! n!} - \frac{(2n)!}{(n+1)! (n-1)!} \
&amp;amp;= \frac{(2n)!}{n! (n-1)!} \left( \frac{1}{n} - \frac{1}{n+1} \right) = \frac{(2n)!}{n! n! (n+1)} = \frac{1}{n+1} C_{2n}^n
\end{aligned}
$$&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Pasted%20image%2020260120163550.png&quot; alt=&quot;Pasted image 20260120163550&quot; /&gt;&lt;/p&gt;
&lt;h5&gt;卡特兰数的特征&lt;/h5&gt;
&lt;p&gt;一旦出现类似二叉树数量的递归定义,或是一种操作数不能超过另一种操作的操作数,大概率是卡特兰数&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;卡特兰数应用&lt;/h3&gt;
&lt;p&gt;求解下面的合法数量&lt;/p&gt;
&lt;h4&gt;1. 0和1组成的字串（任一前缀中 0 的个数 $\ge$ 1）&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;推导&lt;/strong&gt;：这可以直接映射为&lt;strong&gt;网格路径问题&lt;/strong&gt;。
&lt;ul&gt;
&lt;li&gt;令 0 代表“向右走一步”，1 代表“向上走一步”。&lt;/li&gt;
&lt;li&gt;共有 $n$ 个 0 和 $n$ 个 1，意味着从 $(0,0)$ 走到 $(n,n)$。&lt;/li&gt;
&lt;li&gt;“前缀中 0 的个数 $\ge$ 1 的个数”意味着在路径的任何时刻，向右的步数都不小于向上的步数，即路径始终在 $y=x$ 这条线的下方（或接触）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：这就是卡特兰数的标准定义模型，方案数为 $H_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;2. $n$ 组括号的合法运算式&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;推导&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;将左括号 &lt;code&gt;(&lt;/code&gt; 看作数字 0，右括号 &lt;code&gt;)&lt;/code&gt; 看作数字 1。&lt;/li&gt;
&lt;li&gt;合法的括号表达式要求：在任意位置，左括号的数量必须大于等于右括号的数量（否则会出现未匹配的右括号）。&lt;/li&gt;
&lt;li&gt;这与问题 1 的 0-1 字符串约束完全一致。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：方案数为 $H_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;3. 栈的出栈序列&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;推导&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;在操作过程中，我们一共要执行 $n$ 次“入栈”和 $n$ 次“出栈”。&lt;/li&gt;
&lt;li&gt;令入栈为 0，出栈为 1。&lt;/li&gt;
&lt;li&gt;约束条件：在任何时刻，已经出栈的元素个数不能超过已经入栈的元素个数（栈空了就没法出栈）。&lt;/li&gt;
&lt;li&gt;这再次回到了 0-1 字符串的路径模型。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：方案数为 $H_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;4. $n$ 个结点构造二叉树&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;推导&lt;/strong&gt;（递归法）：
&lt;ul&gt;
&lt;li&gt;设 $H_n$ 为 $n$ 个结点的二叉树数量。&lt;/li&gt;
&lt;li&gt;固定一个结点作为&lt;strong&gt;根结点&lt;/strong&gt;，剩下的 $n-1$ 个结点分配给左子树和右子树。&lt;/li&gt;
&lt;li&gt;若左子树分配 $k$ 个结点，则右子树有 $(n-1-k)$ 个结点。&lt;/li&gt;
&lt;li&gt;根据乘法原理，形态数为 $H_k \times H_{n-1-k}$。&lt;/li&gt;
&lt;li&gt;遍历 $k$ 的所有可能值 ($0 \le k \le n-1$)，得到递推式：$H_n = \sum_{k=0}^{n-1} H_k H_{n-1-k}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：这是卡特兰数的标准递归定义，方案数为 $H_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;5. 圆上 $2n$ 个点连成 $n$ 条不相交弦&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;推导&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;任选一个点 $P_1$，它必须连接到另一个点 $P_i$。&lt;/li&gt;
&lt;li&gt;为了使剩下的点能成对且不与弦 $P_1P_i$ 相交，这条弦必须将圆周剩下的 $2n-2$ 个点分成两部分，且每部分点的个数必须是&lt;strong&gt;偶数&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;设 $P_1$ 连接到 $P_{2k+2}$，则一边有 $2k$ 个点，另一边有 $2n-2-2k$ 个点。&lt;/li&gt;
&lt;li&gt;这就转化成了两个规模更小的同类子问题：$H_k$ 和 $H_{n-1-k}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：其递推式与二叉树一致，方案数为 $H_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;6. 多边形三角剖分&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;问题描述&lt;/strong&gt;：通过不相交的对角线将 $(n+2)$ 边凸多边形分割成 $n$ 个三角形。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;推导&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;固定多边形的一条边作为底边。&lt;/li&gt;
&lt;li&gt;选择除了底边端点外的任意一个顶点 $V$ 与底边构成一个三角形。&lt;/li&gt;
&lt;li&gt;这个三角形将原多边形分割成了两个较小的多边形（左边一个 $k+2$ 边形，右边一个 $(n-k+1)+1$ 边形）。&lt;/li&gt;
&lt;li&gt;累加所有顶点的选择情况，其递推结构同样符合卡特兰数。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：对于 $(n+2)$ 边形，剖分方案数为 $H_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P1044&quot;&gt; P1044 [NOIP 2003 普及组] 栈&lt;/a&gt;
超级裸的板子
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#define ll long long
#define N 10005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
ll n, ans, m, cnt, vv, p;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    vector&amp;lt;unsigned long long&amp;gt; f(100, 0);
    f[0] = 1;
    for (unsigned long long i = 1; i &amp;lt;= 20; i++) {
        f[i] = (4 * i - 2) * f[i - 1] / (i + 1);
    }
    cin &amp;gt;&amp;gt; n;
    cout &amp;lt;&amp;lt; f[n];
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;进阶卡特兰数：广义与卷积&lt;/h3&gt;
&lt;p&gt;当问题不再是标准的“从0开始到0结束”，而是增加了“&lt;strong&gt;开局自带 $k$ 个左括号&lt;/strong&gt;”或“&lt;strong&gt;需要分成 $k+1$ 个部分&lt;/strong&gt;”的限制时，我们需要使用广义卡特兰数。&lt;/p&gt;
&lt;h4&gt;1. 问题模型：带 $k$ 个前缀的合法序列&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;场景&lt;/strong&gt;：你需要构造一个合法的括号序列。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;限制&lt;/strong&gt;：序列必须以 $k$ 个左括号开头（或者题目给出的前缀导致当前左括号比右括号多 $k$ 个）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;任务&lt;/strong&gt;：在剩余的位置中，填入 $n$ 个左括号和 $n+k$ 个右括号，使得整个序列合法（最终左括号总数 = 右括号总数，且任意前缀左 $\ge$ 右）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;记号&lt;/strong&gt;：记为 $C_n^{(k)}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;2. 通项公式&lt;/h4&gt;
&lt;p&gt;$$ C_n^{(k)} = \binom{2n+k}{n} - \binom{2n+k}{n-1} $$
化简后可得：
$$ C_n^{(k)} = \frac{k+1}{n+k+1} \binom{2n+k}{n} $$&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;注意&lt;/strong&gt;：当 $k=0$ 时，公式变回普通卡特兰数 $H_n = \frac{1}{n+1}\binom{2n}{n}$。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h4&gt;3. 证明：广义反射原理 (Reflection Principle)&lt;/h4&gt;
&lt;p&gt;依然使用网格路径模型，但&lt;strong&gt;死亡线&lt;/strong&gt;发生了平移。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;初始状态&lt;/strong&gt;：因为开局自带 $k$ 个左括号（相当于有 $k$ 个“复活币”），只有当右括号数量比左括号数量&lt;strong&gt;多出 $k+1$ 个&lt;/strong&gt;时，路径才非法。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;死亡线&lt;/strong&gt;：从 $y = x+1$ 变为 &lt;strong&gt;$y = x + k + 1$&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;坐标变换&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;起点：$(0,0)$。&lt;/li&gt;
&lt;li&gt;终点：$(n, n+k)$ （$n$ 步向右，$n+k$ 步向上）。&lt;/li&gt;
&lt;li&gt;总路径数：$\binom{2n+k}{n}$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;镜像反射&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;非法路径一定触碰 $y = x + k + 1$。&lt;/li&gt;
&lt;li&gt;将第一次触碰点之后的路径关于该直线对称。&lt;/li&gt;
&lt;li&gt;原终点 $(n, n+k)$ 对称后的新终点为 &lt;strong&gt;$(n-1, n+k+1)$&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结论&lt;/strong&gt;：
$$ \text{合法数} = \binom{2n+k}{n} - \binom{2n+k}{n-1} $$&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;4. 结构意义：卡特兰卷积&lt;/h4&gt;
&lt;p&gt;为什么这种形式被称为卷积？
考虑 $k=2$ 的情况，强制开头为 &lt;code&gt;((&lt;/code&gt;。这相当于把整个序列被这两个强制的左括号分割成了三个独立的部分（外层、中层、内层）：
$$ ( \quad ( \quad \text{Part A} \quad ) \quad \text{Part B} \quad ) \quad \text{Part C} $$
总方案数等于将 $n$ 个空闲的括号对分配给 A、B、C 三个区域的方案之和：
$$ C_n^{(2)} = \sum_{a+b+c=n} H_a \times H_b \times H_c $$
这就是卡特兰数列的 &lt;strong&gt;$k$ 次卷积&lt;/strong&gt;。&lt;/p&gt;
&lt;h4&gt;递推公式&lt;/h4&gt;
&lt;p&gt;$$C_n^{(k)}=C_{n−1}^{(k)}\frac{(2n+k)(2n+k−1)}{n(n+k+1)}$$&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/2187&quot;&gt;CSES Bracket Sequences II&lt;/a&gt;
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits / stdc++.h&amp;gt;
#define N 1000005
#define inf 0x3f3f3f3f3f3f3f3f
#define ll long long
#define pr pair&amp;lt;int, int&amp;gt;
#define i128 __int128
using namespace std;
ll n, m, q;
const ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    vector&amp;lt;ll&amp;gt; f(N, 0);
    auto qp = [&amp;amp;](ll x, ll n) {
        ll res = 1;
        while (n) {
            if (n &amp;amp; 1)
                res = (res * x) % mod;
            x = (x * x) % mod;
            n &amp;gt;&amp;gt;= 1;
        }
        return res;
    };
    cin &amp;gt;&amp;gt; n;
    string s;
    cin &amp;gt;&amp;gt; s;
    n -= s.length();
    int k = 0;
    for (auto x : s) {
        if (x == &apos;(&apos;)
            k++;
        else
            k--;
        if (k &amp;lt; 0) {
            cout &amp;lt;&amp;lt; 0;
            return 0;
        }
    }
    n -= k;
    if (n &amp;lt; 0) {
        cout &amp;lt;&amp;lt; 0;
        return 0;
    }
    auto init = [&amp;amp;]() {
        f[0] = 1;
        for (int i = 1; i &amp;lt; N; i++) {
            f[i] = (((f[i - 1] * (2 * i + k)) % mod * (2 * i + k - 1)) % mod * qp(i, mod - 2)) %
                   mod * qp(i + k + 1, mod - 2) % mod;
        }
    };
    init();
    if (n % 2)
        cout &amp;lt;&amp;lt; 0;
    else
        cout &amp;lt;&amp;lt; f[n / 2];
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>可持久化左偏树</title><link>https://sanzenin.top/posts/obsidian/%E5%8F%AF%E6%8C%81%E4%B9%85%E5%8C%96%E5%B7%A6%E5%81%8F%E6%A0%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%8F%AF%E6%8C%81%E4%B9%85%E5%8C%96%E5%B7%A6%E5%81%8F%E6%A0%91/</guid><description>假设我们要合并分别以 为根节点的两棵左偏树，且维护的左偏树满足小根堆的性质： 1. 若为空则返回：如果 中有结点为空，返回 。 2. 确定根节点：选择 两结点中权值更小的结点，作为合并后左偏树的根。 3. 递归合并：递归合并 的右子树与 ，将合并后的根节点作为 的右儿子。 4. 维护性质：维护当前合并后左偏树的左偏性质</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h2&gt;1. 回顾左偏树的合并过程&lt;/h2&gt;
&lt;p&gt;假设我们要合并分别以 $x, y$ 为根节点的两棵左偏树，且维护的左偏树满足&lt;strong&gt;小根堆&lt;/strong&gt;的性质：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;若为空则返回&lt;/strong&gt;：如果 $x, y$ 中有结点为空，返回 $x + y$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;确定根节点&lt;/strong&gt;：选择 $x, y$ 两结点中权值更小的结点，作为合并后左偏树的根。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;递归合并&lt;/strong&gt;：递归合并 $x$ 的右子树与 $y$，将合并后的根节点作为 $x$ 的右儿子。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;维护性质&lt;/strong&gt;：维护当前合并后左偏树的左偏性质，维护 &lt;code&gt;dist&lt;/code&gt; 值，返回选择的根节点。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;时间复杂度分析&lt;/h3&gt;
&lt;p&gt;由于每次递归都会使 &lt;code&gt;dist[x] + dist[y]&lt;/code&gt; 减少一，而 &lt;code&gt;dist[x]&lt;/code&gt; 是 $O(\log n)$ 的，一次最多只会修改 $O(\log n)$ 个结点，所以这样操作的时间复杂度是 &lt;strong&gt;$O(\log n)$&lt;/strong&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 可持久化左偏树&lt;/h2&gt;
&lt;p&gt;可持久化要求保留历史信息，使得之后能够访问之前的版本。要将左偏树可持久化，就要将其沿途修改的路径复制一遍（路径复制）。&lt;/p&gt;
&lt;h3&gt;可持久化合并过程&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;若为空则返回&lt;/strong&gt;：如果 $x, y$ 中有结点为空，返回 $x + y$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;新建副本&lt;/strong&gt;：选择 $x, y$ 两结点中权值更小的结点，&lt;strong&gt;新建该结点的一个复制 $p$&lt;/strong&gt;，作为合并后左偏树的根。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;递归合并&lt;/strong&gt;：递归合并 $p$ 的右子树与 $y$，将合并后的根节点作为 $p$ 的右儿子。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;维护性质&lt;/strong&gt;：维护以 $p$ 为根的左偏树的左偏性质，维护其 &lt;code&gt;dist&lt;/code&gt; 值，返回 $p$。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;复杂度分析&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;空间与时间复杂度&lt;/strong&gt;：由于左偏树一次合并最多只会修改并新建 $O(\log n)$ 个结点，设操作次数为 $m$，则可持久化左偏树的时间复杂度和空间复杂度均为 &lt;strong&gt;$O(m \log n)$&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;复制于OIWIKI&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P2483&quot;&gt;P2483 【模板】k 短路 / [SDOI2010] 魔法猪学院&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;原始的A*算法为,我们对于每条路径,先后扩展之后都按照估价函数压入优先队列中,会发现其中许多路径具有重叠部分,每次扩展都会再次被压入,极大浪费了空间和时间,因此我们将问题进行一个转化.
考虑一个任意一条从起点s到t的一条路径,这条路径一定是经过若干最短路树上的边和非最短路树上的边,显然如果全走最短路树上的边一定是最短路,同时任意两点之间也一定存在一条非最短路树上的路径(树上的路径唯一性),形式化的,一条任意路径可以由一个边序列如下描述:
$$e_1,e_2,e_3\dots e_k $$&lt;/p&gt;
&lt;p&gt;$\text{ s.t.}$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$e_i$不在最短路上&lt;/li&gt;
&lt;li&gt;$\forall i$,$e_i=(u_i,v_i)$,$e_{i+1}=(u_{i+1},v_{i+1})$,$u_{i+1}$在最短路树上是$u_i$的祖先
我们令$\delta (e_i)=w_{e_i}-(dis(u)-dis(v))$,那么这条路径的长度$len=\sum\delta(e_i)$
我们在每个结点都开一个堆,存储从这个结点出发的所有非最短路上的边,在堆内按照$\delta$排序,那么对于当前的序列$e_1,e_2,e_3\dots e_k$,我们有两种扩展方式:&lt;/li&gt;
&lt;li&gt;移动到$v_k$所在堆并取出最大元素 $e_{k+1}$ ,序列变成$e_1,e_2,e_3\dots e_k,e_{k+1}$&lt;/li&gt;
&lt;li&gt;将当前序列的末尾元素替换,已知当前序列在$v_{k-1}$所在堆,继续取出更大的非树边替换掉末尾元素,序列变成$e_1,e_2,e_3\dots e&apos;_k$
能保证不重不漏的扩展出所有状态.&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;queue&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 4000005
#define MAX 5005
#define inf 2e12
#define pr pair&amp;lt;ll, int&amp;gt;
using namespace std;
ll k, n, q, m, ans;
ll E;
class mergeable_heap {
  public:
    struct node {
        ll val = 0;
        int ls = 0, rs = 0, dis = 0, pos = 0;
    } tr[N];
    int id = 0;
    mergeable_heap() { tr[0] = {0, 0, 0, -1, 0}; }
    int new_(pr x) {
        tr[++id].val = x.first;
        tr[id].pos = x.second; // 注意不要++两次
        return id;
    }
    int clone(int x) {
        tr[++id] = tr[x];
        return id;
    }
#define lc tr[x]
    .ls
#define rc tr[x]
        .rs int
        merge(int x, int y) {
        if (!x || !y)
            return x + y;
        if (make_pair(tr[x].val, x) &amp;gt; make_pair(tr[y].val, y))
            swap(x, y);
        x = clone(x);
        rc = merge(rc, y);
        if (tr[lc].dis &amp;lt; tr[rc].dis)
            swap(lc, rc);
        tr[x].dis = tr[rc].dis + 1;
        return x;
    }
    int del(int x) { return merge(lc, rc); }
    auto get_val(int x) { return tr[x].val; }
#undef lc
#undef rc
} mh;
vector&amp;lt;vector&amp;lt;tuple&amp;lt;int, ll, int&amp;gt;&amp;gt;&amp;gt; rev_map1;
vector&amp;lt;vector&amp;lt;tuple&amp;lt;int, ll, int&amp;gt;&amp;gt;&amp;gt; map1;
vector&amp;lt;int&amp;gt; pre;
vector&amp;lt;int&amp;gt; root;
vector&amp;lt;ll&amp;gt; dis;
vector&amp;lt;tuple&amp;lt;int, int, ll&amp;gt;&amp;gt; edges;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    long double ee;
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m &amp;gt;&amp;gt; ee;
    E = (ll)(ee * (10000.0) + 0.5);
    rev_map1.assign(n + 5, {});
    map1.assign(n + 5, {});
    dis.assign(n + 5, inf);
    root.assign(n + 5, 0);
    pre.assign(n + 5, -1);
    for (int i = 1; i &amp;lt;= m; i++) {
        ll a, b, c;
        long double cc;
        cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b &amp;gt;&amp;gt; cc;
        c = (ll)(cc * (10000.0) + 0.5);
        edges.push_back({a, b, c});
        rev_map1[b].push_back({a, c, edges.size() - 1});
        map1[a].push_back({b, c, edges.size() - 1});
    }
    auto dij = [&amp;amp;](int st) {
        vector&amp;lt;bool&amp;gt; vis(n + 5, 0);
        priority_queue&amp;lt;pr&amp;gt; q;
        q.push({0, st});
        dis[st] = 0;
        while (q.size()) {
            auto [_, x] = q.top();
            q.pop();
            if (vis[x])
                continue;
            vis[x] = 1;
            for (auto [v, w, id] : rev_map1[x]) {
                if (dis[v] &amp;gt; dis[x] + w) {
                    dis[v] = dis[x] + w;
                    pre[v] = id;
                    q.push({-dis[v], v});
                }
            }
        }
    };
    dij(n);
    vector&amp;lt;ll&amp;gt; s;
    for (int i = 1; i &amp;lt;= n; i++)
        s.push_back(i);
    sort(s.begin(), s.end(), [&amp;amp;](int x, int y) { return dis[x] &amp;lt; dis[y]; });
    auto build = [&amp;amp;]() {
        for (auto now : s) {
            if (dis[now] &amp;gt;= inf || now == n)
                continue; // 很重要!!改了半天才发现这里的问题,到达n之后就不需要再往祖先走了
            if (pre[now] != -1) {
                int from = get&amp;lt;1&amp;gt;(edges[pre[now]]);
                root[now] = root[from];
            }
            for (auto [v, w, id] : map1[now]) {
                if (id == pre[now])
                    continue;
                root[now] = mh.merge(root[now], mh.new_({w - dis[now] + dis[v], id}));
            }
        }
    };
    build();
#define lc mh.tr[rt]
    .ls
#define rc mh.tr[rt]
        .rs auto astar = [&amp;amp;](int st) {
        priority_queue&amp;lt;pr&amp;gt; q;
        if (dis[st] &amp;lt; inf &amp;amp;&amp;amp; E &amp;gt;= dis[st]) {
            E -= dis[st];
            ans++;
            if (root[st])
                q.push({-(dis[st] + mh.get_val(root[st])), root[st]});
        }
        while (q.size()) {
            auto [cost, rt] = q.top();
            cost = -cost;
            q.pop();
            if (cost &amp;gt; E)
                break;
            E -= cost;
            ans++;
            if (lc) {
                q.push({-(cost - mh.get_val(rt) + mh.get_val(lc)), lc});
            }
            if (rc) {
                q.push({-(cost - mh.get_val(rt) + mh.get_val(rc)), rc});
            }
            int v = get&amp;lt;1&amp;gt;(edges[mh.tr[rt].pos]);
            if (root[v]) {
                q.push({-(cost + mh.get_val(root[v])), root[v]});
            }
        }
    };
    astar(1);
    cout &amp;lt;&amp;lt; ans;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>状压 DP 求解哈密顿路径 (Hamiltonian Path)</title><link>https://sanzenin.top/posts/obsidian/%E5%93%88%E5%AF%86%E9%A1%BF%E8%B7%AF%E5%BE%84/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%93%88%E5%AF%86%E9%A1%BF%E8%B7%AF%E5%BE%84/</guid><description>哈密顿路径是经过图中每个顶点恰好一次的路径。该问题为 NP-Hard，在竞赛中顶点数通常较小（ ），标准解法为状态压缩动态规划。 - 状态表示： 表示当前经过的节点集合为二进制掩码 、当前停留在节点 的方案数或最短路径长度。 - 状态转移：枚举 的出边 ，若 不在集合中（即 ）： - 时间复杂度： ，空间复杂度： 。</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;状压 DP 求解哈密顿路径 (Hamiltonian Path)&lt;/h1&gt;
&lt;h2&gt;1. 核心原理&lt;/h2&gt;
&lt;p&gt;哈密顿路径是经过图中每个顶点恰好一次的路径。该问题为 NP-Hard，在竞赛中顶点数通常较小（$n \le 20$），标准解法为状态压缩动态规划。&lt;/p&gt;
&lt;h2&gt;2. 状态设计与转移&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;状态表示：$dp(mask, u)$ 表示当前经过的节点集合为二进制掩码 $mask$、当前停留在节点 $u$ 的方案数或最短路径长度。&lt;/li&gt;
&lt;li&gt;状态转移：枚举 $u$ 的出边 $(u, v)$，若 $v$ 不在集合中（即 $(mask &amp;amp; (1 \ll v)) == 0$）：
$$
dp(mask \mid (1 \ll v), v) = (dp(mask \mid (1 \ll v), v) + dp(mask, u)) \bmod MOD
$$&lt;/li&gt;
&lt;li&gt;时间复杂度：$O(2^n \cdot n^2)$，空间复杂度：$O(2^n \cdot n)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;3. 实战模板代码 (CSES Hamiltonian Flights)&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
const int MOD = 1e9 + 7;
int n, m;
vector&amp;lt;int&amp;gt; adj[21];
int dp[1 &amp;lt;&amp;lt; 20][20];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    for (int i = 0; i &amp;lt; m; i++) {
        int u, v;
        cin &amp;gt;&amp;gt; u &amp;gt;&amp;gt; v;
        --u;
        --v;
        adj[u].push_back(v);
    }
    dp[1][0] = 1; // 从起点 0 开始，集合为 {0} (mask = 1)
    for (int mask = 1; mask &amp;lt; (1 &amp;lt;&amp;lt; n); mask++) {
        // 剪枝：若终点 n-1 提前被访问且未走完所有点，跳过
        if ((mask &amp;amp; (1 &amp;lt;&amp;lt; (n - 1))) &amp;amp;&amp;amp; mask != (1 &amp;lt;&amp;lt; n) - 1)
            continue;
        for (int u = 0; u &amp;lt; n; u++) {
            if (!dp[mask][u])
                continue;
            for (int v : adj[u]) {
                if (!(mask &amp;amp; (1 &amp;lt;&amp;lt; v))) {
                    int next_mask = mask | (1 &amp;lt;&amp;lt; v);
                    dp[next_mask][v] = (dp[next_mask][v] + dp[mask][u]) % MOD;
                }
            }
        }
    }
    cout &amp;lt;&amp;lt; dp[(1 &amp;lt;&amp;lt; n) - 1][n - 1] &amp;lt;&amp;lt; &apos;
&apos;; return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>字符串哈希</title><link>https://sanzenin.top/posts/obsidian/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%93%88%E5%B8%8C/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%93%88%E5%B8%8C/</guid><description>给定一个仅含小写英文字母的字符串 ，将其划分为若干非空子串 ，满足 称该划分为 palindromic，当且仅当把每个 看作一个原子后，序列 本身是回文的，即 要求输出最大的可能 。 输入第一行为测试组数 ，随后 行每行一个字符串 。约束为 ， 。 样例： | 输入 | 输出 | |------|------| | b</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;字符串哈希&lt;/h1&gt;
&lt;h2&gt;题目重述&lt;/h2&gt;
&lt;p&gt;给定一个仅含小写英文字母的字符串 $s$，将其划分为若干非空子串 $a_1,a_2,\dots,a_d$，满足&lt;/p&gt;
&lt;p&gt;$$
s = a_1 + a_2 + \dots + a_d .
$$&lt;/p&gt;
&lt;p&gt;称该划分为 &lt;strong&gt;palindromic&lt;/strong&gt;，当且仅当把每个 $a_i$ 看作一个原子后，序列 $a_1,a_2,\dots,a_d$ 本身是回文的，即&lt;/p&gt;
&lt;p&gt;$$
a_i = a_{d+1-i}, \qquad 1 \le i \le d .
$$&lt;/p&gt;
&lt;p&gt;要求输出最大的可能 $d$。&lt;/p&gt;
&lt;p&gt;输入第一行为测试组数 $t$，随后 $t$ 行每行一个字符串 $s$。约束为 $1 \le t \le 10$，$1 \le |s| \le 10^6$。&lt;/p&gt;
&lt;p&gt;样例：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;输入&lt;/th&gt;
&lt;th&gt;输出&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;bonobo&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;$3$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;deleted&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;$5$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;racecar&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;$7$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;racecars&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;$1$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;关键观察&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;观察 1.&lt;/strong&gt; 在任意 palindromic 划分中，最左侧的 chunk 与最右侧的 chunk 必须完全相同；同理，第 $i$ 个 chunk 必须等于倒数第 $i$ 个 chunk。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明.&lt;/strong&gt; 由 palindromic 划分的定义，chunk 序列作为原子序列是回文，故对称位置上的原子相等。$\blacksquare$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;观察 2.&lt;/strong&gt; 为最大化 chunk 数量，应反复取当前字符串两端能够匹配的最短相等前后缀作为最外层 chunk，然后对剩余中间子串继续该过程。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;证明.&lt;/strong&gt; 设当前子串为 $s[l\dots r]$，某合法划分的最外层 chunk 长度为 $L$。若存在更短的可匹配长度 $L&apos; &amp;lt; L$，将最外层换成长度为 $L&apos;$ 的相等前后缀后，中间剩余子串长度从 $r-l+1-2L$ 增加到 $r-l+1-2L&apos;$，而划分出的外层 chunk 数量不变。更长的中间子串至多不会减少其内部可划分出的 chunk 数，因此总 chunk 数不会变少。$\blacksquare$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;观察 3.&lt;/strong&gt; 若能在 $O(1)$ 时间内判断任意两个子串是否相等，则上述贪心过程可在 $O(n)$ 总时间内完成。&lt;/p&gt;
&lt;h2&gt;解析&lt;/h2&gt;
&lt;h3&gt;进制视角下的字符串哈希&lt;/h3&gt;
&lt;p&gt;将每个字符映射为一个数字，例如 &lt;code&gt;&apos;a&apos; \to 1, &apos;b&apos; \to 2, \dots, &apos;z&apos; \to 26&lt;/code&gt;。字符串 $s[1\dots k]$ 可视为一个以 $B$ 为基数的“大数”：&lt;/p&gt;
&lt;p&gt;$$
H(s[1\dots k]) = s_1 \cdot B^{k-1} + s_2 \cdot B^{k-2} + \dots + s_{k-1} \cdot B + s_k .
$$&lt;/p&gt;
&lt;p&gt;该值通常过大，因此对其取模 $M$：&lt;/p&gt;
&lt;p&gt;$$
H(s[1\dots k]) \pmod M .
$$&lt;/p&gt;
&lt;p&gt;预处理前缀哈希：&lt;/p&gt;
&lt;p&gt;$$
pre[i] = \bigl(pre[i-1] \cdot B + s_i\bigr) \bmod M .
$$&lt;/p&gt;
&lt;p&gt;同时预处理基数的幂次 $pw[i] = B^i \bmod M$。则任意区间 $[l,r]$ 的哈希值可如下截取：&lt;/p&gt;
&lt;p&gt;$$
H(s[l\dots r]) = \bigl(pre[r] - pre[l-1] \cdot pw[r-l+1]\bigr) \bmod M .
$$&lt;/p&gt;
&lt;p&gt;这正类似于从一个大数中截取连续若干位：先将前缀 $[1,l-1]$ 左移到高位，再整体减去，剩余部分即为区间 $[l,r]$ 对应的数值。&lt;/p&gt;
&lt;h3&gt;贪心双指针过程&lt;/h3&gt;
&lt;p&gt;维护左指针 $l$ 与右指针 $r$，以及当前待匹配长度 $len$：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;len = 0, cnt = 0
for l = 1, r = n; l &amp;lt;= n/2; ++l, --r:
    ++len
    if H(l-len+1, l) == H(r, r+len-1):
        cnt += 2
        len = 0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;循环结束后，若 $len &amp;gt; 0$ 或 $n$ 为奇数，则中间剩余字符单独构成一个 chunk，故 $cnt \leftarrow cnt + 1$。&lt;/p&gt;
&lt;h3&gt;正确性&lt;/h3&gt;
&lt;p&gt;由观察 2，每次取最短匹配外层不会使答案变差；由观察 1，任何合法划分都必须遵守外层 chunk 相等的约束。因此上述贪心得到全局最优解。哈希仅用于 $O(1)$ 比较子串相等性，不影响贪心正确性。&lt;/p&gt;
&lt;h3&gt;复杂度分析&lt;/h3&gt;
&lt;p&gt;预处理前缀哈希与幂次需要 $O(n)$ 时间与 $O(n)$ 空间。双指针扫描过程需要 $O(n)$ 时间。因此每组测试数据的时空复杂度均为 $O(n)$，满足 $|s| \le 10^6$ 的约束。&lt;/p&gt;
&lt;h2&gt;代码&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 200005
using namespace std;
ll ans;
ll n, m, k;
ll t;
#define pr pair&amp;lt;ll, ll&amp;gt;
const ll B = 337;
const ll M = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; t;
    while (t--) {
        auto solve = [&amp;amp;]() {
            string s;
            cin &amp;gt;&amp;gt; s;
            n = s.length();
            vector&amp;lt;ll&amp;gt; pre(n + 5, 0);
            vector&amp;lt;ll&amp;gt; p(n + 5, 0);
            auto init = [&amp;amp;]() {
                p[0] = 1;
                for (int i = 1; i &amp;lt;= n; i++) {
                    pre[i] = (pre[i - 1] * B + s[i]) % M;
                    p[i] = p[i - 1] * B % M;
                }
            };
            s = &apos;0&apos; + s;
            init();
            int mid = n / 2;
            ll len = 0;
            ll cnt = 0;
            auto cal = [&amp;amp;](int l, int r) {
                return (pre[r] - pre[l - 1] * p[r - l + 1] % M + M) % M;
            };
            for (int l = 1, r = n; l &amp;lt;= mid; l++, r--) {
                len++;
                if (cal(l - len + 1, l) == cal(r, r + len - 1)) {
                    len = 0;
                    cnt += 2;
                }
            }
            if (len || (n % 2))
                cnt++;
            cout &amp;lt;&amp;lt; cnt &amp;lt;&amp;lt; &apos;\n&apos;;
        };
        solve();
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>左偏树 可并堆</title><link>https://sanzenin.top/posts/obsidian/%E5%B7%A6%E5%81%8F%E6%A0%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%B7%A6%E5%81%8F%E6%A0%91/</guid><description>左偏树是一种具有左偏性质的堆有序的二叉树。注意，左偏树不是二叉堆。 左偏树的每一个节点存储的信息包括左右子节点 、权值 和 距离 。 左儿子或右儿子为空的节点，称为外节点。节点的距离的定义：即该节点到与其最近的外节点经过的边数。 我们规定，外节点的距离为 0，空节点的距离为 -1。 [图片缺失：Pasted image</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;左偏树 可并堆&lt;/h1&gt;
&lt;p&gt;&lt;strong&gt;左偏树&lt;/strong&gt;是一种具有&lt;strong&gt;左偏&lt;/strong&gt;性质的&lt;strong&gt;堆有序&lt;/strong&gt;的二叉树。注意，左偏树不是二叉堆。&lt;/p&gt;
&lt;p&gt;左偏树的每一个节点存储的信息包括左右子节点 $lc[x], rc[x]$、权值 $v[x]$ 和 距离 $dis[x]$。&lt;/p&gt;
&lt;p&gt;左儿子或右儿子为空的节点，称为&lt;strong&gt;外节点&lt;/strong&gt;。&lt;strong&gt;节点的距离&lt;/strong&gt;的定义：即该节点到与其最近的外节点经过的边数。&lt;/p&gt;
&lt;p&gt;我们规定，外节点的距离为 0，空节点的距离为 -1。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;code&gt;[图片缺失：Pasted image 20260114153201.png]&lt;/code&gt;*左偏树实例&lt;/p&gt;
&lt;h3&gt;左偏树的性质&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;性质1&lt;/strong&gt;：堆的性质，对于任意节点 $v[x] \le v[lc[x]], v[rc[x]]$ （小根堆）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;性质2&lt;/strong&gt;：左偏性质，左儿子的距离 $\ge$ 右儿子的距离，$dis[lc] \ge dis[rc]$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;性质3&lt;/strong&gt;：任意节点的距离 = 其右儿子的距离 + 1，$dis[x] = dis[rc] + 1$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;性质4&lt;/strong&gt;：&lt;strong&gt;一棵有 $n$ 个节点的二叉树，根的 $dis \le \log(n+1) - 1$。&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;性质4 的证明推导&lt;/h3&gt;
&lt;p&gt;因为根的距离为 $x$ 的二叉树至少有 $x+1$ 层是满二叉树，那么至少有 $2^{x+1} - 1$ 个节点。&lt;/p&gt;
&lt;p&gt;即 $n \ge 2^{x+1} - 1$，所以 $x \le \log(n+1) - 1$。&lt;/p&gt;
&lt;h3&gt;合并操作 (Merge)&lt;/h3&gt;
&lt;p&gt;合并操作是左偏树最重要的操作，过程主要包含两个维度的维护：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;维护堆的性质&lt;/strong&gt;：
先取&lt;strong&gt;值较小&lt;/strong&gt;的那个根作为合并后的堆的根节点，然后&lt;strong&gt;递归合并&lt;/strong&gt;其右儿子与另一个堆，作为合并后的堆的右儿子。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;维护左偏性质&lt;/strong&gt;：
合并后若左儿子的 $dis$ 小于右儿子的 $dis$（即 $dis[lc] &amp;lt; dis[rc]$），就交换两个儿子。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h3&gt;时间复杂度分析&lt;/h3&gt;
&lt;p&gt;由于左偏性质，每递归一层，其中一个堆根节点的 $dis$ 就会减小 1。&lt;/p&gt;
&lt;p&gt;而一棵有 $n$ 个节点的二叉树，根的 $dis &amp;lt; \log(n+1)$。&lt;/p&gt;
&lt;p&gt;所以合并两个大小分别为 $n$ 和 $m$ 的堆的&lt;strong&gt;时间复杂度&lt;/strong&gt;是 $O(\log n + \log m)$。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P3377&quot;&gt; P3377 【模板】可并堆 1&lt;/a&gt;
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
ll k, n, m;
class dsu {
  public:
    int fa[N];
    void init() {
        for (int i = 1; i &amp;lt;= N; i++)
            fa[i] = i;
    }
    int find(int x) { return fa[x] = (fa[x] == x ? x : find(fa[x])); }
    bool merge(int x, int y) {
        int rx, ry;
        rx = find(x);
        ry = find(y);
        if (rx == ry)
            return 0;
        fa[rx] = ry;
        return 1;
    }
} ds;
class mergeable_heap {
  public:
    int val[N], rc[N], lc[N], dis[N], id = 0;
    int new_(int x) {
        val[++id] = x;
        return id;
    }
    int merge(int x, int y) {
        if (!x || !y)
            return x + y;
        if (make_pair(val[x], x) &amp;gt; make_pair(val[y], y))
            swap(x, y);
        rc[x] = merge(rc[x], y);
        if (dis[rc[x]] &amp;gt; dis[lc[x]])
            swap(lc[x], rc[x]);
        dis[x] = dis[rc[x]] + 1;
        return x;
    }
} mh;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    ds.init();
    for (int i = 1; i &amp;lt;= n; i++) {
        ll x;
        cin &amp;gt;&amp;gt; x;
        mh.new_(x);
    }
    mh.val[0] = -1; // 可能会合并到空节点
    while (m--) {
        ll opt, x, y;
        cin &amp;gt;&amp;gt; opt;
        if (opt == 1) {
            cin &amp;gt;&amp;gt; x &amp;gt;&amp;gt; y;
            if (mh.val[x] == -1 || mh.val[y] == -1)
                continue;
            x = ds.find(x), y = ds.find(y);
            if (x != y)
                ds.fa[x] = ds.fa[y] = mh.merge(ds.find(x), ds.find(y));
        } else {
            cin &amp;gt;&amp;gt; x;
            if (mh.val[x] == -1)
                cout &amp;lt;&amp;lt; -1 &amp;lt;&amp;lt; &apos;\n&apos;;
            else {
                x = ds.find(x); // 注意要判断的是这个点有无被删除,而不是这个点的祖先
                cout &amp;lt;&amp;lt; mh.val[x] &amp;lt;&amp;lt; &apos;\n&apos;;
                mh.val[x] = -1;
                ds.fa[x] = ds.fa[mh.lc[x]] = ds.fa[mh.rc[x]] = mh.merge(mh.lc[x], mh.rc[x]);
            }
        }
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P1552&quot;&gt;P1552 [APIO2012] 派遣&lt;/a&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cmath&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#define ll long long
#define N 200005
#define M 2005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
ll n, m, ans;
class mergeable_heap {
  public:
    struct node {
        ll ls = 0, rs = 0, siz = 1, val = 0, sum = 0, dis = 0;
    } tr[N];
    int root[N];
    mergeable_heap() {
        tr[0].dis = -1;
        tr[0].siz = 0;
    }
    int id = 0;
    int new_(int x) {
        tr[++id] = {0, 0, 1, x, x};
        return id;
    }
#define lc tr[x]
    .ls
#define rc tr[x]
        .rs int
        merge(int x, int y) {
        if (!x || !y)
            return x + y;
        if (make_pair(tr[x].val, x) &amp;lt; make_pair(tr[y].val, y))
            swap(x, y);
        rc = merge(rc, y);
        if (tr[lc].dis &amp;lt; tr[rc].dis)
            swap(lc, rc);
        tr[x].dis = tr[rc].dis + 1;
        tr[x].siz = tr[lc].siz + tr[rc].siz + 1, tr[x].sum = tr[lc].sum + tr[rc].sum + tr[x].val;
        return x;
    }
    int del(int x) {
        int tem = merge(lc, rc);
        return tem;
    }
} mheap;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    vector&amp;lt;ll&amp;gt; fa(n + 5, 0);
    vector&amp;lt;ll&amp;gt; pay(n + 5, 0);
    vector&amp;lt;ll&amp;gt; lead(n + 5, 0);
    vector&amp;lt;ll&amp;gt; root(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++) {
        cin &amp;gt;&amp;gt; fa[i] &amp;gt;&amp;gt; pay[i] &amp;gt;&amp;gt; lead[i];
        root[i] = mheap.new_(pay[i]);
    }
    for (int i = n; i &amp;gt;= 1; i--) {
        while (mheap.tr[root[i]].sum &amp;gt; m) {
            root[i] = mheap.del(root[i]);
        }
        ans = max(ans, lead[i] * mheap.tr[root[i]].siz);
        int fa_ = fa[i];
        if (fa_)
            root[fa_] = mheap.merge(root[fa_], root[i]);
    }
    cout &amp;lt;&amp;lt; ans;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P4331&quot;&gt;P4331 [BalticOI 2004] Sequence (Day1)&lt;/a&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;cstdlib&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 1000005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
ll n, ans, m, cnt;
vector&amp;lt;ll&amp;gt; a;
class mergeable_heap {
  public:
    struct node {
        int siz = 1, dis = 0, ls = 0, rs = 0, num = 0;
    } tr[N];
    int id = 0;
    mergeable_heap() {
        tr[0].dis = -1;
        tr[0].siz = 0;
    }
    int new_(int x) {
        tr[++id].num = x;
        return id;
    }
#define lc tr[x]
    .ls
#define rc tr[x]
        .rs int
        merge(int x, int y) {
        if (!x || !y)
            return x + y;
        if (make_pair(a[tr[x].num], x) &amp;lt; make_pair(a[tr[y].num], y))
            swap(x, y);
        rc = merge(rc, y);
        if (tr[lc].dis &amp;lt; tr[rc].dis)
            swap(lc, rc);
        tr[x].dis = tr[rc].dis + 1, tr[x].siz = tr[lc].siz + tr[rc].siz + 1;
        return x;
    }
    int del(int x) {
        int tem = merge(lc, rc);
        return tem;
    }
    int size(int x) { return tr[x].siz; }
} mh;
struct segment {
    int l, r, rt;
} s[N];
int top;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    a.assign(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++) {
        cin &amp;gt;&amp;gt; a[i];
        a[i] -= i;
    }
    for (int i = 1; i &amp;lt;= n; i++) {
        s[++top] = {i, i, mh.new_(i)};
        while (top &amp;gt; 1 &amp;amp;&amp;amp; a[mh.tr[s[top - 1].rt].num] &amp;gt; a[mh.tr[s[top].rt].num]) {
            s[top - 1].rt = mh.merge(s[top - 1].rt, s[top].rt);
            s[top - 1].r = s[top].r;
            top--;
            while (mh.size(s[top].rt) &amp;gt; (s[top].r - s[top].l + 1) / 2 + 1) {
                s[top].rt = mh.del(s[top].rt);
            }
        }
    }
    vector&amp;lt;ll&amp;gt; ans;
    ll tol = 0;
    for (int i = 1; i &amp;lt;= top; i++) {
        for (int j = s[i].l; j &amp;lt;= s[i].r; j++) {
            ans.push_back(a[mh.tr[s[i].rt].num] + j);
            tol += abs(a[j] - a[mh.tr[s[i].rt].num]);
        }
    }
    cout &amp;lt;&amp;lt; tol &amp;lt;&amp;lt; &apos;\n&apos;;
    for (auto now : ans)
        cout &amp;lt;&amp;lt; now &amp;lt;&amp;lt; &apos;\n&apos;;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>平面最近点对</title><link>https://sanzenin.top/posts/obsidian/%E5%B9%B3%E9%9D%A2%E6%9C%80%E8%BF%91%E7%82%B9%E5%AF%B9/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%B9%B3%E9%9D%A2%E6%9C%80%E8%BF%91%E7%82%B9%E5%AF%B9/</guid><description>给定平面上任意n个点,求最近的一对点之间的距离 我们使用类似于归并排序的思想解决这道题目.归并排序的思想是,如果一个区间的答案能够由二分划出的左区间,右区间,同时能够通过常数复杂度得到跨越mid左右区间的元素组成的答案,那么我们就可以以 的复杂度解决这道题目. 容易想到,我们可以对x坐标进行排序,然后每次递归处理左右两</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h4&gt;问题&lt;/h4&gt;
&lt;p&gt;给定平面上任意n个点,求最近的一对点之间的距离&lt;/p&gt;
&lt;h4&gt;思路&lt;/h4&gt;
&lt;p&gt;我们使用类似于归并排序的思想解决这道题目.归并排序的思想是,如果一个区间的答案能够由二分划出的左区间,右区间,同时能够通过常数复杂度得到跨越mid左右区间的元素组成的答案,那么我们就可以以$O(nlog(n))$的复杂度解决这道题目.
容易想到,我们可以对x坐标进行排序,然后每次递归处理左右两个区间并取答案最小值.
所以问题就是,我们如何通过常数复杂度得到跨越mid的答案?
我们可以先做一些剪枝操作:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;如果横坐标距离mid的x坐标大于等于已经得出的当前最小d,可以之间不参与计算&lt;/li&gt;
&lt;li&gt;如果两个点的y坐标之差大于等于d,当前点以及比这个点y坐标大的点都不可以参与计算.
然后这次暴力枚举跨越左右区间答案的过程就神奇的变成了常数*n复杂度喵!
接下来给出证明:
&lt;img src=&quot;/obsidian/Pasted%20image%2020260126164803.png&quot; alt=&quot;Pasted image 20260126164803&quot; /&gt;
我们假设以及对y排好序,我们要找所有和当前点b距离最小的点,经过剪枝之后,我们实际上把当前点和所有可以匹配的点限制在了(2*d)*d的一个矩形区域内,即8个边长为$\frac{d}{2}$的小正方形,这个小正方形的对角线为$\frac{\sqrt{2}d}{2}$,小于d,但是当前两个点之间的距离最小是d,故一个小正方形内不可能有两个以上点,一次一个点最多只会和7个点参与计算.&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/2194&quot;&gt;CSES  Minimum Euclidean Distance&lt;/a&gt;
&lt;a href=&quot;https://www.luogu.com.cn/problem/P1429&quot;&gt;P1429 平面最近点对（加强版）&lt;/a&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 1000005
#define pr pair&amp;lt;ll, ll&amp;gt;
#define ll __int128
using namespace std;
long long n, m, ans, x;
const ll mod = 1e9 + 7;
class Point {
  public:
    ll x = 0, y = 0;
    ll operator*(const Point &amp;amp;oth) const { return x * oth.x + y * oth.y; }
    ll mul(const Point &amp;amp;oth) const { return x * oth.y - y * oth.x; }
    Point operator+(const Point &amp;amp;oth) const { return {x + oth.x, y + oth.y}; }
    Point operator-(const Point &amp;amp;oth) { return {x - oth.x, y - oth.y}; }
    ll dis(const Point &amp;amp;oth) { return (x - oth.x) * (x - oth.x) + (y - oth.y) * (y - oth.y); }
    bool operator&amp;lt;(const Point &amp;amp;oth) { return make_pair(x, y) &amp;lt; make_pair(oth.x, oth.y); }
};
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    vector&amp;lt;Point&amp;gt; s(n + 5);
    for (int i = 1; i &amp;lt;= n; i++) {
        long long x, y;
        cin &amp;gt;&amp;gt; x &amp;gt;&amp;gt; y;
        s[i] = {x, y};
    }
    auto abs = [](ll x) { return x &amp;lt; 0 ? -x : x; };
    sort(s.begin() + 1, s.begin() + n + 1);
    auto merge_sort = [&amp;amp;](auto &amp;amp;&amp;amp;self, int l, int r) -&amp;gt; ll {
        if (l == r)
            return 1e19;
        int mid = (l + r) &amp;gt;&amp;gt; 1;
        ll M = s[mid].x; // 一定要记录中点 不然排序后就不是原来的中点了
        ll d = min(self(self, l, mid), self(self, mid + 1, r));
        inplace_merge(s.begin() + l, s.begin() + mid + 1, s.begin() + 1 + r,
                      [](const Point &amp;amp;a, const Point &amp;amp;b) { return a.y &amp;lt; b.y; });
        vector&amp;lt;int&amp;gt; tem;
        for (int i = l; i &amp;lt;= r; i++) {
            if (abs(s[i].x - M) * abs(s[i].x - M) &amp;lt; d)
                tem.push_back(i);
        }
        for (int i = 0; i &amp;lt; tem.size(); i++) {
            int a = tem[i];
            for (int j = i + 1;
                 j &amp;lt; tem.size() &amp;amp;&amp;amp; abs(s[a].y - s[tem[j]].y) * abs(s[a].y - s[tem[j]].y) &amp;lt; d;
                 j++) // 这一层实际上的复杂度只有常数
            {
                d = min(d, s[a].dis(s[tem[j]]));
            }
        }
        return d;
    };
    cout &amp;lt;&amp;lt; fixed &amp;lt;&amp;lt; setprecision(4) &amp;lt;&amp;lt; sqrt((long long)(merge_sort(merge_sort, 1, n)));
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>P5490 【模板】扫描线 &amp; 矩形面积并</title><link>https://sanzenin.top/posts/obsidian/%E6%89%AB%E6%8F%8F%E7%BA%BF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%89%AB%E6%8F%8F%E7%BA%BF/</guid><description>求 个四边平行于坐标轴的矩形的面积并。 第一行一个正整数 。 接下来 行每行四个非负整数 ，表示一个矩形的四个端点坐标为 。 一行一个正整数，表示 个矩形的并集覆盖的总面积。 对于 的数据， 。 对于 的数据， ， ， 。 Updated on 4.10 by Dengduck（口胡） \&amp; yummy（实现）：增加了</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;P5490 【模板】扫描线 &amp;amp; 矩形面积并&lt;/h1&gt;
&lt;h2&gt;题目描述&lt;/h2&gt;
&lt;p&gt;求 $n$ 个四边平行于坐标轴的矩形的面积并。&lt;/p&gt;
&lt;h2&gt;输入格式&lt;/h2&gt;
&lt;p&gt;第一行一个正整数 $n$。&lt;/p&gt;
&lt;p&gt;接下来 $n$ 行每行四个非负整数 $x_1, y_1, x_2, y_2$，表示一个矩形的四个端点坐标为 $(x_1, y_1),(x_1, y_2),(x_2, y_2),(x_2, y_1)$。&lt;/p&gt;
&lt;h2&gt;输出格式&lt;/h2&gt;
&lt;p&gt;一行一个正整数，表示 $n$ 个矩形的并集覆盖的总面积。&lt;/p&gt;
&lt;h2&gt;输入输出样例 #1&lt;/h2&gt;
&lt;h3&gt;输入 #1&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;2
100 100 200 200
150 150 250 255

&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;输出 #1&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;18000

&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;说明/提示&lt;/h2&gt;
&lt;p&gt;对于 $20%$ 的数据，$1 \le n \le 1000$。
对于 $100%$ 的数据，$1 \le n \le {10}^5$，$0 \le x_1 &amp;lt; x_2 \le {10}^9$，$0 \le y_1 &amp;lt; y_2 \le {10}^9$。&lt;/p&gt;
&lt;p&gt;Updated on 4.10 by Dengduck（口胡） &amp;amp; yummy（实现）：增加了一组数据。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;感觉这里不太好想的倒不是扫描线,而是在区间的处理上...
扫描线的思想很简单,我们在y维度上把正方形的拆分为两个&quot;事件&quot;:进入事件和离开时间,当正方形进入时,我们就把对应正方形的横坐标区间都打上标记,我们利用线段树可以维护出在当前y坐标有多少横坐标区域被正方形占据,这里不容易想的是为什么每次传入的区间是(l,r-1).观察下面的图发现其实在线段树上每个点x掌管的是x向右的这个小方格,所以实际上[l,r]这个区间是被线段树上的[l,r-1]接管了!&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Pasted%20image%2020260129210820.png&quot; alt=&quot;Pasted image 20260129210820&quot; /&gt;
当我们每次离开正方形时,就把原来在线段树上打上的标记去掉,利用线段树维护区间并的思想很直观,这里不再赘述.注意我们只需根节点的数据,因此每次都只上传标记即可.
我们每次统计答案的时候实际上是和上面的坐标求差值,这里是因为当我们最后于一次处理y时,能够保证y上的所有离开和进入都能处理完,并且下一个事件的y坐标一定是严格大于当前y,这样求出来的答案一定是对的.
扫描线的进入/离开事件思想实际上用处很广.
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;tuple&amp;gt;
#define ll long long
#define N 100005
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
int n;
vector&amp;lt;ll&amp;gt; y;
class wei_segment_t {
#define lc x &amp;lt;&amp;lt; 1
#define rc x &amp;lt;&amp;lt; 1 | 1
  public:
    struct weisegment_t {
        int cover = 0;
        ll length = 0;
    } tree[N * 8];
    void up(int x, int l, int r) {
        if (tree[x].cover) {
            tree[x].length = y[r + 1] - y[l];
        } else {
            if (l == r)
                tree[x].length = 0;
            else
                tree[x].length = tree[lc].length + tree[rc].length;
        }
    }
    void modify(int x, int l, int r, int L, int R, int add) {
        if (l &amp;gt; R || L &amp;gt; r)
            return;
        if (l &amp;gt;= L &amp;amp;&amp;amp; r &amp;lt;= R) {
            tree[x].cover += add;
            up(x, l, r);
            return;
        }
        int mid = (l + r) &amp;gt;&amp;gt; 1;
        modify(lc, l, mid, L, R, add);
        modify(rc, mid + 1, r, L, R, add);
        up(x, l, r);
    }
} t;
tuple&amp;lt;ll, ll, ll, int&amp;gt; line[N * 2];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    ll ans = 0;
    for (int i = 1; i &amp;lt;= n; i++) {
        ll x1, x2, y1, y2;
        cin &amp;gt;&amp;gt; x1 &amp;gt;&amp;gt; y1 &amp;gt;&amp;gt; x2 &amp;gt;&amp;gt; y2;
        if (x1 &amp;gt; x2)
            swap(x1, x2);
        if (y1 &amp;gt; y2)
            swap(y1, y2);
        line[2 * i - 1] = {x1, y1, y2, 1};
        line[2 * i] = {x2, y1, y2, -1};
        y.push_back(y1);
        y.push_back(y2);
    }
    y.push_back(-999);
    sort(y.begin(), y.end());
    sort(line + 1, line + 2 * n + 1);
    y.erase(unique(y.begin(), y.end()), y.end());
    int len = y.size() - 1;
    int pre = 0;
    for (int i = 1; i &amp;lt;= 2 * n; i++) {
        auto [x, y1, y2, add] = line[i];
        ans += t.tree[1].length * (x - pre);
        // cout&amp;lt;&amp;lt;t.tree[1].length&amp;lt;&amp;lt;&apos; &apos;&amp;lt;&amp;lt;x&amp;lt;&amp;lt;&apos; &apos;&amp;lt;&amp;lt;pre&amp;lt;&amp;lt;&apos;\n&apos;;
        pre = x;
        int id1 = lower_bound(y.begin(), y.end(), y1) - y.begin();
        int id2 = lower_bound(y.begin(), y.end(), y2) - y.begin();
        t.modify(1, 1, len - 1, id1, id2 - 1, add);
    }
    cout &amp;lt;&amp;lt; ans;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>排列进制(Cantor展开)</title><link>https://sanzenin.top/posts/obsidian/%E6%8E%92%E5%88%97%E8%BF%9B%E5%88%B6-cantor%E5%B1%95%E5%BC%80/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%8E%92%E5%88%97%E8%BF%9B%E5%88%B6-cantor%E5%B1%95%E5%BC%80/</guid><description>CSES Permutation Order 这道题让我们求一个排列在全排列中的位次,以及给出n和位次求解这个排列,我们可以把一个排列映射到一个进制上进行处理. 形式化的,我们记一个数字的阶乘进制为 : ,阶乘进制的每一个数字 ，在排列中正好对应了在当前剩余数字中，选第几个小的数字.直接运用进制转换的知识进行转换即可,</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/3397&quot;&gt;CSES  Permutation Order&lt;/a&gt;
这道题让我们求一个排列在全排列中的位次,以及给出n和位次求解这个排列,我们可以把一个排列映射到一个进制上进行处理.
形式化的,我们记一个数字的阶乘进制为$$ X=a_n​⋅n!+a_{n−1}​⋅(n−1)!+⋯+a_1​⋅1!+a_0​⋅0!$$
$s.t.$  :$0\le a_i \le i$,阶乘进制的每一个数字 $a_i$，在排列中正好对应了在当前剩余数字中，选第几个小的数字.直接运用进制转换的知识进行转换即可,注意每次当前排列的数字用完就要移除
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bit&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iterator&amp;gt;
#include &amp;lt;set&amp;gt;
#include &amp;lt;tuple&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#define N 2000005
#define inf 0x3f3f3f3f3f3f3f3f
#define ll unsigned long long
#define pr pair&amp;lt;int, int&amp;gt;
#define i128 __int128
using namespace std;
ll n, m, q, ans, ma, t, product, k;
const ll mod = 1000000007;
ll f[N];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    vector&amp;lt;ll&amp;gt; f(30);
    vector&amp;lt;int&amp;gt; tem;
    f[0] = 1;
    for (ll i = 1; i &amp;lt;= 20; i++)
        f[i] = f[i - 1] * i;
    cin &amp;gt;&amp;gt; t;
    auto reset = [&amp;amp;](int n) {
        tem.clear();
        for (int i = 1; i &amp;lt;= n; i++)
            tem.push_back(i);
        ;
    };
    auto find = [&amp;amp;](int n, ll k) {
        k--;
        reset(n);
        vector&amp;lt;int&amp;gt; res;
        for (int i = n - 1; i &amp;gt;= 0; i--) {
            auto x = k / (f[i]);
            k %= (f[i]);
            res.push_back(tem[x]);
            tem.erase(tem.begin() + x);
        }
        return res;
    };
    auto cal = [&amp;amp;](int n, vector&amp;lt;ll&amp;gt; &amp;amp;p) -&amp;gt; ll {
        reset(n);
        int cnt = n - 1;
        ll res = 0;
        tem.push_back(1e9);
        for (auto num : p) {
            auto pos = upper_bound(tem.begin(), tem.end(), num) - tem.begin();
            res += f[cnt--] * (pos - 1);
            tem.erase(tem.begin() + pos);
        }
        return res;
    };
    while (t--) {
        int flag;
        cin &amp;gt;&amp;gt; flag;
        if (flag == 1) {
            cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k;
            auto res = find(n, k);
            for (auto x : res)
                cout &amp;lt;&amp;lt; x &amp;lt;&amp;lt; &apos; &apos;;
            cout &amp;lt;&amp;lt; &apos;\n&apos;;
        } else {
            cin &amp;gt;&amp;gt; n;
            vector&amp;lt;ll&amp;gt; t;
            for (int i = 1; i &amp;lt;= n; i++) {
                ll x;
                cin &amp;gt;&amp;gt; x, t.push_back(x);
            }
            cout &amp;lt;&amp;lt; cal(n, t) + 1 &amp;lt;&amp;lt; &apos;\n&apos;;
        }
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>斯特林数 (Stirling Numbers)</title><link>https://sanzenin.top/posts/obsidian/%E6%96%AF%E7%89%B9%E6%9E%97%E6%95%B0/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%96%AF%E7%89%B9%E6%9E%97%E6%95%B0/</guid><description>将 个不同元素，划分为 个非空圆排列的方案数，记作 或 。 递推式： 组合意义： 个人坐 张圆桌的方案数。考虑第 个人： 1. 若单独坐一桌，前面 人坐 张桌子，方案数为 ； 2. 若坐到已有人的桌子上，先让前 个人坐 张桌子，第 个人可以坐到这 个人中任意一个人的左边，方案数为 。 将 个不同元素，划分为 个非空子集</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;斯特林数 (Stirling Numbers)&lt;/h1&gt;
&lt;h3&gt;第一类斯特林数（斯特林轮换数）&lt;/h3&gt;
&lt;p&gt;将 $n$ 个不同元素，划分为 $m$ 个非空圆排列的方案数，记作 $\begin{bmatrix} n \ m \end{bmatrix}$ 或 $s(n, m)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;递推式&lt;/strong&gt;：
$$
\begin{bmatrix} n \ m \end{bmatrix} = \begin{bmatrix} n - 1 \ m - 1 \end{bmatrix} + (n - 1) \begin{bmatrix} n - 1 \ m \end{bmatrix}
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;组合意义&lt;/strong&gt;：
$n$ 个人坐 $m$ 张圆桌的方案数。考虑第 $n$ 个人：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若单独坐一桌，前面 $n-1$ 人坐 $m-1$ 张桌子，方案数为 $\begin{bmatrix} n-1 \ m-1 \end{bmatrix}$；&lt;/li&gt;
&lt;li&gt;若坐到已有人的桌子上，先让前 $n-1$ 个人坐 $m$ 张桌子，第 $n$ 个人可以坐到这 $n-1$ 个人中任意一个人的左边，方案数为 $(n-1) \begin{bmatrix} n-1 \ m \end{bmatrix}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h3&gt;第二类斯特林数（斯特林子集数）&lt;/h3&gt;
&lt;p&gt;将 $n$ 个不同元素，划分为 $m$ 个非空子集的方案数，记作 $\begin{Bmatrix} n \ m \end{Bmatrix}$ 或 $S(n, m)$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;递推式&lt;/strong&gt;：
$$
\begin{Bmatrix} n \ m \end{Bmatrix} = \begin{Bmatrix} n - 1 \ m - 1 \end{Bmatrix} + m \begin{Bmatrix} n - 1 \ m \end{Bmatrix}
$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;组合意义&lt;/strong&gt;：
$n$ 个不同的小球放入 $m$ 个无标号盒子的方案数。考虑第 $n$ 个小球：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若单独放入一个新盒子，前面 $n-1$ 个球放入 $m-1$ 个盒子，方案数为 $\begin{Bmatrix} n-1 \ m-1 \end{Bmatrix}$；&lt;/li&gt;
&lt;li&gt;若放入已有球的盒子中，前面 $n-1$ 个球已放入 $m$ 个盒子，第 $n$ 个球有 $m$ 种选择，方案数为 $m \begin{Bmatrix} n-1 \ m \end{Bmatrix}$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;容斥通项公式&lt;/strong&gt;：
$$
\begin{Bmatrix} n \ m \end{Bmatrix} = \frac{1}{m!} \sum_{i=0}^m (-1)^{m-i} \binom{m}{i} i^n
$$&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;经典应用一：P4609 [FJOI2016] 建筑师&lt;/h2&gt;
&lt;p&gt;高度为 $n$ 的建筑是一个分水岭，在它左边有 $a-1$ 个建筑群（每个建筑群左边一个最高建筑，剩下的建筑自由排列，数量等于圆排列的数量），在它右边有 $b-1$ 个建筑群。每个建筑群构成一个圆排列，共计 $a+b-2$ 个圆排列。即把 $n-1$ 个建筑划分成 $a+b-2$ 个圆排列，即 $\begin{bmatrix} n-1 \ a+b-2 \end{bmatrix}$。然后从圆排列数中拿出 $a-1$ 个放在 $n$ 的左边，即 $\binom{a+b-2}{a-1}$。&lt;/p&gt;
&lt;p&gt;答案：$\begin{bmatrix} n-1 \ a+b-2 \end{bmatrix} \times \binom{a+b-2}{a-1}$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define ll long long
#define N 50005
#define M 205
using namespace std;
ll t;
ll c[N][M];
ll s[N][M];
const int mod = 1e9 + 7;
void init() {
    for (int i = 0; i &amp;lt; N; i++) {
        c[i][0] = 1;
        s[i][0] = (i == 0 ? 1 : 0);
    }
    for (int i = 1; i &amp;lt; N; i++) {
        for (int j = 1; j &amp;lt; M; j++) {
            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
        }
    }
    for (int i = 1; i &amp;lt; N; i++) {
        for (int j = 1; j &amp;lt; M; j++) {
            s[i][j] = (s[i - 1][j - 1] + (i - 1) * s[i - 1][j]) % mod;
        }
    }
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    init();
    cin &amp;gt;&amp;gt; t;
    while (t--) {
        ll n, a, b;
        cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b;
        if (a + b - 2 &amp;gt;= M || a + b - 2 &amp;lt; 0) {
            cout &amp;lt;&amp;lt; 0 &amp;lt;&amp;lt; &apos;\n&apos;;
            continue;
        }
        cout &amp;lt;&amp;lt; (s[n - 1][a + b - 2] * c[a + b - 2][a - 1]) % mod &amp;lt;&amp;lt; &apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;经典应用二：第二类斯特林数递推与高精度 (P3904)&lt;/h2&gt;
&lt;p&gt;将 $n$ 个互不相同的元素划分为 $m$ 个非空集合的方案数，递推关系 $S(i, j) = S(i-1, j-1) + j \cdot S(i-1, j)$。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
// 高精度整数辅助类
struct BigInt {
    vector&amp;lt;int&amp;gt; a;
    BigInt(long long v = 0) {
        if (v == 0)
            a.push_back(0);
        while (v &amp;gt; 0) {
            a.push_back(v % 10);
            v /= 10;
        }
    }
    BigInt operator+(const BigInt &amp;amp;o) const {
        BigInt c;
        c.a.clear();
        int carry = 0, n = max(a.size(), o.a.size());
        for (int i = 0; i &amp;lt; n || carry; i++) {
            if (i &amp;lt; a.size())
                carry += a[i];
            if (i &amp;lt; o.a.size())
                carry += o.a[i];
            c.a.push_back(carry % 10);
            carry /= 10;
        }
        return c;
    }
    BigInt operator*(int m) const {
        BigInt c;
        c.a.clear();
        long long carry = 0;
        for (int i = 0; i &amp;lt; a.size() || carry; i++) {
            if (i &amp;lt; a.size())
                carry += 1LL * a[i] * m;
            c.a.push_back(carry % 10);
            carry /= 10;
        }
        while (c.a.size() &amp;gt; 1 &amp;amp;&amp;amp; c.a.back() == 0)
            c.a.pop_back();
        return c;
    }
    void print() const {
        for (int i = (int)a.size() - 1; i &amp;gt;= 0; i--)
            cout &amp;lt;&amp;lt; a[i];
        cout &amp;lt;&amp;lt; &apos;\n&apos;;
    }
};
BigInt S[105][105];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    int n, m;
    if (!(cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m))
        return 0;
    S[0][0] = BigInt(1);
    for (int i = 1; i &amp;lt;= n; i++) {
        for (int j = 1; j &amp;lt;= m; j++) {
            S[i][j] = S[i - 1][j - 1] + S[i - 1][j] * j;
        }
    }
    S[n][m].print();
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>期望DP</title><link>https://sanzenin.top/posts/obsidian/%E6%9C%9F%E6%9C%9Bdp/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%9C%9F%E6%9C%9Bdp/</guid><description>Niuniu 喜欢玩 OSU!。将该游戏简化为如下问题： 给定两个整数 ，接下来有 次点击，每次点击可能成功也可能失败。若一段连续成功的长度（连击长度）为 ，则该段贡献 分。第 次点击成功的概率为 。求总得分的期望值，结果对 取模。 输入 - 第一行两个整数 。 - 第二行 个整数 。 数据范围 样例输入 样例输出 1</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h2&gt;题目重述&lt;/h2&gt;
&lt;p&gt;Niuniu 喜欢玩 OSU!。将该游戏简化为如下问题：&lt;/p&gt;
&lt;p&gt;给定两个整数 $n,m$，接下来有 $n$ 次点击，每次点击可能成功也可能失败。若一段连续成功的长度（连击长度）为 $X$，则该段贡献 $X^m$ 分。第 $i$ 次点击成功的概率为 $\dfrac{p_i}{100}$。求总得分的期望值，结果对 $10^9+7$ 取模。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;输入&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;第一行两个整数 $n,m$。&lt;/li&gt;
&lt;li&gt;第二行 $n$ 个整数 $p_1,\dots,p_n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;数据范围&lt;/strong&gt;
$$1\le n\le 1000,\quad 1\le m\le 1000,\quad 0\le p_i\le 100.$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;样例输入&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;3 4
50 50 50
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;样例输出&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;750000020
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;关键观察&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;总得分可分解为若干极大成功段的贡献&lt;/strong&gt;。一次具体的点击过程会被失败位置与结尾划分成若干段极大的连续成功段，每段长度 $L$ 对答案的贡献为 $L^m$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;期望具有线性性&lt;/strong&gt;。一段长度为 $j$ 的连击是否产生 $j^m$ 的贡献，只取决于该段对应的 $j$ 个位置全成功、且其前一个位置失败（或为开头）这一事件的概率。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;正推与倒推的数学区别&lt;/strong&gt;。正推维护的是“绝对期望”，每次新增得分都要乘以“到达当前状态的概率”；倒推维护的是“条件期望”，利用全期望公式
$$E[X\mid i]=\sum_j P(i\to j)\big(W(i\to j)+E[X\mid j]\big),$$
可以彻底消去历史路径概率，转移只依赖当前一步的概率。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;解析&lt;/h2&gt;
&lt;h3&gt;解法一：倒推 DP&lt;/h3&gt;
&lt;p&gt;定义 $dp[i][j]$ 为：已经完成前 $i-1$ 次点击，当前连击长度为 $j$，从第 $i$ 次点击开始进行到第 $n$ 次点击的期望后续得分。&lt;/p&gt;
&lt;p&gt;第 $i$ 次点击有两种可能：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;失败&lt;/strong&gt;，概率 $1-p_i$：当前连击 $j$ 被结算，获得 $j^m$ 分，连击清零，后续期望为 $dp[i+1][0]$。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;成功&lt;/strong&gt;，概率 $p_i$：连击长度变为 $j+1$，本次不得分，后续期望为 $dp[i+1][j+1]$。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;由全期望公式得到转移方程：
$$dp[i][j]=(1-p_i)\big(j^m+dp[i+1][0]\big)+p_i\cdot dp[i+1][j+1].$$&lt;/p&gt;
&lt;p&gt;边界条件：所有点击结束后，剩余连击直接结算，因此
$$dp[n+1][j]=j^m.$$&lt;/p&gt;
&lt;p&gt;最终答案为 $dp[1][0]$。&lt;/p&gt;
&lt;p&gt;状态数为 $O(n^2)$，每个状态 $O(1)$ 转移，时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。&lt;/p&gt;
&lt;h3&gt;解法二：正推 DP&lt;/h3&gt;
&lt;p&gt;定义 $dp[i][j]$ 为：前 $i$ 次点击中，末尾连续成功的长度恰好为 $j$ 的所有情况下的“得分 $\times$ 概率”之和。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;$j\ge 1$ 的转移&lt;/strong&gt;：第 $i$ 步结尾形成一个长度恰好为 $j$ 的连击，当且仅当第 $i-j$ 步失败（$i=j$ 时视为虚拟失败，即从头开始），且第 $i-j+1,\dots,i$ 步连续成功。该段贡献 $j^m$ 分，因此
$$dp[i][j]=\Big(dp[i-j][0]+j^m\cdot(1-p_{i-j})\Big)\cdot\prod_{k=i-j+1}^{i}p_k.$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;$j=0$ 的转移&lt;/strong&gt;：第 $i$ 步失败，连击清零，无新增得分，继承前一步所有状态：
$$dp[i][0]=\sum_{j=0}^{i-1}dp[i-1][j]\cdot(1-p_i).$$&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;最终答案为
$$\sum_{j=0}^{n}dp[n][j].$$&lt;/p&gt;
&lt;p&gt;复杂度同样为 $O(n^2)$。&lt;/p&gt;
&lt;h2&gt;代码&lt;/h2&gt;
&lt;h3&gt;倒推实现&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 200005
using namespace std;
ll ans;
ll n, m, k;
ll t;
ll mod = 1e9 + 7;
#define pr pair&amp;lt;ll, ll&amp;gt;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    auto qp = [&amp;amp;](ll x, ll k) {
        ll res = 1;
        while (k) {
            if (k &amp;amp; 1)
                res = (res * x) % mod;
            x = (x * x) % mod;
            k &amp;gt;&amp;gt;= 1;
        }
        return res;
    };
    auto inv = qp(100, mod - 2);
    vector&amp;lt;ll&amp;gt; p(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++)
        cin &amp;gt;&amp;gt; p[i], p[i] = p[i] * inv % mod;
    vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt; dp(n + 5, vector&amp;lt;ll&amp;gt;(n + 5, 0));
    for (int i = 1; i &amp;lt;= n; i++)
        dp[n + 1][i] = qp(i, m);
    for (int i = n; i &amp;gt;= 1; i--) {
        for (int j = i - 1; j &amp;gt;= 0; j--) {
            dp[i][j] = ((1 - p[i] + mod) % mod * (qp(j, m) + dp[i + 1][0]) +
                        p[i] * dp[i + 1][j + 1] % mod) %
                       mod;
        }
    }
    cout &amp;lt;&amp;lt; dp[1][0];
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;正推实现&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iomanip&amp;gt;
#include &amp;lt;utility&amp;gt;
#define ll long long
#define N 200005
using namespace std;
ll ans;
ll n, m, k;
ll t;
ll mod = 1e9 + 7;
#define pr pair&amp;lt;ll, ll&amp;gt;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    auto qp = [&amp;amp;](ll x, ll k) {
        ll res = 1;
        while (k) {
            if (k &amp;amp; 1)
                res = (res * x) % mod;
            x = (x * x) % mod;
            k &amp;gt;&amp;gt;= 1;
        }
        return res;
    };
    auto inv = qp(100, mod - 2);
    vector&amp;lt;ll&amp;gt; p(n + 5, 0);
    for (int i = 1; i &amp;lt;= n; i++)
        cin &amp;gt;&amp;gt; p[i];
    vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt; dp(n + 5, vector&amp;lt;ll&amp;gt;(n + 5, 0));
    vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt; pre(n + 5, vector&amp;lt;ll&amp;gt;(n + 5, 0));
    for (int i = 1; i &amp;lt;= n; i++) {
        pre[i][i - 1] = 1;
        for (int j = i; j &amp;lt;= n; j++) {
            pre[i][j] = pre[i][j - 1] * p[j] % mod * inv % mod;
        }
    }
    for (int i = 1; i &amp;lt;= n; i++) {
        for (int j = 1; j &amp;lt;= i; j++) {
            ll now_p;
            now_p = pre[i - j + 1][i];
            dp[i][j] = (dp[i][j] + (dp[i - j][0] + qp(j, m) * (100 - p[i - j]) % mod * inv % mod) %
                                       mod * now_p % mod) %
                       mod;
        }
        for (int j = 0; j &amp;lt; i; j++)
            dp[i][0] = (dp[i][0] + dp[i - 1][j] * (100 - p[i]) % mod * inv % mod) % mod;
    }
    ll res = 0;
    for (int i = 0; i &amp;lt;= n; i++)
        res = (res + dp[n][i]) % mod;
    cout &amp;lt;&amp;lt; res;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>李超线段树</title><link>https://sanzenin.top/posts/obsidian/%E6%9D%8E%E8%B6%85%E7%BA%BF%E6%AE%B5%E6%A0%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%9D%8E%E8%B6%85%E7%BA%BF%E6%AE%B5%E6%A0%91/</guid><description>李超线段树是用于维护平面内线段关系的树. 全局插入版本,插入操作的复杂度为 局部插入版本,插入操作的复杂度为 上述两个版本的查询复杂度均为</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;李超线段树是用于维护平面内线段关系的树.&lt;/p&gt;
&lt;p&gt;全局插入版本,插入操作的复杂度为 $O(nlog(n))$&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define pr pair&amp;lt;ll, ll&amp;gt;
#define ll long long
using namespace std;
long long n, m, ans, k;
const ll mod = 1e9 + 7;
#define inf 1e12
#define N 1e6 + 1
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k;
    vector&amp;lt;int&amp;gt; tr((k + 1) * 4 + 5, 0);
    vector&amp;lt;pr&amp;gt; segments;
    auto cal = [&amp;amp;](ll x, int id) {
        return (segments[id].second - segments[id].first) * (x - 1) / (k) + segments[id].first;
    };
#define lc x &amp;lt;&amp;lt; 1
#define rc x &amp;lt;&amp;lt; 1 | 1
    auto insert = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int l, int r, int id) -&amp;gt; void {
        ll mid = (l + r) &amp;gt;&amp;gt; 1;
        if (cal(mid, id) &amp;gt; cal(mid, tr[x]))
            swap(tr[x], id);
        if (cal(l, id) &amp;gt; cal(l, tr[x]))
            self(self, lc, l, mid, id);
        if (cal(r, id) &amp;gt; cal(r, tr[x]))
            self(self, rc, mid + 1, r, id);
    };
    auto query = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int l, int r, int aim) -&amp;gt; ll {
        auto mid = (l + r) &amp;gt;&amp;gt; 1;
        auto ans = cal(aim, tr[x]);
        if (l == r)
            return ans;
        if (aim &amp;lt;= mid)
            return max(ans, self(self, lc, l, mid, aim));
        else
            return max(ans, self(self, rc, mid + 1, r, aim));
    };
    for (int i = 1; i &amp;lt;= n; i++) {
        ll x, y;
        cin &amp;gt;&amp;gt; x &amp;gt;&amp;gt; y;
        segments.push_back({x, y});
        insert(insert, 1, 1, k + 1, segments.size() - 1);
    }
    for (int i = 0; i &amp;lt;= k; i++) {
        cout &amp;lt;&amp;lt; query(query, 1, 1, k + 1, i + 1) &amp;lt;&amp;lt; &apos; &apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;局部插入版本,插入操作的复杂度为 $O(nlog^2(n))$&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define pr pair&amp;lt;ll, ll&amp;gt;
#define ll long long
using namespace std;
long long n, m, ans, k;
const ll mod = 1e9 + 7;
#define inf 1e12
#define N 1e6 + 1
class Point {
  public:
    ll x = 0, y = 0;
    ll operator*(const Point &amp;amp;oth) const { return x * oth.x + y * oth.y; }
    ll operator^(const Point &amp;amp;oth) const { return x * oth.y - y * oth.x; }
    Point operator+(const Point &amp;amp;oth) const { return {x + oth.x, y + oth.y}; }
    Point operator-(const Point &amp;amp;oth) { return {x - oth.x, y - oth.y}; }
    ll dis(const Point &amp;amp;oth) { return (x - oth.x) * (x - oth.x) + (y - oth.y) * (y - oth.y); }
    bool operator&amp;lt;(const Point &amp;amp;oth) { return make_pair(x, y) &amp;lt; make_pair(oth.x, oth.y); }
};
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; k;
    vector&amp;lt;int&amp;gt; tr((k + 1) * 4 + 5, 0);
    vector&amp;lt;pair&amp;lt;Point, Point&amp;gt;&amp;gt; segments{{{0, -1}, {k + 1, -1}}};
    auto cal = [&amp;amp;](ll x, int id) {
        x--;
        auto now = segments[id].second - segments[id].first;
        auto kk = (now.y) / now.x;
        return kk * x + segments[id].second.y - segments[id].second.x * kk;
    };
#define lc x &amp;lt;&amp;lt; 1
#define rc x &amp;lt;&amp;lt; 1 | 1
    auto insert = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int l, int r, int L, int R, int id) -&amp;gt; void {
        ll mid = (l + r) &amp;gt;&amp;gt; 1;
        if (l &amp;gt;= L &amp;amp;&amp;amp; r &amp;lt;= R) {
            if (cal(mid, id) &amp;gt; cal(mid, tr[x]))
                swap(tr[x], id);
            if (cal(l, id) &amp;gt; cal(l, tr[x]))
                self(self, lc, l, mid, L, R, id);
            if (cal(r, id) &amp;gt; cal(r, tr[x]))
                self(self, rc, mid + 1, r, L, R, id);
            return;
        }
        if (L &amp;lt;= mid)
            self(self, lc, l, mid, L, R, id);
        if (R &amp;gt; mid)
            self(self, rc, mid + 1, r, L, R, id);
    };
    auto query = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int l, int r, int aim) -&amp;gt; ll {
        auto mid = (l + r) &amp;gt;&amp;gt; 1;
        auto ans = cal(aim, tr[x]);
        if (l == r)
            return ans;
        if (aim &amp;lt;= mid)
            return max(ans, self(self, lc, l, mid, aim));
        else
            return max(ans, self(self, rc, mid + 1, r, aim));
    };
    for (int i = 1; i &amp;lt;= n; i++) {
        ll x1, y1, x2, y2;
        cin &amp;gt;&amp;gt; x1 &amp;gt;&amp;gt; y1 &amp;gt;&amp;gt; x2 &amp;gt;&amp;gt; y2;
        segments.push_back({{x1, y1}, {x2, y2}});
        insert(insert, 1, 1, k + 1, x1 + 1, x2 + 1, i);
    }
    for (int i = 0; i &amp;lt;= k; i++) {
        cout &amp;lt;&amp;lt; query(query, 1, 1, k + 1, i + 1) &amp;lt;&amp;lt; &apos; &apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;上述两个版本的查询复杂度均为$O(log(n))$&lt;/p&gt;
</content:encoded></item><item><title>欧拉路径，欧拉回路，欧拉图</title><link>https://sanzenin.top/posts/obsidian/%E6%AC%A7%E6%8B%89%E5%9B%9E%E8%B7%AF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%AC%A7%E6%8B%89%E5%9B%9E%E8%B7%AF/</guid><description>对于一个图，如果存在一条路径恰好经过所有边一次，则称这条路径为一条欧拉路径。 如果存在一条回路经过所有边恰好一次，则称这条路径为一条欧拉回路。 存在欧拉回路的图被称为欧拉图。 如果一个图的边集可以被分成若干个简单环，则称这个图可以环分解。 判定定理 1： 一个图存在欧拉回路当且仅当这个图可以被环分解。 充分性： 如果可</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;欧拉路径，欧拉回路，欧拉图&lt;/h1&gt;
&lt;p&gt;对于一个图，如果存在一条路径恰好经过所有边一次，则称这条路径为一条&lt;strong&gt;欧拉路径&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;如果存在一条回路经过所有边恰好一次，则称这条路径为一条&lt;strong&gt;欧拉回路&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;存在欧拉回路的图被称为&lt;strong&gt;欧拉图&lt;/strong&gt;。&lt;/p&gt;
&lt;h2&gt;环分解&lt;/h2&gt;
&lt;p&gt;如果一个图的边集可以被分成若干个简单环，则称这个图可以&lt;strong&gt;环分解&lt;/strong&gt;。&lt;/p&gt;
&lt;h2&gt;判定&lt;/h2&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;判定定理 1：&lt;/strong&gt; 一个图存在欧拉回路当且仅当这个图可以被环分解。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;充分性：&lt;/strong&gt; 如果可以环分解，那么每次选取两个相交的环合并成一个大环即可。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必要性：&lt;/strong&gt; 对于一条欧拉回路，每次遇到重复点就把这段路径连成的环分解出去，这样一定能形成若干个简单环。&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;判定定理 2：&lt;/strong&gt; 一个图可以被环分解当且仅当所有点度数都为偶数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;充分性：&lt;/strong&gt; 每次选取一个简单环，删掉之后所有点度数依旧是偶数，归纳即可。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;必要性：&lt;/strong&gt; 每个点进入次数和出去次数相等，因此都是偶数。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;结合上面两条我们可以得出欧拉回路的判定定理：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;判定定理 3：&lt;/strong&gt; 一个图存在欧拉回路当且仅当所有点度数都是偶数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;并且我们可以知道，一个图存在欧拉回路、可以被环分解、所有点度数都是偶数，这是三个完全等价的条件。&lt;/p&gt;
&lt;p&gt;对于有向图，类似的可以得出充要条件是所有节点入度等于出度。&lt;/p&gt;
&lt;p&gt;还有下面的推论：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;推论：&lt;/strong&gt; 一个图存在欧拉路径当且仅当恰好有两个结点的度数是奇数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h3&gt;有向图的判定&lt;/h3&gt;
&lt;p&gt;对于有向图，我们需要考虑每个节点的&lt;strong&gt;入度 (in-degree)&lt;/strong&gt; 和 &lt;strong&gt;出度 (out-degree)&lt;/strong&gt;。判定前提同样需要图是连通的（忽略度数为 0 的孤立点后，基图连通）。&lt;/p&gt;
&lt;h4&gt;1. 有向图欧拉回路&lt;/h4&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;判定定理 4：&lt;/strong&gt; 一个有向图存在欧拉回路，当且仅当：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;每个节点的入度等于出度，即对于所有节点 $v$，都有 $in(v) = out(v)$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;h4&gt;2. 有向图欧拉路径&lt;/h4&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;判定定理 5：&lt;/strong&gt; 一个有向图存在欧拉路径，当且仅当满足以下两种情况之一：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;符合欧拉回路的条件（起点和终点重合）。&lt;/li&gt;
&lt;li&gt;恰好有两个节点的入度不等于出度：
&lt;ul&gt;
&lt;li&gt;其中一个节点满足 $out(v) = in(v) + 1$（此为&lt;strong&gt;起点&lt;/strong&gt;）。&lt;/li&gt;
&lt;li&gt;另一个节点满足 $in(v) = out(v) + 1$（此为&lt;strong&gt;终点&lt;/strong&gt;）。&lt;/li&gt;
&lt;li&gt;其余所有节点的入度等于出度。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h3&gt;Hierholzer (HE) 算法&lt;/h3&gt;
&lt;p&gt;Hierholzer 算法是寻找欧拉回路或欧拉路径的一种高效算法，其核心思想是“贪心搜索 + 回溯记录”。&lt;/p&gt;
&lt;h4&gt;1. 算法流程&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;确定起点：&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;如果找欧拉回路，可以从任意度数不为 0 的点出发。&lt;/li&gt;
&lt;li&gt;如果找欧拉路径，必须从满足条件的“起点”（无向图中的奇度数点，或有向图中出度比入度多 1 的点）出发。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;DFS 遍历：&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;从当前节点出发，不断沿着未访问过的边向下搜索。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;当前弧优化：&lt;/strong&gt; 为了保证效率，每次访问一条边后，立刻将其从该点的边表中“逻辑删除”（通常用指针或索引移动），确保每条边只被扫描一次。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;回溯入栈：&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;当某个节点的所有关联边都已经访问完毕（无法再继续走下去）时，将该节点压入结果栈（或数组）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结果输出：&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;遍历结束后，将栈内的节点序列&lt;strong&gt;逆序输出&lt;/strong&gt;，即得到一条完整的欧拉路径/回路。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;3. 复杂度分析&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;时间复杂度：&lt;/strong&gt; $O(V + E)$，因为每条边只被访问并删除一次。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;比较&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;类型&lt;/th&gt;
&lt;th&gt;欧拉回路条件&lt;/th&gt;
&lt;th&gt;欧拉路径条件&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;无向图&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;所有点度数为偶数&lt;/td&gt;
&lt;td&gt;恰有 0 或 2 个奇度数点&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;有向图&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;所有点 $in = out$&lt;/td&gt;
&lt;td&gt;所有点 $in = out$；或只有起点 $out=in+1$ 且终点 $in=out+1$&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/1692&quot;&gt;CSES De Bruijn Sequence&lt;/a&gt;&lt;/p&gt;
&lt;h1&gt;De Bruijn 序列&lt;/h1&gt;
&lt;h2&gt;1. 定义&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;De Bruijn 序列&lt;/strong&gt; $B(k, n)$ 是一个在一个大小为 $k$ 的字符集上、包含所有长度为 $n$ 的子串各一次的&lt;strong&gt;循环序列&lt;/strong&gt;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;长度&lt;/strong&gt;：$k^n$（在圆环意义下）。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;性质&lt;/strong&gt;：任何长度为 $n$ 的组合都在该序列中作为一个连续子串出现，且只出现一次。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例&lt;/strong&gt; ($k=2, n=3$)：
循环序列 &lt;code&gt;00010111&lt;/code&gt; 包含了 &lt;code&gt;000, 001, 010, 101, 011, 111, 110, 100&lt;/code&gt; 全部 8 种情况。&lt;/p&gt;
&lt;h2&gt;2. 构造原理：De Bruijn 图与欧拉回路&lt;/h2&gt;
&lt;p&gt;构造 De Bruijn 序列的核心在于将其转化为一个&lt;strong&gt;图论问题&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;构图规则&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;节点 (Nodes)&lt;/strong&gt;：代表所有长度为 &lt;strong&gt;$n-1$&lt;/strong&gt; 的字符串。
&lt;ul&gt;
&lt;li&gt;节点总数：$k^{n-1}$。&lt;/li&gt;
&lt;li&gt;编号范围：$0$ 到 $k^{n-1} - 1$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;边 (Edges)&lt;/strong&gt;：代表一个“转移”操作，即添加一个新字符。
&lt;ul&gt;
&lt;li&gt;一条边对应一个长度为 &lt;strong&gt;$n$&lt;/strong&gt; 的字符串。&lt;/li&gt;
&lt;li&gt;边总数：$k^n$。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;转移逻辑 (滑动窗口)&lt;/h3&gt;
&lt;p&gt;从节点 $u$（代表前缀）转移到节点 $v$，意味着：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;扔掉&lt;/strong&gt; $u$ 的最高位。&lt;/li&gt;
&lt;li&gt;在末尾 &lt;strong&gt;添加&lt;/strong&gt; 一个新字符 $val$。&lt;/li&gt;
&lt;li&gt;形成新节点 $v$。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;数学公式（二进制 $k=2$）：
$$ v = ((u \ll 1) \ | \ val) \ &amp;amp; \ \text{mask} $$
其中 &lt;code&gt;mask&lt;/code&gt; 用于保留低 $n-1$ 位，&lt;code&gt;mask = (1 &amp;lt;&amp;lt; (n-1)) - 1&lt;/code&gt;。&lt;/p&gt;
&lt;h3&gt;为什么是欧拉回路？&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;每个节点代表 $n-1$ 位状态。&lt;/li&gt;
&lt;li&gt;每个节点都有 $k$ 个出边（加 0 或 加 1...）和 $k$ 个入边。&lt;/li&gt;
&lt;li&gt;图是连通的且 &lt;strong&gt;入度 = 出度&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;因此，该图一定存在&lt;strong&gt;欧拉回路&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;欧拉回路经过所有边恰好一次 $\rightarrow$ 生成所有长度为 $n$ 的子串恰好一次。&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
#define N 100005
#define inf 0x3f3f3f3f3f3f3f3f
#define ll long long
#define pr pair&amp;lt;ll, ll&amp;gt;
using namespace std;
int n, m, q, ma, k, cnt;
vector&amp;lt;vector&amp;lt;tuple&amp;lt;int, int, int&amp;gt;&amp;gt;&amp;gt; map1;
const ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n;
    if (n == 1) {
        cout &amp;lt;&amp;lt; &quot;10&quot;;
        return 0;
    }
    map1.assign(1 &amp;lt;&amp;lt; n, {});
    for (int i = 0; i &amp;lt; (1 &amp;lt;&amp;lt; (n - 1)); i++) {
        auto x = i;
        x &amp;gt;&amp;gt;= 1;
        map1[i].push_back({++cnt, 0, x});
        map1[i].push_back({++cnt, 1, x ^ (1 &amp;lt;&amp;lt; (n - 2))});
    }
    vector&amp;lt;int&amp;gt; ans;
    vector&amp;lt;bool&amp;gt; vis(cnt + 10, 0);
    vector&amp;lt;int&amp;gt; cur(1 &amp;lt;&amp;lt; n, 0);
    auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; void {
        for (int &amp;amp;i = cur[x]; i &amp;lt; map1[x].size(); i++) {
            auto [id, num, y] = map1[x][i];
            if (!vis[id]) {
                vis[id] = 1;
                self(self, y);
                ans.push_back(num);
            }
        }
    };
    dfs(dfs, 0);
    reverse(ans.begin(), ans.end());
    for (int i = 1; i &amp;lt; n; i++)
        cout &amp;lt;&amp;lt; 0;
    for (auto x : ans)
        cout &amp;lt;&amp;lt; x;
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
</content:encoded></item><item><title>原理</title><link>https://sanzenin.top/posts/obsidian/%E6%AC%A7%E6%8B%89%E7%AD%9B%E6%B3%95-%E7%BA%BF%E6%80%A7%E7%AD%9B/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%AC%A7%E6%8B%89%E7%AD%9B%E6%B3%95-%E7%BA%BF%E6%80%A7%E7%AD%9B/</guid><description>在埃氏筛中,我们会发现一个合数我们会筛多次,浪费大量时间,因此我们就会考虑,能不能让每个数只被筛一次?也就引出了欧拉筛,也就是线性筛. 线性筛保证了每个数只被其最小的质因数晒去.我们考虑算术基本定理, ,有 ,且 ,我们都用 去筛掉这个数,从而达成线性时间复杂度 洛谷模板 这里为什么要有i%p=\=0? 考虑当前从小到</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;原理&lt;/h1&gt;
&lt;p&gt;在埃氏筛中,我们会发现一个合数我们会筛多次,浪费大量时间,因此我们就会考虑,能不能让每个数只被筛一次?也就引出了欧拉筛,也就是线性筛.
线性筛保证了每个数只被其最小的质因数晒去.我们考虑算术基本定理,$\forall n \in \mathbb{N}$,有$n=p_1^{r_1}p_2^{r_2}\dots p_s^{r_s}$,且$p_1&amp;lt;p_2&amp;lt;\dots&amp;lt;p_n$
$\forall n$,我们都用$p_1$去筛掉这个数,从而达成线性时间复杂度&lt;/p&gt;
&lt;h1&gt;代码&lt;/h1&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P3383&quot;&gt;洛谷模板&lt;/a&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;ll&amp;gt; primes;
vector&amp;lt;bool&amp;gt; vis;
auto euler = [&amp;amp;](int n) {
    vis.assign(n + 10, 0);
    for (int i = 2; i &amp;lt;= n; i++) {
        if (!vis[i])
            primes.push_back(i);
        for (auto p : primes) {
            if (i * p &amp;gt; n)
                break;
            vis[i * p] = 1;
            if (i % p == 0)
                break;
        }
    }
};
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;em&gt;这里为什么要有i%p==0?&lt;/em&gt;
考虑当前从小到大枚举到了i,质数p,下一个质数为$p_{next}$ 如果此时不break,那么下一个要被筛掉的数为
$$Target=i\cdot p_{next}$$
由$p|i$,且p是从小到大枚举的,则p是筛掉i的第一个质因子
那么可以将i写为$$i=p\cdot m$$
代回得$$Target=p\cdot m\cdot p_{next}=p\cdot (m\cdot p_{next})$$
欧拉筛法一定是用每个最小的质因子筛去这个数,target的最小质因子应该为p,说明此时应该break,等i增长为$m\cdot p_{next}$才能筛去这个数&lt;/p&gt;
&lt;h1&gt;线性筛求积性函数&lt;/h1&gt;
&lt;p&gt;如果用动态规划的观点去看,我们每次筛数的过程也可以将i的信息以及p一起转移到i*p上,因此可以用来求解积性函数.&lt;/p&gt;
&lt;h3&gt;线性筛求解莫比乌斯函数 $\mu$&lt;/h3&gt;
&lt;p&gt;若 $i$ 为质数，则 $\mu(i) = -1$。&lt;/p&gt;
&lt;p&gt;在线性筛中，每个合数 $m$ 都是被&lt;strong&gt;最小的质因子&lt;/strong&gt;筛掉的。
设 $p_j$ 是 $m$ 的最小质因子，则 $m$ 通过 $m = i \times p_j$ 筛掉。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;若 $i$ 能被 $p_j$ 整除 ($i \pmod{p_j} = 0$)
则 $i$ 也包含质因子 $p_j$，这意味着 $m = i \times p_j$ 包含至少两个质因子 $p_j$（即 $m$ 含有平方因子 $p_j^2$）。
根据莫比乌斯函数的定义：
$$\mu(m) = 0$$&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;若 $i$ 不能被 $p_j$ 整除 ($i \pmod{p_j} \neq 0$)
则 $m$ 比 $i$ 多出一个&lt;strong&gt;不同&lt;/strong&gt;的质因子 $p_j$。
根据性质推导：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若 $\mu(i) = -1$，则 $\mu(m) = 1$&lt;/li&gt;
&lt;li&gt;若 $\mu(i) = 1$，则 $\mu(m) = -1$&lt;/li&gt;
&lt;li&gt;若 $\mu(i) = 0$，则 $\mu(m) = 0$&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;结论：&lt;/strong&gt;
在这种情况下，$$\mu(m) = -\mu(i)$$&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P3455&quot;&gt;P3455 [POI 2007] ZAP-Queries&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;题意简述&lt;/h3&gt;
&lt;p&gt;给定 $n, m, k$，求满足以下条件的数对 $(i, j)$ 的个数：
$$\sum_{i=1}^n \sum_{j=1}^m [\gcd(i, j) = k]$$&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;数据规模：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$1 \le k \le n, m \le 5 \times 10^4$&lt;/li&gt;
&lt;li&gt;$T$ 组询问，$T = 5 \times 10^4$&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h3&gt;莫比乌斯函数的性质&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;基本性质：&lt;/strong&gt;
$$\sum_{d|n} \mu(d) = [n = 1]$$
即：当 $n=1$ 时，和为 $1$；当 $n&amp;gt;1$ 时，和为 $0$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;推导应用：&lt;/strong&gt;
根据上述性质，我们可以将“最大公约数为 1”的条件转化为 $\mu$ 函数的求和：
$$[\gcd(i, j) = 1] = \sum_{d|\gcd(i, j)} \mu(d)$$&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;推导过程&lt;/h3&gt;
&lt;h4&gt;阶段一：特殊情况（当 $k=1$ 时）&lt;/h4&gt;
&lt;p&gt;目标：计算 $\sum_{i=1}^n \sum_{j=1}^m [\gcd(i, j) = 1]$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;代入 $\mu$ 函数性质：&lt;/strong&gt;
$$\sum_{i=1}^n \sum_{j=1}^m \sum_{d|\gcd(i, j)} \mu(d)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;变换求和顺序（枚举 $d$）：&lt;/strong&gt;
$$\sum_{d=1}^{\min(n, m)} \mu(d) \sum_{i=1}^n [d|i] \sum_{j=1}^m [d|j]$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;利用整除个数公式：&lt;/strong&gt;
由于 $1 \dots n$ 中 $d$ 的倍数共有 $\lfloor \frac{n}{d} \rfloor$ 个，故公式化简为：
$$\sum_{d=1}^{\min(n, m)} \mu(d) \lfloor \frac{n}{d} \rfloor \lfloor \frac{m}{d} \rfloor$$&lt;/li&gt;
&lt;/ol&gt;
&lt;blockquote&gt;
&lt;p&gt;该式可以使用 &lt;strong&gt;整除分块&lt;/strong&gt;（数论分块）在 $O(\sqrt{n})$ 的时间内求解。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h4&gt;阶段二：一般情况（任意 $k$）&lt;/h4&gt;
&lt;p&gt;目标：计算 $\sum_{i=1}^n \sum_{j=1}^m [\gcd(i, j) = k]$&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;变量替换：&lt;/strong&gt;
令 $i = i \cdot k, j = j \cdot k$，则 $\gcd(i, j) = k \iff \gcd(ik, jk) = k \iff \gcd(i, j) = 1$。
同时，新的范围变为 $i \in [1, \lfloor n/k \rfloor], j \in [1, \lfloor m/k \rfloor]$：
$$\sum_{i=1}^{\lfloor n/k \rfloor} \sum_{j=1}^{\lfloor m/k \rfloor} [\gcd(i, j) = 1]$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;代入阶段一的结论：&lt;/strong&gt;
通过相同的推导过程：
$$\sum_{i=1}^{\lfloor n/k \rfloor} \sum_{j=1}^{\lfloor m/k \rfloor} \sum_{d|\gcd(i, j)} \mu(d)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;得出最终公式：&lt;/strong&gt;
$$\sum_{d=1}^{\lfloor n/k \rfloor} \mu(d) \lfloor \frac{n}{kd} \rfloor \lfloor \frac{m}{kd} \rfloor$$&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cin &amp;gt;&amp;gt; n;
vector&amp;lt;ll&amp;gt; primes;
bitset&amp;lt;N&amp;gt; vis;
vector&amp;lt;ll&amp;gt; mu(N + 5, 0);
auto init = [&amp;amp;]() {
    mu[1] = 1;
    for (int i = 2; i &amp;lt;= N; i++) {
        if (!vis[i])
            primes.push_back(i), mu[i] = -1;
        for (auto p : primes) {
            if (i * p &amp;gt; N)
                break;
            vis[i * p] = 1;
            if (i % p == 0) {
                mu[i * p] = 0;
                break;
            } else {
                mu[i * p] = -mu[i];
            }
        }
    }
    for (int i = 1; i &amp;lt;= N; i++)
        mu[i] += mu[i - 1];
};
init();
auto cal = [&amp;amp;](ll a, ll b, ll d) {
    if (a &amp;gt; b)
        swap(a, b);
    a /= d, b /= d;
    ll res = 0;
    for (ll l = 1, r; l &amp;lt;= a; l = r + 1) {
        r = min(a / (a / l), b / (b / l));
        res += (mu[r] - mu[l - 1]) * (a / l) * (b / l);
    }
    return res;
};
while (n--) {
    ll a, b, d;
    cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b &amp;gt;&amp;gt; d;
    cout &amp;lt;&amp;lt; cal(a, b, d) &amp;lt;&amp;lt; &apos;\n&apos;;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P2158&quot;&gt;P2158 [SDOI2008] 仪仗队&lt;/a&gt;
类似的题目,将原点看作(0,0),从1开始计数直到n-1,对(0,1)与(1,0)特殊讨论,注意n=1&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vector&amp;lt;ll&amp;gt; primes;
bitset&amp;lt;N&amp;gt; vis;
vector&amp;lt;ll&amp;gt; mu(N + 5, 0);
auto init = [&amp;amp;]() {
    mu[1] = 1;
    for (int i = 2; i &amp;lt;= N; i++) {
        if (!vis[i])
            primes.push_back(i), mu[i] = -1;
        for (auto p : primes) {
            if (i * p &amp;gt; N)
                break;
            vis[i * p] = 1;
            if (i % p == 0) {
                mu[i * p] = 0;
                break;
            } else {
                mu[i * p] = -mu[i];
            }
        }
    }
    for (int i = 1; i &amp;lt;= N; i++)
        mu[i] += mu[i - 1];
};
init();
auto cal = [&amp;amp;](ll n) {
    ll res = 0;
    for (ll l = 1, r; l &amp;lt;= n; l = r + 1) {
        r = (n / (n / l));
        res += (mu[r] - mu[l - 1]) * (n / l) * (n / l);
    }
    return res;
};
cin &amp;gt;&amp;gt; n;
cout &amp;lt;&amp;lt; cal(n - 1) + (n == 1 ? 0 : 2);
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/2417&quot;&gt;CSES Counting Coprime Pairs&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;1. 问题定义&lt;/h3&gt;
&lt;p&gt;假设给定数组 $A$ 包含 $n$ 个正整数 $x_1, x_2, \dots, x_n$。
我们需要计算满足 $\gcd(x_i, x_j) = 1$ 的数对 $(i, j)$ 的数量（其中 $1 \le i &amp;lt; j \le n$）。&lt;/p&gt;
&lt;h3&gt;2. 引入莫比乌斯函数性质&lt;/h3&gt;
&lt;p&gt;代入上式：
$$
[\gcd(x_i, x_j) = 1] = \sum_{d | \gcd(x_i, x_j)} \mu(d)
$$&lt;/p&gt;
&lt;h3&gt;3. 代入原式&lt;/h3&gt;
&lt;p&gt;将步骤 2 的等式代入 $Ans$ 的定义中：
$$
Ans = \sum_{1 \le i &amp;lt; j \le n} \left( \sum_{d | \gcd(x_i, x_j)} \mu(d) \right)
$$&lt;/p&gt;
&lt;h3&gt;4. 交换求和顺序&lt;/h3&gt;
&lt;p&gt;目前的求和逻辑是：先枚举所有数对 $(i, j)$，再枚举它们 GCD 的因子 $d$。
为了优化计算，我们需要&lt;strong&gt;交换求和顺序&lt;/strong&gt;：先枚举可能的因子 $d$，再统计有多少对 $(i, j)$ 的 GCD 是 $d$ 的倍数。&lt;/p&gt;
&lt;p&gt;$$
Ans = \sum_{d=1}^{V} \mu(d) \times \sum_{1 \le i &amp;lt; j \le n} [d | \gcd(x_i, x_j)]
$$&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;$V$ 是数组中元素的最大值（本题中为 $10^6$）。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;5. 简化计数条件&lt;/h3&gt;
&lt;p&gt;观察内部的求和条件：
$$
[d | \gcd(x_i, x_j)]
$$
这意味着 $d$ 必须同时整除 $x_i$ 和 $x_j$。即 $x_i$ 和 $x_j$ 都必须是 $d$ 的倍数。&lt;/p&gt;
&lt;p&gt;我们定义 $cnt[d]$ 为输入数组中 &lt;strong&gt;$d$ 的倍数的个数&lt;/strong&gt;。
$$
cnt[d] = \sum_{k=1}^{n} [d | x_k]
$$&lt;/p&gt;
&lt;p&gt;在内部求和中，我们需要从这 $cnt[d]$ 个倍数中，任意选出 2 个组成一对 $(i, j)$（且 $i &amp;lt; j$）。
根据组合数学，从 $m$ 个元素中选 2 个的方案数为 $\binom{m}{2}$。&lt;/p&gt;
&lt;p&gt;因此，内部求和的值为：
$$
\sum_{1 \le i &amp;lt; j \le n} [d | \gcd(x_i, x_j)] = \binom{cnt[d]}{2} = \frac{cnt[d] \times (cnt[d] - 1)}{2}
$$&lt;/p&gt;
&lt;h3&gt;6. 最终公式&lt;/h3&gt;
&lt;p&gt;将步骤 5 的结果代回步骤 4 的公式，得到最终的可计算公式：&lt;/p&gt;
&lt;p&gt;$$
Ans = \sum_{d=1}^{V} \mu(d) \times \frac{cnt[d] \times (cnt[d] - 1)}{2}
$$
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cin &amp;gt;&amp;gt; n;
vector&amp;lt;ll&amp;gt; s(n + 5, 0);
vector&amp;lt;ll&amp;gt; primes;
vector&amp;lt;ll&amp;gt; mu(N + 5, 0);
vector&amp;lt;ll&amp;gt; cnt(N + 5, 0);
unordered_map&amp;lt;ll, ll&amp;gt; nums;
auto euler = [&amp;amp;]() {
    bitset&amp;lt;N + 5&amp;gt; vis;
    mu[1] = 1;
    for (ll i = 2; i &amp;lt;= N; i++) {
        if (!vis[i]) {
            primes.push_back(i), mu[i] = -1;
        }
        for (auto x : primes) {
            if (i * x &amp;gt; N)
                break;
            vis[i * x] = 1;
            if (i % x == 0) {
                mu[i * x] = 0;
                break;
            } else {
                mu[i * x] = -mu[i];
            }
        }
    }
};
euler();
for (int i = 1; i &amp;lt;= n; i++)
    cin &amp;gt;&amp;gt; s[i], nums[s[i]]++, ma = max(ma, s[i]);
for (ll d = 1; d &amp;lt;= ma; d++) {
    for (ll j = d; j &amp;lt;= ma; j += d) {
        if (nums.count(j))
            cnt[d] += nums[j];
    } // 由调和级数为nlogn复杂度
}
for (int i = 1; i &amp;lt;= ma; i++) {
    ans += mu[i] * (cnt[i] - 1) * cnt[i] / 2;
}
cout &amp;lt;&amp;lt; ans;
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>网络流板子</title><link>https://sanzenin.top/posts/obsidian/%E7%BD%91%E7%BB%9C%E6%B5%81%E6%9D%BF%E5%AD%90/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%BD%91%E7%BB%9C%E6%B5%81%E6%9D%BF%E5%AD%90/</guid><description>网络流板子，来自 Obsidian 的算法笔记。</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;dinic板子&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;
#include &amp;lt;bits/stdc++.h&amp;gt;
#include &amp;lt;iterator&amp;gt;
#include &amp;lt;queue&amp;gt;
#include &amp;lt;set&amp;gt;
#include &amp;lt;unordered_map&amp;gt;
#define N 100005
#define inf 0x3f3f3f3f3f3f3f3f
#define ll long long
#define pr pair&amp;lt;int, int&amp;gt;
using namespace std;
int n, m, q, ma, block;
vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; map1;
vector&amp;lt;pr&amp;gt; edges;
const ll mod = 1e9 + 7;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    map1.assign(n + 5, {});
    for (int i = 1; i &amp;lt;= m; i++) {
        int a, b, c;
        cin &amp;gt;&amp;gt; a &amp;gt;&amp;gt; b &amp;gt;&amp;gt; c;
        edges.push_back({b, c});
        map1[a].push_back(edges.size() - 1);
        edges.push_back({a, 0});
        map1[b].push_back(edges.size() - 1);
    }
    vector&amp;lt;int&amp;gt; cur;
    vector&amp;lt;int&amp;gt; d;
    auto bfs = [&amp;amp;](int st, int en) -&amp;gt; bool {
        queue&amp;lt;int&amp;gt; q;
        d.assign(n + 5, 0);
        q.push(st);
        d[st] = 1;
        while (q.size()) {
            auto x = q.front();
            q.pop();
            for (auto id : map1[x]) {
                auto [y, w] = edges[id];
                if (w &amp;amp;&amp;amp; !d[y]) {
                    d[y] = d[x] + 1;
                    q.push(y);
                }
            }
        }
        return d[en];
    };
    auto dinic = [&amp;amp;](int st, int en) {
        auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, ll flow) -&amp;gt; ll {
            ll res = 0;
            if (x == en)
                return flow;
            for (auto &amp;amp;i = cur[x]; i &amp;lt; map1[x].size(); i++) {
                auto &amp;amp;[v, w] = edges[map1[x][i]];
                if (w &amp;amp;&amp;amp; d[v] == d[x] + 1) {
                    auto tem = self(self, v, min(flow, (ll)w));
                    edges[map1[x][i] ^ 1].second += tem, res += tem, w -= tem, flow -= tem;
                }
            }
            if (!res)
                d[x] = 0;
            return res;
        };
        ll res = 0;
        while (bfs(st, en)) {
            cur.assign(n + 5, {});
            res += dfs(dfs, st, 1e9);
        }
        return res;
    };
    cout &amp;lt;&amp;lt; dinic(1, n);
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最小割&lt;/p&gt;
</content:encoded></item><item><title>范德蒙德卷积 (Vandermonde&apos;s Convolution)</title><link>https://sanzenin.top/posts/obsidian/%E8%8C%83%E5%BE%B7%E8%92%99%E5%BE%B7%E5%8D%B7%E7%A7%AF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E8%8C%83%E5%BE%B7%E8%92%99%E5%BE%B7%E5%8D%B7%E7%A7%AF/</guid><description>考虑一个大小为 的集合，其中前 个元素标记为红色，后 个元素标记为蓝色。 从这 个元素中任意选取 个元素的总方案数为 。 若按选出的红色元素个数 分类（ ），则需要从 个红色中选 个，同时从 个蓝色中选 个，方案数为 。 对所有可能的 求和，二者必然相等。 1. 对称平方和： 2. 上指标求和 (朱世杰恒等式)： 3.</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;范德蒙德卷积 (Vandermonde&apos;s Convolution)&lt;/h1&gt;
&lt;h2&gt;1. 核心恒等式&lt;/h2&gt;
&lt;p&gt;$$
\sum_{k=0}^r \binom{m}{k} \binom{n}{r - k} = \binom{m + n}{r}
$$&lt;/p&gt;
&lt;h2&gt;2. 组合意义证明&lt;/h2&gt;
&lt;p&gt;考虑一个大小为 $m + n$ 的集合，其中前 $m$ 个元素标记为红色，后 $n$ 个元素标记为蓝色。
从这 $m + n$ 个元素中任意选取 $r$ 个元素的总方案数为 $\binom{m+n}{r}$。
若按选出的红色元素个数 $k$ 分类（$0 \le k \le r$），则需要从 $m$ 个红色中选 $k$ 个，同时从 $n$ 个蓝色中选 $r-k$ 个，方案数为 $\binom{m}{k}\binom{n}{r-k}$。
对所有可能的 $k$ 求和，二者必然相等。&lt;/p&gt;
&lt;h2&gt;3. 常用推论与变形&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;对称平方和&lt;/strong&gt;：
$$
\sum_{k=0}^n \binom{n}{k}^2 = \sum_{k=0}^n \binom{n}{k} \binom{n}{n - k} = \binom{2n}{n}
$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;上指标求和 (朱世杰恒等式)&lt;/strong&gt;：
$$
\sum_{i=0}^n \binom{i}{k} = \binom{n + 1}{k + 1}
$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;带权范德蒙德卷积&lt;/strong&gt;：
$$
\sum_{k=0}^r k \binom{m}{k} \binom{n}{r - k} = m \binom{m + n - 1}{r - 1}
$$&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;4. 竞赛实战应用：二重计数化简模板&lt;/h2&gt;
&lt;p&gt;在很多组合计数问题中，面对形如 $\sum_{k} \binom{m}{k} \binom{n}{r-k}$ 的二重求和，直接计算为 $O(N)$；使用范德蒙德卷积可化简为单次 $O(1)$ 的组合数 $\binom{m+n}{r}$ 查询。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;
const int MOD = 998244353;
const int N = 200005;
ll fac[N], ifac[N];
ll qpow(ll a, ll b) {
    ll res = 1;
    while (b) {
        if (b &amp;amp; 1)
            res = res * a % MOD;
        a = a * a % MOD;
        b &amp;gt;&amp;gt;= 1;
    }
    return res;
}
void init_comb(int n) {
    fac[0] = 1;
    for (int i = 1; i &amp;lt;= n; i++)
        fac[i] = fac[i - 1] * i % MOD;
    ifac[n] = qpow(fac[n], MOD - 2);
    for (int i = n; i &amp;gt;= 1; i--)
        ifac[i - 1] = ifac[i] * i % MOD;
}
ll C(int n, int m) {
    if (m &amp;lt; 0 || m &amp;gt; n)
        return 0;
    return fac[n] * ifac[m] % MOD * ifac[n - m] % MOD;
}
// 范德蒙德卷积求和：sum_{k=0}^r C(m, k) * C(n, r-k) = C(m+n, r)
ll vandermonde(int m, int n, int r) {
    if (r &amp;lt; 0 || r &amp;gt; m + n)
        return 0;
    return C(m + n, r);
}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>错排问题</title><link>https://sanzenin.top/posts/obsidian/%E9%94%99%E6%8E%92%E9%97%AE%E9%A2%98/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E9%94%99%E6%8E%92%E9%97%AE%E9%A2%98/</guid><description>考虑这样的一个问题,n个人互相送礼物,要求礼物不能留给自己,最后会有多少种方案数? 我们发现直接求解析式很难,需要用到容斥原理,因此我们考虑求递推公式, 令 为n个人互相送礼物的方案数.我们考虑第一个人a会如何送出手中的礼物.显然除自己外a有n-1种送出礼物的方案,假设送给了b,那么b有几种送礼物的方案呢? 1. 送给</description><pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;考虑这样的一个问题,n个人互相送礼物,要求礼物不能留给自己,最后会有多少种方案数?&lt;/p&gt;
&lt;h3&gt;思路&lt;/h3&gt;
&lt;p&gt;我们发现直接求解析式很难,需要用到容斥原理,因此我们考虑求递推公式,
令$f(n)$为n个人互相送礼物的方案数.我们考虑第一个人a会如何送出手中的礼物.显然除自己外a有n-1种送出礼物的方案,假设送给了b,那么b有几种送礼物的方案呢?&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;送给a,那么剩下还要n-2个人的礼物需要处理,即$f(n-2)$种方案数&lt;/li&gt;
&lt;li&gt;不送给a,这时候不妨把a的位置看作b的位置,也就变成了n-1个人的错排问题,共有$f(n-1)$种方案数
综上,递推公式为$$f(n)=(n-1)*(f(n-2)+f(n-1))$$
易得$f(1)=0,f(2)=1$,直接进行递推即可&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;模板题&lt;/h3&gt;
&lt;p&gt;&lt;a href=&quot;https://cses.fi/problemset/task/1717/&quot;&gt;CSES  Christmas Party&lt;/a&gt;
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;auto cal = [&amp;amp;](auto &amp;amp;&amp;amp;self, int n) -&amp;gt; ll {
    if (n == 1)
        return 0;
    if (n == 2)
        return 1;
    if (f[n])
        return f[n];
    return f[n] = (n - 1) * ((self(self, n - 1) + self(self, n - 2)) % mod) % mod;
};
cin &amp;gt;&amp;gt; n;
cout &amp;lt;&amp;lt; cal(cal, n);
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Peterson 算法笔记</title><link>https://sanzenin.top/posts/obsidian/%E5%B9%B6%E5%8F%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E5%B9%B6%E5%8F%91/</guid><description>多个进程/线程同时访问共享数据时，会产生竞态条件（Race Condition）。 例如： count++实际上不是一步： 如果两个进程交错执行： 最终： 而不是： 因此需要保证： 同一时间只能有一个进程进入修改共享数据的代码区域。 这个区域称为： 临界区（Critical Section） 一个正确的同步算法需要满足</description><pubDate>Tue, 25 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Peterson 算法笔记&lt;/h1&gt;
&lt;h2&gt;1. 问题背景：临界区（Critical Section）&lt;/h2&gt;
&lt;p&gt;多个进程/线程同时访问共享数据时，会产生&lt;strong&gt;竞态条件（Race Condition）&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int count = 0;

// 进程A
count++;

// 进程B
count++;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;count++&lt;/code&gt;实际上不是一步：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;读取count
+
1
+
写回count
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果两个进程交错执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A读 count=0
B读 count=0

A写 count=1
B写 count=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最终：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;count=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而不是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;count=2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此需要保证：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;同一时间只能有一个进程进入修改共享数据的代码区域。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这个区域称为：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;临界区（Critical Section）&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 临界区问题的三个要求&lt;/h1&gt;
&lt;p&gt;一个正确的同步算法需要满足：&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;(1) 互斥 Mutual Exclusion&lt;/h2&gt;
&lt;p&gt;任何时刻：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;最多只有一个进程在临界区。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;P0进入临界区

P1必须等待
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;(2) 进展 Progress&lt;/h2&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;当前没有人在临界区&lt;/li&gt;
&lt;li&gt;有进程想进入&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不能无限等待，必须决定谁进入。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;(3) 有限等待 Bounded Waiting&lt;/h2&gt;
&lt;p&gt;一个进程请求进入后：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不能永远被其他进程插队。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;防止：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;P0进去
P0出来
P0又进去
P0又出来

P1永远等待
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;3. Peterson算法简介&lt;/h1&gt;
&lt;p&gt;Peterson算法：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;一个只使用共享变量的软件算法，用于解决两个进程之间的临界区互斥问题。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;特点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;只支持两个进程&lt;/li&gt;
&lt;li&gt;不需要硬件锁指令&lt;/li&gt;
&lt;li&gt;通过共享变量实现同步&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;两个进程：

P0
P1
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;4. Peterson算法核心变量&lt;/h1&gt;
&lt;p&gt;两个共享变量：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;bool flag[2];

int turn;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;(1) flag数组&lt;/h2&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;某个进程是否想进入临界区。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flag[0]=true;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;P0想进入临界区
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;flag[1]=true;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;P1想进入临界区
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;(2) turn变量&lt;/h2&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;如果两个进程同时想进入，让谁优先。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;turn=1;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;如果发生冲突，让P1先进入
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;5. Peterson算法代码&lt;/h1&gt;
&lt;p&gt;对于进程 Pi：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;do {

    flag[i] = true;

    turn = j;


    while(flag[j] &amp;amp;&amp;amp; turn == j)
        ;


    // critical section


    flag[i] = false;


    // remainder section


} while(true);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;i = 当前进程编号

j = 另一个进程编号
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;P0：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;i=0
j=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;P1：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;i=1
j=0
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;6. 代码含义&lt;/h1&gt;
&lt;h2&gt;第一步：表示想进入&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;flag[i]=true;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;含义：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要进入临界区
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;第二步：主动让对方优先&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;turn=j;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;含义：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;如果我们同时想进入，
让对方先
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么？&lt;/p&gt;
&lt;p&gt;因为两个进程都会执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;turn=对方
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最后写入 turn 的进程会让出机会。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第三步：等待&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;while(flag[j] &amp;amp;&amp;amp; turn==j);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;翻译：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;如果：

对方也想进入
并且

现在轮到对方

那么我等待
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;第四步：进入临界区&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;// critical section
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;此时：&lt;/p&gt;
&lt;p&gt;只有一个进程执行。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第五步：退出&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;flag[i]=false;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我已经退出，可以让别人进入。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;7. 关键情况分析：两个进程同时进入&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;p&gt;P0、P1同时想进入。&lt;/p&gt;
&lt;p&gt;初始：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flag[0]=false
flag[1]=false
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;P0执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flag[0]=true;
turn=1;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;P0想进入
冲突时让P1
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;P1执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flag[1]=true;
turn=0;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;P1想进入
冲突时让P0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最终：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flag[0]=true
flag[1]=true

turn=0
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;P0检查：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(flag[1] &amp;amp;&amp;amp; turn==1)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;代入：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;true &amp;amp;&amp;amp; false
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;结果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;false
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;P0进入。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;P1检查：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(flag[0] &amp;amp;&amp;amp; turn==0)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;代入：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;true &amp;amp;&amp;amp; true
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;等待。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;结果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;P0进入临界区
P1等待
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;保证互斥。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;8. 为什么一定不会同时进入？&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;p&gt;P0和P1同时进入。&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flag[0]=true
flag[1]=true
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;两个进程都不能依靠 flag 放行。&lt;/p&gt;
&lt;p&gt;只能依靠：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;turn
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;turn只能等于0或者1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不可能：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;turn=0
同时
turn=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;p&gt;两个进程不可能同时满足进入条件。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;9. Peterson算法的问题&lt;/h1&gt;
&lt;h2&gt;(1) 只能两个进程&lt;/h2&gt;
&lt;p&gt;不能直接扩展到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;P0
P1
P2
...
Pn
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;(2) 忙等待（Busy Waiting）&lt;/h2&gt;
&lt;p&gt;等待代码：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(...)
    ;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU一直执行循环。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU:

检查
检查
检查
检查
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;浪费CPU资源。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;(3) 依赖内存访问顺序&lt;/h2&gt;
&lt;p&gt;现代CPU可能：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;指令乱序执行&lt;/li&gt;
&lt;li&gt;缓存不一致&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;实际系统需要：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;原子指令&lt;/li&gt;
&lt;li&gt;内存屏障（Memory Barrier）&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h1&gt;10. Peterson算法在OS中的意义&lt;/h1&gt;
&lt;p&gt;Peterson算法现在很少直接使用。&lt;/p&gt;
&lt;p&gt;但是它展示了：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;仅靠共享变量，也可以构造进程同步机制。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;发展路线：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Peterson算法
        |
        ↓
硬件原子指令
        |
        ↓
自旋锁 Spinlock
        |
        ↓
互斥锁 Mutex
        |
        ↓
信号量 Semaphore
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;11. 一句话总结&lt;/h1&gt;
&lt;p&gt;&lt;strong&gt;Peterson算法：&lt;/strong&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;两个进程通过 &lt;code&gt;flag[]&lt;/code&gt; 表示“我想进入”，通过 &lt;code&gt;turn&lt;/code&gt; 表示“冲突时谁优先”，利用二者组合保证任意时刻只有一个进程进入临界区。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;核心：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flag[i]=true;    // 我要进入

turn=j;          // 让对方优先

while(flag[j] &amp;amp;&amp;amp; turn==j);
// 等待


// 临界区


flag[i]=false;   // 退出
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;记忆：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flag = 意愿
turn = 谦让

有意愿 + 有优先级
=&amp;gt; 保证互斥
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;你已经理解 Peterson 算法了。现在来看：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;自旋锁（Spinlock）&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;互斥锁（Mutex）&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;它们其实都是为了解决同一个问题：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;两个人不能同时使用同一个东西。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;一个厕所 🚻

小明想进去
小红也想进去

怎么办？
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;一、自旋锁（Spinlock）&lt;/h1&gt;
&lt;h2&gt;1. 最简单理解&lt;/h2&gt;
&lt;p&gt;自旋锁就是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;门口放一个锁，进不去的人一直站在那里看门有没有开。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;p&gt;厕所：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;🚻
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;门上有一个状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0 = 没人
1 = 有人
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;小明来了：&lt;/p&gt;
&lt;p&gt;发现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;锁=0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;锁=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进去。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;小红来了：&lt;/p&gt;
&lt;p&gt;发现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;锁=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;说明：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;有人正在里面
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;怎么办？&lt;/p&gt;
&lt;p&gt;她不走。&lt;/p&gt;
&lt;p&gt;她一直：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;看
看
看
看
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;直到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;锁=0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后进去。&lt;/p&gt;
&lt;p&gt;这就是：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;自旋（spin）&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 代码长什么样？&lt;/h1&gt;
&lt;p&gt;非常像 Peterson：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(lock == 1)
{
    // 什么也不干，一直等
}

lock = 1;


// 临界区


lock = 0;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;重点：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;里面一直循环。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;3. 为什么叫自旋？&lt;/h1&gt;
&lt;p&gt;因为CPU像这样：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;检查锁

↓

没开

↓

再检查

↓

没开

↓

再检查
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;像原地转圈：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;spin spin spin
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以叫：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Spin Lock（自旋锁）&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;4. 自旋锁的问题&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;p&gt;小明进去厕所：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;10秒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;小红：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;门口等10秒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;她一直：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;看门
看门
看门
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU也一样：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(lock)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;100%
100%
100%
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是啥也没干。&lt;/p&gt;
&lt;p&gt;浪费。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;5. 那什么时候用自旋锁？&lt;/h1&gt;
&lt;p&gt;如果等待时间非常短：&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;等1微秒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那睡觉反而更麻烦。&lt;/p&gt;
&lt;p&gt;因为睡眠需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;保存状态
↓
切换进程
↓
唤醒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个过程可能比等待还慢。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;短等待：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;自旋锁
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;二、互斥锁（Mutex）&lt;/h1&gt;
&lt;p&gt;Mutex：&lt;/p&gt;
&lt;p&gt;全称：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Mutual Exclusion Lock&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;意思：&lt;/p&gt;
&lt;p&gt;互斥锁。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 小学生版本&lt;/h2&gt;
&lt;p&gt;还是厕所。&lt;/p&gt;
&lt;p&gt;小红来了：&lt;/p&gt;
&lt;p&gt;发现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;有人
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;她不会站在那里一直看。&lt;/p&gt;
&lt;p&gt;她：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;去旁边休息
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;等有人通知：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;厕所空了
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;再回来。&lt;/p&gt;
&lt;p&gt;这就是互斥锁。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 和自旋锁区别&lt;/h1&gt;
&lt;h2&gt;自旋锁：&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;等待的人：

站门口

一直看
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;图：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;小明 🚻

小红 👀👀👀
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;互斥锁：&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;小明 🚻

小红 😴

等待通知
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;3. 操作系统里面发生什么？&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;p&gt;进程A拿锁：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;成功：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;进入临界区
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进程B：&lt;/p&gt;
&lt;p&gt;也：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;发现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;锁已经有人拿了
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;怎么办？&lt;/p&gt;
&lt;p&gt;不是循环。&lt;/p&gt;
&lt;p&gt;而是：&lt;/p&gt;
&lt;p&gt;操作系统：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;把B挂起
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;阻塞(Block)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;p&gt;原来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A运行
B运行
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;变成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A运行

B睡觉
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;等A：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;unlock()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;释放锁。&lt;/p&gt;
&lt;p&gt;系统：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;唤醒B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;B继续。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;4. Mutex大概实现&lt;/h1&gt;
&lt;p&gt;伪代码：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock(){

    if(lock_free)
    {
        获取锁;
    }
    else
    {
        睡眠等待;
    }

}


unlock(){

    释放锁;

    唤醒等待者;

}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;三、自旋锁 vs 互斥锁&lt;/h1&gt;
&lt;p&gt;看这个表：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;自旋锁&lt;/th&gt;
&lt;th&gt;互斥锁&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;等待方式&lt;/td&gt;
&lt;td&gt;一直循环&lt;/td&gt;
&lt;td&gt;睡眠等待&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CPU占用&lt;/td&gt;
&lt;td&gt;高&lt;/td&gt;
&lt;td&gt;低&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;切换进程&lt;/td&gt;
&lt;td&gt;不需要&lt;/td&gt;
&lt;td&gt;需要&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;适合&lt;/td&gt;
&lt;td&gt;短等待&lt;/td&gt;
&lt;td&gt;长等待&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;实现难度&lt;/td&gt;
&lt;td&gt;简单&lt;/td&gt;
&lt;td&gt;复杂&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;常用于&lt;/td&gt;
&lt;td&gt;内核&lt;/td&gt;
&lt;td&gt;用户程序&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h1&gt;四、举个实际例子&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;h2&gt;情况1&lt;/h2&gt;
&lt;p&gt;锁只需要等：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;100纳秒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;修改一个内核变量。&lt;/p&gt;
&lt;p&gt;如果用mutex：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;睡眠
唤醒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;花：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;几微秒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;反而更慢。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;自旋锁
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;情况2&lt;/h2&gt;
&lt;p&gt;锁可能等：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;5秒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;下载文件。&lt;/p&gt;
&lt;p&gt;如果自旋：&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;100%
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;5秒。&lt;/p&gt;
&lt;p&gt;太浪费。&lt;/p&gt;
&lt;p&gt;使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mutex
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;让线程睡觉。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;五、它们和Peterson算法关系&lt;/h1&gt;
&lt;p&gt;你刚学的：&lt;/p&gt;
&lt;p&gt;Peterson：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;软件方法
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;↓&lt;/p&gt;
&lt;p&gt;自旋锁：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;硬件支持的简单锁
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;↓&lt;/p&gt;
&lt;p&gt;mutex：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;操作系统管理的锁
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;发展：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Peterson算法

     ↓

spinlock
(一直等)

     ↓

mutex
(睡眠等待)

     ↓

semaphore
(多个资源)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;六、为什么需要硬件？&lt;/h1&gt;
&lt;p&gt;这里有一个关键问题：&lt;/p&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock=0;

if(lock==0)
    lock=1;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;两个CPU同时执行：&lt;/p&gt;
&lt;p&gt;CPU1：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;看到0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU2：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;看到0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;p&gt;CPU1：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU2：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;两个都进去了。&lt;/p&gt;
&lt;p&gt;失败。&lt;/p&gt;
&lt;p&gt;所以现代锁需要：&lt;/p&gt;
&lt;h2&gt;原子操作&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;test_and_set()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;检查并修改必须一步完成。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;CPU保证：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;别人不能插进来。
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;最后记忆版&lt;/h1&gt;
&lt;h2&gt;自旋锁&lt;/h2&gt;
&lt;p&gt;一句话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;抢不到锁的人一直在那里等。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;特点：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(lock)
    ;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;快&lt;/li&gt;
&lt;li&gt;没有线程切换&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;缺点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;浪费CPU&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;互斥锁&lt;/h2&gt;
&lt;p&gt;一句话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;抢不到锁的人睡觉，等别人叫醒。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;特点：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock失败

↓

阻塞

↓

等待唤醒
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;节省CPU&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;缺点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;有上下文切换开销&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;最核心区别：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;自旋锁：
    等待 = 消耗CPU

互斥锁：
    等待 = 让出CPU
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;你后面学 Linux 内核时会看到一个很有意思的设计：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Linux 内核里面大量使用 spinlock，而普通应用程序大量使用 mutex。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;原因就是：&lt;strong&gt;内核不能随便睡眠，而用户程序更关心CPU利用率。&lt;/strong&gt;&lt;/p&gt;
&lt;h1&gt;条件变量中的 &lt;code&gt;while + wait&lt;/code&gt; 机制笔记&lt;/h1&gt;
&lt;h2&gt;1. 背景：为什么需要条件变量？&lt;/h2&gt;
&lt;p&gt;在并发程序中，线程经常需要等待某个条件成立。&lt;/p&gt;
&lt;p&gt;例如生产者消费者：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;消费者：

如果没有数据
    等待

有数据
    消费
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最简单的想法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(data == 0)
{
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是这是：&lt;/p&gt;
&lt;h2&gt;忙等待（Busy Waiting）&lt;/h2&gt;
&lt;p&gt;线程一直占用 CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;检查
检查
检查
检查
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;导致：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;浪费 CPU&lt;/li&gt;
&lt;li&gt;占用时间片&lt;/li&gt;
&lt;li&gt;无法充分利用处理器&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;因此需要：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当条件不满足时，让线程睡眠；条件满足后，再唤醒线程。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这就是条件变量（Condition Variable）。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 条件变量核心接口&lt;/h1&gt;
&lt;p&gt;典型使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;std::unique_lock&amp;lt;std::mutex&amp;gt; lock(mtx);

while(!condition)
{
    cv.wait(lock);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;mutex：保护共享数据&lt;/li&gt;
&lt;li&gt;condition：判断是否满足条件&lt;/li&gt;
&lt;li&gt;wait：等待条件成立&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h1&gt;3. &lt;code&gt;wait()&lt;/code&gt; 的真正作用&lt;/h1&gt;
&lt;p&gt;很多初学者误解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(!ready)
{
    cv.wait(lock);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;认为：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;while会不断检查ready。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;实际上错误。&lt;/p&gt;
&lt;p&gt;真正流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while判断一次

↓

条件不满足

↓

进入wait()

↓

线程睡眠

↓

等待唤醒

↓

重新判断
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;4. wait()内部发生了什么？&lt;/h1&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cv.wait(lock);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际上包含三个关键步骤。&lt;/p&gt;
&lt;h2&gt;第一步：释放mutex&lt;/h2&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;p&gt;消费者：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock();

while(buffer.empty())
{
    wait();
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果wait不释放锁：&lt;/p&gt;
&lt;p&gt;消费者睡眠，但是还拿着锁。&lt;/p&gt;
&lt;p&gt;生产者：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock();
buffer.push();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;无法获得锁。&lt;/p&gt;
&lt;p&gt;结果：&lt;/p&gt;
&lt;p&gt;生产者无法生产。&lt;/p&gt;
&lt;p&gt;消费者无法醒来。&lt;/p&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;p&gt;wait必须：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;释放锁
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;第二步：线程进入阻塞状态&lt;/h2&gt;
&lt;p&gt;操作系统：&lt;/p&gt;
&lt;p&gt;修改线程状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RUNNING

↓

BLOCKED
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;p&gt;调度器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;不再选择该线程运行
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU去运行其他线程。&lt;/p&gt;
&lt;p&gt;此时：&lt;/p&gt;
&lt;p&gt;线程：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;不占CPU&lt;/li&gt;
&lt;li&gt;不执行while&lt;/li&gt;
&lt;li&gt;不检查条件&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;第三步：等待唤醒&lt;/h2&gt;
&lt;p&gt;其他线程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cv.notify_one();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;或者：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cv.notify_all();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;操作系统：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;等待队列

↓

就绪队列
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;线程重新等待调度。&lt;/p&gt;
&lt;p&gt;注意：&lt;/p&gt;
&lt;p&gt;唤醒 ≠ 立即执行。&lt;/p&gt;
&lt;p&gt;线程只是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;READY
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;状态。&lt;/p&gt;
&lt;p&gt;什么时候运行：&lt;/p&gt;
&lt;p&gt;由调度器决定。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;5. 为什么需要 while，而不是 if？&lt;/h1&gt;
&lt;p&gt;错误：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;if(!ready)
{
    cv.wait(lock);
}

使用资源;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;正确：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(!ready)
{
    cv.wait(lock);
}

使用资源;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;原因：&lt;/p&gt;
&lt;h2&gt;原因1：虚假唤醒（Spurious Wakeup）&lt;/h2&gt;
&lt;p&gt;条件变量允许：&lt;/p&gt;
&lt;p&gt;没有收到通知，也可能醒来。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;线程睡眠

↓

突然醒

↓

检查条件

↓

ready=false
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果使用if：&lt;/p&gt;
&lt;p&gt;直接继续执行。&lt;/p&gt;
&lt;p&gt;产生错误。&lt;/p&gt;
&lt;p&gt;while：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;醒来

↓

检查

↓

条件不满足

↓

重新睡眠
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;原因2：多个线程竞争资源&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;两个消费者：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;C1
C2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;生产者：&lt;/p&gt;
&lt;p&gt;生产一个资源：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;resource=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;调用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;notify_all()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;两个消费者醒来。&lt;/p&gt;
&lt;p&gt;但是：&lt;/p&gt;
&lt;p&gt;只有一个能拿到资源。&lt;/p&gt;
&lt;p&gt;流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;C1获得锁

检查:

resource=1

消费


释放锁


C2获得锁

检查:

resource=0

重新wait
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果使用if：&lt;/p&gt;
&lt;p&gt;C2会错误执行。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;6. while + wait 和忙等待区别&lt;/h1&gt;
&lt;h2&gt;忙等待&lt;/h2&gt;
&lt;p&gt;代码：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(!ready)
{

}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU运行

检查ready

检查ready

检查ready
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RUNNING
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU占用：&lt;/p&gt;
&lt;p&gt;高。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;条件变量&lt;/h2&gt;
&lt;p&gt;代码：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(!ready)
{
    wait();
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;检查一次

↓

睡眠

↓

等待通知

↓

醒来检查
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;BLOCKED
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU占用：&lt;/p&gt;
&lt;p&gt;接近0。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;7. notify_one 和 notify_all&lt;/h1&gt;
&lt;h2&gt;notify_one&lt;/h2&gt;
&lt;p&gt;唤醒一个等待线程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cv.notify_one();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;适合：&lt;/p&gt;
&lt;p&gt;只有一个线程能够继续工作的情况。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;生产一个商品：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;消费者1
消费者2
消费者3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;只需要叫醒一个。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;notify_all&lt;/h2&gt;
&lt;p&gt;唤醒所有线程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cv.notify_all();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;系统状态发生变化：&lt;/p&gt;
&lt;p&gt;所有等待者都需要重新检查。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;8. notify_all 会不会导致CPU空转？&lt;/h1&gt;
&lt;p&gt;不会。&lt;/p&gt;
&lt;p&gt;错误理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;notify_all

↓

所有线程同时运行
↓

CPU爆炸
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;notify_all

↓

所有线程进入READY

↓

竞争mutex

↓

只有一个获得锁

↓

其他线程继续阻塞
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;过程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;线程A:
获得锁
检查条件

线程B:
等待锁

线程C:
等待锁
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;没有大量循环。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;但是：&lt;/p&gt;
&lt;p&gt;会产生：&lt;/p&gt;
&lt;h2&gt;惊群效应（Thundering Herd）&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;1000个线程等待：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;notify_all()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;全部醒来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1000个线程竞争锁
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最后：&lt;/p&gt;
&lt;p&gt;只有一个成功。&lt;/p&gt;
&lt;p&gt;造成：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;调度开销增加&lt;/li&gt;
&lt;li&gt;缓存失效&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;p&gt;能使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;notify_one()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就不要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;notify_all()
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;9. 条件变量完整模型&lt;/h1&gt;
&lt;p&gt;条件变量由：&lt;/p&gt;
&lt;h2&gt;共享状态&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int count;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;Mutex&lt;/h2&gt;
&lt;p&gt;保护状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mutex
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;Condition Variable&lt;/h2&gt;
&lt;p&gt;等待通知：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;condition_variable
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;关系：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;              共享数据
                  |
                  |
              mutex保护
                  |
                  |
        ------------------
        |
   condition variable
        |
   wait / notify
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;10. 生产者消费者模型&lt;/h1&gt;
&lt;h2&gt;消费者&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;lock();

while(buffer.empty())
{
    wait();
}


取数据;


unlock();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;含义：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;没有数据

↓

睡觉

↓

有数据

↓

消费
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;生产者&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;lock();


生产数据;


notify();


unlock();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;含义：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;产生数据

↓

通知消费者
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;11. 与操作系统调度联系&lt;/h1&gt;
&lt;p&gt;条件变量本质是：&lt;/p&gt;
&lt;p&gt;线程状态转换。&lt;/p&gt;
&lt;h2&gt;wait()&lt;/h2&gt;
&lt;p&gt;线程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Running

↓

Blocked
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;notify()&lt;/h2&gt;
&lt;p&gt;线程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Blocked

↓

Ready
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;调度器&lt;/h2&gt;
&lt;p&gt;决定：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Ready

↓

Running
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;条件变量依赖：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;线程状态管理&lt;/li&gt;
&lt;li&gt;调度器&lt;/li&gt;
&lt;li&gt;阻塞队列&lt;/li&gt;
&lt;li&gt;唤醒机制&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h1&gt;12. 核心总结&lt;/h1&gt;
&lt;h2&gt;wait()&lt;/h2&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;让线程等待条件成立。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;内部：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;释放锁

↓

进入阻塞队列

↓

睡眠

↓

被唤醒

↓

重新获得锁

↓

返回
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;while&lt;/h2&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;保证醒来后重新检查条件。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;不是轮询。&lt;/p&gt;
&lt;p&gt;执行次数：&lt;/p&gt;
&lt;p&gt;约等于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;唤醒次数
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU循环次数
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;忙等待 vs 条件等待&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;忙等待&lt;/th&gt;
&lt;th&gt;条件变量&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;代码&lt;/td&gt;
&lt;td&gt;while空循环&lt;/td&gt;
&lt;td&gt;while + wait&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;线程状态&lt;/td&gt;
&lt;td&gt;Running&lt;/td&gt;
&lt;td&gt;Blocked&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CPU&lt;/td&gt;
&lt;td&gt;持续占用&lt;/td&gt;
&lt;td&gt;释放&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;效率&lt;/td&gt;
&lt;td&gt;低&lt;/td&gt;
&lt;td&gt;高&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;用途&lt;/td&gt;
&lt;td&gt;极短等待&lt;/td&gt;
&lt;td&gt;事件等待&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h1&gt;一句话记忆&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;wait负责让线程睡觉，while负责保证正确；while + wait不是轮询，而是“醒一次检查一次，不满足继续睡”。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这也是 Linux/POSIX 线程同步中最重要的设计模式之一。&lt;/p&gt;
</content:encoded></item><item><title>操作系统笔记：虚拟内存、页表、TLB、ASID 与上下文切换</title><link>https://sanzenin.top/posts/obsidian/%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98-%E9%A1%B5%E8%A1%A8-io/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98-%E9%A1%B5%E8%A1%A8-io/</guid><description>本章核心问题： 程序看到的地址和真实内存地址为什么不同？操作系统如何管理内存？进程切换时 CPU、页表、TLB 如何协作？ 早期系统中： 程序直接访问物理地址： 存在问题： 例如： 进程 A： 进程 B： 如果直接对应物理地址： 因此不同进程必须拥有独立地址空间。 假设连续分配： 虽然总空闲空间足够，但是不连续。 例如</description><pubDate>Mon, 24 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;操作系统笔记：虚拟内存、页表、TLB、ASID 与上下文切换&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;本章核心问题：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;程序看到的地址和真实内存地址为什么不同？操作系统如何管理内存？进程切换时 CPU、页表、TLB 如何协作？&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;1. 为什么需要虚拟内存（Virtual Memory）&lt;/h1&gt;
&lt;h2&gt;1.1 直接使用物理内存的问题&lt;/h2&gt;
&lt;p&gt;早期系统中：&lt;/p&gt;
&lt;p&gt;程序直接访问物理地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;程序地址
    |
    v
物理内存(RAM)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;存在问题：&lt;/p&gt;
&lt;h3&gt;① 进程无法隔离&lt;/h3&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;进程 A：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进程 B：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果直接对应物理地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A修改1000

↓

B的数据被破坏
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此不同进程必须拥有独立地址空间。&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;② 内存碎片问题&lt;/h3&gt;
&lt;p&gt;假设连续分配：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM:

[A][空][B][空][C]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;虽然总空闲空间足够，但是不连续。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;需要20MB连续空间：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;空闲:

10MB + 10MB
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;仍然无法分配。&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;③ 程序不一定需要全部数据&lt;/h3&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;游戏：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;100GB
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是当前只需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地图1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;没必要全部加载到RAM。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;因此引入：&lt;/p&gt;
&lt;h1&gt;虚拟内存&lt;/h1&gt;
&lt;p&gt;核心思想：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;给每个进程一个独立、连续、巨大的虚拟地址空间，实际由操作系统映射到有限的物理内存。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;结构：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;进程

虚拟地址空间

        |
        |
        v

    地址转换

        |
        v

物理内存(RAM)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 虚拟地址与物理地址&lt;/h1&gt;
&lt;p&gt;程序看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;虚拟地址 Virtual Address
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x4000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际上：&lt;/p&gt;
&lt;p&gt;可能对应：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;物理地址 Physical Address

0x90000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;转换：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;虚拟地址
    |
    v
   MMU
    |
    v
物理地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;3. 分页机制（Paging）&lt;/h1&gt;
&lt;p&gt;为了方便管理，操作系统把内存切成固定大小。&lt;/p&gt;
&lt;h2&gt;3.1 页(Page)&lt;/h2&gt;
&lt;p&gt;虚拟内存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page0
Page1
Page2
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;通常：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4KB
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;3.2 页框(Frame)&lt;/h2&gt;
&lt;p&gt;物理内存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Frame0
Frame1
Frame2
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;大小同样：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4KB
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;映射：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;虚拟页(Page)

        ↓

物理页框(Frame)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page0  ---&amp;gt; Frame10

Page1  ---&amp;gt; Frame50

Page2  ---&amp;gt; Frame3
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;4. 地址拆分&lt;/h1&gt;
&lt;p&gt;虚拟地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;+----------------+-------------+
|  页号 VPN       | 页内偏移     |
+----------------+-------------+
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;页面大小：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4KB = 2^12 byte
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;p&gt;页内偏移：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;12 bit
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;剩余：&lt;/p&gt;
&lt;p&gt;虚拟页号。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;为什么偏移不用转换？&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;p&gt;页大小相同。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;虚拟地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page5 + offset100
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;页表：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page5 -&amp;gt; Frame20
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Frame20 + offset100
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;5. 页表(Page Table)&lt;/h1&gt;
&lt;h2&gt;5.1 作用&lt;/h2&gt;
&lt;p&gt;页表记录：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;虚拟页
   |
   v
物理页框
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;虚拟页&lt;/th&gt;
&lt;th&gt;物理帧&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;20&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;100&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;p&gt;每个进程拥有自己的页表。&lt;/p&gt;
&lt;p&gt;原因：&lt;/p&gt;
&lt;p&gt;不同进程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;相同虚拟地址

↓

不同物理地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;进程A：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page10 -&amp;gt; Frame100
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进程B：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page10 -&amp;gt; Frame500
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;6. 页表项(Page Table Entry)&lt;/h1&gt;
&lt;p&gt;页表中的每一项叫：&lt;/p&gt;
&lt;p&gt;PTE。&lt;/p&gt;
&lt;p&gt;典型字段：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;+----------------+
| Frame Number   |
| Permission     |
| Status         |
+----------------+
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;6.1 Frame Number&lt;/h2&gt;
&lt;p&gt;记录：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;虚拟页对应哪个物理帧
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;6.2 权限位&lt;/h2&gt;
&lt;h3&gt;Read Only&lt;/h3&gt;
&lt;p&gt;只读。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;代码段：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;hello&quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不能修改。&lt;/p&gt;
&lt;p&gt;否则：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Segmentation Fault
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;User / Kernel&lt;/h3&gt;
&lt;p&gt;限制访问权限。&lt;/p&gt;
&lt;p&gt;用户程序：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;User mode
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;操作系统：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Kernel mode
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;防止：&lt;/p&gt;
&lt;p&gt;用户程序直接修改内核。&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;NX（No Execute）&lt;/h3&gt;
&lt;p&gt;禁止执行。&lt;/p&gt;
&lt;p&gt;防止：&lt;/p&gt;
&lt;p&gt;攻击者把代码写入栈：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stack

↓

执行
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;7. 状态位&lt;/h1&gt;
&lt;hr /&gt;
&lt;h2&gt;7.1 Present 位&lt;/h2&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;p&gt;页面是否在RAM。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Present=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;页表映射有效
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Present=0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;页面不在内存
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可能：&lt;/p&gt;
&lt;p&gt;在磁盘。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;7.2 Dirty 位（修改位）&lt;/h2&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;p&gt;RAM中的页面是否被修改。&lt;/p&gt;
&lt;p&gt;例：&lt;/p&gt;
&lt;p&gt;磁盘：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x=10
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;加载：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM:

x=10
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;程序修改：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM:

x=20
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;此时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM != Disk
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Dirty=1
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;p&gt;决定换出页面时：&lt;/p&gt;
&lt;p&gt;是否写回磁盘。&lt;/p&gt;
&lt;h3&gt;Dirty=0&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;RAM:

x=10

Disk:

x=10
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;一样。&lt;/p&gt;
&lt;p&gt;直接丢弃。&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;Dirty=1&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;RAM:

x=20


Disk:

x=10
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不同。&lt;/p&gt;
&lt;p&gt;必须：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM

↓

Disk
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;写回。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;7.3 Accessed 位&lt;/h2&gt;
&lt;p&gt;记录页面是否最近访问。&lt;/p&gt;
&lt;p&gt;用途：&lt;/p&gt;
&lt;p&gt;页面置换算法。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;LRU、Clock。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;7.4 Global 位&lt;/h2&gt;
&lt;p&gt;标记共享页面。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;内核代码：&lt;/p&gt;
&lt;p&gt;所有进程共享。&lt;/p&gt;
&lt;p&gt;切换进程时：&lt;/p&gt;
&lt;p&gt;不用删除相关TLB。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;8. MMU（Memory Management Unit）&lt;/h1&gt;
&lt;p&gt;MMU：&lt;/p&gt;
&lt;p&gt;内存管理单元。&lt;/p&gt;
&lt;p&gt;位置：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU内部硬件
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;地址转换&lt;/li&gt;
&lt;li&gt;权限检查&lt;/li&gt;
&lt;li&gt;内存保护&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU产生虚拟地址

        |

        v

       MMU

        |

        v

   物理地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;9. TLB（Translation Lookaside Buffer）&lt;/h1&gt;
&lt;h2&gt;9.1 为什么需要TLB？&lt;/h2&gt;
&lt;p&gt;如果每次访问：&lt;/p&gt;
&lt;p&gt;先查页表：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;访问页表

↓

访问数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;一次内存访问变两次。&lt;/p&gt;
&lt;p&gt;因此加入缓存：&lt;/p&gt;
&lt;p&gt;TLB。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;TLB：&lt;/p&gt;
&lt;p&gt;本质：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;页表项缓存。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;虚拟页 -&amp;gt; 物理帧
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;9.2 TLB命中&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;TLB：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page5 -&amp;gt; Frame20
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;访问：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;直接：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Frame20
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不用查页表。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;9.3 TLB缺失&lt;/h2&gt;
&lt;p&gt;没有找到：&lt;/p&gt;
&lt;p&gt;流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;访问TLB

↓

查页表

↓

得到物理帧

↓

更新TLB
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;10. ASID（地址空间标识符）&lt;/h1&gt;
&lt;h2&gt;10.1 没有ASID的问题&lt;/h2&gt;
&lt;p&gt;TLB：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;VPN -&amp;gt; PFN
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进程A：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1000 -&amp;gt; 5000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进程B：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1000 -&amp;gt; 9000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;虚拟地址一样。&lt;/p&gt;
&lt;p&gt;切换进程后：&lt;/p&gt;
&lt;p&gt;TLB不知道是谁的。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;必须：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;刷新TLB
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;11. ASID解决方案&lt;/h1&gt;
&lt;p&gt;TLB增加字段：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ASID + VPN -&amp;gt; PFN
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;ASID&lt;/th&gt;
&lt;th&gt;VPN&lt;/th&gt;
&lt;th&gt;PFN&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;1000&lt;/td&gt;
&lt;td&gt;5000&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;1000&lt;/td&gt;
&lt;td&gt;9000&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;p&gt;现在：&lt;/p&gt;
&lt;p&gt;TLB知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;这个地址属于哪个进程
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;12. 为什么切换进程需要修改当前ASID？&lt;/h1&gt;
&lt;p&gt;关键：&lt;/p&gt;
&lt;p&gt;TLB里面保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;历史进程的ASID
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU内部保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;当前运行进程的ASID
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;TLB：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;ASID&lt;/th&gt;
&lt;th&gt;VPN&lt;/th&gt;
&lt;th&gt;PFN&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;1000&lt;/td&gt;
&lt;td&gt;5000&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;1000&lt;/td&gt;
&lt;td&gt;9000&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;当前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Current ASID=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;访问：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;VPN=1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;(1,1000)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;5000
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;切换到B：&lt;/p&gt;
&lt;p&gt;修改：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Current ASID=2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;TLB不用动。&lt;/p&gt;
&lt;p&gt;访问：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;VPN=1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;(2,1000)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;9000
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;核心：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;TLB里的ASID是标签，CPU当前ASID是查询条件。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;13. CR3、TLB、ASID与上下文切换&lt;/h1&gt;
&lt;p&gt;这是整个机制最重要部分。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;13.1 CR3是什么？&lt;/h2&gt;
&lt;p&gt;CR3：&lt;/p&gt;
&lt;p&gt;页表基址寄存器。&lt;/p&gt;
&lt;p&gt;保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;当前进程页表地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;进程A：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CR3 = PageTableA
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进程B：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CR3 = PageTableB
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;13.2 一次上下文切换&lt;/h2&gt;
&lt;p&gt;从A切换到B：&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;第一步&lt;/h3&gt;
&lt;p&gt;保存A状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;寄存器
栈
RIP
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;第二步&lt;/h3&gt;
&lt;p&gt;切换页表：&lt;/p&gt;
&lt;p&gt;修改：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CR3:

PageTableA

↓

PageTableB
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;第三步&lt;/h3&gt;
&lt;p&gt;切换身份：&lt;/p&gt;
&lt;p&gt;修改：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Current ASID:

1

↓

2
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;第四步&lt;/h3&gt;
&lt;p&gt;TLB处理：&lt;/p&gt;
&lt;p&gt;没有ASID：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;清空TLB
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;有ASID：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;保留TLB
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;14. 三者关系总结&lt;/h1&gt;
&lt;h2&gt;CR3&lt;/h2&gt;
&lt;p&gt;回答：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当前进程的页表在哪里？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;ASID&lt;/h2&gt;
&lt;p&gt;回答：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当前访问属于哪个进程？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;TLB&lt;/h2&gt;
&lt;p&gt;回答：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;以前查过的地址转换是什么？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;p&gt;完整流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU访问虚拟地址

        |
        v

      TLB查询

        |
        |
  +-----+-----+
  |           |
命中          未命中

  |           |
  |           v

  |          CR3
  |           |
  |           v

  |        页表查询

  |
  v

物理地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;15. Page Fault（缺页异常）&lt;/h1&gt;
&lt;p&gt;发生：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;页表 Present=0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;p&gt;页面不在RAM。&lt;/p&gt;
&lt;p&gt;流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU访问页面

↓

MMU查页表

↓

Present=0

↓

Page Fault

↓

OS处理

↓

磁盘读取页面

↓

放入RAM

↓

更新页表

↓

重新执行指令
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;16. 磁盘与虚拟内存关系总结&lt;/h1&gt;
&lt;p&gt;两个方向：&lt;/p&gt;
&lt;h2&gt;换入&lt;/h2&gt;
&lt;p&gt;页面不在内存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Disk

↓

RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;触发：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Page Fault
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;换出&lt;/h2&gt;
&lt;p&gt;RAM不足：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM

↓

Disk
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Dirty=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;需要写回。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;17. 最终总图&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;                 程序

                  |
                  v

             虚拟地址

                  |
                  v

                 MMU

                  |
          +-------+-------+
          |               |

        TLB            页表

          |               |

          +-------+-------+

                  |

             物理地址

                  |

                 RAM


如果页面不存在:

                  |

                  v

             Page Fault

                  |

                  v

                磁盘
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;本章核心记忆&lt;/h1&gt;
&lt;p&gt;一句话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;虚拟内存让每个进程拥有独立的虚拟地址空间；页表负责虚拟页到物理帧映射；MMU负责硬件转换；TLB缓存映射提高速度；ASID让不同进程的TLB缓存共存；CR3负责切换当前进程页表；Page Fault负责在RAM和磁盘之间搬运页面。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;掌握这套关系，后续学习：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;fork&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;exec&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;mmap&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;malloc&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Copy-on-Write&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Linux进程地址空间&lt;/li&gt;
&lt;li&gt;上下文切换&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;都会直接建立联系。&lt;/p&gt;
&lt;p&gt;可以。你给出的字幕已经足够，我可以完整总结这个视频。&lt;/p&gt;
&lt;p&gt;这个视频主题是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;DMA Controller（直接内存访问控制器）：外设如何绕过 CPU 高效读写 RAM，以及现代 PCIe + IOMMU 下 DMA 的工作方式&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;它其实是操作系统里 &lt;strong&gt;I/O 系统、设备管理、中断、虚拟内存&lt;/strong&gt; 的交叉内容。和你之前学的进程、虚拟内存、页表、TLB 有直接关系。&lt;/p&gt;
&lt;p&gt;我会按照你之前学习 OS 的方式，从底层机制讲，而不是简单翻译。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;1. 计算机最基本结构&lt;/h1&gt;
&lt;p&gt;视频先提出：&lt;/p&gt;
&lt;p&gt;普通人认为计算机：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;显示器
键盘
鼠标
硬盘
显卡
CPU
内存
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是从计算机体系结构角度：&lt;/p&gt;
&lt;p&gt;一个最基本计算机只需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;        Bus
         |
 ----------------
 |              |
CPU           RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;三个核心部分：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;CPU&lt;/li&gt;
&lt;li&gt;Memory（RAM）&lt;/li&gt;
&lt;li&gt;Bus（连接 CPU 和 RAM 的通路）&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;其他：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;硬盘&lt;/li&gt;
&lt;li&gt;网卡&lt;/li&gt;
&lt;li&gt;GPU&lt;/li&gt;
&lt;li&gt;USB&lt;/li&gt;
&lt;li&gt;声卡&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;都叫：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Peripheral Device（外设）&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 外设为什么需要访问 RAM？&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;p&gt;你运行游戏。&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;执行游戏代码
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;GPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;渲染画面
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;GPU 需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM ---&amp;gt; GPU显存(VRAM)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;人物模型数据
纹理
顶点数据
shader
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;都在 RAM。&lt;/p&gt;
&lt;p&gt;GPU 需要拿。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;最简单的方法&lt;/h2&gt;
&lt;p&gt;让 CPU 搬。&lt;/p&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;p&gt;RAM：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址1000:
00101010
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;data = RAM[1000];

GPU_MEMORY = data;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际上对应：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM
 |
CPU
 |
GPU
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;但是问题来了：&lt;/p&gt;
&lt;p&gt;现代电脑数据量巨大。&lt;/p&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;p&gt;GPU 每秒需要传：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;几十 GB 数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果全部让 CPU 搬：&lt;/p&gt;
&lt;p&gt;CPU 大部分时间：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;搬数据
搬数据
搬数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而不是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;运行程序
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU 就废了。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;所以需要：&lt;/p&gt;
&lt;h1&gt;DMA&lt;/h1&gt;
&lt;p&gt;Direct Memory Access&lt;/p&gt;
&lt;p&gt;直接内存访问。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;3. DMA 的核心思想&lt;/h1&gt;
&lt;p&gt;一句话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;让专门硬件负责搬数据，CPU 只负责下命令。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;以前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU:
    RAM读
    |
    写GPU
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU
 |
告诉DMA:

&quot;把RAM地址1000-2000的数据
复制给GPU&quot;

DMA:
 |
自己搬
 |
RAM &amp;lt;------&amp;gt; GPU
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU 可以继续运行。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;类似：&lt;/p&gt;
&lt;p&gt;搬家。&lt;/p&gt;
&lt;p&gt;没有 DMA：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;老板(CPU)
自己搬所有箱子
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;DMA：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;老板:
&quot;把这些箱子搬过去&quot;

搬家公司(DMA):
自己完成
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;4. DMA Controller 是什么？&lt;/h1&gt;
&lt;p&gt;DMA Controller：&lt;/p&gt;
&lt;p&gt;本质：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;一个专门负责数据搬运的小处理器&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;它拥有：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;地址寄存器&lt;/li&gt;
&lt;li&gt;计数器&lt;/li&gt;
&lt;li&gt;控制逻辑&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;CPU 设置：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;source = 0x1000

destination = GPU buffer

size = 1GB
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;p&gt;DMA：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;while(size):

    read RAM

    write GPU
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;CPU 不参与每一个 byte 的移动。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;5. 早期 DMA：集中式 DMA&lt;/h1&gt;
&lt;p&gt;视频讲：&lt;/p&gt;
&lt;h2&gt;Centralized DMA&lt;/h2&gt;
&lt;p&gt;也叫：&lt;/p&gt;
&lt;p&gt;Third Party DMA&lt;/p&gt;
&lt;p&gt;为什么叫第三方？&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;p&gt;CPU 第一方&lt;/p&gt;
&lt;p&gt;外设第二方&lt;/p&gt;
&lt;p&gt;DMA 控制器第三方&lt;/p&gt;
&lt;p&gt;结构：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;             Bus

CPU --------|
            |
RAM --------|------ DMA Controller
            |
GPU --------|
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所有设备：&lt;/p&gt;
&lt;p&gt;先找 DMA Controller：&lt;/p&gt;
&lt;p&gt;GPU:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要传数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;DMA:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;好的
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;p&gt;DMA 请求：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要控制总线
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Bus Arbiter：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;批准
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后 DMA 开始搬。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;为什么需要 Bus Arbiter？&lt;/h2&gt;
&lt;p&gt;因为总线同一时间只能一个人用。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要访问RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;GPU:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要访问RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;同时：&lt;/p&gt;
&lt;p&gt;线路冲突。&lt;/p&gt;
&lt;p&gt;叫：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Bus contention（总线竞争）&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;所以需要裁判：&lt;/p&gt;
&lt;p&gt;Bus Arbiter&lt;/p&gt;
&lt;p&gt;决定：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;谁先用
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;6. 后来的 DMA：Bus Mastering&lt;/h1&gt;
&lt;p&gt;集中 DMA 的问题：&lt;/p&gt;
&lt;p&gt;DMA Controller 成瓶颈。&lt;/p&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;p&gt;100个设备：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;GPU
网卡
SSD
声卡
USB
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;全部：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;请求DMA Controller
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它忙不过来。&lt;/p&gt;
&lt;p&gt;所以现代：&lt;/p&gt;
&lt;p&gt;每个设备自己带 DMA。&lt;/p&gt;
&lt;p&gt;叫：&lt;/p&gt;
&lt;h2&gt;Bus Mastering&lt;/h2&gt;
&lt;p&gt;或者：&lt;/p&gt;
&lt;p&gt;First Party DMA&lt;/p&gt;
&lt;p&gt;结构：&lt;/p&gt;
&lt;p&gt;以前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;GPU
 |
DMA Controller
 |
RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;GPU
 |
自己的DMA Controller
 |
RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;GPU 可以：&lt;/p&gt;
&lt;p&gt;自己申请总线。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;7. 三种 DMA 工作模式&lt;/h1&gt;
&lt;p&gt;视频讲三个。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;7.1 Burst Mode（突发模式）&lt;/h1&gt;
&lt;p&gt;一次拿走总线。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;GPU：&lt;/p&gt;
&lt;p&gt;复制：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1GB
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;DMA:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要整个bus
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DMA ---------------- RAM

疯狂传输
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;p&gt;快。&lt;/p&gt;
&lt;p&gt;缺点：&lt;/p&gt;
&lt;p&gt;CPU 等。&lt;/p&gt;
&lt;p&gt;类似：&lt;/p&gt;
&lt;p&gt;搬家公司占电梯：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;一次搬100箱

别人不能用
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;7.2 Cycle Stealing（周期窃取）&lt;/h1&gt;
&lt;p&gt;DMA：&lt;/p&gt;
&lt;p&gt;不长期占用。&lt;/p&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;p&gt;传：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;一个cache line
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;释放。&lt;/p&gt;
&lt;p&gt;再抢。&lt;/p&gt;
&lt;p&gt;过程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU
CPU
DMA
CPU
CPU
DMA
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;p&gt;CPU还能运行。&lt;/p&gt;
&lt;p&gt;缺点：&lt;/p&gt;
&lt;p&gt;稍慢。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;7.3 Transparent Mode（透明模式）&lt;/h1&gt;
&lt;p&gt;最礼貌。&lt;/p&gt;
&lt;p&gt;DMA：&lt;/p&gt;
&lt;p&gt;只在 CPU 不用 bus 时工作。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;休息
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;DMA：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;偷偷搬一点
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;优点：&lt;/p&gt;
&lt;p&gt;CPU完全不影响。&lt;/p&gt;
&lt;p&gt;缺点：&lt;/p&gt;
&lt;p&gt;速度慢。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;8. DMA 和 CPU Cache 的关系（重要）&lt;/h1&gt;
&lt;p&gt;这里和你之前学的 cache 有联系。&lt;/p&gt;
&lt;p&gt;问题：&lt;/p&gt;
&lt;p&gt;DMA 占用 RAM 总线。&lt;/p&gt;
&lt;p&gt;CPU 会不会停？&lt;/p&gt;
&lt;p&gt;答案：&lt;/p&gt;
&lt;p&gt;不一定。&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;p&gt;CPU 有 cache。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;CPU执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a+b
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;a,b:&lt;/p&gt;
&lt;p&gt;已经在 L1 cache。&lt;/p&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;p&gt;不需要访问 RAM。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;DMA:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;占RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;继续跑
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;但是：&lt;/p&gt;
&lt;p&gt;如果 cache miss：&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要RAM数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;发现：&lt;/p&gt;
&lt;p&gt;DMA正在使用总线。&lt;/p&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;p&gt;CPU stall。&lt;/p&gt;
&lt;p&gt;等待：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DMA结束
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;9. PCI Express 下 DMA&lt;/h1&gt;
&lt;p&gt;现代电脑不用老式共享总线。&lt;/p&gt;
&lt;p&gt;现在：&lt;/p&gt;
&lt;p&gt;PCIe。&lt;/p&gt;
&lt;p&gt;区别：&lt;/p&gt;
&lt;p&gt;旧：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;所有设备共享一条路


CPU
 |
 BUS
 |
GPU
SSD
网卡
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现代 PCIe：&lt;/p&gt;
&lt;p&gt;类似高速公路：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU
 |
PCIe Switch
 |
----------------
GPU
SSD
网卡
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每个设备：&lt;/p&gt;
&lt;p&gt;有自己的 lane。&lt;/p&gt;
&lt;p&gt;可以并行。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;10. 最关键：DMA 和虚拟内存&lt;/h1&gt;
&lt;p&gt;这是视频最后，也是 OS 最重要部分。&lt;/p&gt;
&lt;p&gt;问题：&lt;/p&gt;
&lt;p&gt;DMA 访问什么地址？&lt;/p&gt;
&lt;p&gt;CPU 有：&lt;/p&gt;
&lt;p&gt;虚拟地址。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;程序看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x400000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;物理RAM:

0x12345000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;靠：&lt;/p&gt;
&lt;p&gt;页表。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;那么设备呢？&lt;/p&gt;
&lt;p&gt;GPU 也需要访问内存。&lt;/p&gt;
&lt;p&gt;如果 GPU 直接使用物理地址：&lt;/p&gt;
&lt;p&gt;危险。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;GPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要写:

0x100000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果这里是：&lt;/p&gt;
&lt;p&gt;别的进程数据。&lt;/p&gt;
&lt;p&gt;安全崩溃。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;现代系统：&lt;/p&gt;
&lt;p&gt;给设备也做虚拟地址。&lt;/p&gt;
&lt;p&gt;叫：&lt;/p&gt;
&lt;h2&gt;I/O Virtual Memory&lt;/h2&gt;
&lt;p&gt;结构：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;设备 DMA

虚拟地址

     |
     v

IOMMU

     |
     v

物理地址 RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;11. IOMMU 是什么？&lt;/h1&gt;
&lt;p&gt;IOMMU:&lt;/p&gt;
&lt;p&gt;Input Output Memory Management Unit&lt;/p&gt;
&lt;p&gt;可以理解：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;给设备用的 MMU&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;CPU:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;虚拟地址
 |
MMU
 |
物理地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;设备:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DMA地址
 |
IOMMU
 |
物理地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;12. 为什么需要 IOMMU？&lt;/h1&gt;
&lt;p&gt;三个原因。&lt;/p&gt;
&lt;h2&gt;1. 地址转换&lt;/h2&gt;
&lt;p&gt;设备不用知道：&lt;/p&gt;
&lt;p&gt;真实 RAM 在哪里。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 内存保护&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;GPU只能访问：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x1000-0x2000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不能访问：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;kernel memory
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 防 DMA 攻击&lt;/h2&gt;
&lt;p&gt;历史：&lt;/p&gt;
&lt;p&gt;恶意设备：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DMA写kernel内存
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;直接控制系统。&lt;/p&gt;
&lt;p&gt;IOMMU阻止。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;13. 把整个流程串起来&lt;/h1&gt;
&lt;p&gt;现代 Linux 中：&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;网卡收到数据。&lt;/p&gt;
&lt;p&gt;流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;网卡
 |
产生DMA请求
 |
网卡DMA Controller
 |
IOMMU检查地址
 |
虚拟DMA地址转换
 |
物理RAM
 |
写入buffer
 |
产生interrupt
 |
CPU收到中断
 |
处理数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意：&lt;/p&gt;
&lt;p&gt;CPU不是搬数据的人。&lt;/p&gt;
&lt;p&gt;CPU只是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;设置任务
等待通知
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;14. 和你之前学的 OS 知识连接&lt;/h1&gt;
&lt;p&gt;你之前学：&lt;/p&gt;
&lt;h2&gt;虚拟内存&lt;/h2&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;VA
 |
Page Table
 |
PA
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在增加：&lt;/p&gt;
&lt;p&gt;设备：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DMA Address
 |
IO Page Table
 |
PA
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以现代系统：&lt;/p&gt;
&lt;p&gt;其实有两个地址转换体系：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU:

Virtual Memory
        |
       MMU
        |
      Physical RAM



Device:

IO Virtual Memory
        |
       IOMMU
        |
      Physical RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;15. 期末可能考什么？&lt;/h1&gt;
&lt;h2&gt;问题1&lt;/h2&gt;
&lt;p&gt;为什么需要 DMA？&lt;/p&gt;
&lt;p&gt;答案：&lt;/p&gt;
&lt;p&gt;因为 CPU 如果负责所有外设数据搬运，会大量消耗 CPU 时间，降低系统吞吐量。DMA 允许外设直接访问内存。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;问题2&lt;/h2&gt;
&lt;p&gt;DMA 是否完全不需要 CPU？&lt;/p&gt;
&lt;p&gt;错误。&lt;/p&gt;
&lt;p&gt;正确：&lt;/p&gt;
&lt;p&gt;CPU负责：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;初始化 DMA&lt;/li&gt;
&lt;li&gt;设置地址&lt;/li&gt;
&lt;li&gt;设置长度&lt;/li&gt;
&lt;li&gt;启动 DMA&lt;/li&gt;
&lt;li&gt;接收完成中断&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;DMA负责：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;实际数据搬运&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;问题3&lt;/h2&gt;
&lt;p&gt;DMA 和虚拟内存有什么关系？&lt;/p&gt;
&lt;p&gt;答案：&lt;/p&gt;
&lt;p&gt;设备 DMA 使用 IOMMU，通过 IO 页表把设备虚拟地址转换为物理地址，同时提供隔离和保护。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;问题4&lt;/h2&gt;
&lt;p&gt;为什么 DMA 会导致 CPU stall？&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;p&gt;DMA 和 CPU 都需要访问内存总线。&lt;/p&gt;
&lt;p&gt;当 DMA 占用总线时：&lt;/p&gt;
&lt;p&gt;CPU cache miss 后需要访问 RAM，会等待。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;总结一句话&lt;/h1&gt;
&lt;p&gt;这个视频讲的核心就是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;DMA 是让外设拥有“像 CPU 一样访问内存的能力”的机制；现代 PCIe 设备内部集成 DMA Controller，并通过 IOMMU 使用类似虚拟内存的机制安全访问 RAM。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;它正好连接你最近学的：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;虚拟内存&lt;/li&gt;
&lt;li&gt;页表&lt;/li&gt;
&lt;li&gt;MMU&lt;/li&gt;
&lt;li&gt;中断&lt;/li&gt;
&lt;li&gt;设备管理&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;如果继续学 JYY OS / 南大 OS，这部分通常会接在 &lt;strong&gt;文件系统之前的设备与 I/O 系统&lt;/strong&gt;，属于非常核心的一块。你之前学的 CR3/TLB/ASID，其实可以自然扩展到这里的 IOMMU。&lt;/p&gt;
&lt;p&gt;这个视频讲的是 &lt;strong&gt;Memory-Mapped I/O（内存映射 I/O，MMIO）和 Port-Mapped I/O（端口映射 I/O，PMIO）&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;它和你刚刚看的 DMA 视频是连续关系：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;DMA 解决的是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;设备如何高效搬运数据到 RAM&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;MMIO/PMIO 解决的是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;CPU 如何和设备通信、控制设备&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;也就是说：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU
 |
 | ① 命令设备（MMIO/PMIO）
 |
设备
 |
 | ② 搬数据（DMA）
 |
RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;下面详细讲。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;1. CPU 原本如何访问内存？&lt;/h1&gt;
&lt;p&gt;CPU 最基本两个操作：&lt;/p&gt;
&lt;h2&gt;Load&lt;/h2&gt;
&lt;p&gt;从内存读数据：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM -----&amp;gt; CPU寄存器
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;C：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x = a;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;汇编：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, [address]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思：&lt;/p&gt;
&lt;p&gt;读取 address 地址的数据到 eax。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;Store&lt;/h2&gt;
&lt;p&gt;写回内存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU寄存器 -----&amp;gt; RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a = 10;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;汇编：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov [address], eax
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;所以 CPU 看世界：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址
 |
 v

+-------------+
| RAM         |
+-------------+
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;但是问题来了：&lt;/p&gt;
&lt;h2&gt;设备也有内存！&lt;/h2&gt;
&lt;p&gt;比如 GPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;GPU Memory

地址:

0x1000
0x1004
0x1008
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;RAM：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM

地址:

0x1000
0x1004
0x1008
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;冲突了。&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax,[0x1000]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;到底：&lt;/p&gt;
&lt;p&gt;读取 RAM？&lt;/p&gt;
&lt;p&gt;还是：&lt;/p&gt;
&lt;p&gt;读取 GPU？&lt;/p&gt;
&lt;p&gt;CPU 不知道。&lt;/p&gt;
&lt;p&gt;所以需要解决：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;CPU 如何区分不同设备的地址？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 两种解决方案&lt;/h1&gt;
&lt;p&gt;视频讲：&lt;/p&gt;
&lt;h2&gt;方法1&lt;/h2&gt;
&lt;p&gt;给设备单独地址空间：&lt;/p&gt;
&lt;p&gt;Port-Mapped I/O&lt;/p&gt;
&lt;p&gt;简称：&lt;/p&gt;
&lt;p&gt;PMIO&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;方法2&lt;/h2&gt;
&lt;p&gt;把设备地址放进统一地址空间：&lt;/p&gt;
&lt;p&gt;Memory-Mapped I/O&lt;/p&gt;
&lt;p&gt;简称：&lt;/p&gt;
&lt;p&gt;MMIO&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;3. Port-Mapped I/O（端口映射）&lt;/h1&gt;
&lt;h2&gt;核心思想&lt;/h2&gt;
&lt;p&gt;设备不用占 RAM 地址。&lt;/p&gt;
&lt;p&gt;单独开一个：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;I/O address space
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;结构：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU地址空间


0x0000
 |
 RAM
 |
0xfffffff


另外：

I/O空间

port 0
port 1
port 2

设备
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;老 PC：&lt;/p&gt;
&lt;p&gt;DMA控制器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;port 0~F
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;硬盘：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;port 320~32F
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;CPU访问：&lt;/p&gt;
&lt;p&gt;不能：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax,[320]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为这是 RAM。&lt;/p&gt;
&lt;p&gt;需要特殊指令：&lt;/p&gt;
&lt;p&gt;例如 x86：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;IN
OUT
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;OUT port, data
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思：&lt;/p&gt;
&lt;p&gt;向某设备端口写数据。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;4. PMIO的问题&lt;/h1&gt;
&lt;p&gt;看起来很合理。&lt;/p&gt;
&lt;p&gt;但是缺点明显。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;问题1：需要特殊指令&lt;/h2&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;p&gt;访问 RAM：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;load/store
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;访问设备：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;IN/OUT
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;两套机制。&lt;/p&gt;
&lt;p&gt;硬件复杂。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;问题2：数据传输效率低&lt;/h2&gt;
&lt;p&gt;视频说：&lt;/p&gt;
&lt;p&gt;一次 IO：&lt;/p&gt;
&lt;p&gt;可能只能传：&lt;/p&gt;
&lt;p&gt;1 byte&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;声卡：&lt;/p&gt;
&lt;p&gt;需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1GB 音频数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;p&gt;一次：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;OUT 1 byte
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;需要：&lt;/p&gt;
&lt;p&gt;10亿次指令。&lt;/p&gt;
&lt;p&gt;太慢。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;问题3：优化困难&lt;/h2&gt;
&lt;p&gt;现代 CPU 有：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;cache&lt;/li&gt;
&lt;li&gt;pipeline&lt;/li&gt;
&lt;li&gt;burst transfer&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;但是 PMIO：&lt;/p&gt;
&lt;p&gt;很难利用这些机制。&lt;/p&gt;
&lt;p&gt;所以现代系统基本转向 MMIO。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;5. Memory-Mapped I/O（重点）&lt;/h1&gt;
&lt;h2&gt;核心思想：&lt;/h2&gt;
&lt;blockquote&gt;
&lt;p&gt;把设备寄存器映射到普通内存地址。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;也就是说：&lt;/p&gt;
&lt;p&gt;CPU看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;统一地址空间
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x00000000
        |
        RAM

0x80000000
        |
        GPU寄存器

0x90000000
        |
        网卡寄存器

0xA0000000
        |
        SSD控制器
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;现在：&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax,[0x80000000]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可能访问：&lt;/p&gt;
&lt;p&gt;GPU。&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;p&gt;这个地址属于 GPU。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;CPU 不需要知道：&lt;/p&gt;
&lt;p&gt;&quot;这是设备&quot;&lt;/p&gt;
&lt;p&gt;它只知道：&lt;/p&gt;
&lt;p&gt;&quot;访问地址&quot;&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;6. MMIO 的本质&lt;/h1&gt;
&lt;p&gt;注意：&lt;/p&gt;
&lt;p&gt;这里非常容易混淆。&lt;/p&gt;
&lt;p&gt;MMIO 地址：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;不是 RAM！&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x80000000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可能：&lt;/p&gt;
&lt;p&gt;物理地址范围属于 GPU。&lt;/p&gt;
&lt;p&gt;CPU 发起：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;read address 0x80000000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;总线看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;这个地址属于GPU
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;p&gt;转给 GPU。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;地址一样：&lt;/p&gt;
&lt;p&gt;但是：&lt;/p&gt;
&lt;p&gt;背后设备不同。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;7. 一个设备有哪些 MMIO 区域？&lt;/h1&gt;
&lt;p&gt;视频讲：&lt;/p&gt;
&lt;p&gt;通常四类。&lt;/p&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;p&gt;声卡。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;① Data Input Region&lt;/h2&gt;
&lt;p&gt;输入数据。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;p&gt;把音频数据给声卡：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM

音乐数据

 |
 v

声卡输入buffer
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;② Data Output Region&lt;/h2&gt;
&lt;p&gt;设备输出。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;声卡：&lt;/p&gt;
&lt;p&gt;处理完成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;声卡
 |
扬声器
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;③ Control Register（控制寄存器）&lt;/h2&gt;
&lt;p&gt;最重要。&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;p&gt;通过写某个地址控制设备。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;含义：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;写1:

开始播放
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov [0x1000],1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;声卡：&lt;/p&gt;
&lt;p&gt;收到：&lt;/p&gt;
&lt;p&gt;开始工作。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;④ Status Register（状态寄存器）&lt;/h2&gt;
&lt;p&gt;设备告诉 CPU：&lt;/p&gt;
&lt;p&gt;自己状态。&lt;/p&gt;
&lt;p&gt;例如 SSD：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;busy bit
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x2000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;p&gt;读取：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax,[0x2000]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;返回：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;p&gt;正在工作。&lt;/p&gt;
&lt;p&gt;返回：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;p&gt;完成。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;8. Device Driver 是什么？&lt;/h1&gt;
&lt;p&gt;这里和 OS 联系起来。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;问题：&lt;/p&gt;
&lt;p&gt;不同硬件：&lt;/p&gt;
&lt;p&gt;接口完全不同。&lt;/p&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;p&gt;SSD：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;寄存器A:
启动

寄存器B:
状态
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;GPU：&lt;/p&gt;
&lt;p&gt;完全不同。&lt;/p&gt;
&lt;p&gt;如果 OS 直接管理：&lt;/p&gt;
&lt;p&gt;OS代码：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;if Nvidia
else AMD
else Intel
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;灾难。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;引入：&lt;/p&gt;
&lt;h2&gt;Device Driver&lt;/h2&gt;
&lt;p&gt;驱动就是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;操作系统和硬件之间的翻译层。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;结构：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;应用程序

     |
     v

操作系统

     |
     v

设备驱动

     |
     v

硬件
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;应用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;play_music();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;OS：&lt;/p&gt;
&lt;p&gt;不知道声卡细节。&lt;/p&gt;
&lt;p&gt;调用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;audio_driver.play()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;驱动：&lt;/p&gt;
&lt;p&gt;知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;写哪个MMIO地址
设置哪个寄存器
启动DMA
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;9. 系统启动时 MMIO 怎么建立？&lt;/h1&gt;
&lt;p&gt;视频流程：&lt;/p&gt;
&lt;h2&gt;第一步：BIOS/UEFI&lt;/h2&gt;
&lt;p&gt;开机：&lt;/p&gt;
&lt;p&gt;扫描硬件。&lt;/p&gt;
&lt;p&gt;发现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;GPU
网卡
SSD
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后分配地址。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;GPU:

0x80000000-0x8fffffff


网卡:

0x90000000-0x900fffff
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;记录：&lt;/p&gt;
&lt;p&gt;Memory Map。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第二步：OS启动&lt;/h2&gt;
&lt;p&gt;Linux：&lt;/p&gt;
&lt;p&gt;加载驱动。&lt;/p&gt;
&lt;p&gt;驱动读取：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;memory map
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;知道：&lt;/p&gt;
&lt;p&gt;自己的设备在哪里。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;p&gt;映射到内核虚拟地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;物理MMIO地址

        |
        v

kernel virtual address
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;类似：&lt;/p&gt;
&lt;p&gt;普通内存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;VA
 |
page table
 |
PA
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;MMIO：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;kernel VA
 |
页表
 |
设备物理地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;10. 用户程序如何访问设备？&lt;/h1&gt;
&lt;p&gt;重点：&lt;/p&gt;
&lt;p&gt;用户不能直接访问 MMIO。&lt;/p&gt;
&lt;p&gt;为什么？&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;p&gt;危险。&lt;/p&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;p&gt;用户：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov [GPU_CONTROL],0xffff
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可能：&lt;/p&gt;
&lt;p&gt;直接控制硬件。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;p&gt;流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;用户程序

播放音乐

   |
   v

system call

   |
   v

kernel

   |
   v

device driver

   |
   v

MMIO寄存器

   |
   v

声卡
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;11. 和 DMA 视频连接起来&lt;/h1&gt;
&lt;p&gt;现在把两个视频串起来。&lt;/p&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;p&gt;播放音乐。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第一步：用户程序&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;write(audio)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;第二步：系统调用&lt;/h2&gt;
&lt;p&gt;进入 kernel。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第三步：驱动控制声卡&lt;/h2&gt;
&lt;p&gt;通过 MMIO：&lt;/p&gt;
&lt;p&gt;写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;control register

start=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;告诉声卡：&lt;/p&gt;
&lt;p&gt;开始播放。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第四步：DMA搬数据&lt;/h2&gt;
&lt;p&gt;声卡 DMA：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RAM
 |
 |
声卡buffer
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不需要 CPU 搬。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;第五步：完成中断&lt;/h2&gt;
&lt;p&gt;声卡：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;interrupt CPU
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;p&gt;处理下一批数据。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;完整图：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;                 MMIO
User
 |
syscall
 |
Kernel
 |
Driver
 |
 +----------------+
 |                |
控制设备       DMA
 |                |
 v                v
Device &amp;lt;------ RAM

&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;12. 和你之前学的虚拟内存联系&lt;/h1&gt;
&lt;p&gt;你之前学：&lt;/p&gt;
&lt;p&gt;CPU：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;虚拟地址

     |
     v

页表

     |
     v

物理地址 RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在增加：&lt;/p&gt;
&lt;p&gt;MMIO：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU虚拟地址

      |
      v

页表

      |
      v

设备物理地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意：&lt;/p&gt;
&lt;p&gt;这个物理地址不一定对应 RAM。&lt;/p&gt;
&lt;p&gt;可能对应：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;GPU寄存器&lt;/li&gt;
&lt;li&gt;网卡寄存器&lt;/li&gt;
&lt;li&gt;SSD控制器&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h1&gt;13. 期末重点总结&lt;/h1&gt;
&lt;h2&gt;Q1：什么是 MMIO？&lt;/h2&gt;
&lt;p&gt;答案：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;将设备寄存器映射到统一物理地址空间，使 CPU 可以通过普通 load/store 指令访问设备。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;Q2：MMIO 为什么比 PMIO 好？&lt;/h2&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;使用统一地址空间&lt;/li&gt;
&lt;li&gt;不需要特殊 IO 指令&lt;/li&gt;
&lt;li&gt;可以利用 CPU/cache/burst 优化&lt;/li&gt;
&lt;li&gt;硬件设计简单&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h2&gt;Q3：用户程序为什么不能直接访问 MMIO？&lt;/h2&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;安全&lt;/li&gt;
&lt;li&gt;防止破坏硬件状态&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;必须：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;system call
+
driver
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;Q4：DMA 和 MMIO 区别？&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;作用&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;MMIO&lt;/td&gt;
&lt;td&gt;CPU控制设备&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DMA&lt;/td&gt;
&lt;td&gt;设备搬数据&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;一句话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;MMIO负责“告诉设备干什么”，DMA负责“设备自己搬数据”。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;p&gt;这两个视频合起来其实就是操作系统 &lt;strong&gt;I/O 系统核心框架&lt;/strong&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;             Application
                  |
             System Call
                  |
              Kernel
                  |
          Device Driver
                  |
        -----------------
        |               |
       MMIO            DMA
        |               |
     控制寄存器       数据搬运
        |               |
        ------ Device ------
                  |
                 RAM
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这部分在 JYY OS / 南大 OS 里面通常属于 &lt;strong&gt;设备驱动 + I/O subsystem&lt;/strong&gt;，也是理解 Linux 驱动、网卡、NVMe、GPU 工作原理的基础。你前面学的虚拟内存、页表、IOMMU 到这里刚好串起来。&lt;/p&gt;
</content:encoded></item><item><title>Linux 应用程序链接与加载：从 C 源码到进程的完整链路</title><link>https://sanzenin.top/posts/obsidian/elf%E9%93%BE%E6%8E%A5%E4%B8%8E%E5%8A%A0%E8%BD%BD/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/elf%E9%93%BE%E6%8E%A5%E4%B8%8E%E5%8A%A0%E8%BD%BD/</guid><description>本章目标：理解一个 C 程序为什么能够运行。 从： 到： 中间经历了什么？ 重点掌握： - 编译（compile） - 链接（link） - ELF 文件格式 - 静态链接 - 动态链接 - PLT/GOT - ld.so - execve 加载过程 - 常用二进制分析工具 写一个程序： 执行： 表面看： 实际上： 作</description><pubDate>Sun, 23 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Linux 应用程序链接与加载：从 C 源码到进程的完整链路&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;本章目标：理解一个 C 程序为什么能够运行。&lt;/p&gt;
&lt;p&gt;从：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hello.c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU执行指令
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;中间经历了什么？&lt;/p&gt;
&lt;p&gt;重点掌握：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;编译（compile）&lt;/li&gt;
&lt;li&gt;链接（link）&lt;/li&gt;
&lt;li&gt;ELF 文件格式&lt;/li&gt;
&lt;li&gt;静态链接&lt;/li&gt;
&lt;li&gt;动态链接&lt;/li&gt;
&lt;li&gt;PLT/GOT&lt;/li&gt;
&lt;li&gt;ld.so&lt;/li&gt;
&lt;li&gt;execve 加载过程&lt;/li&gt;
&lt;li&gt;常用二进制分析工具&lt;/li&gt;
&lt;/ul&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;1. 程序运行的完整流程&lt;/h1&gt;
&lt;p&gt;写一个程序：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;stdio.h&amp;gt;

int main()
{
    puts(&quot;hello&quot;);
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;gcc hello.c -o hello
./hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表面看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hello.c
    |
    v
hello
    |
    v
运行
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际上：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hello.c

   |
   | compiler
   v

hello.o

   |
   | linker
   v

hello (ELF)

   |
   | execve()

   v

Linux kernel

   |
   | loader

   v

进程地址空间

   |
   | CPU执行

   v

main()
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 三个核心角色&lt;/h1&gt;
&lt;h2&gt;2.1 Compiler（编译器）&lt;/h2&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;C代码 → 汇编 → 目标文件
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;gcc -c hello.c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;生成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hello.o
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2.2 Linker（链接器）&lt;/h2&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;p&gt;把多个目标文件组合。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main.o

+

foo.o

↓

program
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;解决两个问题：&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;符号解析（Symbol Resolution）&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;main.c：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;foo();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是：&lt;/p&gt;
&lt;p&gt;foo 在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;foo.c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;里面。&lt;/p&gt;
&lt;p&gt;linker 找到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;foo在哪里
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;重定位（Relocation）&lt;/h2&gt;
&lt;p&gt;修改：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call ????
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;成为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call 真实地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2.3 Loader（加载器）&lt;/h2&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;p&gt;把 ELF 文件放入内存。&lt;/p&gt;
&lt;p&gt;负责：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;创建地址空间&lt;/li&gt;
&lt;li&gt;加载代码段&lt;/li&gt;
&lt;li&gt;创建栈&lt;/li&gt;
&lt;li&gt;设置寄存器&lt;/li&gt;
&lt;li&gt;跳转入口地址&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h1&gt;3. ELF：Linux可执行文件格式&lt;/h1&gt;
&lt;p&gt;Linux使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ELF
Executable and Linkable Format
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;file hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hello: ELF 64-bit LSB executable
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;ELF 不只是可执行文件：&lt;/p&gt;
&lt;p&gt;包括：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;类型&lt;/th&gt;
&lt;th&gt;说明&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;.o&lt;/td&gt;
&lt;td&gt;目标文件&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;可执行文件&lt;/td&gt;
&lt;td&gt;程序&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;.so&lt;/td&gt;
&lt;td&gt;共享库&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;core&lt;/td&gt;
&lt;td&gt;崩溃转储&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h1&gt;4. ELF结构&lt;/h1&gt;
&lt;p&gt;大致：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ELF

+----------------+
| ELF Header     |
+----------------+
| Program Header |
+----------------+
| .text          |
| .rodata        |
| .data          |
| .bss           |
+----------------+
| Section Header |
+----------------+
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;5. Section 和 Segment&lt;/h1&gt;
&lt;p&gt;这是 ELF 最重要概念之一。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;5.1 Section&lt;/h1&gt;
&lt;p&gt;面向：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;linker
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;链接器关心：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;哪些东西需要合并？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;常见：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Section&lt;/th&gt;
&lt;th&gt;作用&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;.text&lt;/td&gt;
&lt;td&gt;代码&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;.rodata&lt;/td&gt;
&lt;td&gt;只读数据&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;.data&lt;/td&gt;
&lt;td&gt;初始化全局变量&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;.bss&lt;/td&gt;
&lt;td&gt;未初始化全局变量&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;.symtab&lt;/td&gt;
&lt;td&gt;符号表&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h1&gt;5.2 Segment&lt;/h1&gt;
&lt;p&gt;面向：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;loader
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;加载器关心：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;哪些内容需要映射到内存？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;LOAD

R-X

RW-
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;关系：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Section
    |
    | linker视角

Segment
    |
    | loader视角
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;6. 程序加载后的地址空间&lt;/h1&gt;
&lt;p&gt;一个进程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

+----------------+
| stack          |
+----------------+

+----------------+
| shared library |
| libc.so        |
+----------------+

+----------------+
| mmap           |
+----------------+

+----------------+
| heap           |
+----------------+

+----------------+
| .bss/.data     |
+----------------+

+----------------+
| .text          |
+----------------+

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;对应 C：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;C代码&lt;/th&gt;
&lt;th&gt;位置&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;函数&lt;/td&gt;
&lt;td&gt;.text&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;字符串常量&lt;/td&gt;
&lt;td&gt;.rodata&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;global变量&lt;/td&gt;
&lt;td&gt;.data/.bss&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;malloc&lt;/td&gt;
&lt;td&gt;heap&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;局部变量&lt;/td&gt;
&lt;td&gt;stack&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h1&gt;7. 静态链接&lt;/h1&gt;
&lt;h2&gt;思想&lt;/h2&gt;
&lt;p&gt;把库代码直接复制进程序。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;来自：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc.a
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;静态链接：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hello.o

+

libc.a

↓

hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最终：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hello

.text

main

printf

malloc

...
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;优点&lt;/h2&gt;
&lt;p&gt;运行时不依赖外部库。&lt;/p&gt;
&lt;h2&gt;缺点&lt;/h2&gt;
&lt;h3&gt;1. 文件大&lt;/h3&gt;
&lt;h3&gt;2. 内存浪费&lt;/h3&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;程序A libc

程序B libc

程序C libc
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;8. 动态链接&lt;/h1&gt;
&lt;p&gt;解决静态链接问题。&lt;/p&gt;
&lt;p&gt;思想：&lt;/p&gt;
&lt;p&gt;共享库。&lt;/p&gt;
&lt;p&gt;结构：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vim

 |
 |
 libc.so


bash

 |
 |
 libc.so
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;多个程序共享：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc.so
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;9. 动态链接的问题&lt;/h1&gt;
&lt;p&gt;代码：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;puts(&quot;hello&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是：&lt;/p&gt;
&lt;p&gt;puts在哪里？&lt;/p&gt;
&lt;p&gt;答案：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc.so
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;编译 hello 时：&lt;/p&gt;
&lt;p&gt;不知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc加载在哪里
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;ASLR&lt;/li&gt;
&lt;li&gt;动态库地址随机&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;p&gt;解决：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;PLT + GOT
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;10. GOT&lt;/h1&gt;
&lt;h2&gt;Global Offset Table&lt;/h2&gt;
&lt;p&gt;全局偏移表。&lt;/p&gt;
&lt;p&gt;本质：&lt;/p&gt;
&lt;p&gt;一个地址表。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;GOT

+-------------+
| puts地址    |
+-------------+
| malloc地址  |
+-------------+
| printf地址  |
+-------------+
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;启动前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;puts = ?
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;动态链接后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;puts = 0x7ffff7xxxx
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;11. PLT&lt;/h1&gt;
&lt;h2&gt;Procedure Linkage Table&lt;/h2&gt;
&lt;p&gt;函数跳板。&lt;/p&gt;
&lt;p&gt;调用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;puts();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call puts@plt
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main

 |
 |
puts@plt

 |
 |
GOT

 |
 |
libc puts
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;12. 第一次调用 puts&lt;/h1&gt;
&lt;p&gt;流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main

call puts@plt

        |

        v

      PLT

        |

        v

      GOT

        |

        v

      ld.so

        |

        v

    查找 libc

        |

        v

    修改 GOT
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;之后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main

↓

PLT

↓

GOT

↓

puts
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这叫：&lt;/p&gt;
&lt;h2&gt;Lazy Binding&lt;/h2&gt;
&lt;p&gt;延迟绑定。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;13. ld.so&lt;/h1&gt;
&lt;p&gt;动态链接器。&lt;/p&gt;
&lt;p&gt;文件：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;/lib64/ld-linux-x86-64.so.2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ls -l /lib64/ld-linux-x86-64.so.2
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;h2&gt;1. 加载共享库&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc.so
libm.so
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 符号解析&lt;/h2&gt;
&lt;p&gt;找到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;puts在哪里
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 修改GOT&lt;/h2&gt;
&lt;p&gt;填入：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;真实地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;14. 程序启动流程&lt;/h1&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;./hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;真实：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;shell

 |
 |
execve()

 |
 v

kernel

 |
 |
读取ELF

 |
 |
发现.interp

 |
 |
启动ld.so

 |
 |
加载libc.so

 |
 |
修改GOT

 |
 |
_start

 |
 |
__libc_start_main

 |
 |
main
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;15. 为什么不是main开始执行？&lt;/h1&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;readelf -h hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Entry point address
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;通常：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;原因：&lt;/p&gt;
&lt;p&gt;main之前需要：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;初始化libc&lt;/li&gt;
&lt;li&gt;设置argc argv&lt;/li&gt;
&lt;li&gt;初始化环境&lt;/li&gt;
&lt;li&gt;初始化全局变量&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h1&gt;16. objdump：查看机器指令&lt;/h1&gt;
&lt;p&gt;命令：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;objdump -d hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;p&gt;反汇编。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;C：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;puts(&quot;hello&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;汇编：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lea string,%rax

mov %rax,%rdi

call puts@plt
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;17. main函数解释&lt;/h1&gt;
&lt;p&gt;典型：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push rbp
mov rsp,rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;建立栈帧。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;加载字符串：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lea offset(%rip),%rax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;原因：&lt;/p&gt;
&lt;p&gt;PIE。&lt;/p&gt;
&lt;p&gt;不能固定地址。&lt;/p&gt;
&lt;p&gt;使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RIP + offset
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;参数传递：&lt;/p&gt;
&lt;p&gt;Linux x86-64 ABI：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;参数&lt;/th&gt;
&lt;th&gt;寄存器&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;rdi&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;rsi&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;rdx&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;rcx&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;r8&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;r9&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;puts(&quot;hello&quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;变成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rdi = hello地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18. 常用命令总结&lt;/h1&gt;
&lt;hr /&gt;
&lt;h1&gt;18.1 查看文件类型&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;file hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;p&gt;查看是否 ELF。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;18.2 查看 ELF Header&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;readelf -h hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;ELF类型&lt;/li&gt;
&lt;li&gt;entry point&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;重点：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Entry point address
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18.3 查看 Program Header&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;readelf -l hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;重点：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;LOAD

INTERP

DYNAMIC
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18.4 查看 Section&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;readelf -S hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;.text
.data
.bss
.rodata
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18.5 查看动态依赖&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;ldd hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc.so.6

libm.so.6

ld-linux
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18.6 查看汇编&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;objdump -d hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start

main

PLT
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18.7 C代码和汇编对应&lt;/h1&gt;
&lt;p&gt;编译：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;gcc -g hello.c -o hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;objdump -S hello
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18.8 查看符号表&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;nm hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;动态符号：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;nm -D hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;U puts
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;p&gt;undefined。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;18.9 查看重定位&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;objdump -R hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;JUMP_SLOT puts
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18.10 查看运行时地址空间&lt;/h1&gt;
&lt;p&gt;启动：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;./hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查 PID：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ps aux
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;查看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;pmap PID
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;或者：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cat /proc/PID/maps
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;19. LD_PRELOAD&lt;/h1&gt;
&lt;p&gt;作用：&lt;/p&gt;
&lt;p&gt;强制加载自己的动态库。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;LD_PRELOAD=./hook.so ./hello
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;替换函数&lt;/li&gt;
&lt;li&gt;监控调用&lt;/li&gt;
&lt;li&gt;调试&lt;/li&gt;
&lt;/ul&gt;
&lt;hr /&gt;
&lt;h1&gt;20. 总结：完整知识链&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;C源码

↓

gcc

↓

.o目标文件

↓

linker

↓

ELF

↓

execve

↓

kernel

↓

loader

↓

ld.so

↓

加载动态库

↓

解析符号

↓

修改GOT

↓

_start

↓

libc初始化

↓

main

↓

PLT

↓

GOT

↓

libc函数
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;最终需要掌握的核心概念&lt;/h1&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;概念&lt;/th&gt;
&lt;th&gt;一句话&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;ELF&lt;/td&gt;
&lt;td&gt;描述程序如何运行的文件格式&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Section&lt;/td&gt;
&lt;td&gt;链接器看到的组织方式&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Segment&lt;/td&gt;
&lt;td&gt;加载器看到的组织方式&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Linker&lt;/td&gt;
&lt;td&gt;生成最终程序&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Loader&lt;/td&gt;
&lt;td&gt;把程序放入内存&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ld.so&lt;/td&gt;
&lt;td&gt;动态加载和链接&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PLT&lt;/td&gt;
&lt;td&gt;函数调用跳板&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GOT&lt;/td&gt;
&lt;td&gt;保存真实地址&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Relocation&lt;/td&gt;
&lt;td&gt;修正地址&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Lazy Binding&lt;/td&gt;
&lt;td&gt;第一次调用时解析&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;p&gt;这一章学完以后，后面的：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;shell 为什么能执行程序&lt;/li&gt;
&lt;li&gt;execve 如何工作&lt;/li&gt;
&lt;li&gt;fork 为什么复制地址空间&lt;/li&gt;
&lt;li&gt;mmap 为什么能加载共享库&lt;/li&gt;
&lt;li&gt;调试器如何找到函数&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;都会建立在这套模型上。你现在用 &lt;code&gt;pmap + readelf + objdump + ldd&lt;/code&gt; 这几个工具观察程序，已经是在用 Linux 系统程序员的视角理解 OS 了。&lt;/p&gt;
</content:encoded></item><item><title>mmp,进程地址空间</title><link>https://sanzenin.top/posts/obsidian/mmp-%E8%BF%9B%E7%A8%8B%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/mmp-%E8%BF%9B%E7%A8%8B%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4/</guid><description>mmp,进程地址空间，来自 Obsidian 的操作系统笔记。</description><pubDate>Sun, 23 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
</content:encoded></item><item><title>绪论</title><link>https://sanzenin.top/posts/obsidian/%E7%BB%AA%E8%AE%BA/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%BB%AA%E8%AE%BA/</guid><description>绪论，来自 Obsidian 的操作系统笔记。</description><pubDate>Sun, 23 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;状态机&lt;/p&gt;
</content:encoded></item><item><title>硬件与多任务：中断、寄存器和上下文切换</title><link>https://sanzenin.top/posts/obsidian/03-%E7%A1%AC%E4%BB%B6%E4%B8%8E%E5%A4%9A%E4%BB%BB%E5%8A%A1-%E4%B8%AD%E6%96%AD-%E5%AF%84%E5%AD%98%E5%99%A8%E5%92%8C%E4%B8%8A%E4%B8%8B%E6%96%87%E5%88%87%E6%8D%A2/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/03-%E7%A1%AC%E4%BB%B6%E4%B8%8E%E5%A4%9A%E4%BB%BB%E5%8A%A1-%E4%B8%AD%E6%96%AD-%E5%AF%84%E5%AD%98%E5%99%A8%E5%92%8C%E4%B8%8A%E4%B8%8B%E6%96%87%E5%88%87%E6%8D%A2/</guid><description>这一节回答一个很关键的问题：进程被中断时，CPU 寄存器里还放着这个进程的运行现场。操作系统想切换到另一个进程，就必须先保存现场；但保存现场本身又需要执行指令，而执行指令会修改寄存器。这个循环怎么打破？ 答案是：进入内核的第一步必须有硬件支持。纯软件无法在毫无硬件约束的情况下可靠保存被打断的现场。 但也要区分两个概念：</description><pubDate>Sat, 22 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;硬件与多任务：中断、寄存器和上下文切换&lt;/h1&gt;
&lt;p&gt;这一节回答一个很关键的问题：进程被中断时，CPU 寄存器里还放着这个进程的运行现场。操作系统想切换到另一个进程，就必须先保存现场；但保存现场本身又需要执行指令，而执行指令会修改寄存器。这个循环怎么打破？&lt;/p&gt;
&lt;p&gt;答案是：进入内核的第一步必须有硬件支持。纯软件无法在毫无硬件约束的情况下可靠保存被打断的现场。&lt;/p&gt;
&lt;p&gt;但也要区分两个概念：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;trap/interrupt entry：CPU 因中断、异常或系统调用进入内核；&lt;/li&gt;
&lt;li&gt;context switch：调度器决定从当前任务切到另一个任务。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;一次进入内核不一定会发生上下文切换。例如普通 &lt;code&gt;getpid()&lt;/code&gt; 系统调用通常进入内核后很快返回原线程。&lt;/p&gt;
&lt;h2&gt;进程为什么依赖寄存器上下文&lt;/h2&gt;
&lt;p&gt;CPU 只是不断取指、译码、执行。指令本身不包含全部状态，同一条指令在不同寄存器值下会产生不同结果。&lt;/p&gt;
&lt;p&gt;进程的运行现场至少包括：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;program counter：下一条指令地址；&lt;/li&gt;
&lt;li&gt;general purpose registers：通用寄存器；&lt;/li&gt;
&lt;li&gt;stack pointer：当前栈顶；&lt;/li&gt;
&lt;li&gt;flags：条件码、中断位等标志；&lt;/li&gt;
&lt;li&gt;地址空间相关寄存器或页表根；&lt;/li&gt;
&lt;li&gt;部分架构相关状态。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;因此，进程让出 CPU 时，不能只记住“它是哪个程序”。还要保存它执行到哪一行、寄存器里是什么、栈在哪里。&lt;/p&gt;
&lt;h2&gt;上下文切换&lt;/h2&gt;
&lt;p&gt;上下文切换就是：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;保存当前进程的 CPU 状态；&lt;/li&gt;
&lt;li&gt;把这些状态写入该进程的 PCB / 内核任务结构；&lt;/li&gt;
&lt;li&gt;选择下一个要运行的进程或线程；&lt;/li&gt;
&lt;li&gt;加载新任务之前保存的 CPU 状态；&lt;/li&gt;
&lt;li&gt;回到用户态，从新任务上次停止的位置继续执行。&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    A[进程 A 正在运行] --&amp;gt; B[中断或系统调用]
    B --&amp;gt; C[CPU 进入内核态]
    C --&amp;gt; D[保存 A 的 PC/SP/寄存器]
    D --&amp;gt; E[调度器选择进程 B]
    E --&amp;gt; F[恢复 B 的 PC/SP/寄存器]
    F --&amp;gt; G[返回用户态，B 继续运行]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里的难点在第 3 步之前：操作系统必须先获得一小段可靠的执行环境，才能保存旧进程。&lt;/p&gt;
&lt;h2&gt;进程中断的两种来源&lt;/h2&gt;
&lt;p&gt;软件触发的陷入：进程主动执行特殊指令，请求操作系统服务。例如系统调用、断点、主动 yield。&lt;/p&gt;
&lt;p&gt;异常：当前指令执行时触发，例如缺页、除零、非法指令。异常不是“自愿中断”，它是当前指令导致的同步事件。&lt;/p&gt;
&lt;p&gt;硬件中断或被动中断：进程没有主动请求，但外部设备或定时器触发了中断。例如时钟中断、I/O 完成、键盘输入。&lt;/p&gt;
&lt;p&gt;不管来源是什么，中断发生时 CPU 通常会：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;等当前指令执行完；&lt;/li&gt;
&lt;li&gt;根据事件类型和当前特权级，保存架构规定的最小返回现场；&lt;/li&gt;
&lt;li&gt;切换到内核态或提高特权级，并跳转到入口；&lt;/li&gt;
&lt;li&gt;让操作系统接管。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;“执行完当前指令再中断”很重要，因为否则一条指令执行一半，寄存器和内存可能处于不可恢复的中间状态。&lt;/p&gt;
&lt;h2&gt;纯软件为什么不够&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/hardware%26multitasking-1784045618371.webp&quot; alt=&quot;hardware&amp;amp;multitasking-1784045618371&quot; /&gt;&lt;/p&gt;
&lt;p&gt;看起来，操作系统进入中断处理程序后只要执行几条保存指令就行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;STR SP, [2200]
LOAD SP, 2100
PUSH R0
PUSH R1
PUSH R2
PUSH R3
PUSH flags
PUSH [2200]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;问题是这些指令一开始仍然在使用“被中断进程”的寄存器和栈。&lt;/p&gt;
&lt;p&gt;如果直接 &lt;code&gt;PUSH R0&lt;/code&gt;，压入的是用户进程自己的栈。这样会修改被中断进程的内存，破坏它原本的栈布局。&lt;/p&gt;
&lt;p&gt;如果想先切到内核栈，就要修改 &lt;code&gt;SP&lt;/code&gt;。但修改 &lt;code&gt;SP&lt;/code&gt; 之前，又必须先保存旧 &lt;code&gt;SP&lt;/code&gt;，否则用户栈位置就丢了。现实 CPU 会通过特权级切换规则、专用寄存器或入口代码约定来解决这个问题，而不是让普通软件在用户栈上硬保存。&lt;/p&gt;
&lt;p&gt;如果把旧 &lt;code&gt;SP&lt;/code&gt; 存到某个固定内存地址，也会遇到问题：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;固定地址本身需要硬件保证可用；&lt;/li&gt;
&lt;li&gt;多核或嵌套中断时会互相覆盖；&lt;/li&gt;
&lt;li&gt;存储指令可能也需要临时寄存器；&lt;/li&gt;
&lt;li&gt;最关键的是，program counter 在跳到中断处理程序时已经被覆盖，纯软件没有机会在覆盖前保存它。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/hardware%26multitasking-1784046286735.webp&quot; alt=&quot;hardware&amp;amp;multitasking-1784046286735&quot; /&gt;&lt;/p&gt;
&lt;p&gt;所以真正的问题不是“操作系统不会写保存寄存器的代码”，而是：进入保存代码之前，CPU 已经改变了一些必须保存的状态。&lt;/p&gt;
&lt;p&gt;结论：进入内核入口的第一步必须由硬件定义好。硬件至少要提供“从哪里进入、以什么权限执行、怎样能返回原位置”的机制；具体保存多少寄存器则因架构而异。&lt;/p&gt;
&lt;h2&gt;硬件辅助方案一：多套寄存器组&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/hardware%26multitasking-1784046355562.webp&quot; alt=&quot;hardware&amp;amp;multitasking-1784046355562&quot; /&gt;
&lt;img src=&quot;/obsidian/hardware%26multitasking-1784046505373.webp&quot; alt=&quot;hardware&amp;amp;multitasking-1784046505373&quot; /&gt;&lt;/p&gt;
&lt;p&gt;这种设计给 CPU 准备多套寄存器。例如：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;common register set：用户程序平时使用；&lt;/li&gt;
&lt;li&gt;privilege register set：内核或中断处理程序使用。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;中断发生时，CPU 不覆盖用户寄存器组，而是切换到特权寄存器组。这样中断处理程序可以用另一套寄存器运行，用户进程的 program counter、stack pointer 和通用寄存器还留在原来的寄存器组里。&lt;/p&gt;
&lt;p&gt;流程大致是：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;用户程序使用 common register set；&lt;/li&gt;
&lt;li&gt;中断发生；&lt;/li&gt;
&lt;li&gt;CPU 切到内核态，并启用 privilege register set；&lt;/li&gt;
&lt;li&gt;用户寄存器组保持不变；&lt;/li&gt;
&lt;li&gt;OS 用特权指令读取被停用的用户寄存器组；&lt;/li&gt;
&lt;li&gt;OS 把这些值写入该进程 PCB；&lt;/li&gt;
&lt;li&gt;OS 从另一个进程 PCB 取出状态，写回用户寄存器组；&lt;/li&gt;
&lt;li&gt;执行类似 &lt;code&gt;cisr&lt;/code&gt; 的特权指令，切回用户态和用户寄存器组。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/hardware%26multitasking-1784046836809.webp&quot; alt=&quot;hardware&amp;amp;multitasking-1784046836809&quot; /&gt;&lt;/p&gt;
&lt;p&gt;这里的 &lt;code&gt;cisr&lt;/code&gt; 可以理解为“从中断返回”的特殊指令。它不是普通跳转，而是同时完成：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;切回用户模式；&lt;/li&gt;
&lt;li&gt;恢复或切换活动寄存器组；&lt;/li&gt;
&lt;li&gt;让 CPU 从目标进程的 program counter 继续执行。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这种方案的好处是概念清楚：中断处理程序不会踩到用户现场。缺点也明显：硬件成本高。现代 CPU 寄存器越来越多，还包括浮点、SIMD、向量寄存器等，为每种模式复制完整寄存器组代价很大。&lt;/p&gt;
&lt;p&gt;因此多寄存器组在一些架构或场景里存在，但不是现代通用 CPU 最常依赖的完整方案。&lt;/p&gt;
&lt;h2&gt;硬件辅助方案二：硬件自动切内核栈并保存关键寄存器&lt;/h2&gt;
&lt;p&gt;更常见的做法是：CPU 在中断、异常或系统调用入口提供一套最小进入机制，然后让内核入口代码继续保存其余寄存器。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/hardware%26multitasking-1784047384216.webp&quot; alt=&quot;hardware&amp;amp;multitasking-1784047384216&quot; /&gt;&lt;/p&gt;
&lt;p&gt;CPU 必须至少知道内核栈在哪里。这个位置可以来自：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;特权寄存器；&lt;/li&gt;
&lt;li&gt;当前 CPU 的 per-CPU 内存；&lt;/li&gt;
&lt;li&gt;架构规定的任务状态结构；&lt;/li&gt;
&lt;li&gt;中断描述符或类似机制。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;以传统中断/异常入口为例，硬件可能先做一小段不可分割的工作：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;找到当前 CPU 的内核栈；&lt;/li&gt;
&lt;li&gt;把用户态的 PC、SP、flags 等关键状态压入内核栈；&lt;/li&gt;
&lt;li&gt;切换到内核态；&lt;/li&gt;
&lt;li&gt;跳到中断处理入口。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;但不能把这条流程当成所有架构的统一规则。例如 x86-64 的 &lt;code&gt;syscall&lt;/code&gt; 指令不会像普通中断门那样自动把完整返回现场压到内核栈；Linux 入口代码需要用 &lt;code&gt;swapgs&lt;/code&gt;、per-CPU 数据和汇编保存约定来切换到合适的内核栈并保存寄存器。&lt;/p&gt;
&lt;p&gt;之后操作系统的汇编入口代码再保存通用寄存器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;硬件或入口约定保存：返回地址 / flags / privilege info / 必要的栈信息
软件保存：general registers / SIMD state / scheduler state
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这解决了两个最致命的问题：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;返回位置有明确定义，不会因为跳到内核入口而丢失；&lt;/li&gt;
&lt;li&gt;用户栈和内核栈之间的切换有架构支持或内核入口约定。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;现代系统大多采用这种“硬件定义最小入口语义 + 软件保存剩余现场”的思路。它在硬件复杂度和操作系统灵活性之间比较平衡。&lt;/p&gt;
&lt;h2&gt;硬件辅助方案三：TSS 或全硬件任务切换&lt;/h2&gt;
&lt;p&gt;TSS 是 Task State Segment，任务状态段。它是一种由操作系统准备、CPU 理解的数据结构。&lt;/p&gt;
&lt;p&gt;在更激进的设计中，CPU 可以在任务切换时自动把完整寄存器状态保存到一个任务结构中，再从另一个任务结构恢复状态。对软件来说，好像上下文切换几乎由硬件完成。&lt;/p&gt;
&lt;p&gt;这种方案听起来很省事，但主流操作系统通常不愿意完全依赖硬件任务切换，原因包括：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;硬件机制复杂，不方便做调度器优化；&lt;/li&gt;
&lt;li&gt;保存哪些状态、何时保存，软件更想自己控制；&lt;/li&gt;
&lt;li&gt;不同架构行为不一致，影响可移植性；&lt;/li&gt;
&lt;li&gt;现代上下文状态很多，全交给硬件未必更快。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;在 x86 上，TSS 现在仍有用途，但主流内核通常不会用它来做完整任务切换。更常见的用途是保存特权级切换时需要的栈信息，例如 ring 0 栈指针；x86-64 还用 IST 为某些异常提供专用栈。&lt;/p&gt;
&lt;h2&gt;和 Linux 的关系&lt;/h2&gt;
&lt;p&gt;Linux 的相关路径可以分成两层看：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;中断/异常入口：架构相关汇编保存硬件现场；&lt;/li&gt;
&lt;li&gt;调度切换：内核在 &lt;code&gt;task_struct&lt;/code&gt; 和架构相关 thread context 中切换任务。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;概念上对应：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;笔记概念&lt;/th&gt;
&lt;th&gt;Linux 中的影子&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;PCB&lt;/td&gt;
&lt;td&gt;&lt;code&gt;task_struct&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;地址空间&lt;/td&gt;
&lt;td&gt;&lt;code&gt;mm_struct&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CPU 上下文&lt;/td&gt;
&lt;td&gt;&lt;code&gt;thread_struct&lt;/code&gt; 和内核栈上的 pt_regs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;调度器选择&lt;/td&gt;
&lt;td&gt;&lt;code&gt;schedule()&lt;/code&gt; 相关代码&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;线程/进程创建&lt;/td&gt;
&lt;td&gt;&lt;code&gt;kernel/fork.c&lt;/code&gt; 中的 &lt;code&gt;copy_process()&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;不同 CPU 架构的保存细节不一样，所以 Linux 把大量入口代码放在 &lt;code&gt;arch/&amp;lt;架构&amp;gt;/&lt;/code&gt; 下面。通用调度逻辑在内核调度器里，具体寄存器怎么保存和恢复则由架构相关代码处理。&lt;/p&gt;
&lt;h2&gt;这节最重要的结论&lt;/h2&gt;
&lt;p&gt;上下文切换不是“操作系统随便暂停一个进程再启动另一个进程”这么简单。CPU 必须提供受控进入内核的机制，让内核有办法知道返回位置、当前权限、用户栈和必要状态。否则操作系统还没来得及执行保存代码，最关键的运行位置和栈位置就可能已经不可恢复。&lt;/p&gt;
&lt;p&gt;所以多任务操作系统依赖硬件提供：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;用户态 / 内核态；&lt;/li&gt;
&lt;li&gt;中断入口；&lt;/li&gt;
&lt;li&gt;内核栈切换或等价的入口约定；&lt;/li&gt;
&lt;li&gt;返回现场的硬件定义；&lt;/li&gt;
&lt;li&gt;从中断返回的特权指令。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;操作系统负责策略：什么时候切、切给谁、保存到哪个任务结构。硬件负责保证：切入内核的那一瞬间，旧进程的现场还有办法被可靠保存。&lt;/p&gt;
</content:encoded></item><item><title>Hosted 与 Freestanding</title><link>https://sanzenin.top/posts/obsidian/c-%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86-%E8%B0%83%E8%AF%95libc/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/c-%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86-%E8%B0%83%E8%AF%95libc/</guid><description>C语言可以直接调用汇编 实现了直接调用系统调用 C 标准把程序运行环境大体分成两类： 它们最核心的区别不是“有没有 libc”，而是： 程序能不能假设自己运行在一个已经准备好的完整软件环境中。 典型例子： 程序下面已经存在： 程序员通常不用操心： - 栈怎么建立 - main 谁调用 - printf 怎么输出 - m</description><pubDate>Sat, 22 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787334827509.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787334827509&quot; /&gt;
&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787334923680.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787334923680&quot; /&gt;&lt;/p&gt;
&lt;p&gt;C语言可以直接调用汇编 实现了直接调用系统调用&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787421499224.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787421499224&quot; /&gt;&lt;/p&gt;
&lt;h1&gt;Hosted 与 Freestanding&lt;/h1&gt;
&lt;h2&gt;1. 两种 C 程序运行环境&lt;/h2&gt;
&lt;p&gt;C 标准把程序运行环境大体分成两类：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Hosted Environment       托管环境
Freestanding Environment 独立环境 / 裸机环境
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它们最核心的区别不是“有没有 libc”，而是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;程序能不能假设自己运行在一个已经准备好的完整软件环境中。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h3&gt;Hosted&lt;/h3&gt;
&lt;p&gt;典型例子：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Linux 用户程序
Windows 用户程序
macOS 用户程序
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;程序下面已经存在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;应用程序
   ↓
libc / runtime
   ↓
操作系统
   ↓
硬件
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;程序员通常不用操心：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;栈怎么建立&lt;/li&gt;
&lt;li&gt;&lt;code&gt;main&lt;/code&gt; 谁调用&lt;/li&gt;
&lt;li&gt;&lt;code&gt;printf&lt;/code&gt; 怎么输出&lt;/li&gt;
&lt;li&gt;&lt;code&gt;malloc&lt;/code&gt; 怎么获得内存&lt;/li&gt;
&lt;li&gt;程序结束后谁回收资源&lt;/li&gt;
&lt;li&gt;&lt;code&gt;.bss&lt;/code&gt; 谁清零&lt;/li&gt;
&lt;li&gt;文件系统、进程、终端怎么实现&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这些基础设施已经由 OS、loader、C runtime 和 libc 提供。&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;Freestanding&lt;/h3&gt;
&lt;p&gt;典型例子：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;操作系统内核
Bootloader
MCU 裸机程序
固件 Firmware
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里不能假设存在完整 OS。&lt;/p&gt;
&lt;p&gt;结构更接近：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;自己的程序
   ↓
自己提供的 runtime / libc 子集 / 驱动
   ↓
硬件
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是说：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;许多在 Hosted 环境中“天然存在”的东西，在 Freestanding 环境中都需要自己提供。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;2. C 语言本身和 libc 不是一回事&lt;/h1&gt;
&lt;p&gt;这是理解 Freestanding 最重要的一点。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int add(int a, int b) {
    return a + b;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;函数
整数
加法
return
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;都是 C 语言本身的能力。&lt;/p&gt;
&lt;p&gt;它们最终可以直接变成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov
add
ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU 能直接执行。&lt;/p&gt;
&lt;p&gt;所以完全不需要 Linux，也不需要 libc。&lt;/p&gt;
&lt;p&gt;但：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;hello&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不同。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;printf&lt;/code&gt;：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不是 C 语言语法，而是 C 标准库提供的函数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;类似的还有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf
malloc
free
fopen
strlen
memcpy
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此必须区分：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;C language
≠
libc
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;3. 为什么 &lt;code&gt;printf&lt;/code&gt; 特别依赖运行环境&lt;/h1&gt;
&lt;p&gt;普通 Linux 程序：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;hello&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;大致经历：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf
  ↓
libc
  ↓
write 等系统调用
  ↓
Linux kernel
  ↓
终端驱动
  ↓
设备
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果你正在写 Linux 内核类似的东西：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;你的 kernel
    ↓
？？？
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;下面已经没有操作系统给你调用。&lt;/p&gt;
&lt;p&gt;因此 Freestanding 环境不能默认存在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果想输出，就要自己构建：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;自己的 printf
   ↓
console_putc
   ↓
UART / framebuffer / VGA
   ↓
硬件
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Freestanding 并不是“绝对不能有 printf”，而是系统不会自动替你提供它。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;4. &lt;code&gt;memcpy&lt;/code&gt; 为什么比较特殊&lt;/h1&gt;
&lt;p&gt;像：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;memcpy()
memset()
memcmp()
strlen()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这类函数主要只需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;读内存
写内存
循环
比较
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不依赖文件系统、进程或终端。&lt;/p&gt;
&lt;p&gt;因此它们很适合在 Freestanding 环境中自己实现。&lt;/p&gt;
&lt;p&gt;例如最简单的 &lt;code&gt;memcpy&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;void *memcpy(void *dst, const void *src, unsigned long n) {
    unsigned char *d = dst;
    const unsigned char *s = src;

    while (n--)
        *d++ = *s++;

    return dst;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本质只有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;load
store
loop
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;5. 一个重要陷阱：源代码没写 &lt;code&gt;memcpy&lt;/code&gt;，编译器也可能调用它&lt;/h1&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct Big {
    char data[1000];
};

void f(struct Big *a, struct Big *b) {
    *a = *b;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;编译器可能生成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call memcpy
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是说：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;编译器可能主动把某些操作转换成对 runtime helper 的调用。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;于是你的 Freestanding 程序可能必须自己提供：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;memcpy
memmove
memset
memcmp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;否则链接阶段可能报：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;undefined reference to `memcpy`
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;-ffreestanding&lt;/code&gt; 不代表编译器从此绝不会产生任何库函数依赖。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;6. Hosted 程序并不是从 &lt;code&gt;main&lt;/code&gt; 真正开始&lt;/h1&gt;
&lt;p&gt;平时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int main() {
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;很容易让人产生：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;程序入口 = main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;的错觉。&lt;/p&gt;
&lt;p&gt;实际上 Linux 用户程序通常更接近：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Linux kernel
    ↓
加载 ELF
    ↓
跳到 ELF entry point
    ↓
_start
    ↓
C runtime 初始化
    ↓
main()
    ↓
exit()
    ↓
系统调用
    ↓
Linux kernel
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;main&lt;/code&gt; 通常是 C runtime 调用的，而不是 CPU 或 Linux 直接寻找的。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;7. Freestanding 环境甚至不要求有 &lt;code&gt;main&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;例如内核可以写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;void kernel_main(void) {
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;启动代码：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start:
    mov rsp, stack_top
    call kernel_main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;此时执行路径：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Bootloader
   ↓
_start
   ↓
kernel_main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;CPU 根本不知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main
kernel_main
runtime_init
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这些名字有什么特殊意义。&lt;/p&gt;
&lt;p&gt;CPU 最终只知道地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x100000
0x100100
...
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;8. 那 &lt;code&gt;_start&lt;/code&gt; 又是谁调用的？&lt;/h1&gt;
&lt;p&gt;这里要继续向下追。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU reset
   ↓
BIOS / UEFI / 固件
   ↓
Bootloader
   ↓
加载 kernel.elf
   ↓
读取 ELF entry point
   ↓
跳到 _start
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;链接脚本中可能写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ENTRY(_start)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;链接器于是会把：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start 的地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;写入 ELF 的入口信息。&lt;/p&gt;
&lt;p&gt;Bootloader 加载后直接跳过去。&lt;/p&gt;
&lt;p&gt;所以不存在：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;CPU 看见一个叫 &lt;code&gt;_start&lt;/code&gt; 的函数，然后认为它应该执行。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;真正重要的是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;入口地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;9. Freestanding 程序怎么找到自己实现的 runtime&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start:
    call runtime_init
    call kernel_main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;void runtime_init(void) {
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;位于另外一个源文件。&lt;/p&gt;
&lt;p&gt;编译后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;boot.o
    需要 runtime_init

runtime.o
    提供 runtime_init
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;链接器执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;符号解析 Symbol Resolution
+
重定位 Relocation
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;把：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call runtime_init
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最终转换成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call 某个确定地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;程序运行时并不会“寻找 runtime”。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;runtime 在运行之前已经被 linker 绑定好了。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;10. 两种 runtime 调用来源&lt;/h1&gt;
&lt;p&gt;需要区分两种情况。&lt;/p&gt;
&lt;h2&gt;情况一：程序员显式调用&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call runtime_init
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;过程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;程序员写调用
↓
产生 runtime_init 符号引用
↓
linker 找到自己的实现
↓
绑定地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;情况二：编译器自动生成调用&lt;/h2&gt;
&lt;p&gt;比如源代码没写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;memcpy(...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但编译器生成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call memcpy
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;目标文件需要 memcpy
↓
linker 查找 memcpy
↓
找到自己实现的 memcpy
↓
绑定
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果没有找到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;链接失败
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;11. C Runtime 是什么&lt;/h1&gt;
&lt;p&gt;Runtime 并不是 CPU 执行 C 所必须存在的一个神秘程序。&lt;/p&gt;
&lt;p&gt;它本质是一系列：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;为了让更完整的 C/C++ 程序能够正常运行而提供的基础设施。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如一个 Freestanding 系统可能需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start
  ↓
建立栈
  ↓
复制 .data
  ↓
清零 .bss
  ↓
初始化 CPU / 页表等
  ↓
初始化 console
  ↓
初始化 allocator
  ↓
kernel_main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这些工作可以统称为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;startup/runtime initialization
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但如果程序特别简单：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start:
    mov rsp, stack_top
    call kernel_main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也可以根本不存在一个单独的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;runtime_init()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;函数。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;12. 为什么 Freestanding 中需要自己初始化栈&lt;/h1&gt;
&lt;p&gt;普通 Linux 用户进程启动时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;已经由系统准备好。&lt;/p&gt;
&lt;p&gt;但裸机程序没有人替你做。&lt;/p&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call function
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;会使用栈保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;返回地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;push&lt;/code&gt;、局部变量、函数栈帧也都需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此早期启动代码常见：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start:
    mov rsp, stack_top
    call kernel_main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果 &lt;code&gt;rsp&lt;/code&gt; 没有指向合法栈：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call
push
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;都可能直接把数据写到未知地址。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;建立栈往往是进入 C 世界前最基本的工作之一。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;13. 为什么 &lt;code&gt;.bss&lt;/code&gt; 也可能要自己清零&lt;/h1&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int global;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;C 语义要求：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;global 初始值 = 0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样的未初始化全局变量通常位于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;.bss
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Hosted 环境中，loader/runtime 会保证它为 0。&lt;/p&gt;
&lt;p&gt;Freestanding 环境中可能需要启动代码自己：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__bss_start
     ↓
逐字节/逐字清零
     ↓
__bss_end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int global;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这种看起来理所当然的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;初值为 0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际上也依赖程序启动阶段做过工作。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;14. &lt;code&gt;malloc&lt;/code&gt; 为什么不能凭空存在&lt;/h1&gt;
&lt;p&gt;Hosted：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;malloc(100);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;下面大致：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;malloc allocator
    ↓
已有 heap
    ↓
必要时 mmap / brk
    ↓
Linux kernel
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但内核自己就是内存管理者。&lt;/p&gt;
&lt;p&gt;因此 Freestanding 系统如果需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;malloc
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;必须先实现自己的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;物理内存分配
虚拟内存管理
heap allocator
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;内核中常见：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;kmalloc
kfree
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而不是直接依赖用户态 libc 的 &lt;code&gt;malloc/free&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;15. &lt;code&gt;free()&lt;/code&gt; 也不是机器指令&lt;/h1&gt;
&lt;p&gt;CPU 没有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;free rax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;free()&lt;/code&gt; 本质是内存分配器的一段软件逻辑：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;根据 ptr 找到内存块
↓
标记为空闲
↓
加入 free list 等数据结构
↓
可能复用
↓
不一定马上归还物理内存
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;malloc/free
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;属于 runtime / allocator 世界，而不是 CPU 指令集本身。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;16. GCC 的 &lt;code&gt;-ffreestanding&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;gcc -ffreestanding -c kernel.c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思是告诉 GCC：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当前程序不是普通 Hosted C 程序，不要假设完整标准运行环境存在。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;典型效果包括减少编译器对于标准库环境的假设。&lt;/p&gt;
&lt;p&gt;还可以通过：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__STDC_HOSTED__
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;判断当前编译环境。&lt;/p&gt;
&lt;p&gt;通常：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Hosted:

__STDC_HOSTED__ == 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Freestanding：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__STDC_HOSTED__ == 0
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;17. &lt;code&gt;-ffreestanding&lt;/code&gt;、&lt;code&gt;-nostdlib&lt;/code&gt;、&lt;code&gt;-nostartfiles&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;这三个一定不要混。&lt;/p&gt;
&lt;h2&gt;&lt;code&gt;-ffreestanding&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;主要影响：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;编译阶段
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;告诉编译器：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不要假设完整 Hosted 环境。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;&lt;code&gt;-nostartfiles&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;主要影响：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;链接阶段
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;告诉 GCC：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不要自动链接标准启动文件。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如常见的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;crt*.o
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;&lt;code&gt;-nostdlib&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;范围更大：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不自动链接标准启动文件和通常的系统标准库。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;所以可以粗略记为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-ffreestanding
    → 编译环境假设

-nostartfiles
    → 不要默认启动代码

-nostdlib
    → 不要默认标准运行库
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;18. libc 和 libgcc 不一样&lt;/h1&gt;
&lt;p&gt;另外一个常见混淆：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;glibc
musl
newlib
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;主要提供：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf
malloc
strlen
fopen
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libgcc
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;属于 GCC 自己的编译器 runtime 支持。&lt;/p&gt;
&lt;p&gt;编译器在某些机器操作不能方便地直接实现时，可能生成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;runtime helper
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;由 &lt;code&gt;libgcc&lt;/code&gt; 提供。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc ≠ libgcc
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Freestanding 项目中经常需要分别考虑：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我是否需要 libc？
我是否需要 compiler runtime？
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;19. Hosted 与 Freestanding 的完整对比&lt;/h1&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;内容&lt;/th&gt;
&lt;th&gt;Hosted&lt;/th&gt;
&lt;th&gt;Freestanding&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;操作系统&lt;/td&gt;
&lt;td&gt;通常存在&lt;/td&gt;
&lt;td&gt;不保证&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;完整 libc&lt;/td&gt;
&lt;td&gt;通常存在&lt;/td&gt;
&lt;td&gt;不保证&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;main&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;通常由 runtime 调用&lt;/td&gt;
&lt;td&gt;不要求存在&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;程序入口&lt;/td&gt;
&lt;td&gt;通常 &lt;code&gt;_start&lt;/code&gt; 等&lt;/td&gt;
&lt;td&gt;自己决定&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;栈初始化&lt;/td&gt;
&lt;td&gt;系统/runtime 帮忙&lt;/td&gt;
&lt;td&gt;往往自己处理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;.bss&lt;/code&gt; 初始化&lt;/td&gt;
&lt;td&gt;系统/runtime 处理&lt;/td&gt;
&lt;td&gt;可能自己处理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;printf&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;一般可用&lt;/td&gt;
&lt;td&gt;需要自己提供底层输出&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;malloc&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;一般可用&lt;/td&gt;
&lt;td&gt;需要自己的内存管理&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;fopen&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;有文件系统支持&lt;/td&gt;
&lt;td&gt;除非自己实现文件系统&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;memcpy&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;libc 通常提供&lt;/td&gt;
&lt;td&gt;常需要自己实现&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Runtime&lt;/td&gt;
&lt;td&gt;系统提供&lt;/td&gt;
&lt;td&gt;自己提供或不需要&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;典型程序&lt;/td&gt;
&lt;td&gt;Linux 应用&lt;/td&gt;
&lt;td&gt;Kernel / MCU / Bootloader&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h1&gt;20. 最重要的几个结论&lt;/h1&gt;
&lt;h3&gt;① C 语言和 libc 是两层东西&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;C language
    ↓
可以直接编译为机器代码

libc
    ↓
提供大量额外的软件功能
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;② Freestanding 不等于“完全不能有 libc”&lt;/h3&gt;
&lt;p&gt;准确说法是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不保证存在完整 libc。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;你可以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;自己实现 libc 子集
使用面向裸机的 libc
只实现 memcpy/memset 等必要部分
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;③ &lt;code&gt;main&lt;/code&gt; 没有硬件层面的特殊身份&lt;/h3&gt;
&lt;p&gt;Hosted 中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start
↓
runtime
↓
main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Freestanding 可以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start
↓
kernel_main
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;④ CPU 根本不知道函数名&lt;/h3&gt;
&lt;p&gt;CPU 最终看到的是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;机器地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call 0x102000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而不是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;“调用 runtime_init”
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;符号名称主要属于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;编译器
汇编器
链接器
调试器
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;的世界。&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;⑤ Freestanding runtime 不会被“自动发现”&lt;/h3&gt;
&lt;p&gt;如果想执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;runtime_init();
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;必须有人调用它：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start
↓
call runtime_init
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;或者编译器产生某个固定符号依赖，例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;memcpy
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;再由 linker 将它与自己的实现绑定。&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;⑥ Linker 是理解 Freestanding 的关键&lt;/h3&gt;
&lt;p&gt;过程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;source code
    ↓
compiler
    ↓
.o
    ↓
symbol table + relocation
    ↓
linker
    ↓
ELF / binary
    ↓
loader / bootloader
    ↓
entry point
    ↓
CPU execution
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;boot.o
需要 runtime_init

runtime.o
提供 runtime_init

        ↓ linker

call runtime_init
        ↓

call 某个确定机器地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;21. 一张图记住整个区别&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;Hosted
────────────────────────

            C Program
                │
                ▼
        libc / C runtime
                │
                ▼
        Operating System
                │
                ▼
             Hardware


Freestanding
────────────────────────

            C Program
                │
                ▼
    自己的 runtime / libc 子集
                │
                ▼
     Kernel / Firmware / 裸机代码
                │
                ▼
             Hardware
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以用一句话记：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Hosted：舞台已经搭好了，你只需要写 &lt;code&gt;main&lt;/code&gt;。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Freestanding：CPU 给你了，舞台、入口、栈、runtime、驱动乃至内存管理都可能要自己搭。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;再从操作系统角度进一步压缩：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;普通应用程序是在“使用操作系统”。

Freestanding kernel 则是在“成为操作系统”。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这也是为什么学习操作系统以后，&lt;code&gt;_start&lt;/code&gt;、&lt;code&gt;rsp&lt;/code&gt;、ELF、linker、&lt;code&gt;.bss&lt;/code&gt;、&lt;code&gt;memcpy&lt;/code&gt;、allocator 这些原本分散的知识会突然全部串起来。&lt;/p&gt;
&lt;h1&gt;&lt;code&gt;offsetof&lt;/code&gt; 与结构体成员偏移&lt;/h1&gt;
&lt;h2&gt;1. 核心概念&lt;/h2&gt;
&lt;p&gt;对于结构体：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct foo {
    int x;
    int y;
};
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sizeof(int) = 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;典型内存布局：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct foo 基地址
      ↓

offset 0   ┌─────────────┐
           │      x      │  4 bytes
offset 4   ├─────────────┤
           │      y      │  4 bytes
offset 8   └─────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x 的偏移量 = 0
y 的偏移量 = 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所谓成员偏移量 &lt;code&gt;offset&lt;/code&gt;：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;结构体成员地址相对于结构体起始地址的字节距离。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;即：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;成员偏移量
=
成员地址 - 结构体基地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;2. &lt;code&gt;p-&amp;gt;y&lt;/code&gt; 的底层本质&lt;/h2&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct foo *p;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;p-&amp;gt;y
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从机器角度，本质就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;结构体基地址 + y 的偏移量
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;offset(y) = 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;p-&amp;gt;y
≈
读取地址 p + 4 中的 int
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;p = 1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x 地址 = 1000 + 0 = 1000
y 地址 = 1000 + 4 = 1004
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;汇编可能类似：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rdi+4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rdi = p
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rdi+4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是访问 &lt;code&gt;p-&amp;gt;y&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 结构体成员访问本质上是“基地址 + 偏移量”&lt;/h2&gt;
&lt;p&gt;可以把：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct foo {
    int x;
    int y;
};
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;理解为编译器提前记录：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct foo:

x → offset 0
y → offset 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;p-&amp;gt;x
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;底层相当于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;memory[p + 0]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;p-&amp;gt;y
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;相当于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;memory[p + 4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意这里说的是&lt;strong&gt;字节地址偏移&lt;/strong&gt;，不是 C 中直接写 &lt;code&gt;p + 4&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;因为 C 的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;p + 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果 &lt;code&gt;p&lt;/code&gt; 是 &lt;code&gt;struct foo *&lt;/code&gt;，实际上会移动：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4 × sizeof(struct foo)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;更严谨的表达是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;*(int *)((char *)p + 4)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;4. &lt;code&gt;offsetof&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;C 标准库提供：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;stddef.h&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;offsetof(type, member)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以得到结构体成员相对于结构体起点的偏移量。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;offsetof(struct foo, x)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;通常为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;offsetof(struct foo, y)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;通常为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;5. 经典的 &lt;code&gt;offsetof&lt;/code&gt; 思想&lt;/h2&gt;
&lt;p&gt;经典教材中经常用下面的表达式解释原理：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;amp;(((struct foo *)0)-&amp;gt;y)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;逐层理解。&lt;/p&gt;
&lt;h3&gt;第一步&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;(struct foo *)0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;相当于：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;假设一个 &lt;code&gt;struct foo&lt;/code&gt; 从地址 0 开始。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct 基地址 = 0
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;第二步&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;((struct foo *)0)-&amp;gt;y
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示找到这个假想结构体中的 &lt;code&gt;y&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;y offset = 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以 &lt;code&gt;y&lt;/code&gt; 的假想地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0 + 4 = 4
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h3&gt;第三步&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;&amp;amp;(((struct foo *)0)-&amp;gt;y)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;取 &lt;code&gt;y&lt;/code&gt; 的地址。&lt;/p&gt;
&lt;p&gt;得到概念上的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;由于结构体基地址人为设为了 0：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;成员地址
=
0 + offset
=
offset
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以成员地址本身就等于成员偏移量。&lt;/p&gt;
&lt;p&gt;核心技巧：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;令结构体基地址 = 0

成员地址
= 基地址 + offset
= 0 + offset
= offset
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;6. 实际代码不要自己这样写&lt;/h2&gt;
&lt;p&gt;虽然：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;amp;(((struct foo *)0)-&amp;gt;y)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;非常适合解释 &lt;code&gt;offsetof&lt;/code&gt; 的原理，但实际代码应直接使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;offsetof(struct foo, y)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现代编译器通常会通过类似：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;__builtin_offsetof
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实现它。&lt;/p&gt;
&lt;p&gt;原因是手动构造：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;(struct foo *)0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;涉及空指针相关语义，不适合作为可移植的正式实现。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;理解原理：
&amp;amp;(((TYPE *)0)-&amp;gt;member)

实际使用：
offsetof(TYPE, member)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;7. 偏移量不能简单靠 &lt;code&gt;sizeof&lt;/code&gt; 累加&lt;/h2&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct A {
    char a;
    int b;
};
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不能简单认为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a 占 1 byte
所以 b offset = 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际常见布局：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;offset 0   a
offset 1   padding
offset 2   padding
offset 3   padding
offset 4   b
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;offsetof(struct A, b) = 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这是因为存在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;padding
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;即对齐填充。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;成员偏移量由编译器按照 ABI、类型大小和对齐规则决定，不能简单把前面成员的 &lt;code&gt;sizeof&lt;/code&gt; 全部相加。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;8. 与汇编中的地址计算统一起来&lt;/h2&gt;
&lt;p&gt;之前见过：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其本质：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;基地址 rbp
+
偏移 -4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;访问某个局部变量。&lt;/p&gt;
&lt;p&gt;结构体：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rdi+4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本质：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;基地址 rdi
+
成员偏移 +4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;访问 &lt;code&gt;p-&amp;gt;y&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;二者其实是完全相同的地址计算思想：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;有效地址 = 基地址 + 偏移量
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此可以统一理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;局部变量：
rbp + offset

结构体成员：
struct 地址 + offset

数组元素：
数组首地址 + 下标 × 元素大小
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;底层最终都归结为：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;计算地址，然后访问该地址中的内存。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;9. 最重要的结论&lt;/h2&gt;
&lt;p&gt;记住这几条即可：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. offset = 成员地址 - 结构体起始地址

2. p-&amp;gt;member
   本质是：
   基地址 + member offset

3. offsetof(type, member)
   用来获取成员的字节偏移量

4. 经典技巧：
   把 struct 基地址假设成 0，
   那么成员地址就直接等于成员 offset

5. 结构体可能存在 padding，
   所以 offset 不能简单靠 sizeof 手算

6. 汇编中的 [base + offset]
   就是结构体成员访问最直接的底层形式
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;一句话总结：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;结构体并没有什么特殊魔法：它本质上就是一块连续内存，而字段名只是编译器帮我们记住的固定字节偏移量。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787422991407.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787422991407&quot; /&gt;&lt;/p&gt;
&lt;h1&gt;&lt;code&gt;setjmp / longjmp&lt;/code&gt;：保存与恢复执行现场&lt;/h1&gt;
&lt;p&gt;&lt;code&gt;setjmp / longjmp&lt;/code&gt; 是理解 &lt;strong&gt;执行上下文、协程、用户态上下文切换&lt;/strong&gt; 的一个很好例子。&lt;/p&gt;
&lt;p&gt;核心思想：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;setjmp&lt;/code&gt; 保存当前执行现场，&lt;code&gt;longjmp&lt;/code&gt; 恢复之前保存的执行现场。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 基本用法&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;setjmp.h&amp;gt;

jmp_buf buf;

int x = setjmp(buf);

...

longjmp(buf, 5);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;buf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以理解为：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;一个“执行现场存档”。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;它不是整个栈的副本，而是保存以后恢复现场所需的关键状态。&lt;/p&gt;
&lt;p&gt;概念上类似：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;jmp_buf buf

┌──────────────────────┐
│ saved rsp            │  栈顶位置
│ saved rip / pc       │  恢复后从哪里继续
│ saved rbp            │
│ 其他需要保存的寄存器 │
└──────────────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;具体保存哪些寄存器由平台和 libc 实现决定。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;2. &lt;code&gt;setjmp&lt;/code&gt; 的作用：保存现场&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int main() {
    int x = setjmp(buf);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行到 &lt;code&gt;setjmp(buf)&lt;/code&gt; 时，栈可能是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;栈顶
 ↓

┌──────────────┐
│    main      │
└──────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;setjmp&lt;/code&gt; 会把当前执行状态保存进：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;buf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以粗略理解为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;buf.saved_rsp = 当前 rsp
buf.saved_pc  = setjmp 返回后继续执行的位置
buf.saved_registers = 当前必要寄存器
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;setjmp&lt;/code&gt; 不会主动改变当前栈。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;执行前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行后仍然：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;只是多了一份：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;buf = 当前现场的存档
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;3. &lt;code&gt;setjmp&lt;/code&gt; 第一次返回 0&lt;/h1&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int x = setjmp(buf);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第一次正常执行时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;setjmp(buf)
    ↓
返回 0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x = 0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此常见写法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;if (setjmp(buf) == 0) {
    // 第一次正常执行
} else {
    // 从 longjmp 跳回来
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;4. &lt;code&gt;longjmp&lt;/code&gt; 的作用：恢复现场&lt;/h1&gt;
&lt;p&gt;假设程序继续调用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main
 ↓
A
 ↓
B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;此时栈：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;栈顶
 ↓

┌──────────────┐
│      B       │
├──────────────┤
│      A       │
├──────────────┤
│    main      │
└──────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但是 &lt;code&gt;buf&lt;/code&gt; 是在只有 &lt;code&gt;main&lt;/code&gt; 时保存的。&lt;/p&gt;
&lt;p&gt;现在 B 中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp(buf, 5);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其核心行为可以理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;读取 buf
↓
恢复当初保存的 rsp
↓
恢复相关寄存器
↓
恢复执行位置
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是栈直接恢复成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;┌──────────────┐
│    main      │
└──────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A 和 B 的栈帧被直接抛弃。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;5. 与普通 &lt;code&gt;return&lt;/code&gt; 的区别&lt;/h1&gt;
&lt;p&gt;原来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;B
A
main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;普通返回：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;B return
↓
A

A return
↓
main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;必须逐层退出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;B → A → main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp(buf, 5);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以直接：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;B ─────────────→ main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;中间的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A
B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;栈帧一次性被丢弃。&lt;/p&gt;
&lt;p&gt;因此称为：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;non-local jump，非局部跳转&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;6. &lt;code&gt;buf&lt;/code&gt; 的核心作用&lt;/h1&gt;
&lt;p&gt;&lt;code&gt;buf&lt;/code&gt; 回答的是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;longjmp 到底应该跳回哪里？&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;jmp_buf a;
jmp_buf b;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以分别保存两个位置：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a → main 中的某个现场

b → f() 中的某个现场
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp(a, 1);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;恢复 &lt;code&gt;a&lt;/code&gt; 保存的现场。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp(b, 1);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;恢复 &lt;code&gt;b&lt;/code&gt; 保存的现场。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;setjmp(buf)
=
把当前位置写进 buf
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;longjmp(buf, ...)
=
读取 buf 并恢复那个位置
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;7. 为什么 &lt;code&gt;longjmp&lt;/code&gt; 还有一个返回值参数&lt;/h1&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int x = setjmp(buf);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第一次：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x = 0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;后来某处：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp(buf, 5);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;恢复现场后，程序会表现得像：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;之前那个 setjmp(buf)
又返回了一次
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但这次：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;返回值 = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;整个过程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;第一次：

setjmp(buf)
↓
0
↓
x = 0


后来：

longjmp(buf, 5)
↓
恢复现场
↓
原 setjmp 表现得像返回 5
↓
x = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;setjmp&lt;/code&gt; 并没有真的重新执行一遍。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;是 &lt;code&gt;longjmp&lt;/code&gt; 恢复了现场，并安排了新的返回值。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;8. &lt;code&gt;longjmp&lt;/code&gt; 自己不会正常返回&lt;/h1&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;void B() {
    longjmp(buf, 5);

    printf(&quot;hello&quot;);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;printf&lt;/code&gt; 不会执行。&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp
↓
B 的栈帧直接被丢弃
↓
跳回 setjmp 保存的位置
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以真正得到 &lt;code&gt;5&lt;/code&gt; 的不是 &lt;code&gt;longjmp&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;而是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;原来的 &lt;code&gt;setjmp&lt;/code&gt; 表现得像返回了 &lt;code&gt;5&lt;/code&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;9. 为什么 &lt;code&gt;longjmp(buf, 0)&lt;/code&gt; 会变成 1&lt;/h1&gt;
&lt;p&gt;规定：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;setjmp 第一次正常返回 = 0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp(buf, 0);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;恢复以后也返回 0，就无法区分：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;这是第一次执行？
还是 longjmp 回来的？
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此 C 标准规定：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp(buf, 0)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;会使 &lt;code&gt;setjmp&lt;/code&gt; 表现得像返回：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;总结：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;情况&lt;/th&gt;
&lt;th&gt;&lt;code&gt;setjmp&lt;/code&gt; 表现出的返回值&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;第一次正常执行&lt;/td&gt;
&lt;td&gt;&lt;code&gt;0&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;longjmp(buf, 5)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;5&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;longjmp(buf, 10)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;10&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;longjmp(buf, 0)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h1&gt;10. 用栈理解 &lt;code&gt;setjmp / longjmp&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int main() {
    int x = setjmp(buf);

    if (x == 0)
        A();
}

void A() {
    B();
}

void B() {
    longjmp(buf, 5);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行过程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;① main

┌────────┐
│ main   │
└────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;setjmp(buf);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;buf → “当前栈只有 main”
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;② main → A

┌────────┐
│ A      │
├────────┤
│ main   │
└────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;③ main → A → B

┌────────┐
│ B      │
├────────┤
│ A      │
├────────┤
│ main   │
└────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;B 执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp(buf, 5);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;直接恢复：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;④

┌────────┐
│ main   │
└────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;同时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;setjmp 的返回值变成 5
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;11. 和 &lt;code&gt;rsp / rip&lt;/code&gt; 的关系&lt;/h1&gt;
&lt;p&gt;真实机器上，函数执行现场至少与这些状态有关：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RSP → 栈顶在哪里
RIP → 代码执行到哪里
其他寄存器 → 当前计算状态
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以可以粗略理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;setjmp
≈
保存 rsp + 执行位置 + 必要寄存器
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;longjmp
≈
恢复 rsp + 执行位置 + 必要寄存器
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如原来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;setjmp 时：

RSP = 1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;后来调用 A、B：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RSP = 800
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行 &lt;code&gt;longjmp&lt;/code&gt; 后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;RSP = 1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A/B 的栈帧全部被放弃
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;12. 和协程的关系&lt;/h1&gt;
&lt;p&gt;协程最核心的问题也是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;怎样暂停当前执行流，以后从原位置继续？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;协程切换可以抽象成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;协程 A → 协程 B

1. 保存 A context
2. 恢复 B context
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;setjmp
≈ save_context
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;longjmp
≈ restore_context
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此 &lt;code&gt;setjmp/longjmp&lt;/code&gt; 展示了协程的核心思想：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;执行现场可以保存
↓
以后可以恢复
↓
恢复后从之前的位置继续
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不过：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;标准 &lt;code&gt;setjmp/longjmp&lt;/code&gt; 本身并不等于完整的协程实现。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;真正的 stackful coroutine 通常还需要：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;每个协程自己的栈
+
上下文保存/恢复机制
+
scheduler
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;13. 一个重要限制&lt;/h1&gt;
&lt;p&gt;&lt;code&gt;longjmp&lt;/code&gt; 只能恢复仍然有效的 &lt;code&gt;setjmp&lt;/code&gt; 环境。&lt;/p&gt;
&lt;p&gt;错误例子：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;jmp_buf buf;

void f() {
    setjmp(buf);
}

int main() {
    f();              // f 已经 return
    longjmp(buf, 1);  // 错误
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;f 的栈帧已经被正常销毁
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;此时再恢复过去保存的现场属于未定义行为。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;jmp_buf&lt;/code&gt; 不是“永久存档”。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;它保存的执行环境必须仍然有效。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;14. 与 OS 上下文切换的联系&lt;/h1&gt;
&lt;p&gt;&lt;code&gt;setjmp/longjmp&lt;/code&gt; 和操作系统上下文切换有相似的核心思想：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;保存执行上下文
+
恢复执行上下文
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;setjmp/longjmp&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;用户态程序
自己保存/恢复部分执行现场
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;OS context switch：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;内核
保存当前线程 CPU context
↓
恢复另一个线程 CPU context
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;两者共同的底层思想：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;一个执行流的身份，不只是“它执行哪个程序”，而是由栈、程序计数器和寄存器状态共同决定的。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;最终记忆版&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;setjmp(buf)
=
存档

保存：
栈在哪里
代码执行到哪里
必要寄存器状态

第一次返回 0
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;longjmp(buf, x)
=
读档

恢复：
栈
执行位置
相关寄存器

并让原 setjmp 表现得像返回 x
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最核心的一句话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;setjmp&lt;/code&gt; 保存执行上下文，&lt;code&gt;longjmp&lt;/code&gt; 恢复执行上下文；普通 &lt;code&gt;return&lt;/code&gt; 是逐层退栈，而 &lt;code&gt;longjmp&lt;/code&gt; 可以一次跨过多个函数栈帧。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这页其实在讲两件事，而且老师把它们放在了一张 PPT 上，所以第一次看会很跳：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;FILE *&lt;/code&gt; 到底是什么，它和 Linux 的文件描述符 &lt;code&gt;fd&lt;/code&gt; 有什么关系？&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;为什么 &lt;code&gt;printf / fprintf / vfprintf&lt;/code&gt; 这些函数长得这么像，却不应该把代码重复写很多遍？&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;我们从最底层重新搭起来。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;一、先别看 &lt;code&gt;FILE *&lt;/code&gt;，先看 Linux 最底层怎么表示“打开的文件”&lt;/h1&gt;
&lt;p&gt;假设你在 Linux 里：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int fd = open(&quot;a.txt&quot;, O_RDONLY);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;open()&lt;/code&gt; 成功后可能返回：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fd = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就叫：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;文件描述符 file descriptor&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;它就是一个小整数。&lt;/p&gt;
&lt;p&gt;你可以粗略理解成内核给这个进程的一张号码牌：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;进程：

fd 0 → 标准输入
fd 1 → 标准输出
fd 2 → 标准错误

fd 3 → a.txt
fd 4 → b.txt
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;read(3, buf, 100);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;从编号为 3 的那个已打开文件读取最多 100 字节。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;所以系统调用这一层是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;open
read
write
close
lseek
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它们和：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int fd
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;打交道。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;二、那为什么 C 又搞出来一个 &lt;code&gt;FILE *&lt;/code&gt;？&lt;/h1&gt;
&lt;p&gt;平时我们可能不写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int fd = open(...);
read(...);
write(...);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *fp = fopen(&quot;a.txt&quot;, &quot;r&quot;);

fscanf(fp, &quot;%d&quot;, &amp;amp;x);
fgets(buf, 100, fp);

fclose(fp);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里出现了：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *fp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这是什么？&lt;/p&gt;
&lt;p&gt;最重要的理解是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;FILE *&lt;/code&gt; 不是文件描述符本身。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;FILE *&lt;/code&gt; 指向 libc 在用户态维护的一个“文件流对象”。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;可以想象 libc 内部有一个结构体，大概：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct FILE {
    int fd;

    char buffer[...];

    int buffer_pos;
    int buffer_size;

    int eof;
    int error;

    // 还有很多状态
};
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这只是帮助理解，真实 glibc 的 &lt;code&gt;FILE&lt;/code&gt; 结构复杂得多。&lt;/p&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *fp;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其实是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fp
 │
 │ 指针
 ▼

┌─────────────────────┐
│ fd = 3              │
│                     │
│ buffer = ...        │
│                     │
│ 当前读到哪里        │
│ 是否遇到 EOF        │
│ 是否发生错误        │
│ ...                 │
└─────────────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以你 PPT 第一行：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;FILE *&lt;/code&gt; 背后其实是一个文件描述符&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这个说法适合入门，但稍微不严谨。&lt;/p&gt;
&lt;p&gt;更准确应该是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;在 Unix 上，一个普通文件对应的 &lt;code&gt;FILE&lt;/code&gt; 流通常内部封装了一个文件描述符，并额外维护缓冲区、EOF、错误状态等 libc 信息。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;三、那为什么不用 &lt;code&gt;fd&lt;/code&gt; 就好了？&lt;/h1&gt;
&lt;p&gt;因为 &lt;code&gt;FILE *&lt;/code&gt; 给我们提供了更舒服的高级功能。&lt;/p&gt;
&lt;p&gt;例如最典型的：&lt;/p&gt;
&lt;h2&gt;直接用 &lt;code&gt;write&lt;/code&gt;&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;write(fd, &quot;hello&quot;, 5);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这是比较底层的。&lt;/p&gt;
&lt;p&gt;你得明确告诉它：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址在哪里
写多少字节
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;而 &lt;code&gt;fprintf&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fprintf(fp, &quot;x = %d, y = %.2f\n&quot;, x, y);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;libc 会帮你：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;整数 x
    ↓
转换成字符

浮点 y
    ↓
转换成字符

拼接格式字符串
    ↓
先塞进缓冲区
    ↓
必要的时候 write()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这明显舒服多了。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fd
=
内核层面的“打开文件句柄”
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *
=
libc 层面的高级文件流
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;四、最重要的一张分层图&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;hello %d\n&quot;, 123);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;大致可以理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;你的 C 程序

printf(&quot;hello %d\n&quot;, 123)
          │
          ▼

=========================
libc / stdio
=========================

FILE *stdout

格式化：
&quot;hello 123\n&quot;

缓冲：
┌──────────────────┐
│ hello 123\n ...  │
└──────────────────┘

          │
          │ 最终需要真正输出
          ▼

write(1, buffer, n)

=========================
Linux kernel
=========================

fd = 1
   │
   ▼

终端 / 管道 / 文件等
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stdio
↓
系统调用
↓
kernel
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;之间的关系。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;五、&lt;code&gt;stdout&lt;/code&gt; 到底是什么？&lt;/h1&gt;
&lt;p&gt;PPT 特别写了：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;例如 &lt;code&gt;stdout&lt;/code&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;你平时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;hello\n&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;没有告诉 &lt;code&gt;printf&lt;/code&gt; 输出到哪个文件。&lt;/p&gt;
&lt;p&gt;为什么它知道输出到屏幕？&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;默认向：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stdout
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;输出。&lt;/p&gt;
&lt;p&gt;而 &lt;code&gt;stdout&lt;/code&gt; 本质上就是一个：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以粗略想成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *stdout;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它内部通常对应：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fd = 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是标准输出。&lt;/p&gt;
&lt;p&gt;所以可以画：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stdout
   │
   ▼
FILE 对象
┌─────────────────┐
│ fd = 1          │
│ buffer = ...    │
│ flags = ...     │
│ ...             │
└─────────────────┘
   │
   ▼
Linux fd 1
   │
   ▼
终端
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fprintf(stdout, &quot;hello\n&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;和：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;hello\n&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;效果基本一样。&lt;/p&gt;
&lt;p&gt;这句话非常重要：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;printf(...)&lt;/code&gt; 可以理解成“向 &lt;code&gt;stdout&lt;/code&gt; 做格式化输出”。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;六、那 stdin、stdout、stderr 呢？&lt;/h1&gt;
&lt;p&gt;三个都是标准 I/O 流：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stdin  → 标准输入
stdout → 标准输出
stderr → 标准错误
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从 C 的角度，它们都是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Unix 下通常对应：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stdin  → fd 0
stdout → fd 1
stderr → fd 2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;C stdio                 Unix fd

stdin   ───────────────→ 0
stdout  ───────────────→ 1
stderr  ───────────────→ 2
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;七、&lt;code&gt;FILE *&lt;/code&gt; 最大的一个功能：缓冲&lt;/h1&gt;
&lt;p&gt;这个非常重要。&lt;/p&gt;
&lt;p&gt;假设你连续：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;a&quot;);
printf(&quot;b&quot;);
printf(&quot;c&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;你可能以为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;a&quot;) → write syscall
printf(&quot;b&quot;) → write syscall
printf(&quot;c&quot;) → write syscall
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不一定。&lt;/p&gt;
&lt;p&gt;因为系统调用有开销。&lt;/p&gt;
&lt;p&gt;libc 可以先存在用户态缓冲区：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;第一次 printf：

buffer:
[a]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第二次：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;buffer:
[a][b]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第三次：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;buffer:
[a][b][c]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;达到某些条件之后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;一次 write：

&quot;abc&quot;
    ↓
kernel
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样比频繁系统调用高效。&lt;/p&gt;
&lt;p&gt;所以 &lt;code&gt;FILE&lt;/code&gt; 对象里一个非常重要的东西就是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;buffer 缓冲区&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这也是为什么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;hello&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;有时不会马上显示。&lt;/p&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;hello\n&quot;);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在终端上往往更容易马上看到，因为 &lt;code&gt;stdout&lt;/code&gt; 连到终端时通常使用行缓冲。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;八、PPT 上的 &lt;code&gt;fseek / fgetpos / ftell / feof&lt;/code&gt; 是什么意思？&lt;/h1&gt;
&lt;p&gt;它写：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;封装了文件描述符上的系统调用&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这里思想对，但措辞别理解得太死。&lt;/p&gt;
&lt;p&gt;这些：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fseek()
fgetpos()
ftell()
feof()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本身都是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;libc 的 stdio 函数&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;不是 Linux 系统调用。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fseek(fp, 100, SEEK_SET);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;把 &lt;code&gt;FILE *fp&lt;/code&gt; 的文件位置移动到指定位置。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;libc 可能最终调用 Linux：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lseek(fd, ...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但因为 &lt;code&gt;FILE&lt;/code&gt; 自己还有缓冲区，所以实际逻辑可能比简单调用一次 &lt;code&gt;lseek&lt;/code&gt; 更复杂。&lt;/p&gt;
&lt;p&gt;可以理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;C：

fseek(fp, ...)
       │
       ▼
libc stdio
       │
       │ 必要时
       ▼
lseek(fd, ...)
       │
       ▼
kernel
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;九、&lt;code&gt;feof()&lt;/code&gt; 更能说明 &lt;code&gt;FILE *&lt;/code&gt; 不只是 fd&lt;/h1&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;if (feof(fp)) {
    ...
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它是在问：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;这个 stdio 流是不是已经遇到 EOF？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这个 EOF 状态很多时候是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc 的 FILE 对象自己记录的
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE
┌────────────────────┐
│ fd = 3             │
│ buffer = ...       │
│ eof_flag = 1       │
│ error_flag = 0     │
└────────────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;feof(fp)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可能主要是在检查：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fp-&amp;gt;eof_flag
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;并不意味着每执行一次 &lt;code&gt;feof()&lt;/code&gt; 都去做一次系统调用。&lt;/p&gt;
&lt;p&gt;这就是为什么更准确地说：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;FILE *&lt;/code&gt; 是建立在 Unix 文件描述符之上的一层 libc 抽象。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;十、现在看 PPT 下半部分：&lt;code&gt;printf()&lt;/code&gt; family&lt;/h1&gt;
&lt;p&gt;下面突然写：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;The &lt;code&gt;printf()&lt;/code&gt; family&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;为什么突然从 &lt;code&gt;FILE *&lt;/code&gt; 跳到 printf？&lt;/p&gt;
&lt;p&gt;因为 &lt;code&gt;printf&lt;/code&gt; 系列大量使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(...)
fprintf(...)
vprintf(...)
vfprintf(...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中最关键的就是 PPT 最下面：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int vfprintf(FILE *, const char *, va_list);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;完整声明类似：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int vfprintf(
    FILE *stream,
    const char *format,
    va_list ap
);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;先不怕 &lt;code&gt;va_list&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;我们一项一项看。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;十一、&lt;code&gt;fprintf&lt;/code&gt; 比 &lt;code&gt;printf&lt;/code&gt; 多了什么？&lt;/h1&gt;
&lt;p&gt;&lt;code&gt;printf&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;x = %d\n&quot;, x);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;固定输出到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stdout
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fprintf(fp, &quot;x = %d\n&quot;, x);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以指定：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;输出到 fp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以可以把：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fprintf(stdout, ...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;概念上非常接近：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(format, ...)
{
    fprintf(stdout, format, ...);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;当然实际实现不能如此简单地直接传 &lt;code&gt;...&lt;/code&gt;，马上解释。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;十二、&lt;code&gt;...&lt;/code&gt; 为什么是个麻烦？&lt;/h1&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;%d %s %f&quot;, 10, &quot;hello&quot;, 3.14);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;参数数量是不固定的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;format
10
&quot;hello&quot;
3.14
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;另一个：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;%d&quot;, 10);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;只有两个参数。&lt;/p&gt;
&lt;p&gt;这种：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;叫：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;可变参数 variadic arguments&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如函数声明：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int printf(const char *format, ...);
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;十三、&lt;code&gt;va_list&lt;/code&gt; 是什么？&lt;/h1&gt;
&lt;p&gt;为了在一个函数内部遍历：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这些可变参数，C 提供：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;va_list
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以暂时理解为：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;“剩余可变参数在哪里”的一个迭代器/描述对象。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;va_list ap;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ap
 ↓
10
&quot;hello&quot;
3.14
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后可以通过：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;va_arg(...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;依次取得参数。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vfprintf(FILE *stream,
         const char *format,
         va_list ap)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思就是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;给我一个输出流、一个格式字符串，以及已经整理好的可变参数列表，我负责完成真正的格式化输出。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;十四、为什么需要 &lt;code&gt;vfprintf&lt;/code&gt;？&lt;/h1&gt;
&lt;p&gt;这就是 PPT 上：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;这些代码里应该没有 &quot;code clones&quot;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;要讲的东西。&lt;/p&gt;
&lt;p&gt;假设 libc 要实现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf
fprintf
vprintf
vfprintf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最蠢的方法是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf：
    写一遍解析 %d %s %f 的代码

fprintf：
    再写一遍解析 %d %s %f 的代码

vprintf：
    再写一遍

vfprintf：
    再写一遍
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这就是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;code clone&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;大量重复代码。&lt;/p&gt;
&lt;p&gt;很糟糕。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;十五、更漂亮的方法：只写一个核心&lt;/h1&gt;
&lt;p&gt;我们让：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vfprintf()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;承担真正复杂的工作：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vfprintf

解析 format
↓
发现 %d
↓
取一个 int

发现 %s
↓
取一个 char *

发现 %f
↓
取一个 double

↓
格式化

↓
写入指定 FILE *
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其他函数都包装它。&lt;/p&gt;
&lt;p&gt;于是结构类似：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;                 vfprintf
                /        \
               /          \
          printf         fprintf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;更准确地说是其他函数最终复用核心逻辑。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;十六、例如 &lt;code&gt;printf&lt;/code&gt; 可以怎样实现？&lt;/h1&gt;
&lt;p&gt;概念版：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int printf(const char *format, ...)
{
    va_list ap;

    va_start(ap, format);

    int ret = vfprintf(stdout, format, ap);

    va_end(ap);

    return ret;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这段特别值得看。&lt;/p&gt;
&lt;p&gt;调用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;x = %d\n&quot;, 123);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进入：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;之后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;format = &quot;x = %d\n&quot;

ap
 ↓
123
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vfprintf(stdout, format, ap);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vfprintf

输出目标：stdout
格式：&quot;x = %d\n&quot;
参数：123
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最终：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x = 123
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;写入 &lt;code&gt;stdout&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;十七、&lt;code&gt;fprintf&lt;/code&gt; 同样可以复用&lt;/h1&gt;
&lt;p&gt;概念上：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int fprintf(FILE *fp, const char *format, ...)
{
    va_list ap;

    va_start(ap, format);

    int ret = vfprintf(fp, format, ap);

    va_end(ap);

    return ret;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以区别只是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf
    ↓
vfprintf(stdout, ...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fprintf
    ↓
vfprintf(fp, ...)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;真正复杂的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;%d
%s
%x
%f
格式宽度
精度
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;解析，只需要写一次。&lt;/p&gt;
&lt;p&gt;这就是 PPT：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;不应该出现 code clones&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;的意思。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;十八、现在整张 PPT 就串起来了&lt;/h1&gt;
&lt;p&gt;上半部分讲：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是 stdio 的核心抽象。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stdin
stdout
stderr
fopen() 得到的 fp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;都是文件流。&lt;/p&gt;
&lt;p&gt;下半部分讲：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;既然我们已经有统一的 &lt;code&gt;FILE *&lt;/code&gt; 抽象，那么各种格式化输出函数也可以统一实现。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;核心：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;vfprintf(FILE *stream,
         const char *format,
         va_list ap);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;FILE *stream
↓
往哪里输出
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;format
↓
怎么格式化
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;va_list
↓
要格式化的数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以 &lt;code&gt;vfprintf&lt;/code&gt; 几乎把三个问题完全分开了。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;十九、完整调用链看一次&lt;/h1&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;age = %d\n&quot;, 20);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以粗略理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;你的代码

printf(&quot;age = %d\n&quot;, 20)
        │
        ▼

printf
        │
        │ 把可变参数整理成 va_list
        ▼

vfprintf(stdout,
         &quot;age = %d\n&quot;,
         ap)
        │
        ▼

解析格式字符串

&quot;age = &quot;
&quot;%d&quot; → 取 20
&quot;\n&quot;

        │
        ▼

得到字符：

&quot;age = 20\n&quot;

        │
        ▼

写入 stdout 的 FILE buffer

        │
        │ 必要时 flush
        ▼

write(fd=1, ...)
        │
        ▼

Linux kernel
        │
        ▼

终端
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这张图就是整页 PPT 真正想表达的东西。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;二十、和你之前学的 Hosted/Freestanding 正好连起来&lt;/h1&gt;
&lt;p&gt;你前面问过：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;libc 到底干什么？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这里就是一个非常具体的例子。&lt;/p&gt;
&lt;p&gt;CPU 本身没有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf &quot;x=%d&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样的机器指令。&lt;/p&gt;
&lt;p&gt;Linux kernel 也没有一个：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf syscall
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;真正的 Linux 系统调用更加底层：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;write
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;%d&quot;, 123);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;中间大量工作其实发生在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;libc
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高级 C 接口

printf
fprintf
vfprintf
FILE *
缓冲区
格式化
EOF 状态
       ↓

低级 OS 接口

read/write/lseek
fd
       ↓

kernel
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这就是为什么 &lt;code&gt;stdio.h&lt;/code&gt; 是 Hosted C 世界里很重要的一层抽象。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;二十一、最后压缩成四层&lt;/h1&gt;
&lt;p&gt;这页你最后只需要建立这个模型：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;第一层：你的 C 代码
────────────────────

printf(...)
fscanf(...)
fgets(...)


第二层：libc stdio
────────────────────

FILE *
vfprintf
buffer
EOF/error state


第三层：Unix 系统调用
────────────────────

fd

read
write
lseek
close


第四层：kernel
────────────────────

文件系统
终端
管道
设备
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后记住两个对应：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fd
=
内核给进程的“打开文件编号”
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;FILE *
=
libc 对 fd 等底层对象做出的高级“文件流包装”
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;以及：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(format, ...)
≈
vfprintf(stdout, format, va_list)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这就是 PPT 最下面为什么突然出现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int vfprintf(FILE *, const char *, va_list);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;它是 &lt;code&gt;printf&lt;/code&gt; 家族非常核心的复用接口：把“输出到哪个流”“格式字符串是什么”“可变参数是什么”统一起来，避免每个 &lt;code&gt;printf&lt;/code&gt; 家族函数都重新实现一遍格式化逻辑。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787427640539.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787427640539&quot; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787427998877.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787427998877&quot; /&gt;
&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787428388520.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787428388520&quot; /&gt;&lt;/p&gt;
&lt;p&gt;你看到老师写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern void **************end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后说：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;&quot;end&quot; can be of any type&lt;/code&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;你可能感觉：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;什么？C 语言不是强类型吗？变量类型怎么可以乱写？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;关键在于：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;这里的 &lt;code&gt;end&lt;/code&gt; 根本不是一个普通 C 变量。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;它是一个 &lt;strong&gt;链接器符号（linker symbol）&lt;/strong&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;1. 先回忆普通变量是什么&lt;/h1&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int x = 100;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;编译器看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;变量名：x
类型：int
大小：4字节
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是生成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;.data

地址 0x1000:

+---------+
| 100     |
+---------+

x
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里：&lt;/p&gt;
&lt;p&gt;&lt;code&gt;x&lt;/code&gt; 有：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;名字&lt;/li&gt;
&lt;li&gt;类型&lt;/li&gt;
&lt;li&gt;大小&lt;/li&gt;
&lt;li&gt;内存位置&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x + 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;编译器知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int 加法
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;2. 但是 end 不一样&lt;/h1&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern int end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里你告诉编译器：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;有一个叫 end 的东西，类型是 int，但是它定义在别处。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;注意：&lt;/p&gt;
&lt;p&gt;这里没有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int end = 10;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;没有分配空间。&lt;/p&gt;
&lt;p&gt;编译器只记录：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;符号表：

end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;真正是谁定义它？&lt;/p&gt;
&lt;p&gt;以后链接器负责。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;3. 链接器看到 end 是什么？&lt;/h1&gt;
&lt;p&gt;比如链接器最后发现：&lt;/p&gt;
&lt;p&gt;程序内存布局：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;.text
----------------
机器代码


.data
----------------
全局变量


.bss
----------------
未初始化变量


heap
----------------
动态内存


stack
----------------
栈
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;链接器知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;.bss 结束地址 = 0x601000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是它可能产生：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;符号表:

end ---&amp;gt; 0x601000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意：&lt;/p&gt;
&lt;p&gt;这里：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不是一个对象。&lt;/p&gt;
&lt;p&gt;它只是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;一个地址标签。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;类似汇编：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;section .data

hello:
    db &quot;hello&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;hello:
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是什么？&lt;/p&gt;
&lt;p&gt;只是一个地址名字。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;4. 所以为什么类型可以乱？&lt;/h1&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;p&gt;真正存在的是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;变量
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end 地址：

0x1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;你写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern int end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;编译器理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end 地址 = 0x1000
这里放一个 int
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;%d&quot;, end);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;会去读：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x1000 ~ 0x1003
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;但是如果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern char end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;编译器理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end 地址 = 0x1000
这里放一个 char
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;%c&quot;, end);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;读：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x1000
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern void *end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;编译器理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end 地址 = 0x1000
这里存一个指针
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;printf(&quot;%p&quot;, end);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它会把：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x1000 ~ 0x1007
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;解释成一个地址。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;但是注意：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;链接器完全不关心这些。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;链接器只知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end = 0x1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它不知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int?
char?
pointer?
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;5. 一个汇编类比&lt;/h1&gt;
&lt;p&gt;汇编里面：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end:
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是一个标签：&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;.text

start:
    mov eax, 1

end:
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;start = 0x400000
end   = 0x400005
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;汇编器不会问：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;end 是 int 还是 char？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;因为汇编里没有类型。&lt;/p&gt;
&lt;p&gt;C 的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern int end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;只是告诉 C 编译器：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;用什么方式访问这个地址。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;6. 那为什么老师写：&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;extern void **************end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;？&lt;/p&gt;
&lt;p&gt;这是为了故意说明：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;类型不重要。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern int end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;和：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern char end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;和：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern void *end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;链接器都认为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要找一个叫 end 的符号
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;7. 但是这样真的安全吗？&lt;/h1&gt;
&lt;p&gt;不安全。&lt;/p&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;p&gt;链接器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end = 0x1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际：&lt;/p&gt;
&lt;p&gt;那里没有 int。&lt;/p&gt;
&lt;p&gt;你写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern int end;

printf(&quot;%d&quot;, end);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;相当于：&lt;/p&gt;
&lt;p&gt;读取：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x1000
0x1001
0x1002
0x1003
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果这些地址不可读：&lt;/p&gt;
&lt;p&gt;可能：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Segmentation fault
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;可以乱写 ≠ 应该乱写。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这是因为：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;链接阶段只匹配名字，不检查 C 类型。&lt;/strong&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;8. 这个和 Linux 内核有什么关系？&lt;/h1&gt;
&lt;p&gt;很多底层代码会用这种技巧。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;p&gt;Linux 内核链接脚本：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start = .;

.text
{
    ...
}

_end = .;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;产生符号：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_start
_end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后 C：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern char _end[];
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;内核/程序结束位置
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;heap_start = _end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;堆从程序结束后开始。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这里 &lt;code&gt;_end&lt;/code&gt; 就不是变量。&lt;/p&gt;
&lt;p&gt;它是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;一个地址标记
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;9. 和你前面学的进程内存布局联系起来&lt;/h1&gt;
&lt;p&gt;程序加载后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

stack
 |
 |
heap

_end  ← 这里

.bss
.data
.text

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;链接器知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;.text 结束在哪里
.data 结束在哪里
.bss 结束在哪里
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以它生成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_end = bss结束地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;程序运行时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern char _end;

brk(_end);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就可以知道：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;初始堆应该从哪里开始。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;10. 最终记忆&lt;/h1&gt;
&lt;p&gt;普通变量：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int x;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;名字
+
类型
+
大小
+
内存
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;链接器符号：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;名字
+
地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;没有类型。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;extern int end;
extern char end;
extern void *end;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;链接器看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要找 end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;全部一样。&lt;/p&gt;
&lt;p&gt;区别只是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;C 编译器以后访问这个地址时，按照你声明的类型解释它。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;一句话：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;end&lt;/code&gt; 可以乱写类型，是因为它本质上不是 C 变量，而是链接器提供的一个地址符号；类型只是 C 编译器为了生成访问代码而做的假设，链接器根本不管。&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这个知识点其实和你前面学的 &lt;code&gt;environ&lt;/code&gt; 正好形成对比：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;environ&lt;/code&gt;：真正的变量（有类型、有内存）&lt;/li&gt;
&lt;li&gt;&lt;code&gt;end&lt;/code&gt;：链接器符号（主要是一个地址标签）&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这也是为什么老师说它“more mysterious”。它已经跨到 C 和 ELF 链接层了。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787428814980.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787428814980&quot; /&gt;
_ start会调用上述代码,由于操作系统规定了初始栈的形状 所以可以通过上面函数直接调到环境变量&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787428914826.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787428914826&quot; /&gt;&lt;/p&gt;
&lt;p&gt;_&lt;/p&gt;
</content:encoded></item><item><title>从 add(2, 3) 到 ret：零基础看懂 C 函数背后的 x86-64 汇编</title><link>https://sanzenin.top/posts/obsidian/%E6%B1%87%E7%BC%96%E5%85%A5%E9%97%A8/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E6%B1%87%E7%BC%96%E5%85%A5%E9%97%A8/</guid><description>很多人第一次看到汇编代码时都会有一种感觉： C 语言明明只有三行，为什么编译出来突然变成十几行看不懂的东西？ 例如下面这个再简单不过的函数： 调用它： 在 x86-64 平台上，如果暂时关闭编译器优化，可能得到类似这样的汇编代码： 如果没有学过计算机组成原理，这段东西里几乎每一个词都会形成一个新问题： rbp 是什么？</description><pubDate>Sat, 22 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;从 &lt;code&gt;add(2, 3)&lt;/code&gt; 到 &lt;code&gt;ret&lt;/code&gt;：零基础看懂 C 函数背后的 x86-64 汇编&lt;/h1&gt;
&lt;p&gt;很多人第一次看到汇编代码时都会有一种感觉：&lt;/p&gt;
&lt;p&gt;C 语言明明只有三行，为什么编译出来突然变成十几行看不懂的东西？&lt;/p&gt;
&lt;p&gt;例如下面这个再简单不过的函数：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int add(int a, int b) {
    int c = a + b;
    return c;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;调用它：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add(2, 3);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在 x86-64 平台上，如果暂时关闭编译器优化，可能得到类似这样的汇编代码：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add:
    push rbp
    mov rbp, rsp
    sub rsp, 16

    mov DWORD PTR [rbp-4], edi
    mov DWORD PTR [rbp-8], esi

    mov eax, DWORD PTR [rbp-4]
    add eax, DWORD PTR [rbp-8]

    mov DWORD PTR [rbp-12], eax
    mov eax, DWORD PTR [rbp-12]

    leave
    ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果没有学过计算机组成原理，这段东西里几乎每一个词都会形成一个新问题：&lt;/p&gt;
&lt;p&gt;&lt;code&gt;rbp&lt;/code&gt; 是什么？&lt;/p&gt;
&lt;p&gt;&lt;code&gt;rsp&lt;/code&gt; 又是什么？&lt;/p&gt;
&lt;p&gt;为什么参数突然变成了 &lt;code&gt;edi&lt;/code&gt; 和 &lt;code&gt;esi&lt;/code&gt;？&lt;/p&gt;
&lt;p&gt;&lt;code&gt;[rbp-4]&lt;/code&gt; 为什么代表变量？&lt;/p&gt;
&lt;p&gt;&lt;code&gt;DWORD PTR&lt;/code&gt; 又是什么？&lt;/p&gt;
&lt;p&gt;&lt;code&gt;leave&lt;/code&gt; 和 &lt;code&gt;ret&lt;/code&gt; 到底干了什么？&lt;/p&gt;
&lt;p&gt;其实这段汇编没有做任何神秘的事情。它只是把 C 语言隐藏掉的细节全部摆到了桌面上。&lt;/p&gt;
&lt;p&gt;本文就从这一个 &lt;code&gt;add(2, 3)&lt;/code&gt; 出发，把寄存器、内存、栈、函数调用、返回值以及 &lt;code&gt;call/ret&lt;/code&gt; 串起来。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 先暂时忘掉 C 语言里的“变量”&lt;/h2&gt;
&lt;p&gt;在 C 语言里，我们习惯这样思考：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int a = 2;
int b = 3;
int c = a + b;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;脑子里自然会出现三个变量：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a = 2
b = 3
c = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但 CPU 并不知道什么叫“变量 a”。&lt;/p&gt;
&lt;p&gt;CPU 真正能够直接处理的东西大致只有两类：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;寄存器中的数据
内存中的数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;以及一些最基础的指令：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;复制
加法
减法
跳转
比较
……
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以从底层看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;c = a + b;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;必须被拆成类似这样的过程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;找到 a
↓
把 a 取到 CPU 中

找到 b
↓
执行加法

保存结果
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;汇编做的事情，本质上就是把这些过程明确写出来。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;2. CPU 手边的小盒子：寄存器&lt;/h1&gt;
&lt;p&gt;CPU 内部有一批很小、很快的存储空间，叫做寄存器。&lt;/p&gt;
&lt;p&gt;x86-64 中常见的名字有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rax
rbx
rcx
rdx
rsi
rdi
rsp
rbp
rip
……
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以暂时把它们理解成 CPU 手边的一排小盒子：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;┌─────────────┐
│ rax         │
├─────────────┤
│ rbx         │
├─────────────┤
│ rdi         │
├─────────────┤
│ rsi         │
├─────────────┤
│ rsp         │
├─────────────┤
│ rbp         │
└─────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;例如某一刻可能是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rdi = 2
rsi = 3
rax = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rdi
rsi
rax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不是 C 变量。&lt;/p&gt;
&lt;p&gt;它们是真正存在于 CPU 内部的硬件存储位置。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;3. &lt;code&gt;rax&lt;/code&gt; 和 &lt;code&gt;eax&lt;/code&gt; 为什么长得这么像？&lt;/h1&gt;
&lt;p&gt;代码中没有大量出现 &lt;code&gt;rax&lt;/code&gt;，反而出现了：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax
edi
esi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这是因为 x86 寄存器可以按照不同宽度访问。&lt;/p&gt;
&lt;p&gt;例如 &lt;code&gt;rax&lt;/code&gt; 是一个 64 位寄存器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;63                                      0
┌────────────────────────────────────────┐
│                  rax                   │
└────────────────────────────────────────┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而 &lt;code&gt;eax&lt;/code&gt; 表示它的低 32 位：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;63                 32 31                 0
┌────────────────────┬────────────────────┐
│                    │        eax         │
└────────────────────┴────────────────────┘
          整个仍然是 rax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;同理：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rdi：64 位
edi：rdi 的低 32 位

rsi：64 位
esi：rsi 的低 32 位
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;我们的函数参数是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int a
int b
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而现代 x86-64 系统上的普通 &lt;code&gt;int&lt;/code&gt; 一般是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;32 bit = 4 byte
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以这里经常直接使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;edi
esi
eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;来处理这些 32 位整数。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;4. 内存其实可以理解成一排带编号的小格子&lt;/h1&gt;
&lt;p&gt;内存没有 &lt;code&gt;a&lt;/code&gt;、&lt;code&gt;b&lt;/code&gt;、&lt;code&gt;c&lt;/code&gt; 这种名字。&lt;/p&gt;
&lt;p&gt;它更接近：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址           内容

0x1000         ?
0x1001         ?
0x1002         ?
0x1003         ?
0x1004         ?
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每一个内存位置都有一个编号，这个编号就是地址。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以理解为：&lt;/p&gt;
&lt;p&gt;“编号为 &lt;code&gt;0x1000&lt;/code&gt; 的内存位置”。&lt;/p&gt;
&lt;p&gt;这里的 &lt;code&gt;0x&lt;/code&gt; 表示十六进制。刚开始学习汇编时，不需要急着熟练进行十六进制计算，只需要知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x1000
0x1001
0x1002
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;都是地址即可。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;5. 一个 &lt;code&gt;int&lt;/code&gt; 为什么需要 4 个字节？&lt;/h1&gt;
&lt;p&gt;计算机中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1 byte = 8 bit
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;一个普通的 &lt;code&gt;int&lt;/code&gt; 通常是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;32 bit = 4 byte
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int x;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;需要连续占用 4 个字节的内存。&lt;/p&gt;
&lt;p&gt;可以想象成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址

100    ┐
101    │
102    │  int x
103    ┘
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这也解释了汇编中的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DWORD PTR
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在本文这段代码里，可以直接理解成：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;接下来操作的是 4 个字节。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DWORD = 32 bit = 4 byte
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-4], edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际上是在说：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;从 &lt;code&gt;[rbp-4]&lt;/code&gt; 对应的地址开始，写入 4 字节数据。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;6. 汇编里最重要的符号之一：&lt;code&gt;[]&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;初学汇编时，最容易混淆的是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;和：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp - 4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这两者完全不是一回事。&lt;/p&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4 = 996
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到的是一个地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;996
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果地址 996 中存的是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp - 4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;访问地址 996 中保存的数据。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以理解为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址 996
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp - 4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;才相当于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址 996 中的内容
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这和 C 语言中的指针很像。&lt;/p&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int *p;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;并且：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;p = 996
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;p
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;代表地址。&lt;/p&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;*p
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;代表这个地址里的数据。&lt;/p&gt;
&lt;p&gt;因此初学阶段可以粗略地把：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;理解为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;*(rbp - 4)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;当然二者在类型系统等方面并不完全等价，但这种理解非常适合入门。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;7. 什么是栈？&lt;/h1&gt;
&lt;p&gt;接下来进入整段代码的核心。&lt;/p&gt;
&lt;p&gt;函数运行的时候经常需要保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;局部变量
返回地址
寄存器旧值
临时数据
……
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这些东西通常会使用一块特殊用途的内存区域：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stack
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是栈。&lt;/p&gt;
&lt;p&gt;需要强调一点：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;栈本质上仍然是普通内存。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;并不存在一个神秘的“栈芯片”。&lt;/p&gt;
&lt;p&gt;它只是操作系统为程序准备的一块虚拟内存区域，同时 CPU 和编译器按照特定规则来使用它。&lt;/p&gt;
&lt;p&gt;假设栈附近的地址是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

1000
992
984
976
968

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在 x86 上有一个比较反直觉的特点：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;栈向低地址增长。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;也就是说，栈里的东西越多，地址反而越小。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;原来：

rsp = 1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;压入 8 字节之后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 992
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;再压入 8 字节：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此可以画成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址
   ↑

1000

 992

 984

 976

   ↓
低地址

栈向低地址增长
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;8. &lt;code&gt;rsp&lt;/code&gt;：当前栈顶在哪里？&lt;/h1&gt;
&lt;p&gt;CPU 有一个专门的寄存器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它叫：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Stack Pointer
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是栈指针。&lt;/p&gt;
&lt;p&gt;它保存的是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当前栈顶的位置。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示当前栈顶在地址 984。&lt;/p&gt;
&lt;p&gt;因此以后看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sub rsp, 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不要把它理解成某种神秘汇编语法。&lt;/p&gt;
&lt;p&gt;它真的就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = rsp - 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;由于栈向低地址增长，所以这相当于向栈中“腾出”16字节的新空间。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;9. &lt;code&gt;rbp&lt;/code&gt;：给当前函数放一把固定的尺子&lt;/h1&gt;
&lt;p&gt;另一个经常和 &lt;code&gt;rsp&lt;/code&gt; 一起出现的寄存器是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它通常叫：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Base Pointer
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以把它理解为当前函数栈帧的一个固定参考点。&lt;/p&gt;
&lt;p&gt;原因是 &lt;code&gt;rsp&lt;/code&gt; 可能经常变化：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push ...
sub rsp, ...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;都会改变它。&lt;/p&gt;
&lt;p&gt;如果所有变量都相对于 &lt;code&gt;rsp&lt;/code&gt; 查找，就容易变得麻烦。&lt;/p&gt;
&lt;p&gt;于是无优化代码中常见这样的做法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 当前函数的固定基准点
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;以后变量就可以写成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a 在 rbp - 4
b 在 rbp - 8
c 在 rbp - 12
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;无论 &lt;code&gt;rsp&lt;/code&gt; 如何变化，只要 &lt;code&gt;rbp&lt;/code&gt; 保持不动：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4
rbp - 8
rbp - 12
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;的位置就不会变。&lt;/p&gt;
&lt;p&gt;可以把二者记成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp：会移动的栈顶

rbp：当前函数固定的尺子零点
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;10. &lt;code&gt;add(2, 3)&lt;/code&gt; 的参数是怎么进入函数的？&lt;/h1&gt;
&lt;p&gt;现在正式执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add(2, 3);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本文假设的是 Linux 等平台常见的 x86-64 System V ABI。&lt;/p&gt;
&lt;p&gt;按照这个函数调用约定，前几个整数或指针参数通常依次放入：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;第 1 个参数 → rdi
第 2 个参数 → rsi
第 3 个参数 → rdx
第 4 个参数 → rcx
第 5 个参数 → r8
第 6 个参数 → r9
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;由于这里是 32 位的 &lt;code&gt;int&lt;/code&gt;，所以我们看到的是这些寄存器的低 32 位：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;第 1 个 int 参数 → edi
第 2 个 int 参数 → esi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add(2, 3)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在进入函数之前，可以理解为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;edi = 2
esi = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;对应：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int add(int a, int b)
            ↑      ↑
            │      │
           edi    esi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里需要注意：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;“第一个参数放 &lt;code&gt;edi&lt;/code&gt;”不是 CPU 天生规定的语言规则，而是调用约定规定的。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;如果换成 Windows x64，参数寄存器规则就不同。&lt;/p&gt;
&lt;p&gt;因此学习汇编时，一定要逐渐形成一个概念：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;汇编语言本身是一层；操作系统、编译器和 ABI 又规定了一层约定。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;11. 调用函数前，还有一个问题：怎么回来？&lt;/h1&gt;
&lt;p&gt;假设调用者正在执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int x = add(2, 3);
printf(&quot;%d\n&quot;, x);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进入 &lt;code&gt;add&lt;/code&gt; 很容易。&lt;/p&gt;
&lt;p&gt;但 &lt;code&gt;add&lt;/code&gt; 结束以后，CPU 怎么知道：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;应该回来继续执行 &lt;code&gt;printf&lt;/code&gt; 前面的下一条机器指令？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;因此函数调用还需要保存一个东西：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;返回地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;假设：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call add
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;后面的下一条机器指令地址是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x400500
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call add
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;时，CPU 大致做两件事情：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;1. 把返回地址 0x400500 压入栈

2. 跳转到 add
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这就是为什么后面的 &lt;code&gt;ret&lt;/code&gt; 能找到回去的地方。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;12. 完整模拟一次 &lt;code&gt;add(2, 3)&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;下面真正开始逐条执行。&lt;/p&gt;
&lt;p&gt;为了方便观察，假设调用前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;edi = 2
esi = 3

rsp = 1000
rbp = 2000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;并假设返回地址：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x400500
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里的数字只是为了方便演示，并不代表真实程序一定使用这些地址。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;13. &lt;code&gt;call add&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;调用者执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call add
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在 x86-64 上，返回地址占 8 字节。&lt;/p&gt;
&lt;p&gt;因此原来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 1000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;保存返回地址之后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 992
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;栈变成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

1000

992    返回地址 0x400500    ← rsp

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后 CPU 跳到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add:
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;开始执行我们的函数。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;14. 第一条：&lt;code&gt;push rbp&lt;/code&gt;&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;push rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;push&lt;/code&gt; 可以先粗略理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp -= 8
[rsp] = 要保存的东西
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里为什么要保存 &lt;code&gt;rbp&lt;/code&gt;？&lt;/p&gt;
&lt;p&gt;因为调用者自己也在使用 &lt;code&gt;rbp&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;现在 &lt;code&gt;add&lt;/code&gt; 想把 &lt;code&gt;rbp&lt;/code&gt; 改成自己的栈帧基准，但不能把调用者原本的值弄丢。&lt;/p&gt;
&lt;p&gt;所以先保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;旧 rbp = 2000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;原来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 992
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;之后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;并且：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[984] = 2000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

1000

992    返回地址 0x400500

984    调用者原来的 rbp = 2000    ← rsp

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;此时寄存器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;edi = 2
esi = 3

rbp = 2000
rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;只是把 &lt;code&gt;rbp&lt;/code&gt; 中的旧值复制到栈里。&lt;/p&gt;
&lt;p&gt;它并没有直接修改 &lt;code&gt;rbp&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;15. 第二条：&lt;code&gt;mov rbp, rsp&lt;/code&gt;&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;mov rbp, rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本文使用的是 Intel 汇编语法。&lt;/p&gt;
&lt;p&gt;Intel 语法中的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov A, B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;基本可以理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A = B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov rbp, rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;当前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以执行后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;栈：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

992    返回地址

984    调用者原来的 rbp    ← rbp
                            ← rsp

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从这一刻开始：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就成为 &lt;code&gt;add()&lt;/code&gt; 自己的固定参考点。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;16. 第三条：&lt;code&gt;sub rsp, 16&lt;/code&gt;&lt;/h1&gt;
&lt;pre&gt;&lt;code&gt;sub rsp, 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = rsp - 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;984 - 16 = 968
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
rsp = 968
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意 &lt;code&gt;rbp&lt;/code&gt; 没动。&lt;/p&gt;
&lt;p&gt;现在栈大致变成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

992    返回地址

984    旧 rbp                 ← rbp

980
976
972
968                            ← rsp

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里的 16 字节：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;968 ~ 983
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是当前函数腾出来的局部空间。&lt;/p&gt;
&lt;p&gt;这就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sub rsp, 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;的真正意义。&lt;/p&gt;
&lt;p&gt;它没有向操作系统重新申请 16 字节物理内存，也没有调用 &lt;code&gt;malloc&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;只是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;把栈顶往下移动 16 字节，宣布这 16 字节暂时归当前函数使用。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;17. 编译器给 &lt;code&gt;a&lt;/code&gt;、&lt;code&gt;b&lt;/code&gt;、&lt;code&gt;c&lt;/code&gt; 安排位置&lt;/h1&gt;
&lt;p&gt;我们的 C 代码里有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int a;
int b;
int c;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每一个 &lt;code&gt;int&lt;/code&gt; 4 字节。&lt;/p&gt;
&lt;p&gt;编译器可以给它们安排成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a → [rbp-4]
b → [rbp-8]
c → [rbp-12]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4  = 980
rbp - 8  = 976
rbp - 12 = 972
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;栈帧就可以画成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

992       返回地址

984       调用者旧 rbp           ← rbp

980~983   a

976~979   b

972~975   c

968~971   暂未使用               ← rsp

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这张图几乎是理解整个函数最重要的一张图。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;18. 为什么变量在 &lt;code&gt;rbp-4&lt;/code&gt;，而不是 &lt;code&gt;rbp+4&lt;/code&gt;？&lt;/h1&gt;
&lt;p&gt;因为栈向低地址增长。&lt;/p&gt;
&lt;p&gt;当前函数通过：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sub rsp, 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;获得的空间在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;下面。&lt;/p&gt;
&lt;p&gt;也就是比 &lt;code&gt;rbp&lt;/code&gt; 更小的地址。&lt;/p&gt;
&lt;p&gt;因此局部变量自然是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4
rbp - 8
rbp - 12
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;反过来看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp + 8
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是什么？&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp + 8 = 992
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而我们刚刚知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;992
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;保存的正是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;返回地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此整个布局非常整齐：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

rbp + 8     返回地址

rbp         调用者旧 rbp

rbp - 4     a

rbp - 8     b

rbp - 12    c

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;19. 保存参数 &lt;code&gt;a&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;接下来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-4], edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;拆开来看。&lt;/p&gt;
&lt;p&gt;首先：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;edi = 2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4 = 980
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;地址 980 中的数据
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DWORD PTR
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;操作 4 字节
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此整句话：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-4], edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;把 &lt;code&gt;edi&lt;/code&gt; 中的 32 位整数 2 写入从地址 980 开始的 4 个字节。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;结果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a = 2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;栈：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;992       返回地址

984       旧 rbp                 ← rbp

980~983   a = 2

976~979   ?

972~975   ?

968~971                           ← rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;20. 保存参数 &lt;code&gt;b&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;下一条：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-8], esi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;当前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;esi = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;并且：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 8 = 976
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以执行之后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;b = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;栈：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;992       返回地址

984       旧 rbp                 ← rbp

980~983   a = 2

976~979   b = 3

972~975   c = ?

968~971                           ← rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;至此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int add(int a, int b)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;中的两个参数已经从参数寄存器保存到了当前函数自己的栈帧中。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;21. 为什么不直接用 &lt;code&gt;edi&lt;/code&gt; 和 &lt;code&gt;esi&lt;/code&gt;？&lt;/h1&gt;
&lt;p&gt;这时很容易发现：&lt;/p&gt;
&lt;p&gt;本来已经：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;edi = 2
esi = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么还要先存进内存，稍后又取出来？&lt;/p&gt;
&lt;p&gt;其实完全可以不这么做。&lt;/p&gt;
&lt;p&gt;优化后的代码很可能接近：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, edi
add eax, esi
ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;甚至编译器还可能根据上下文进一步优化。&lt;/p&gt;
&lt;p&gt;本文使用的是便于观察的无优化代码。&lt;/p&gt;
&lt;p&gt;无优化情况下，编译器往往会机械地维护源代码中的变量：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;参数 a
↓
给 a 一个栈位置

参数 b
↓
给 b 一个栈位置

局部变量 c
↓
也给 c 一个栈位置
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此代码更长，但反而非常适合入门理解 C 与汇编之间的映射。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;22. 把 &lt;code&gt;a&lt;/code&gt; 取进 CPU&lt;/h1&gt;
&lt;p&gt;下一条：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意这一次 &lt;code&gt;mov&lt;/code&gt; 的方向发生了变化。&lt;/p&gt;
&lt;p&gt;之前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-4], edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;内存 ← edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax ← 内存
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;我们知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp-4] = a = 2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以执行之后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在 CPU 的状态大致是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 2
edi = 2
esi = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而栈依然：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a = 2
b = 3
c = ?
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;23. 真正的加法只发生在这一条指令&lt;/h1&gt;
&lt;p&gt;下面：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add eax, DWORD PTR [rbp-8]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Intel 语法里的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add A, B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A = A + B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add eax, DWORD PTR [rbp-8]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = eax + [rbp-8]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 2
[rbp-8] = b = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 2 + 3
eax = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;到这一刻：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a + b
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;真正计算完成。&lt;/p&gt;
&lt;p&gt;注意一个很有意思的事实：&lt;/p&gt;
&lt;p&gt;这一整个 C 表达式：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a + b
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;真正涉及数学意义上加法的机器指令，其实只有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add eax, DWORD PTR [rbp-8]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其他大量代码都在处理：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;参数
内存
栈帧
函数调用
返回
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这也是为什么理解汇编之后，会发现高级语言隐藏了多少运行时细节。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;24. 保存局部变量 &lt;code&gt;c&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;C 中写的是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int c = a + b;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;目前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;但变量 &lt;code&gt;c&lt;/code&gt; 对应：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp-12]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以接下来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-12], eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;相当于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;c = eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;c = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;完整栈帧：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

992       返回地址

984       调用者旧 rbp           ← rbp

980~983   a = 2

976~979   b = 3

972~975   c = 5

968~971                           ← rsp

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这时源代码里的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int c = a + b;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;已经彻底完成。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;25. &lt;code&gt;return c&lt;/code&gt; 在 CPU 眼中是什么？&lt;/h1&gt;
&lt;p&gt;接下来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-12]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么 &lt;code&gt;return c&lt;/code&gt; 要把值放进 &lt;code&gt;eax&lt;/code&gt;？&lt;/p&gt;
&lt;p&gt;还是因为调用约定。&lt;/p&gt;
&lt;p&gt;在当前 ABI 中，一个普通整数函数返回 &lt;code&gt;int&lt;/code&gt; 时：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;返回值通过 &lt;code&gt;eax&lt;/code&gt; 交给调用者。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;return c;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从底层看，并不存在一个带参数的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;return c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;机器指令。&lt;/p&gt;
&lt;p&gt;它实际上由两个概念组成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;第一步：

eax = c

第二步：

返回调用者
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是大致：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, ...
ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以以后看到函数结束前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;里面的值，往往值得特别关注。&lt;/p&gt;
&lt;p&gt;它很可能就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;函数返回值
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;26. 为什么又把 5 存进 &lt;code&gt;c&lt;/code&gt;，又马上读回 &lt;code&gt;eax&lt;/code&gt;？&lt;/h1&gt;
&lt;p&gt;现在代码显得更“笨”了：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add eax, DWORD PTR [rbp-8]

mov DWORD PTR [rbp-12], eax
mov eax, DWORD PTR [rbp-12]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;明明：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本来已经是 5。&lt;/p&gt;
&lt;p&gt;理论上直接返回就行。&lt;/p&gt;
&lt;p&gt;之所以出现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax → c
c → eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;仍然是因为这是无优化代码。&lt;/p&gt;
&lt;p&gt;源代码明确写了：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int c = a + b;
return c;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以编译器忠实地制造出了一个真实存在于栈中的 &lt;code&gt;c&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;打开优化以后，这种无意义的来回搬运通常会被直接删除。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;27. 函数执行完了，但栈还没恢复&lt;/h1&gt;
&lt;p&gt;现在状态大概是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 5

rbp = 984
rsp = 968
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;栈：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;高地址

992       返回地址

984       调用者旧 rbp           ← rbp

980~983   a = 2

976~979   b = 3

972~975   c = 5

968~971                           ← rsp

低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;问题来了：&lt;/p&gt;
&lt;p&gt;当前函数马上要结束。&lt;/p&gt;
&lt;p&gt;它不能就这样直接回去。&lt;/p&gt;
&lt;p&gt;因为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp
rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;都已经被 &lt;code&gt;add()&lt;/code&gt; 改过了。&lt;/p&gt;
&lt;p&gt;必须恢复进入函数之前的状态。&lt;/p&gt;
&lt;p&gt;于是出现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;leave
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;28. &lt;code&gt;leave&lt;/code&gt; 并不神秘&lt;/h1&gt;
&lt;p&gt;可以把：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;leave
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;理解成基本等价于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov rsp, rbp
pop rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;分两步理解即可。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;29. &lt;code&gt;leave&lt;/code&gt; 第一步：丢掉整个局部变量区域&lt;/h1&gt;
&lt;p&gt;首先：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov rsp, rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
rsp = 968
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行后：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;992       返回地址

984       调用者旧 rbp        ← rbp
                              ← rsp

980       a = 2

976       b = 3

972       c = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这一步相当于：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;一口气释放当前函数的局部变量栈空间。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;注意这里的“释放”并不表示：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a
b
c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所在的字节立刻被全部清零。&lt;/p&gt;
&lt;p&gt;内存里面原先的比特甚至可能暂时仍然存在。&lt;/p&gt;
&lt;p&gt;只是：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;rsp&lt;/code&gt; 已经移动过去，程序不再把那片区域看作当前有效栈空间。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;以后新的函数调用、&lt;code&gt;push&lt;/code&gt; 等操作完全可以把它覆盖掉。&lt;/p&gt;
&lt;p&gt;这也是为什么 C 中：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;返回局部变量地址&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;往往是危险行为。&lt;/p&gt;
&lt;p&gt;因为函数返回以后，那片栈空间已经不再归这个函数所有。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;30. &lt;code&gt;leave&lt;/code&gt; 第二步：恢复调用者的 &lt;code&gt;rbp&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;第二步相当于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;pop rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;当前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[984] = 2000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里保存的是函数开始时通过：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;保存下来的旧值。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;pop rbp&lt;/code&gt; 可以粗略理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = [rsp]
rsp += 8
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 2000
rsp = 992
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;992       返回地址       ← rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;调用者原来的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 2000
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也已经恢复。&lt;/p&gt;
&lt;p&gt;开头和结尾形成了一组非常漂亮的对称：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push rbp
mov rbp, rsp

...

leave
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本质上就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;进入函数：
保存调用者环境
建立自己的栈帧

离开函数：
销毁自己的栈帧
恢复调用者环境
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;31. 最后的 &lt;code&gt;ret&lt;/code&gt; 到底返回到哪里？&lt;/h1&gt;
&lt;p&gt;现在只剩：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;当前栈顶：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 992
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[992] = 0x400500
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这正是之前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call add
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;保存下来的返回地址。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;ret&lt;/code&gt; 可以粗略理解为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;取出栈顶的返回地址

↓

跳转到这个地址

↓

rsp 再增加 8
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也就是近似：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rip = [rsp]
rsp += 8
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里又出现了一个重要寄存器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rip
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;32. &lt;code&gt;rip&lt;/code&gt;：CPU 下一步应该执行哪里？&lt;/h1&gt;
&lt;p&gt;CPU 执行机器代码时，总得知道：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;下一条指令在哪里？&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;x86-64 使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rip
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个指令指针寄存器保存代码执行位置。&lt;/p&gt;
&lt;p&gt;当：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从栈里取到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x400500
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;以后，CPU 会回到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;0x400500
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;继续执行。&lt;/p&gt;
&lt;p&gt;而这个地址恰好就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call add
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;后面的那条指令。&lt;/p&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;和：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是天然的一对。&lt;/p&gt;
&lt;p&gt;可以把整个过程理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main
 │
 │
 │ call add
 │
 │ 把“回来以后继续执行的位置”压入栈
 │
 ▼
add
 │
 │ 执行函数
 │
 │ ret
 │
 │ 从栈里取出返回地址
 │
 ▼
main 中 call 后面的下一条指令
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此 &lt;code&gt;ret&lt;/code&gt; 并不知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;我要返回 main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它也不认识什么 C 函数。&lt;/p&gt;
&lt;p&gt;它只是知道：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;栈顶有一个地址，把它取出来，然后跳过去。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;这就是函数“返回”的底层含义。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;33. 把整个函数执行过程放到一张图里&lt;/h1&gt;
&lt;p&gt;现在重新执行一次：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add(2, 3);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进入之前：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;edi = 2
esi = 3

rsp = 1000
rbp = 2000
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call add
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp = 992

992    返回地址
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;992    返回地址

984    旧 rbp          ← rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov rbp, rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
rsp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sub rsp, 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
rsp = 968
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-4], edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a = 2
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-8], esi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;b = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 2
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add eax, DWORD PTR [rbp-8]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-12], eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;c = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-12]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个 &lt;code&gt;5&lt;/code&gt; 已经准备作为函数返回值。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;leave
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 2000
rsp = 992
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;局部变量区域被放弃，只剩：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;992    返回地址       ← rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;从栈顶获得返回地址，回到调用者。&lt;/p&gt;
&lt;p&gt;同时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是调用者得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add(2, 3) = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;34. 这段代码执行到中间时，机器到底是什么样？&lt;/h1&gt;
&lt;p&gt;假设此时已经计算完：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int c = a + b;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么 CPU 与内存可以画成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;                CPU

┌────────────────────────┐
│ edi = 2                │
│ esi = 3                │
│ eax = 5                │
│ rbp = 984              │
│ rsp = 968              │
└────────────────────────┘


                内存 / 栈

高地址
   ↑

992        返回地址 0x400500

984        调用者旧 rbp = 2000
           ↑
           rbp

980~983    a = 2

976~979    b = 3

972~975    c = 5

968~971    临时空间
           ↑
           rsp

   ↓
低地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这张图真正体现了高级语言和机器运行之间的区别。&lt;/p&gt;
&lt;p&gt;C 语言里只看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a
b
c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;而机器真正处理的是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;寄存器里的值

+

内存地址

+

栈指针

+

函数调用约定
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;35. 再看原汇编，就已经不是乱码了&lt;/h1&gt;
&lt;p&gt;重新看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add:
    push rbp
    mov rbp, rsp
    sub rsp, 16

    mov DWORD PTR [rbp-4], edi
    mov DWORD PTR [rbp-8], esi

    mov eax, DWORD PTR [rbp-4]
    add eax, DWORD PTR [rbp-8]

    mov DWORD PTR [rbp-12], eax
    mov eax, DWORD PTR [rbp-12]

    leave
    ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在完全可以逐句翻译成人话。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;push rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;保存调用者原来的 &lt;code&gt;rbp&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;mov rbp, rsp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;建立当前函数自己的栈帧基准。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;sub rsp, 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;给当前函数腾出 16 字节栈空间。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-4], edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;把第一个整数参数保存成 &lt;code&gt;a&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-8], esi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;把第二个整数参数保存成 &lt;code&gt;b&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;把 &lt;code&gt;a&lt;/code&gt; 取进 &lt;code&gt;eax&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;add eax, DWORD PTR [rbp-8]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;计算：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = a + b
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-12], eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;把结果保存到 &lt;code&gt;c&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-12]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;把 &lt;code&gt;c&lt;/code&gt; 放入整数返回值寄存器 &lt;code&gt;eax&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;leave
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;销毁当前函数栈帧，恢复调用者的 &lt;code&gt;rbp&lt;/code&gt;。&lt;/p&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;取出返回地址，回到调用者。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;36. &lt;code&gt;rbp-4&lt;/code&gt; 中的 &lt;code&gt;4&lt;/code&gt; 和 &lt;code&gt;DWORD&lt;/code&gt; 中的“4字节”不是一回事&lt;/h1&gt;
&lt;p&gt;这是初学时一个非常容易留下的错误理解。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DWORD PTR [rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;里面恰好同时出现了两个“4字节相关”的概念。&lt;/p&gt;
&lt;p&gt;但两者完全不同。&lt;/p&gt;
&lt;p&gt;首先：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;中的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;表示：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;地址偏移量。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;如果：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp = 984
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp - 4 = 980
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;只是算出了地址 980。&lt;/p&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DWORD PTR
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;才是在说：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;从这个地址开始操作 4 个字节的数据。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;所以：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;DWORD PTR [rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;应该理解成：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;从地址 &lt;code&gt;rbp-4&lt;/code&gt; 开始的 4 字节内存。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;不能理解成：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;因为减了 4，所以这里自然是 4 字节。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;例如理论上完全可能看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;QWORD PTR [rbp-16]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;-16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;仍然只是地址偏移。&lt;/p&gt;
&lt;p&gt;而：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;QWORD
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;才表示操作 8 字节。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;37. 为什么真实编译器生成的代码可能和本文不一样？&lt;/h1&gt;
&lt;p&gt;学习汇编时很快会遇到一个问题：&lt;/p&gt;
&lt;p&gt;明明都是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int add(int a, int b)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么不同网站、不同编译器甚至不同优化等级生成的代码不一样？&lt;/p&gt;
&lt;p&gt;因为汇编并不存在“唯一正确翻译”。&lt;/p&gt;
&lt;p&gt;例如本文的无优化版本：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push rbp
mov rbp, rsp
sub rsp, 16

mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi

mov eax, DWORD PTR [rbp-4]
add eax, DWORD PTR [rbp-8]

mov DWORD PTR [rbp-12], eax
mov eax, DWORD PTR [rbp-12]

leave
ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际上非常啰嗦。&lt;/p&gt;
&lt;p&gt;编译器一看就知道：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a 没必要存到内存

b 没必要存到内存

c 也没必要真的存在
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是优化后完全可能变成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, edi
add eax, esi
ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;直接三条。&lt;/p&gt;
&lt;p&gt;甚至还能使用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lea eax, [rdi+rsi]
ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;完成类似效果。&lt;/p&gt;
&lt;p&gt;所以刚开始学习 C 到汇编的映射时：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;无优化代码往往更适合学习。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;而研究程序真实性能时：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;优化后的汇编才更有意义。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;38. 栈帧不是所有函数都必须存在&lt;/h1&gt;
&lt;p&gt;看完本文，很容易产生另一个误解：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;每一个函数都一定有 &lt;code&gt;push rbp / mov rbp,rsp / leave&lt;/code&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;并不是。&lt;/p&gt;
&lt;p&gt;这是很经典的一种栈帧写法，尤其常见于：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;关闭优化
保留 frame pointer
调试构建
教学示例
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现代编译器优化以后，经常直接省略 &lt;code&gt;rbp&lt;/code&gt; 栈帧。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add:
    mov eax, edi
    add eax, esi
    ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里根本没有：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp
rsp
局部变量栈空间
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为这个函数太简单，所有事情只靠寄存器就能完成。&lt;/p&gt;
&lt;p&gt;所以更准确的理解应该是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rbp 栈帧是一种常见的函数管理方式

但不是“函数存在”的必要条件
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;39. 汇编中的“变量”其实只是人为解释&lt;/h1&gt;
&lt;p&gt;这是理解底层非常关键的一步。&lt;/p&gt;
&lt;p&gt;当看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov DWORD PTR [rbp-4], edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;我们说：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp-4] 是变量 a
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其实 CPU 根本不知道它叫 &lt;code&gt;a&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;对 CPU 来说：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就只是一段内存。&lt;/p&gt;
&lt;p&gt;所谓：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a
b
c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;C 编译器
调试信息
程序员
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;赋予这些存储位置的意义。&lt;/p&gt;
&lt;p&gt;类似地：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax 是返回值
edi 是第一个参数
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也并不是这些寄存器刻在硬件上的永久身份。&lt;/p&gt;
&lt;p&gt;它们只是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;在当前调用约定和当前时间点下承担这样的角色
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;同一个 &lt;code&gt;rax&lt;/code&gt; 在别的代码中完全可能只是普通临时寄存器。&lt;/p&gt;
&lt;p&gt;这也是理解汇编最重要的思想之一：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;寄存器和内存本身没有“变量语义”，语义来自程序如何使用它们。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h1&gt;40. 从这一个函数，可以看见 C 语言背后很多东西&lt;/h1&gt;
&lt;p&gt;一个只有三行的函数：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int add(int a, int b) {
    int c = a + b;
    return c;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;实际上已经涉及：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU 寄存器
内存地址
字节
栈
栈指针
栈帧
参数传递
调用约定
局部变量
返回地址
函数返回值
程序跳转
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这些概念以后会不断出现。&lt;/p&gt;
&lt;p&gt;例如学习：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int x;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就会涉及栈上的局部变量。&lt;/p&gt;
&lt;p&gt;学习：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int *p;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就会真正开始操作地址。&lt;/p&gt;
&lt;p&gt;学习：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int a[10];
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就会发现数组其实是一片连续内存。&lt;/p&gt;
&lt;p&gt;学习：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;f(g(x));
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就会看到多层函数调用如何不断产生栈帧。&lt;/p&gt;
&lt;p&gt;学习递归时：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;f(n - 1);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就会理解为什么每一次递归都能够拥有自己的局部变量。&lt;/p&gt;
&lt;p&gt;学习栈溢出时，也会明白：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;无限递归为什么最终把栈空间耗尽。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;甚至以后学习缓冲区溢出时，会发现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;局部数组
保存的 rbp
返回地址
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么在栈中彼此离得如此之近。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;41. 初学阶段真正需要记住的寄存器并不多&lt;/h1&gt;
&lt;p&gt;现在没有必要背几十个寄存器。&lt;/p&gt;
&lt;p&gt;理解本文只需要先记住几个：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;寄存器&lt;/th&gt;
&lt;th&gt;当前阶段的理解&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;rax&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;64 位通用寄存器&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;eax&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;rax&lt;/code&gt; 的低 32 位，常处理 &lt;code&gt;int&lt;/code&gt;，也常装整数返回值&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;rdi/edi&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;当前调用约定下常用于第一个整数参数&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;rsi/esi&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;当前调用约定下常用于第二个整数参数&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;rsp&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;当前栈顶&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;rbp&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;常作为当前函数栈帧参考点&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;rip&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;指令执行位置&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;同样，指令也只需要先熟悉几条。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov A, B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A = B
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;add A, B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A = A + B
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;sub A, B
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;A = A - B
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;push X
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;大致理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rsp -= 8
[rsp] = X
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;pop X
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;大致理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;X = [rsp]
rsp += 8
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;call X
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;大致理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;保存返回地址
跳到 X
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;pre&gt;&lt;code&gt;ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;大致理解成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;取出返回地址
跳回去
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;42. 一套很实用的汇编阅读方法&lt;/h1&gt;
&lt;p&gt;以后再遇到 C 对应汇编，不要试图直接“读懂整段代码”。&lt;/p&gt;
&lt;p&gt;可以按照下面的顺序。&lt;/p&gt;
&lt;p&gt;第一步，先找参数在哪里。&lt;/p&gt;
&lt;p&gt;例如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;edi
esi
rdx
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;看函数一开始如何使用它们。&lt;/p&gt;
&lt;p&gt;第二步，找到栈帧。&lt;/p&gt;
&lt;p&gt;看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;push rbp
mov rbp, rsp
sub rsp, ...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就先画：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;返回地址
旧 rbp
rbp-4
rbp-8
rbp-12
...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第三步，给每个栈位置标名字。&lt;/p&gt;
&lt;p&gt;例如发现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov [rbp-4], edi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就标：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp-4] = a
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;发现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov [rbp-8], esi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就标：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[rbp-8] = b
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样后面的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, [rbp-4]
add eax, [rbp-8]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;立刻就可以重新翻译成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = a
eax += b
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第四步，始终跟踪几个关键寄存器：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax
rsp
rbp
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第五步，看到 &lt;code&gt;ret&lt;/code&gt; 前重点观察：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rax/eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为那里往往是返回值。&lt;/p&gt;
&lt;p&gt;这套方法比背几十条汇编指令有效得多。&lt;/p&gt;
&lt;hr /&gt;
&lt;h1&gt;43. 最后重新看一次 &lt;code&gt;add&lt;/code&gt;&lt;/h1&gt;
&lt;p&gt;现在把源代码和汇编并排来看。&lt;/p&gt;
&lt;p&gt;C：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int add(int a, int b) {
    int c = a + b;
    return c;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;汇编：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add:
    push rbp
    mov rbp, rsp
    sub rsp, 16
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;建立当前函数的栈帧。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;    mov DWORD PTR [rbp-4], edi
    mov DWORD PTR [rbp-8], esi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;保存：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a = 2
b = 3
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;    mov eax, DWORD PTR [rbp-4]
    add eax, DWORD PTR [rbp-8]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = a + b = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;    mov DWORD PTR [rbp-12], eax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;得到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;c = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;    mov eax, DWORD PTR [rbp-12]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;准备：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;返回值 = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;    leave
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;恢复栈帧。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;    ret
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;根据栈中的返回地址回到调用者。&lt;/p&gt;
&lt;p&gt;最终调用者看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;eax = 5
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;add(2, 3)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;的值就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;5
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;结语&lt;/h1&gt;
&lt;p&gt;刚开始学汇编时，很容易把注意力全部放在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov 是什么？
DWORD 是什么？
rbp 是什么？
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;于是汇编就变成了一堆需要死记硬背的缩写。&lt;/p&gt;
&lt;p&gt;更好的方式，是先建立一幅机器运行的画面：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;CPU 有几个寄存器。

内存是一大排带地址的字节。

rsp 指着栈顶。

rbp 给当前函数提供一个参考点。

call 把返回地址放进栈。

函数把参数和局部数据放在寄存器或栈里。

运算指令真正进行计算。

返回值放入约定的寄存器。

ret 从栈里找到返回地址并跳回去。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;有了这幅图，再看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mov eax, DWORD PTR [rbp-4]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就不会再把它当成一句陌生咒语。&lt;/p&gt;
&lt;p&gt;它只是非常机械地说：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;去当前函数栈帧中找到那个 4 字节整数，把它复制到 &lt;code&gt;eax&lt;/code&gt;。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;汇编难的地方从来不只是指令本身，而是它把高级语言替我们隐藏的所有细节重新暴露了出来。&lt;/p&gt;
&lt;p&gt;而一旦这些细节能够在脑子里连成一张图，汇编反而会变得相当直白。&lt;/p&gt;
</content:encoded></item><item><title>终端</title><link>https://sanzenin.top/posts/obsidian/%E7%BB%88%E7%AB%AF/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%BB%88%E7%AB%AF/</guid><description>终端，来自 Obsidian 的操作系统笔记。</description><pubDate>Sat, 22 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;pty命令 ptyrecord&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787415205883.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787415205883&quot; /&gt;
&lt;img src=&quot;/obsidian/C%20%E6%A0%87%E5%87%86%E5%BA%93%E5%8E%9F%E7%90%86%26%E8%B0%83%E8%AF%95libc-1787416185687.webp&quot; alt=&quot;C 标准库原理&amp;amp;调试libc-1787416185687&quot; /&gt;&lt;/p&gt;
</content:encoded></item><item><title>Minimind：从零实现一个小型语言模型</title><link>https://sanzenin.top/posts/obsidian/minimind%E4%BB%8E%E9%9B%B6%E5%AE%9E%E7%8E%B0%E5%B0%8F%E8%AF%AD%E8%A8%80%E6%A8%A1%E5%9E%8B/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/minimind%E4%BB%8E%E9%9B%B6%E5%AE%9E%E7%8E%B0%E5%B0%8F%E8%AF%AD%E8%A8%80%E6%A8%A1%E5%9E%8B/</guid><description>个人实现地址：SanzeninMind 参考原型：MiniMind 1. 项目概览与模型配置 2. 从文本到 Token：数据预处理 3. 输入嵌入：Token ID → 向量 4. RMSNorm：为什么不用 LayerNorm 5. RoPE / YaRN：把位置信息转进 Query/Key 6. GQA 注意力：</description><pubDate>Mon, 10 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Minimind：从零实现一个小型语言模型&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;个人实现地址：&lt;a href=&quot;https://github.com/wlz6/SanzeninMind&quot;&gt;SanzeninMind&lt;/a&gt;
参考原型：&lt;a href=&quot;https://github.com/jingyaogong/minimind&quot;&gt;MiniMind&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2&gt;目录&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;a href=&quot;#1-%E9%A1%B9%E7%9B%AE%E6%A6%82%E8%A7%88%E4%B8%8E%E6%A8%A1%E5%9E%8B%E9%85%8D%E7%BD%AE&quot;&gt;项目概览与模型配置&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#2-%E4%BB%8E%E6%96%87%E6%9C%AC%E5%88%B0-token%E6%95%B0%E6%8D%AE%E9%A2%84%E5%A4%84%E7%90%86&quot;&gt;从文本到 Token：数据预处理&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#3-%E8%BE%93%E5%85%A5%E5%B5%8C%E5%85%A5token-id--%E5%90%91%E9%87%8F&quot;&gt;输入嵌入：Token ID → 向量&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#4-rmsnorm%E4%B8%BA%E4%BB%80%E4%B9%88%E4%B8%8D%E7%94%A8-layernorm&quot;&gt;RMSNorm：为什么不用 LayerNorm&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#5-rope--yarn%E6%8A%8A%E4%BD%8D%E7%BD%AE%E4%BF%A1%E6%81%AF%E8%BD%AC%E8%BF%9B-querykey&quot;&gt;RoPE / YaRN：把位置信息转进 Query/Key&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#6-gqa-%E6%B3%A8%E6%84%8F%E5%8A%9B%E7%9C%81%E6%98%BE%E5%AD%98%E7%9A%84%E5%A4%9A%E5%A4%B4%E6%9C%BA%E5%88%B6&quot;&gt;GQA 注意力：省显存的多头机制&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#7-ffn-%E4%B8%8E-moe%E4%BB%8E%E7%A8%A0%E5%AF%86%E5%88%B0%E7%A8%80%E7%96%8F%E5%89%8D%E9%A6%88&quot;&gt;FFN 与 MoE：从稠密到稀疏前馈&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#8-%E8%AE%AD%E7%BB%83%E6%B5%81%E7%A8%8B%E9%A2%84%E8%AE%AD%E7%BB%83%E8%84%9A%E6%9C%AC%E8%AF%A6%E8%A7%A3&quot;&gt;训练流程：预训练脚本详解&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#9-%E6%8E%A8%E7%90%86%E4%B8%8E%E8%AF%84%E4%BC%B0%E6%8A%8A%E6%A8%A1%E5%9E%8B%E8%B7%91%E8%B5%B7%E6%9D%A5&quot;&gt;推理与评估：把模型跑起来&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;hr /&gt;
&lt;h2&gt;1. 项目概览与模型配置&lt;/h2&gt;
&lt;p&gt;SanzeninMind 是一个跟着 MiniMind 学习、从零实现的小型 Decoder-only 语言模型。当前代码已经覆盖了：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Decoder-only 的 Transformer 骨架；&lt;/li&gt;
&lt;li&gt;基于 HuggingFace &lt;code&gt;tokenizers&lt;/code&gt; 的本地 BPE 词表；&lt;/li&gt;
&lt;li&gt;预训练数据流水线；&lt;/li&gt;
&lt;li&gt;RMSNorm、RoPE/YaRN、GQA Attention、SwiGLU FFN；&lt;/li&gt;
&lt;li&gt;MoE（Mixture-of-Experts）稀疏前馈；&lt;/li&gt;
&lt;li&gt;预训练脚本与 Eval 推理脚本。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;1.1 核心配置&lt;/h3&gt;
&lt;p&gt;模型配置集中在 &lt;code&gt;model/model.py&lt;/code&gt; 的 &lt;code&gt;SanzeninMindConfig&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class SanzeninMindConfig(PretrainedConfig):
    model_type = &quot;sanzeninmind&quot;

    def __init__(
        self,
        hidden_size: int = 512,              # 隐藏层维度
        num_attention_heads: int = 8,        # 注意力头数
        num_key_value_heads: int = 2,        # GQA 的 KV 头数
        num_hidden_layers: int = 8,          # Transformer 层数
        vocab_size: int = 6400,              # 词表大小
        max_position_embeddings: int = 32768,# 最大序列长度
        rope_theta: int = 1000000,           # RoPE 基频
        rms_norm_eps: float = 1e-05,
        use_moe: bool = True,
        num_experts_per_tok: int = 2,
        n_routed_experts: int = 4,
        n_shared_experts: int = 1,
        # ...
    )
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;几个后文会反复用到的派生量：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;head_dim = hidden_size // num_attention_heads&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;repeat_nums = num_attention_heads // num_key_value_heads&lt;/code&gt;（GQA 里每个 KV 头被多少个 Q 头共享）&lt;/li&gt;
&lt;li&gt;&lt;code&gt;intermediate_size&lt;/code&gt; 默认按 &lt;code&gt;hidden_size * 8 // 3&lt;/code&gt; 向上取整到 64 的倍数。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;以默认配置 &lt;code&gt;hidden_size=512, num_attention_heads=8&lt;/code&gt; 为例：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;超参&lt;/th&gt;
&lt;th&gt;数值&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;head_dim&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;64&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;num_key_value_heads&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;repeat_nums&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;intermediate_size&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;1408&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;&lt;code&gt;trainer/train_pretrain.py&lt;/code&gt; 默认把 &lt;code&gt;hidden_size&lt;/code&gt; 覆盖成 768，此时 &lt;code&gt;head_dim=96&lt;/code&gt;，&lt;code&gt;intermediate_size=2048&lt;/code&gt;。&lt;/p&gt;
&lt;h3&gt;1.2 整体架构&lt;/h3&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/LLM-structure.jpg&quot; alt=&quot;LLM-structure&quot; /&gt;&lt;/p&gt;
&lt;p&gt;上图是 MiniMind 的 Dense 模型结构。数据流可以概括为：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Tokenizer → Input Embedding → [RMSNorm → GQA + RoPE → 残差 → RMSNorm → FFN/MoE → 残差] × L → RMSNorm → LM Head → Softmax
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;SanzeninMind 在 Dense 基础上增加了可选的 &lt;strong&gt;MoE-FFN&lt;/strong&gt;：&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/LLM-structure-moe.jpg&quot; alt=&quot;LLM-structure-moe&quot; /&gt;&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;2. 从文本到 Token：数据预处理&lt;/h2&gt;
&lt;p&gt;预训练数据放在 &lt;code&gt;dataset/pretrain_t2t_mini.jsonl&lt;/code&gt;，每行一个 JSON：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;{&quot;text&quot;: &quot;神经网络是一种模仿动物神经网络行为特征的算法模型...&quot;}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;dataset/lm_dataset.py&lt;/code&gt; 里的 &lt;code&gt;PretrainDataset&lt;/code&gt; 做三件事：惰性加载、tokenize、补齐并生成 labels。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class PretrainDataset(Dataset):
    def __init__(self, data_path, tokenizer: PreTrainedTokenizerBase, max_length=512):
        super().__init__()
        self.tokenizer = tokenizer
        self.max_length = max_length
        # HuggingFace datasets 惰性加载，避免一次性读入大文件
        self.samples = load_dataset(&quot;json&quot;, data_files=data_path, split=&quot;train&quot;)

    def __len__(self):
        return len(self.samples)

    def __getitem__(self, index):
        sample = self.samples[index]

        # tokenize，不自动加特殊 token，max_length 留出 2 个位置给 BOS 和 EOS
        tokens = self.tokenizer(
            str(sample[&quot;text&quot;]),
            add_special_tokens=False,
            max_length=self.max_length - 2,
            truncation=True,
        ).input_ids

        # 手动拼接 BOS + 正文 token + EOS
        tokens = [self.tokenizer.bos_token_id] + tokens + [self.tokenizer.eos_token_id]

        # 右侧 PAD 补齐到 max_length
        pad_len = self.max_length - len(tokens)
        input_ids = tokens + [self.tokenizer.pad_token_id] * pad_len
        input_ids = torch.tensor(input_ids, dtype=torch.long)

        # labels 与 input_ids 相同，PAD 位置置 -100 让 CrossEntropy 忽略
        labels = input_ids.clone()
        labels[input_ids == self.tokenizer.pad_token_id] = -100

        return input_ids, labels
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;形状变化：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;原始文本      : str
input_ids     : [max_length]        (torch.long)
labels        : [max_length]        (PAD 位置为 -100)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Tokenizer 配置（&lt;code&gt;model/tokenizer_config.json&lt;/code&gt;）：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;bos_token&lt;/code&gt;: &lt;code&gt;&amp;lt;|im_start|&amp;gt;&lt;/code&gt; (id=1)&lt;/li&gt;
&lt;li&gt;&lt;code&gt;eos_token&lt;/code&gt;: &lt;code&gt;&amp;lt;|im_end|&amp;gt;&lt;/code&gt;   (id=2)&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pad_token&lt;/code&gt;: &lt;code&gt;&amp;lt;|endoftext|&amp;gt;&lt;/code&gt; (id=0)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;为什么 labels 和 input_ids 相同？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;因果语言模型训练的是&quot;给定前 t 个 token，预测第 t+1 个 token&quot;。在 &lt;code&gt;SanzeninMindForCausalLM.forward&lt;/code&gt; 里会手动错位：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;shift_logits = logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以 Dataset 里 labels 直接复用 input_ids 就行。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;3. 输入嵌入：Token ID → 向量&lt;/h2&gt;
&lt;p&gt;模型入口在 &lt;code&gt;SanzeninMindForCausalLM.forward&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;batch_size, seq_len = input_ids.shape
hidden_states = self.model.dropout(self.model.embed_tokens(input_ids))
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;embed_tokens&lt;/code&gt; 就是一个 &lt;code&gt;nn.Embedding(vocab_size, hidden_size)&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;形状变化（以 &lt;code&gt;hidden_size=512&lt;/code&gt; 为例）：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;input_ids      : [batch_size, seq_len]          例如 [2, 128]
embed_tokens   : [vocab_size, hidden_size]       [6400, 512]
hidden_states  : [batch_size, seq_len, hidden_size]  [2, 128, 512]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每个 token id 去词表里查一行，得到一个 &lt;code&gt;hidden_size&lt;/code&gt; 维向量。这一步之后，模型还不知道 token 的顺序——之后的rope位置编码就是来解决这个问题的。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;4. RMSNorm：为什么不用 LayerNorm&lt;/h2&gt;
&lt;h3&gt;4.1 动机&lt;/h3&gt;
&lt;p&gt;LayerNorm 的公式是：&lt;/p&gt;
&lt;p&gt;$$
\text{LayerNorm}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \varepsilon}} \odot \gamma + \beta
$$&lt;/p&gt;
&lt;p&gt;其中：&lt;/p&gt;
&lt;p&gt;$$
\mu = \frac{1}{d} \sum_{i=1}^{d} x_i, \quad \sigma^2 = \frac{1}{d} \sum_{i=1}^{d} (x_i - \mu)^2
$$&lt;/p&gt;
&lt;p&gt;RMSNorm 的作者发现，在 Transformer 里&lt;strong&gt;减去均值这一步并不是必须的&lt;/strong&gt;，直接用均方根做归一化就够了：&lt;/p&gt;
&lt;p&gt;$$
\text{RMS}(x) = \sqrt{\frac{1}{d} \sum_{i=1}^{d} x_i^2 + \varepsilon}
$$&lt;/p&gt;
&lt;p&gt;$$
\text{RMSNorm}(x) = \frac{x}{\text{RMS}(x)} \odot \gamma
$$&lt;/p&gt;
&lt;p&gt;这样做有两个好处：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;计算量减少&lt;/strong&gt;：省掉一次求均值和方差中的减均值操作；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;效果相当&lt;/strong&gt;：在 LLaMA、Qwen 等主流模型中被验证有效。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;4.2 代码实现&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;class RMSNorm(nn.Module):
    def __init__(self, dim: int, eps: float = 1e-8):
        super().__init__()
        self.eps = eps
        # 可学习的逐维度缩放参数 gamma，初始为 1
        self.weight = nn.Parameter(torch.ones(dim))

    def norm(self, x: torch.Tensor):
        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)

    def forward(self, x: torch.Tensor):
        # 先转 float32 做归一化，避免低精度数值问题，再转回输入 dtype
        return (self.weight * self.norm(x.float())).type_as(x)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;关键点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;x.pow(2).mean(-1, keepdim=True)&lt;/code&gt; 对最后一个维度 &lt;code&gt;hidden_size&lt;/code&gt; 求平方均值，返回 &lt;code&gt;[batch_size, seq_len, 1]&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;torch.rsqrt(...)&lt;/code&gt; 等价于 &lt;code&gt;1 / sqrt(...)&lt;/code&gt;，是 PyTorch 里更快也更稳定的写法；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;self.weight&lt;/code&gt; 是可学习的逐维度缩放参数，形状 &lt;code&gt;[hidden_size]&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;.type_as(x)&lt;/code&gt; 把 float32 的归一化结果转回输入 dtype（如 bfloat16）。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;形状变化：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;输入 x         : [batch_size, seq_len, hidden_size]   [2, 128, 512]
x.pow(2).mean(-1, keepdim=True) : [2, 128, 1]
缩放系数       : [2, 128, 1]
输出           : [batch_size, seq_len, hidden_size]   [2, 128, 512]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;RMSNorm 不改变形状，只改变数值分布。它出现在三个地方：每个 Transformer Block 的 Attention 之前、FFN/MoE 之前、以及最后一层之后。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;5. RoPE / YaRN：把位置信息转进 Query/Key&lt;/h2&gt;
&lt;h3&gt;5.1 动机&lt;/h3&gt;
&lt;p&gt;Transformer 本身对输入顺序不敏感——Self-Attention 是置换等变的。早期做法是把绝对位置编码直接加到 Embedding 上：&lt;/p&gt;
&lt;p&gt;$$
x = \text{embed}(\text{token}) + \text{pos_embed}(\text{position})
$$&lt;/p&gt;
&lt;p&gt;但这样只能表达绝对位置。RoPE（Rotary Position Embedding）的思路是：&lt;strong&gt;对 Query 和 Key 的每两个维度做一次二维旋转&lt;/strong&gt;，让注意力点积里天然出现 $\cos((m-n)\theta)$ 和 $\sin((m-n)\theta)$，从而表达&lt;strong&gt;相对位置差&lt;/strong&gt;。&lt;/p&gt;
&lt;h3&gt;5.2 二维旋转推导&lt;/h3&gt;
&lt;p&gt;取 query 和 key 的某两个维度，分别记为向量：&lt;/p&gt;
&lt;p&gt;$$
q = (q_1, q_2), \quad k = (k_1, k_2)
$$&lt;/p&gt;
&lt;p&gt;对位置 $m$ 的 query 旋转角度 $m\theta$，对位置 $n$ 的 key 旋转角度 $n\theta$，旋转矩阵为：&lt;/p&gt;
&lt;p&gt;$$
R(\phi) = \begin{bmatrix} \cos\phi &amp;amp; -\sin\phi \ \sin\phi &amp;amp; \cos\phi \end{bmatrix}
$$&lt;/p&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;p&gt;$$
q&apos; = R(m\theta) , q = \begin{bmatrix} q_1\cos m\theta - q_2\sin m\theta \ q_1\sin m\theta + q_2\cos m\theta \end{bmatrix}
$$&lt;/p&gt;
&lt;p&gt;$$
k&apos; = R(n\theta) , k = \begin{bmatrix} k_1\cos n\theta - k_2\sin n\theta \ k_1\sin n\theta + k_2\cos n\theta \end{bmatrix}
$$&lt;/p&gt;
&lt;p&gt;计算点积 $q&apos; \cdot k&apos;$，展开并整理后：&lt;/p&gt;
&lt;p&gt;$$
q&apos; \cdot k&apos; = (q_1 k_1 + q_2 k_2) \cos((m-n)\theta) + (q_1 k_2 - q_2 k_1) \sin((m-n)\theta)
$$&lt;/p&gt;
&lt;p&gt;关键结论：&lt;strong&gt;位置信息只与相对距离 $m-n$ 有关&lt;/strong&gt;，这正是 RoPE 名字的由来。&lt;/p&gt;
&lt;h3&gt;5.3 频率分配&lt;/h3&gt;
&lt;p&gt;RoPE 把 &lt;code&gt;head_dim&lt;/code&gt; 维向量按二维一组处理，第 $i$ 组的频率为：&lt;/p&gt;
&lt;p&gt;$$
\theta_i = \frac{1}{\text{rope_base}^{2i / d}}
$$&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$i$ 越小，$\theta_i$ 越大 → &lt;strong&gt;高频&lt;/strong&gt;，对局部位置敏感；&lt;/li&gt;
&lt;li&gt;$i$ 越大，$\theta_i$ 越小 → &lt;strong&gt;低频&lt;/strong&gt;，负责长距离关系。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;对应波长（转一圈需要的步数）为：&lt;/p&gt;
&lt;p&gt;$$
\lambda_i = \frac{2\pi}{\theta_i} = 2\pi \cdot \text{rope_base}^{2i/d}
$$&lt;/p&gt;
&lt;h3&gt;5.4 代码实现：&lt;code&gt;precompute_freqs_cis&lt;/code&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;def precompute_freqs_cis(dim, rope_base, end=(32*1024), rope_scaling=None):
    # 生成每对维度的旋转基频
    # torch.arange(0, dim, 2) 取 0, 2, 4, ..., 共 dim//2 个频率组
    # 第 i 组频率 theta_i = 1 / rope_base^(2i / dim)
    freqs = 1.0 / (rope_base ** (torch.arange(0, dim, 2)[:dim//2].float() / dim))
    attention_factor = 1.0

    # 如果启用 YaRN / RoPE scaling，对低频做外推缩放
    if rope_scaling is not None:
        orig_max = rope_scaling[&quot;original_max_position_embeddings&quot;]
        factor = rope_scaling[&quot;factor&quot;]
        beta_fast = rope_scaling[&quot;beta_fast&quot;]
        beta_slow = rope_scaling[&quot;beta_slow&quot;]
        attention_factor = rope_scaling.get(&quot;attention_factor&quot;, 1.0)

        if end &amp;gt; orig_max:
            # inv_dim: 把&quot;在训练长度内旋转 beta 圈&quot;的条件映射回维度索引 i
            inv_dim = lambda b: (dim * math.log(orig_max / (b * 2 * math.pi))) / (2 * math.log(rope_base))
            low = max(math.floor(inv_dim(beta_fast)), 0)
            high = min(math.ceil(inv_dim(beta_slow)), dim // 2 - 1)

            # ramp: 在 [low, high] 区间内从 0 平滑过渡到 1
            # i &amp;lt; low 时 ramp=0（高频，不缩放）
            # i &amp;gt; high 时 ramp=1（低频，除以 factor）
            # low &amp;lt;= i &amp;lt;= high 时线性插值（中频，平滑过渡）
            ramp = torch.clamp(
                (torch.arange(dim // 2, device=freqs.device).float() - low) / max(high - low, 0.001),
                0, 1
            )
            freqs = freqs * (1 - ramp + ramp / factor)

    # 生成位置索引，并计算每个位置、每个频率的旋转角度
    t = torch.arange(end, device=freqs.device).float()
    freqs = torch.outer(t, freqs).float()

    # 把角度表复制一份，拼成 [end, dim]，分别对应前半维和后半维
    freqs_cos = torch.cat([torch.cos(freqs), torch.cos(freqs)], dim=-1) * attention_factor
    freqs_sin = torch.cat([torch.sin(freqs), torch.sin(freqs)], dim=-1) * attention_factor
    return freqs_cos, freqs_sin
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;形状变化：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;torch.arange(0, dim, 2)      : [dim//2]            例如 [32]
freqs                        : [dim//2]            [32]
t                            : [end]               [32768]
torch.outer(t, freqs)        : [end, dim//2]       [32768, 32]
torch.cat([cos, cos], dim=-1): [end, dim]          [32768, 64]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在 &lt;code&gt;SanzeninMindForCausalLM.__init__&lt;/code&gt; 中，&lt;code&gt;dim&lt;/code&gt; 传入的是 &lt;code&gt;head_dim&lt;/code&gt;（64 或 96），所以 &lt;code&gt;freqs_cos&lt;/code&gt; 形状是 &lt;code&gt;[max_position_embeddings, head_dim]&lt;/code&gt;。&lt;/p&gt;
&lt;h3&gt;5.5 YaRN：按频率分段的外推缩放&lt;/h3&gt;
&lt;h4&gt;符号约定&lt;/h4&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;符号&lt;/th&gt;
&lt;th&gt;含义&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;$d$&lt;/td&gt;
&lt;td&gt;head_dim&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$i$&lt;/td&gt;
&lt;td&gt;RoPE 频率组索引，$i = 0, 1, \dots, d/2 - 1$&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\theta_i$&lt;/td&gt;
&lt;td&gt;第 $i$ 组维度的旋转频率&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\lambda_i$&lt;/td&gt;
&lt;td&gt;第 $i$ 组维度的波长&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$L$&lt;/td&gt;
&lt;td&gt;训练时的最大长度，代码中叫 &lt;code&gt;orig_max&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\beta$&lt;/td&gt;
&lt;td&gt;某个维度在训练长度 $L$ 内旋转的圈数&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\text{factor}$&lt;/td&gt;
&lt;td&gt;外推缩放因子&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;$\text{ramp}_i$&lt;/td&gt;
&lt;td&gt;$[0, 1]$ 之间的平滑过渡系数&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h4&gt;波长与频率的关系&lt;/h4&gt;
&lt;p&gt;频率 $\theta_i$ 表示 token 每前进一步，向量在复平面上旋转的弧度。转满一圈 $2\pi$ 需要的步数就是波长：&lt;/p&gt;
&lt;p&gt;$$
\lambda_i = \frac{2\pi}{\theta_i}
$$&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/rope_wavelengths.png&quot; alt=&quot;rope_wavelengths&quot; /&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;高频维度（$i$ 小）：波长短，如 $i=2$ 时波长仅约 6；&lt;/li&gt;
&lt;li&gt;低频维度（$i$ 大）：波长长，如 $i=30$ 时波长超过 20000。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;从&quot;旋转圈数&quot;到维度索引&lt;/h4&gt;
&lt;p&gt;YaRN 用 &lt;code&gt;beta_fast&lt;/code&gt; 和 &lt;code&gt;beta_slow&lt;/code&gt; 划分频段。它们的含义是：在原始训练长度 $L$ 内，某个维度大约旋转 $\beta$ 圈。&lt;/p&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;p&gt;$$
\beta = \frac{L}{\lambda_i} = \frac{L \cdot \theta_i}{2\pi}
$$&lt;/p&gt;
&lt;p&gt;把 RoPE 频率公式代入，解出维度索引 $i$：&lt;/p&gt;
&lt;p&gt;$$
i = \frac{d \cdot \ln\left(\frac{L}{\beta \cdot 2\pi}\right)}{2 \ln(\text{rope_base})}
$$&lt;/p&gt;
&lt;p&gt;代码里就是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;inv_dim = lambda b: (dim * math.log(orig_max / (b * 2 * math.pi))) / (2 * math.log(rope_base))
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;对 &lt;code&gt;beta_fast&lt;/code&gt; 和 &lt;code&gt;beta_slow&lt;/code&gt; 分别调用 &lt;code&gt;inv_dim&lt;/code&gt;，得到两个临界索引 &lt;code&gt;low&lt;/code&gt; 和 &lt;code&gt;high&lt;/code&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;$i &amp;lt; \text{low}$：在训练长度内旋转圈数多于 &lt;code&gt;beta_fast&lt;/code&gt; → &lt;strong&gt;高频&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;$\text{low} \le i \le \text{high}$：&lt;strong&gt;中频&lt;/strong&gt;；&lt;/li&gt;
&lt;li&gt;$i &amp;gt; \text{high}$：在训练长度内旋转圈数少于 &lt;code&gt;beta_slow&lt;/code&gt; → &lt;strong&gt;低频&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;YaRN 缩放公式&lt;/h4&gt;
&lt;p&gt;对频率做分段处理：&lt;/p&gt;
&lt;p&gt;$$
\theta&apos;_i = \theta_i \cdot \left(1 - \text{ramp}_i + \frac{\text{ramp}_i}{\text{factor}}\right)
$$&lt;/p&gt;
&lt;p&gt;其中 &lt;code&gt;ramp&lt;/code&gt; 是一个在 $[0, 1]$ 之间平滑过渡的向量：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ramp = torch.clamp(
    (torch.arange(dim // 2, device=freqs.device).float() - low) / max(high - low, 0.001),
    0, 1
)
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;当 $i &amp;lt; \text{low}$（高频）：$\text{ramp}_i = 0$，$\theta&apos;_i = \theta_i$，&lt;strong&gt;不缩放&lt;/strong&gt;，保留局部精度；&lt;/li&gt;
&lt;li&gt;当 $i &amp;gt; \text{high}$（低频）：$\text{ramp}_i = 1$，$\theta&apos;_i = \theta_i / \text{factor}$，&lt;strong&gt;显著放慢&lt;/strong&gt;，让长距离位置落回训练分布；&lt;/li&gt;
&lt;li&gt;当中间：$0 &amp;lt; \text{ramp}_i &amp;lt; 1$，&lt;strong&gt;线性插值&lt;/strong&gt;，平滑过渡。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;为什么要这样分段？&lt;/h4&gt;
&lt;p&gt;如果不做任何外推缩放，三个频段在超长序列下的表现截然不同。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/rope_yarn_phase.png&quot; alt=&quot;rope_yarn_phase&quot; /&gt;&lt;/p&gt;
&lt;p&gt;上图横轴是位置，纵轴是相位（对 $2\pi$ 取模），红线标出训练长度 $L=2048$。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;左图：不缩放&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;高频&lt;/strong&gt;（散点）：继续快速周期震荡。训练时已经见过很多完整周期，外推时相位值仍是熟悉的；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;中频&lt;/strong&gt;（蓝色折线）：超过训练长度后进入部分未见过相位，但波长较短，还能靠周期性维持；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;低频&lt;/strong&gt;（橙色折线）：最致命。训练时只见过 $0 \sim 0.3\pi$ 左右一小段，外推后相位一路飙升到 $1.5\pi$ 以上，完全脱离训练分布。模型学到的长距离位置规律在这里失效。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;右图：YaRN 缩放&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;高频&lt;/strong&gt;：轨迹几乎不变，局部精度保留；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;中频&lt;/strong&gt;：被适度放慢，相位轨迹被&quot;压回&quot;训练区间；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;低频&lt;/strong&gt;：被显著放慢，原本到 8000 位置才涨到 $1.5\pi$，现在几乎贴地，仍落在训练时见过的相位范围内。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;YaRN 的核心直觉：&lt;strong&gt;不要一刀切地把所有频率都放慢，只放慢训练时没见过长距离相位的低频维度，同时保护高频的局部精度。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;下图是 MiniMind 官方给出的 RoPE 外推效果：开启 YaRN 后，长文本困惑度明显更低。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/rope_ppl.png&quot; alt=&quot;rope_ppl&quot; /&gt;&lt;/p&gt;
&lt;h3&gt;5.6 应用旋转：&lt;code&gt;apply_rotary_pos_emb&lt;/code&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;def apply_rotary_pos_emb(q, k, cos, sin, position_ids=None, unsqueeze_dim=1):
    def rotate_half(x):
        # 把向量按前后两半拆分：
        # 输入 x = [x_1, ..., x_{d/2}, x_{d/2+1}, ..., x_d]
        # 输出   = [-x_{d/2+1}, ..., -x_d, x_1, ..., x_{d/2}]
        return torch.cat([
            -x[..., x.shape[-1]//2:],
            x[..., :x.shape[-1]//2]
        ], dim=-1)

    q_embed = q * cos.unsqueeze(unsqueeze_dim) + rotate_half(q) * sin.unsqueeze(unsqueeze_dim)
    k_embed = k * cos.unsqueeze(unsqueeze_dim) + rotate_half(k) * sin.unsqueeze(unsqueeze_dim)
    return q_embed, k_embed
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;这里的配对方式是&quot;前半维与后半维配对&quot;&lt;/strong&gt;：把向量分成前 $d/2$ 维和后 $d/2$ 维，对应位置组成二维旋转对。&lt;/p&gt;
&lt;p&gt;设 $x = (x_1, x_2, \dots, x_{d/2}, x_{d/2+1}, \dots, x_d)$，则：&lt;/p&gt;
&lt;p&gt;$$
\text{rotate_half}(x) = (-x_{d/2+1}, \dots, -x_d, x_1, \dots, x_{d/2})
$$&lt;/p&gt;
&lt;p&gt;于是：&lt;/p&gt;
&lt;p&gt;$$
x&apos; = x \odot \cos\phi + \text{rotate_half}(x) \odot \sin\phi
$$&lt;/p&gt;
&lt;p&gt;这与二维旋转公式完全等价，只是索引约定不同。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;形状变化（Attention 内部）：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;进入 Attention 前:
  xq : [batch_size, seq_len, num_heads * head_dim]   [2, 128, 512]
  xk : [batch_size, seq_len, num_kv_heads * head_dim] [2, 128, 128]
  xv : [batch_size, seq_len, num_kv_heads * head_dim] [2, 128, 128]

view 拆头后:
  xq : [batch_size, seq_len, num_heads, head_dim]     [2, 128, 8, 64]
  xk : [batch_size, seq_len, num_kv_heads, head_dim]  [2, 128, 2, 64]
  xv : [batch_size, seq_len, num_kv_heads, head_dim]  [2, 128, 2, 64]

RoPE 前 cos/sin (从 buffer 中切片):
  cos : [seq_len, head_dim]                           [128, 64]

unsqueeze(1) 后:
  cos : [seq_len, 1, head_dim]                        [128, 1, 64]

应用 RoPE 后:
  q_embed : [batch_size, seq_len, num_heads, head_dim] [2, 128, 8, 64]
  k_embed : [batch_size, seq_len, num_kv_heads, head_dim] [2, 128, 2, 64]
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h2&gt;6. GQA 注意力：省显存的多头机制&lt;/h2&gt;
&lt;h3&gt;6.1 动机&lt;/h3&gt;
&lt;p&gt;标准 Multi-Head Attention（MHA）中，每个注意力头都有独立的 Q/K/V 投影。当模型很大、序列很长时，&lt;strong&gt;KV Cache&lt;/strong&gt; 会占用大量显存。&lt;/p&gt;
&lt;p&gt;GQA（Grouped-Query Attention）让多个 Query 头共享同一组 K/V 头：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;num_attention_heads&lt;/code&gt; 个 Q 头；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;num_key_value_heads&lt;/code&gt; 个 K/V 头；&lt;/li&gt;
&lt;li&gt;每个 K/V 头被 &lt;code&gt;repeat_nums = num_attention_heads // num_key_value_heads&lt;/code&gt; 个 Q 头共享。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这样 KV Cache 大小降到原来的 &lt;code&gt;num_key_value_heads / num_attention_heads&lt;/code&gt;。&lt;/p&gt;
&lt;h3&gt;6.2 代码实现&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;class Attention(nn.Module):
    def __init__(self, args: SanzeninMindConfig):
        super().__init__()
        self.num_key_value_heads = args.num_key_value_heads
        assert args.num_attention_heads % self.num_key_value_heads == 0, \
            &quot;num_attention_heads 必须能被 num_key_value_heads 整除&quot;

        self.local_heads = args.num_attention_heads
        self.local_kv_heads = self.num_key_value_heads
        self.repeat_nums = self.local_heads // self.local_kv_heads
        self.head_dim = args.hidden_size // args.num_attention_heads

        # Q/K/V/O 投影，均无偏置
        self.q_proj = nn.Linear(args.hidden_size, self.head_dim * self.local_heads, bias=False)
        self.k_proj = nn.Linear(args.hidden_size, self.head_dim * self.local_kv_heads, bias=False)
        self.v_proj = nn.Linear(args.hidden_size, self.head_dim * self.local_kv_heads, bias=False)
        self.o_proj = nn.Linear(self.head_dim * self.local_heads, args.hidden_size, bias=False)

        self.attn_dropout = nn.Dropout(args.dropout)
        self.resid_dropout = nn.Dropout(args.dropout)
        self.dropout = args.dropout

        # 检测 PyTorch 是否支持 Flash Attention fused kernel
        self.flash = hasattr(nn.functional, &apos;scaled_dot_product_attention&apos;) and args.flash_attention

    def forward(
        self,
        x: torch.Tensor,
        position_embeddings: Tuple[torch.Tensor, torch.Tensor],
        past_key_value: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
        use_cache: bool = False,
        attention_mask: Optional[torch.Tensor] = None,
    ) -&amp;gt; Tuple[torch.Tensor, Optional[KVCache]]:
        batch_size, seq_len, _ = x.shape

        # 线性投影得到 Q/K/V
        # xq: [B, S, num_heads * head_dim]
        # xk/xv: [B, S, num_kv_heads * head_dim]
        xq, xk, xv = self.q_proj(x), self.k_proj(x), self.v_proj(x)

        # reshape 成多头形式
        xq = xq.view(batch_size, seq_len, self.local_heads, self.head_dim)
        xk = xk.view(batch_size, seq_len, self.local_kv_heads, self.head_dim)
        xv = xv.view(batch_size, seq_len, self.local_kv_heads, self.head_dim)

        # 应用 RoPE 位置编码（只对 Q/K，V 不需要）
        cos, sin = position_embeddings
        xq, xk = apply_rotary_pos_emb(xq, xk, cos, sin)

        # KV Cache 拼接（推理时复用已计算的 key/value）
        if past_key_value is not None:
            xk = torch.cat([past_key_value[0], xk], dim=1)
            xv = torch.cat([past_key_value[1], xv], dim=1)
        past_kv = (xk, xv) if use_cache else None

        # 调整维度并复制 KV 头以匹配 Q 头数量
        # 从 [B, S, H, D] -&amp;gt; [B, H, S, D]，便于做 batch 矩阵乘法
        xq, xk, xv = (
            xq.transpose(1, 2),
            repeat_kv(xk, self.repeat_nums).transpose(1, 2),
            repeat_kv(xv, self.repeat_nums).transpose(1, 2),
        )

        # 注意力计算
        if (
            self.flash
            and seq_len &amp;gt; 1
            and past_key_value is None
            and (attention_mask is None or torch.all(attention_mask == 1))
        ):
            # Flash Attention 快速路径：fused kernel，省显存
            output = F.scaled_dot_product_attention(
                xq, xk, xv,
                dropout_p=self.dropout if self.training else 0.0,
                is_causal=True,
            )
        else:
            # 手动实现路径
            # scores[b, h, q_pos, k_pos] 表示第 h 头中 q_pos 对 k_pos 的注意力分数
            scores = (xq @ xk.transpose(-2, -1)) / math.sqrt(self.head_dim)

            # Causal Mask：当前 query 位置只能看到当前及之前的 key 位置
            # scores 最后一维是 cached_seq_len + seq_len，只对最右侧 seq_len 加掩码
            scores[:, :, :, -seq_len:] += torch.triu(
                torch.full((seq_len, seq_len), float(&apos;-inf&apos;), device=scores.device),
                diagonal=1
            )

            # Padding Mask：把 PAD 位置对应的分数置为 -inf
            if attention_mask is not None:
                extended_attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)
                extended_attention_mask = (1 - extended_attention_mask) * (-1e9)
                scores = scores + extended_attention_mask

            scores = F.softmax(scores.float(), dim=-1).type_as(xq)
            scores = self.attn_dropout(scores)
            output = scores @ xv

        # 合并多头并做输出投影
        output = output.transpose(1, 2).reshape(batch_size, seq_len, -1)
        output = self.resid_dropout(self.o_proj(output))
        return output, past_kv
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.3 &lt;code&gt;repeat_kv&lt;/code&gt;：把 KV 头复制给多个 Q 头&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;def repeat_kv(x: torch.Tensor, repeat_nums: int) -&amp;gt; torch.Tensor:
    bs, seq_len, num_key_value_heads, head_dim = x.shape
    if repeat_nums == 1:
        return x

    return (
        x[:, :, :, None, :]
        .expand(bs, seq_len, num_key_value_heads, repeat_nums, head_dim)
        .reshape(bs, seq_len, num_key_value_heads * repeat_nums, head_dim)
    )
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;形状变化：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;输入 x                       : [2, 128, 2, 64]
x[:, :, :, None, :]         : [2, 128, 2, 1, 64]
expand(..., repeat_nums)    : [2, 128, 2, 4, 64]
reshape(..., 2*4, 64)       : [2, 128, 8, 64]
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.4 Attention 完整形状流&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;x (经 RMSNorm 后)            : [2, 128, 512]

投影:
  q_proj: [512, 512]   -&amp;gt; xq [2, 128, 512]
  k_proj: [512, 128]   -&amp;gt; xk [2, 128, 128]
  v_proj: [512, 128]   -&amp;gt; xv [2, 128, 128]

拆头:
  xq [2, 128, 8, 64]
  xk [2, 128, 2, 64]
  xv [2, 128, 2, 64]

RoPE 后形状不变

KV Cache 拼接后 (假设已有 64 个缓存位置):
  xk [2, 192, 2, 64]
  xv [2, 192, 2, 64]

transpose + repeat_kv:
  xq [2, 8, 128, 64]
  xk [2, 8, 192, 64]
  xv [2, 8, 192, 64]

注意力得分:
  scores = xq @ xk.T  -&amp;gt; [2, 8, 128, 192]
  softmax 后           -&amp;gt; [2, 8, 128, 192]
  output = scores @ xv -&amp;gt; [2, 8, 128, 64]

合并头:
  transpose -&amp;gt; [2, 128, 8, 64]
  reshape   -&amp;gt; [2, 128, 512]

o_proj: [512, 512] -&amp;gt; output [2, 128, 512]
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6.5 Causal Mask&lt;/h3&gt;
&lt;p&gt;手动实现分支里：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;scores[:, :, :, -seq_len:] += torch.triu(
    torch.full((seq_len, seq_len), float(&apos;-inf&apos;), device=scores.device),
    diagonal=1
)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;scores&lt;/code&gt; 的最后一维是 &lt;code&gt;cached_seq_len + seq_len&lt;/code&gt;。我们只对&lt;strong&gt;最右边的 &lt;code&gt;seq_len&lt;/code&gt; 个位置&lt;/strong&gt;加上三角 mask，保证当前 token 看不到未来 token。&lt;/p&gt;
&lt;h3&gt;6.6 Flash Attention 快速路径&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;F.scaled_dot_product_attention&lt;/code&gt; 是 PyTorch 2.0+ 提供的 fused attention 封装，传入 &lt;code&gt;is_causal=True&lt;/code&gt; 会自动构造因果 mask，并调用底层优化 kernel（FlashAttention / Memory-Efficient Attention / cuDNN），显著节省显存和计算。代码里只在 &lt;code&gt;seq_len &amp;gt; 1&lt;/code&gt;、没有 KV Cache、没有 padding mask 时走这条路径，否则回退到手动实现。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;7. FFN 与 MoE：从稠密到稀疏前馈&lt;/h2&gt;
&lt;h3&gt;7.1 稠密 FFN：SwiGLU&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;class FeedForward(nn.Module):
    # 增加 intermediate_size 参数，方便 MoE 每个专家传入 config.moe_intermediate_size
    def __init__(self, config: SanzeninMindConfig, intermediate_size: int = None):
        super().__init__()
        # 优先使用调用方传入的 intermediate_size；否则使用 config.intermediate_size；都没有时再自动计算
        intermediate_size = intermediate_size if intermediate_size is not None else config.intermediate_size
        if intermediate_size is None:
            intermediate_size = config.hidden_size * 8 // 3
            intermediate_size = 64 * ((intermediate_size + 63) // 64)  # 向上取整为 64 的倍数，有利于 GPU 性能

        self.gate_proj = nn.Linear(config.hidden_size, intermediate_size, bias=False)
        self.down_proj = nn.Linear(intermediate_size, config.hidden_size, bias=False)
        self.up_proj   = nn.Linear(config.hidden_size, intermediate_size, bias=False)
        self.dropout   = nn.Dropout(config.dropout)
        # 通常是 silu，即 Swish 激活
        self.act_fn    = ACT2FN[config.hidden_act]

    def forward(self, x):
        # SwiGLU: silu(gate_proj(x)) * up_proj(x) 逐元素相乘，再过 down_proj
        return self.dropout(self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x)))
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;形状变化（&lt;code&gt;hidden_size=512, intermediate_size=1408&lt;/code&gt;）：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x              : [2, 128, 512]
gate_proj(x)   : [2, 128, 1408]
up_proj(x)     : [2, 128, 1408]
act_fn(gate) * up : [2, 128, 1408]
down_proj(...) : [2, 128, 512]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;SwiGLU 用两个投影（gate 和 up）逐元素相乘后再投影回去，表达能力比单投影 + ReLU/GELU 更强，这也是 LLaMA2/3、Qwen 等模型的选择。&lt;/p&gt;
&lt;h3&gt;7.2 MoE：稀疏激活的专家层&lt;/h3&gt;
&lt;p&gt;MoE（Mixture-of-Experts）把一个大 FFN 拆成多个小 FFN（专家），并用一个 Router 决定每个 token 激活哪几个专家。&lt;/p&gt;
&lt;p&gt;形式上，对于输入 $x_s$，Router 输出门控分数：&lt;/p&gt;
&lt;p&gt;$$
g_s = \text{GATE}(x_s) \in \mathbb{R}^E
$$&lt;/p&gt;
&lt;p&gt;每个专家 $e$ 独立计算，最终输出是门控分数与专家输出的加权和：&lt;/p&gt;
&lt;p&gt;$$
y_s = \sum_{e=1}^{E} g_{s,e} \cdot \text{FFN}_e(x_s)
$$&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/image-17.png&quot; alt=&quot;image-17&quot; /&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class MoEGate(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        # Router：把每个 token 的 hidden 向量映射到专家数维度的分数
        self.gate = nn.Linear(config.hidden_size, config.num_experts, bias=False)

        # 被 Router 选中的专家（稀疏激活）
        self.experts = nn.ModuleList([
            FeedForward(config, intermediate_size=config.moe_intermediate_size)
            for _ in range(config.num_experts)
        ])

        # 共享专家：所有 token 都会经过，提供公共知识通道
        self.shared_experts = nn.ModuleList([
            FeedForward(config, intermediate_size=config.moe_intermediate_size)
            for _ in range(config.n_shared_experts)
        ])
        # 共享专家同样使用 silu 激活
        self.act_fn = ACT2FN[config.hidden_act]
        self.aux_loss = torch.tensor(0.0)

    def forward(self, x: torch.Tensor):
        batch_size, seq_len, hidden_dim = x.shape
        identity = x  # 保存原始输入，用于共享专家残差

        # 把所有 token 展平成二维，方便统一做路由
        x_flat = x.view(-1, hidden_dim)

        # Router 输出每个 token 对每个专家的分数，并 softmax 归一化
        scores = F.softmax(self.gate(x_flat), dim=-1)

        # 每个 token 选出 Top-K 个专家
        # topk_weight: [token_count, num_experts_per_tok] 选中专家的权重
        # topk_idx:    [token_count, num_experts_per_tok] 选中专家的编号
        topk_weight, topk_idx = torch.topk(
            scores,
            k=self.config.num_experts_per_tok,
            dim=-1,
            sorted=False
        )

        # 可选：对 Top-K 权重做归一化，使每个 token 的专家权重和为 1
        if self.config.norm_topk_prob:
            topk_weight = topk_weight / (topk_weight.sum(dim=-1, keepdim=True) + 1e-20)

        # 准备输出缓存，遍历每个专家，只处理被路由到的 token
        y = torch.zeros_like(x_flat)
        for i, expert in enumerate(self.experts):
            # mask[b, k] 表示第 b 个 token 的第 k 个 topk 是否选中了专家 i
            mask = (topk_idx == i)

            if mask.any():
                # 找出选中专家 i 的所有 token 的索引
                token_idx = mask.any(dim=-1).nonzero().flatten()
                # 取出这些 token 对应专家 i 的权重，reshape 以便广播
                weight = topk_weight[mask].view(-1, 1)
                # 只对选中的 token 过专家 FFN，并乘以对应权重
                expert_out = expert(x_flat[token_idx]) * weight
                # 把专家输出累加回全局输出 y 的对应位置
                y.index_add_(0, token_idx, expert_out.to(y.dtype))
            elif self.training:
                # 训练时，即使某个专家没被选中，也要让它参与计算图，
                # 否则参数会长期不更新。0 * sum(parameters) 是无实际数值影响但有梯度的操作
                y[0, 0] += 0 * sum(p.sum() for p in expert.parameters())

        y = y.view(batch_size, seq_len, hidden_dim)

        # 加上共享专家的输出（所有 token 都经过）
        for expert in self.shared_experts:
            shared_out = expert(identity)
            y = y + shared_out

        # 计算辅助损失，防止路由崩塌（某些专家始终不被选中）
        if self.training and self.config.router_aux_loss_coef &amp;gt; 0:
            # load[k, e]: 专家 e 作为第 k 个 topk 被选中的平均频率
            load = F.one_hot(topk_idx, self.config.num_experts).float().mean(0)
            self.aux_loss = (
                (load * scores.mean(0)).sum()
                * self.config.num_experts
                * self.config.router_aux_loss_coef
            )
        else:
            self.aux_loss = scores.new_zeros(1).squeeze()

        return y
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;形状变化（&lt;code&gt;num_experts=4, num_experts_per_tok=2&lt;/code&gt;）：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;x                : [2, 128, 512]
x_flat           : [256, 512]

Router:
  gate(x_flat)   : [256, 4]
  scores         : [256, 4]
  topk_weight    : [256, 2]
  topk_idx       : [256, 2]

Experts (稀疏激活):
  每个专家只处理被路由到的 token
  y                : [256, 512]
  view 后          : [2, 128, 512]

Shared Experts:
  identity         : [2, 128, 512]
  shared_out       : [2, 128, 512]
  y = y + shared_out : [2, 128, 512]
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;7.3 为什么要加 Shared Experts？&lt;/h3&gt;
&lt;p&gt;Shared Experts 是所有 token 都会经过的 FFN，相当于保留了 Dense FFN 的&quot;公共知识通道&quot;。这样做有两个好处：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;稳定训练&lt;/strong&gt;：避免所有知识都靠 Router 动态分配，降低路由随机性带来的抖动；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;表达兜底&lt;/strong&gt;：保证每个 token 都能获得一些基础变换，不因为路由选择而丢失信息。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;7.4 辅助损失：防止路由崩塌&lt;/h3&gt;
&lt;p&gt;如果没有约束，Router 可能会把所有 token 都推给少数几个&quot;受欢迎&quot;的专家，其他专家学不到东西，这就是 &lt;strong&gt;路由崩塌（Router Collapse）&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;辅助损失的设计思路是：&lt;strong&gt;让每个专家被均匀使用&lt;/strong&gt;。代码中：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;load = F.one_hot(topk_idx, num_experts).float().mean(0)  # [K, E]
self.aux_loss = (load * scores.mean(0)).sum() * num_experts * router_aux_loss_coef
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它同时考虑了实际选中的频率（&lt;code&gt;load&lt;/code&gt;）和路由分数的均值（&lt;code&gt;scores.mean(0)&lt;/code&gt;），让两者都趋向均匀。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;8. 训练流程：预训练脚本详解&lt;/h2&gt;
&lt;h3&gt;8.1 主循环&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;trainer/train_pretrain.py&lt;/code&gt; 是预训练入口。核心训练循环：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def train_epoch(epoch, loader, iters, start_step=0, wandb=None):
    # 记录当前 epoch 的起始时间，用于估算剩余训练时间
    start_time = time.time()
    # last_step 用于处理 epoch 末尾不足 accumulation_steps 的残余梯度
    last_step = start_step

    # loader 每次返回一个 batch；start_step 用于断点续训时从中间 step 继续计数
    for step, (input_ids, labels) in enumerate(loader, start=start_step + 1):
        # 将输入和标签移动到训练设备，例如 cuda:0 或 cpu
        input_ids = input_ids.to(args.device)
        labels = labels.to(args.device)
        last_step = step

        # 按当前训练进度计算学习率，实现随 step 变化的学习率调度
        lr = get_lr(epoch * iters + step, args.epochs * iters, args.learning_rate)
        for param_group in optimizer.param_groups:
            param_group[&apos;lr&apos;] = lr

        # 在混合精度上下文中做前向计算，GPU 上可减少显存并加速
        with autocast_ctx:
            # 传入 labels 后，模型内部会计算 next-token prediction 的交叉熵 loss
            res = model(input_ids, labels=labels)
            # 总 loss = 语言模型主损失 + MoE 路由辅助损失
            loss = res.loss + res.aux_loss
            # 梯度累积时，每个小 batch 的 loss 要除以累积步数，保持总梯度尺度不变
            loss = loss / args.accumulation_steps

        # GradScaler 在 float16 训练时放大 loss，避免梯度下溢
        scaler.scale(loss).backward()

        # 每 accumulation_steps 个小 batch 才真正更新一次参数
        if step % args.accumulation_steps == 0:
            # 梯度裁剪前先把 scaler 放大的梯度还原
            scaler.unscale_(optimizer)
            # 裁剪梯度范数，防止梯度爆炸
            torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)

            # optimizer.step() 的混合精度版本；若检测到 inf/NaN 梯度会跳过更新
            scaler.step(optimizer)
            # 动态调整 loss scale，供下一轮 backward 使用
            scaler.update()

            # 清空梯度，set_to_none=True 可略省显存
            optimizer.zero_grad(set_to_none=True)

        # 定期打印训练日志，最后一个 step 也强制打印一次
        if step % args.log_interval == 0 or step == iters:
            spend_time = time.time() - start_time
            # loss 前面除过 accumulation_steps，日志展示时乘回来
            current_loss = loss.item() * args.accumulation_steps
            current_aux_loss = res.aux_loss.item() if res.aux_loss is not None else 0.0
            current_logits_loss = current_loss - current_aux_loss
            current_lr = optimizer.param_groups[-1][&apos;lr&apos;]
            # 根据当前平均耗时粗略估算剩余分钟数
            eta_min = spend_time / max(step - start_step, 1) * (iters - step) // 60
            Logger(f&apos;Epoch:[{epoch + 1}/{args.epochs}]({step}/{iters}), loss: {current_loss:.4f}, logits_loss: {current_logits_loss:.4f}, aux_loss: {current_aux_loss:.4f}, lr: {current_lr:.8f}, epoch_time: {eta_min:.1f}min&apos;)
            if wandb:
                wandb.log({&quot;loss&quot;: current_loss, &quot;logits_loss&quot;: current_logits_loss, &quot;aux_loss&quot;: current_aux_loss, &quot;learning_rate&quot;: current_lr, &quot;epoch_time&quot;: eta_min})

        # 定期保存权重和可恢复训练状态；只让主进程保存，避免多卡同时写文件
        if (step % args.save_interval == 0 or step == iters) and is_main_process():
            model.eval()
            moe_suffix = &apos;_moe&apos; if lm_config.use_moe else &apos;&apos;
            ckp = f&apos;{args.save_dir}/{args.save_weight}_{lm_config.hidden_size}{moe_suffix}.pth&apos;
            # DDP 包装后真实模型在 model.module；torch.compile 后可能在 _orig_mod
            raw_model = model.module if isinstance(model, DistributedDataParallel) else model
            raw_model = getattr(raw_model, &apos;_orig_mod&apos;, raw_model)
            state_dict = raw_model.state_dict()

            # 保存半精度权重用于推理/后续加载，减少磁盘占用
            torch.save({k: v.half().cpu() for k, v in state_dict.items()}, ckp)
            # 额外保存 optimizer/scaler/epoch/step，支持断点续训
            lm_checkpoint(lm_config, weight=args.save_weight, model=model, optimizer=optimizer,
                          scaler=scaler, epoch=epoch, step=step, wandb=wandb, save_dir=&apos;../checkpoints&apos;)
            model.train()
            del state_dict

        # 及时释放本轮 batch 的大对象引用，降低显存峰值
        del input_ids, labels, res, loss

    # 如果 epoch 结束时还攒着不足 accumulation_steps 的梯度，也执行一次参数更新
    if last_step &amp;gt; start_step and last_step % args.accumulation_steps != 0:
        scaler.unscale_(optimizer)
        torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
        scaler.step(optimizer)
        scaler.update()
        optimizer.zero_grad(set_to_none=True)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;8.2 关键训练技巧&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;技巧&lt;/th&gt;
&lt;th&gt;作用&lt;/th&gt;
&lt;th&gt;代码体现&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;混合精度&lt;/td&gt;
&lt;td&gt;加速训练、省显存&lt;/td&gt;
&lt;td&gt;&lt;code&gt;torch.cuda.amp.autocast&lt;/code&gt; + &lt;code&gt;GradScaler&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;梯度累积&lt;/td&gt;
&lt;td&gt;模拟大 batch&lt;/td&gt;
&lt;td&gt;&lt;code&gt;loss / accumulation_steps&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;梯度裁剪&lt;/td&gt;
&lt;td&gt;防止梯度爆炸&lt;/td&gt;
&lt;td&gt;&lt;code&gt;clip_grad_norm_(..., grad_clip=1.0)&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;余弦学习率&lt;/td&gt;
&lt;td&gt;训练前期高、后期低&lt;/td&gt;
&lt;td&gt;&lt;code&gt;get_lr(...)&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;断点续训&lt;/td&gt;
&lt;td&gt;从上次 step 恢复&lt;/td&gt;
&lt;td&gt;&lt;code&gt;lm_checkpoint&lt;/code&gt; + &lt;code&gt;SkipBatchSampler&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DDP&lt;/td&gt;
&lt;td&gt;多卡并行&lt;/td&gt;
&lt;td&gt;&lt;code&gt;DistributedDataParallel&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;8.3 学习率调度&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;def get_lr(current_step, total_steps, lr):
    return lr * (0.1 + 0.45 * (1 + math.cos(math.pi * current_step / total_steps)))
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这是一个&lt;strong&gt;带 warm-up 底座的余弦退火&lt;/strong&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;初始学习率约为 &lt;code&gt;lr&lt;/code&gt;（&lt;code&gt;current_step=0&lt;/code&gt; 时，&lt;code&gt;cos(0)=1&lt;/code&gt;，括号内 &lt;code&gt;0.1 + 0.45*2 = 1.0&lt;/code&gt;）；&lt;/li&gt;
&lt;li&gt;结束时约为 &lt;code&gt;0.1 * lr&lt;/code&gt;（&lt;code&gt;cos(π) = -1&lt;/code&gt;，括号内 &lt;code&gt;0.1 + 0&lt;/code&gt;）。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;8.4 保存与恢复&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;trainer/trainer_utils.py&lt;/code&gt; 中的 &lt;code&gt;lm_checkpoint&lt;/code&gt; 同时保存：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;xxx.pth&lt;/code&gt;：半精度模型权重；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;xxx_resume.pth&lt;/code&gt;：模型 + 优化器 + scaler + epoch/step + wandb_id。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这样可以通过 &lt;code&gt;--from_resume 1&lt;/code&gt; 从中断处继续训练。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;9. 推理与评估：把模型跑起来&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;eval.py&lt;/code&gt; 是推理脚本。它支持两种加载方式：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;code&gt;--load_from model&lt;/code&gt;：加载本项目的原生 PyTorch 权重；&lt;/li&gt;
&lt;li&gt;其他路径：按 HuggingFace transformers 格式加载。&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;def print_model_params(model):
    # 统计所有可训练参数，方便确认当前加载的是哪个规模的模型
    total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
    print(f&quot;Model trainable params: {total_params / 1e6:.3f}M&quot;)


def init_model(args):
    # tokenizer 负责文本 &amp;lt;-&amp;gt; token id 的转换；默认从本地 model/ 目录加载
    tokenizer = AutoTokenizer.from_pretrained(args.load_from)

    # 官方逻辑：load_from 包含 &quot;model&quot; 时，认为加载的是本项目的原生 PyTorch 模型
    if &quot;model&quot; in args.load_from:
        # 先按命令行参数创建同结构模型；权重 shape 必须和这些参数一致
        model = SanzeninMindForCausalLM(
            SanzeninMindConfig(
                hidden_size=args.hidden_size,
                num_hidden_layers=args.num_hidden_layers,
                use_moe=bool(args.use_moe),
                inference_rope_scaling=args.inference_rope_scaling,
            )
        )

        # MoE 权重保存时通常会带 _moe 后缀，用来和 dense 模型区分
        moe_suffix = &quot;_moe&quot; if args.use_moe else &quot;&quot;
        ckp = f&quot;./{args.save_dir}/{args.weight}_{args.hidden_size}{moe_suffix}.pth&quot;

        # strict=True 要求权重文件和当前模型结构完全匹配，适合学习时尽早暴露不一致问题
        model.load_state_dict(torch.load(ckp, map_location=args.device), strict=True)
    else:
        # 如果 load_from 不是本地 model/，就按 Hugging Face transformers 格式加载
        model = AutoModelForCausalLM.from_pretrained(
            args.load_from,
            trust_remote_code=True,
        )

    print_model_params(model)

    # 推理阶段切到 eval 模式，关闭 dropout 等训练行为
    model = model.eval().to(args.device)
    # GPU 推理时转半精度节省显存；CPU 上保持 float32 更稳
    if &quot;cuda&quot; in args.device:
        model = model.half()
    return model, tokenizer


def build_inputs(args, tokenizer, conversation, prompt):
    # 预训练权重没有学聊天模板，直接用 BOS + 用户文本做续写
    if &quot;pretrain&quot; in args.weight:
        return tokenizer.bos_token + prompt

    # SFT/Chat 权重通常需要 chat template，把多轮对话渲染成模型训练时见过的格式
    return tokenizer.apply_chat_template(
        conversation,
        tokenize=False,
        add_generation_prompt=True,
        open_thinking=bool(args.open_thinking),
    )
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;9.1 推理时的关键参数&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;参数&lt;/th&gt;
&lt;th&gt;说明&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;--inference_rope_scaling&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;启用 YaRN 长上下文外推&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;--max_new_tokens&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;最多生成多少个新 token&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;--temperature&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;采样温度，越高越随机&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;--top_p&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Nucleus Sampling 阈值&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;--historys&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;保留多少轮对话历史&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;9.2 长文本外推&lt;/h3&gt;
&lt;p&gt;只要在创建配置时开启 &lt;code&gt;inference_rope_scaling=True&lt;/code&gt;，就会启用 YaRN：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;self.rope_scaling = {
    &quot;beta_fast&quot;: 32,
    &quot;beta_slow&quot;: 1,
    &quot;factor&quot;: 16,
    &quot;original_max_position_embeddings&quot;: 2048,
    &quot;attention_factor&quot;: 1.0,
    &quot;type&quot;: &quot;yarn&quot;,
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这意味着：模型虽然只在 2048 长度上训练，但推理时可以外推到 &lt;code&gt;2048 * 16 = 32768&lt;/code&gt; 个位置。&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;向量形状全景图&lt;/h3&gt;
&lt;p&gt;以 &lt;code&gt;batch_size=2, seq_len=128, hidden_size=512, num_heads=8, num_kv_heads=2, head_dim=64&lt;/code&gt; 为例：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;input_ids              [2, 128]
  ↓ embed_tokens
hidden_states          [2, 128, 512]
  ↓ [×8 Transformer Block]
    RMSNorm            [2, 128, 512]  → [2, 128, 512]
    Attention
      q_proj           [2, 128, 512]
      k_proj           [2, 128, 128]
      v_proj           [2, 128, 128]
      view             q[2,128,8,64], k[2,128,2,64], v[2,128,2,64]
      RoPE             形状不变
      repeat_kv + transpose  q[2,8,128,64], k[2,8,192,64], v[2,8,192,64]
      softmax @ v      output [2,8,128,64]
      reshape + o_proj [2, 128, 512]
    残差连接           [2, 128, 512]
    RMSNorm            [2, 128, 512]
    FFN/MoE            [2, 128, 512]
    残差连接           [2, 128, 512]
  ↓ final RMSNorm
hidden_states          [2, 128, 512]
  ↓ lm_head
logits                 [2, 128, 6400]
  ↓ cross_entropy
loss                   scalar
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Neovim 快捷键速查</title><link>https://sanzenin.top/posts/obsidian/neovim-%E5%BF%AB%E6%8D%B7%E9%94%AE/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/neovim-%E5%BF%AB%E6%8D%B7%E9%94%AE/</guid><description>基于 LazyVim + 个人自定义配置。 Leader 键为空格键 。 最后更新：2026-08-10 | 模式 | 按键 | 功能 | |------|------|------| | n | | 编译并运行当前文件（C++ / Python / Go） | | n | rr | 运行 CompetiTest |</description><pubDate>Mon, 10 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Neovim 快捷键速查&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;基于 &lt;strong&gt;LazyVim&lt;/strong&gt; + 个人自定义配置。
Leader 键为空格键 &lt;code&gt;&amp;lt;Space&amp;gt;&lt;/code&gt;。
最后更新：2026-08-10&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h2&gt;一、自定义快捷键（&lt;code&gt;~/.config/nvim/lua/config/keymaps.lua&lt;/code&gt;）&lt;/h2&gt;
&lt;h3&gt;运行与测试&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;F5&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;编译并运行当前文件（C++ / Python / Go）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;rr&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;运行 CompetiTest&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;ra&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;添加 CompetiTest 测试用例&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;re&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;编辑 CompetiTest 测试用例&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;rd&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;删除 CompetiTest 测试用例&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;rt&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换 CompetiTest UI&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;rc&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;接收 CompetiTest 测试用例&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;移动与滚动&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-d&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;半屏向下滚动并居中光标&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-u&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;半屏向上滚动并居中光标&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;下一个搜索结果并居中&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;N&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;上一个搜索结果并居中&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;v&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;J&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;将选区向下移动一行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;v&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;K&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;将选区向上移动一行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;v&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;向左缩进并保持选中&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;v&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;向右缩进并保持选中&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;终端模式&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;t&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;Esc&amp;gt;&amp;lt;Esc&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;退出终端模式&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;二、补全（&lt;code&gt;blink.cmp&lt;/code&gt;）&lt;/h2&gt;
&lt;p&gt;当前使用 &lt;code&gt;super-tab&lt;/code&gt; preset。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;Tab&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;选择下一个补全项；在 snippet 中跳转到下一占位符&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;S-Tab&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;选择上一个补全项；在 snippet 中跳转到上一占位符&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;CR&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;确认并插入当前补全项&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-e&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;取消补全菜单&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-space&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;手动触发补全&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-n&amp;gt;&lt;/code&gt; / &lt;code&gt;&amp;lt;C-p&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;下 / 上一个候选&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-f&amp;gt;&lt;/code&gt; / &lt;code&gt;&amp;lt;C-b&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;向下 / 向上滚动文档&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-k&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;显示函数签名帮助&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-s&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;显示函数签名帮助（LSP）&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;三、文件与搜索&lt;/h2&gt;
&lt;h3&gt;Snacks Picker / Telescope（LazyVim 默认）&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;&amp;lt;Space&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;查找文件&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;/&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;全局搜索（live grep）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;:&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;命令历史&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;,&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;.&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换最近文件&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;ff&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;查找文件&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;fg&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;全局搜索&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;fb&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;查找 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;fh&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;查找帮助&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;fr&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;查找最近文件&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;fk&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;查找 keymaps&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;uC&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;查找并切换 colorscheme&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;文件树（Neo-tree）&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;e&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开/关闭文件树（当前文件定位）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;E&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开文件树并定位到当前文件&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;Buffer&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;bd&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;删除当前 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;bD&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;强制删除当前 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;bp&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;固定当前 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;bo&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;关闭其他 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;[b&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;上一个 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;]b&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;下一个 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;S-h&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换到上一个 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;S-l&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换到下一个 buffer&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;四、LSP（语言服务器）&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;gd&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;跳转到定义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;gD&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;跳转到声明&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;gr&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;显示引用（Telescope）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;gI&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;跳转到实现&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;gy&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;跳转到类型定义&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;K&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;显示悬停文档&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;ca&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;代码操作（code action）&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;cA&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;范围代码操作&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;cr&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;重命名&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;cf&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;格式化&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;cd&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;显示行内诊断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;[d&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;上一个诊断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;]d&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;下一个诊断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;[D&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;第一个诊断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;]D&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;最后一个诊断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-w&amp;gt;d&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;显示光标下诊断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-k&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;显示签名帮助&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;五、代码编辑&lt;/h2&gt;
&lt;h3&gt;注释（mini.comment / nvim-ts-context-commentstring）&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;gcc&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换当前行注释&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;gc&lt;/code&gt; + motion&lt;/td&gt;
&lt;td&gt;切换指定范围注释&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;v&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;gc&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换选区注释&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;Surround / Text Objects&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;ys&lt;/code&gt; + motion + char&lt;/td&gt;
&lt;td&gt;添加包围符号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;ds&lt;/code&gt; + char&lt;/td&gt;
&lt;td&gt;删除包围符号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;cs&lt;/code&gt; + old + new&lt;/td&gt;
&lt;td&gt;修改包围符号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;v&lt;/code&gt; / &lt;code&gt;x&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;an&lt;/code&gt; / &lt;code&gt;in&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;选择 treesitter 父/子节点&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;o&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;an&lt;/code&gt; / &lt;code&gt;in&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;treesitter 节点 textobject&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;Flash（快速跳转）&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt; / &lt;code&gt;x&lt;/code&gt; / &lt;code&gt;o&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;s&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;触发 flash 跳转&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt; / &lt;code&gt;x&lt;/code&gt; / &lt;code&gt;o&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;S&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;触发 treesitter 选择&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;撤销树（undotree）&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;uo&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开 undo 树&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;六、窗口与终端&lt;/h2&gt;
&lt;h3&gt;窗口分屏&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;w&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;窗口相关前缀&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;ww&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换到另一个窗口&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;wd&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;关闭当前窗口&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;w-&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;水平分割&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;w|&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;垂直分割&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-h&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;移动到左边窗口&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-j&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;移动到下方窗口&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-k&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;移动到上方窗口&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-l&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;移动到右边窗口&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-Up&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;增加窗口高度&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-Down&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;减小窗口高度&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-Left&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;减小窗口宽度&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-Right&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;增加窗口宽度&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;终端&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;ft&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开浮动终端&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;fT&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开底部终端&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;t&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;Esc&amp;gt;&amp;lt;Esc&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;退出终端模式（自定义）&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;七、Git&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;gg&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开 LazyGit&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;gB&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开 Git blame&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;gh&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Git hunk 前缀&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;]h&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;下一个 hunk&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;[h&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;上一个 hunk&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;八、LazyVim 自身&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;l&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;LazyVim 前缀&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;ll&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开 Lazy 插件管理器&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;lc&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开 LazyVim Changelog&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;u&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;UI 相关前缀&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;uc&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换行号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;ud&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换诊断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;ui&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换缩进线&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;un&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;关闭所有通知&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;up&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换 paste 模式&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;us&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换拼写检查&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;uw&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换换行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;n&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;leader&amp;gt;uz&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;切换 Zen 模式&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;九、常用 Vim 基础操作&lt;/h2&gt;
&lt;h3&gt;移动&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;h&lt;/code&gt; &lt;code&gt;j&lt;/code&gt; &lt;code&gt;k&lt;/code&gt; &lt;code&gt;l&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;左 / 下 / 上 / 右&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;w&lt;/code&gt; / &lt;code&gt;b&lt;/code&gt; / &lt;code&gt;e&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;下一个词首 / 上一个词首 / 下一个词尾&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;0&lt;/code&gt; / &lt;code&gt;$&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;行首 / 行尾&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;gg&lt;/code&gt; / &lt;code&gt;G&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;文件开头 / 文件末尾&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;:{n}&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;跳到第 n 行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;%&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;匹配括号&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;*&lt;/code&gt; / &lt;code&gt;#&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;搜索当前单词下 / 上一个&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;编辑&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;i&lt;/code&gt; / &lt;code&gt;a&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;光标前 / 后插入&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;I&lt;/code&gt; / &lt;code&gt;A&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;行首 / 行尾插入&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;o&lt;/code&gt; / &lt;code&gt;O&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;下方 / 上方插入新行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;dd&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;删除一行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;yy&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;复制一行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;p&lt;/code&gt; / &lt;code&gt;P&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;在光标后 / 前粘贴&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;u&lt;/code&gt; / &lt;code&gt;&amp;lt;C-r&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;撤销 / 重做&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;x&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;删除光标下字符&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;r&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;替换单个字符&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;cw&lt;/code&gt; / &lt;code&gt;ciw&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;修改单词&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;dap&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;删除整个段落&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;di&quot;&lt;/code&gt; / &lt;code&gt;di(&lt;/code&gt; / &lt;code&gt;di{&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;删除引号 / 圆括号 / 花括号内内容&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3&gt;可视模式&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;按键&lt;/th&gt;
&lt;th&gt;功能&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;v&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;字符选择&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;V&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;行选择&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;&amp;lt;C-v&amp;gt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;块选择&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;&amp;gt;&lt;/code&gt; / &lt;code&gt;&amp;lt;&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;缩进 / 反缩进&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;y&lt;/code&gt; / &lt;code&gt;d&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;复制 / 删除选区&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;hr /&gt;
&lt;h2&gt;配置文件位置&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;文件&lt;/th&gt;
&lt;th&gt;作用&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;~/.config/nvim/init.lua&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;入口文件&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;~/.config/nvim/lua/config/keymaps.lua&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;自定义快捷键&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;~/.config/nvim/lua/config/options.lua&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;编辑器选项&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;~/.config/nvim/lua/config/autocmds.lua&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;自动命令&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;~/.config/nvim/lua/plugins/&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;插件配置目录&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;~/.config/nvim/lazyvim.json&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;LazyVim extras 配置&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
</content:encoded></item><item><title>Go Channel 与 select</title><link>https://sanzenin.top/posts/obsidian/go-channel-%E4%B8%8E-select/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/go-channel-%E4%B8%8E-select/</guid><description>goroutine 让代码并发跑起来，channel 负责让 goroutine 之间说话。 创建一个 channel： 这个 ch 只能传 string。 &lt;- 是 channel 的收发语法。 发送： 意思是把 &quot;hello&quot; 放进 ch。 接收： 意思是从 ch 里取一个值，赋给 msg。 只接收、不关心值： 这</description><pubDate>Sat, 01 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Go Channel 与 select&lt;/h1&gt;
&lt;p&gt;goroutine 让代码并发跑起来，channel 负责让 goroutine 之间说话。&lt;/p&gt;
&lt;p&gt;创建一个 channel：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ch := make(chan string)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个 &lt;code&gt;ch&lt;/code&gt; 只能传 &lt;code&gt;string&lt;/code&gt;。&lt;/p&gt;
&lt;h2&gt;&lt;code&gt;&amp;lt;-&lt;/code&gt; 是什么&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;&amp;lt;-&lt;/code&gt; 是 channel 的收发语法。&lt;/p&gt;
&lt;p&gt;发送：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ch &amp;lt;- &quot;hello&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思是把 &lt;code&gt;&quot;hello&quot;&lt;/code&gt; 放进 &lt;code&gt;ch&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;接收：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;msg := &amp;lt;-ch
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;意思是从 &lt;code&gt;ch&lt;/code&gt; 里取一个值，赋给 &lt;code&gt;msg&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;只接收、不关心值：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;-ch
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这种经常用来等一个信号。&lt;/p&gt;
&lt;p&gt;比如：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;case &amp;lt;-ctx.Done():
	return
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它不是为了拿到什么业务数据，只是等 context 被取消。&lt;/p&gt;
&lt;h2&gt;无缓冲 channel&lt;/h2&gt;
&lt;p&gt;默认创建的是无缓冲 channel：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ch := make(chan string)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;无缓冲 channel 要求发送和接收同时出现。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	ch := make(chan string)

	go func() {
		ch &amp;lt;- &quot;hello&quot;
	}()

	msg := &amp;lt;-ch
	fmt.Println(msg)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;后台 goroutine 发送，main goroutine 接收，所以能跑。&lt;/p&gt;
&lt;p&gt;如果只有发送，没有接收：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	ch := make(chan string)
	ch &amp;lt;- &quot;hello&quot;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;会死锁。&lt;/p&gt;
&lt;p&gt;如果只有接收，没有发送：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	ch := make(chan string)
	msg := &amp;lt;-ch
	fmt.Println(msg)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也会死锁。&lt;/p&gt;
&lt;p&gt;无缓冲 channel 很像一次当面交接：你给的时候，必须有人接。&lt;/p&gt;
&lt;h2&gt;有缓冲 channel&lt;/h2&gt;
&lt;p&gt;有缓冲 channel 创建时带容量：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ch := make(chan string, 2)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它可以先放两个值：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ch &amp;lt;- &quot;A&quot;
ch &amp;lt;- &quot;B&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第三个值会阻塞，除非有人先取走一个：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ch &amp;lt;- &quot;C&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;有缓冲 channel 像一个小队列。它能让发送方和接收方的节奏稍微错开。&lt;/p&gt;
&lt;p&gt;比如流式输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;events := make(chan StreamEvent, 64)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;模型返回事件可能很快，UI 渲染可能慢一点。给 64 个缓冲，生产者不用每发一个事件都立刻等消费者。&lt;/p&gt;
&lt;p&gt;但缓冲不是无限的。消费者一直不读，缓冲满了以后，发送方照样会阻塞。&lt;/p&gt;
&lt;h2&gt;用 chan bool 做一把简单的锁&lt;/h2&gt;
&lt;p&gt;channel 也可以拿来做“锁”的效果。&lt;/p&gt;
&lt;p&gt;比如用容量为 1 的 &lt;code&gt;chan bool&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock := make(chan bool, 1)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;加锁：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock &amp;lt;- true
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;解锁：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;-lock
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;完整例子：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	lock := make(chan bool, 1)
	count := 0

	var wg sync.WaitGroup
	for i := 0; i &amp;lt; 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()

			lock &amp;lt;- true
			count++
			&amp;lt;-lock
		}()
	}

	wg.Wait()
	fmt.Println(count)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么它像锁？&lt;/p&gt;
&lt;p&gt;因为 &lt;code&gt;lock&lt;/code&gt; 容量只有 1。第一个 goroutine 写入成功后，其他 goroutine 再执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;lock &amp;lt;- true
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;就会阻塞。只有前一个 goroutine 执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;-lock
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;把位置让出来，下一个 goroutine 才能进去。&lt;/p&gt;
&lt;p&gt;实际项目里，普通互斥优先用 &lt;code&gt;sync.Mutex&lt;/code&gt;，表达更直接：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;var mu sync.Mutex
mu.Lock()
defer mu.Unlock()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;chan bool&lt;/code&gt; 这种写法适合理解 channel 的阻塞机制，也适合做简单的并发限制。&lt;/p&gt;
&lt;h2&gt;close&lt;/h2&gt;
&lt;p&gt;发送方可以关闭 channel：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;close(ch)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;关闭不是删除 channel，而是告诉接收方：后面不会再有新数据了。&lt;/p&gt;
&lt;p&gt;接收时可以拿到两个值：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;v, ok := &amp;lt;-ch
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;ok == false&lt;/code&gt; 表示 channel 已经关闭，并且没有剩余数据。&lt;/p&gt;
&lt;p&gt;更常用的是 &lt;code&gt;for range&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;for msg := range ch {
	fmt.Println(msg)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;当 channel 关闭，并且里面的数据都读完，循环会结束。&lt;/p&gt;
&lt;p&gt;发送方关闭，接收方不要关。&lt;/p&gt;
&lt;p&gt;原因也简单：发送方才知道自己还会不会继续发。&lt;/p&gt;
&lt;p&gt;重复关闭 channel 会 panic：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;close(ch)
close(ch) // panic
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;单向 channel&lt;/h2&gt;
&lt;p&gt;函数参数可以限制 channel 方向。&lt;/p&gt;
&lt;p&gt;只发送：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func producer(out chan&amp;lt;- int) {
	out &amp;lt;- 1
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;只接收：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func consumer(in &amp;lt;-chan int) {
	v := &amp;lt;-in
	fmt.Println(v)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这不是必须写，但写了以后意图更清楚。编译器也能帮你挡住一部分误用。&lt;/p&gt;
&lt;p&gt;比如 &lt;code&gt;consumer&lt;/code&gt; 里不能发送：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;in &amp;lt;- 1 // 编译不过
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;select&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;select&lt;/code&gt; 用来同时等多个 channel。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;select {
case msg := &amp;lt;-ch:
	fmt.Println(&quot;message:&quot;, msg)
case &amp;lt;-time.After(time.Second):
	fmt.Println(&quot;timeout&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;哪个 case 先准备好，就执行哪个。&lt;/p&gt;
&lt;p&gt;如果都没准备好，&lt;code&gt;select&lt;/code&gt; 会阻塞。&lt;/p&gt;
&lt;p&gt;如果多个 case 同时准备好，Go 会随机选一个。&lt;/p&gt;
&lt;h2&gt;default&lt;/h2&gt;
&lt;p&gt;加了 &lt;code&gt;default&lt;/code&gt;，&lt;code&gt;select&lt;/code&gt; 就不会阻塞。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;select {
case msg := &amp;lt;-ch:
	fmt.Println(msg)
default:
	fmt.Println(&quot;no message&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果 &lt;code&gt;ch&lt;/code&gt; 没数据，直接走 &lt;code&gt;default&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;这个适合“试一下”的场景。不要为了看起来完整就乱加 default。很多时候，我们就是希望 goroutine 等在那里。&lt;/p&gt;
&lt;h2&gt;context.Done&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;context.Context&lt;/code&gt; 常用来通知取消。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ctx, cancel := context.WithCancel(context.Background())
defer cancel()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;调用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cancel()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;之后，&lt;code&gt;ctx.Done()&lt;/code&gt; 会关闭。&lt;/p&gt;
&lt;p&gt;所以可以这么写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;select {
case &amp;lt;-ctx.Done():
	return ctx.Err()
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;ctx.Done()&lt;/code&gt; 本质上也是一个 channel。我们从里面接收，不是为了拿数据，而是为了知道“该停了”。&lt;/p&gt;
&lt;h2&gt;用 channel 改写等待&lt;/h2&gt;
&lt;p&gt;假设有一个很慢的函数：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func slow() string {
	time.Sleep(2 * time.Second)
	return &quot;done&quot;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;直接调用会卡住：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;result := slow()
fmt.Println(result)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果希望同时支持超时，可以把结果送进 channel：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ch := make(chan string, 1)

go func() {
	ch &amp;lt;- slow()
}()

select {
case result := &amp;lt;-ch:
	fmt.Println(result)
case &amp;lt;-time.After(time.Second):
	fmt.Println(&quot;timeout&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里后台 goroutine 等 &lt;code&gt;slow()&lt;/code&gt;，主 goroutine 等两个信号：结果或超时。&lt;/p&gt;
&lt;h2&gt;SSE 流式读取里的用法&lt;/h2&gt;
&lt;p&gt;LLM 流式响应里，经常会有类似：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stream.Next()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它的意思是：等服务端发来下一条事件。&lt;/p&gt;
&lt;p&gt;问题在于，它可能阻塞很久。服务端一直不发，或者连接静默挂住，它就不返回。&lt;/p&gt;
&lt;p&gt;如果直接写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;for stream.Next() {
	// 处理事件
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;一旦 &lt;code&gt;stream.Next()&lt;/code&gt; 卡住，当前 goroutine 就没机会处理取消和超时。&lt;/p&gt;
&lt;p&gt;所以可以这样拆：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;readNext := func() {
	nextCh &amp;lt;- sseResult{
		hasNext: stream.Next(),
	}
}

go readNext()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;后台 goroutine 负责卡在 &lt;code&gt;stream.Next()&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;主 goroutine 用 &lt;code&gt;select&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;select {
case &amp;lt;-ctx.Done():
	return ctx.Err()
case &amp;lt;-idle.C:
	return errors.New(&quot;stream timeout&quot;)
case res := &amp;lt;-nextCh:
	_ = res
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样主 goroutine 同时等三件事：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;用户取消&lt;/li&gt;
&lt;li&gt;空闲超时&lt;/li&gt;
&lt;li&gt;下一条事件到了&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;收到一次 &lt;code&gt;nextCh&lt;/code&gt; 的结果后，再启动下一次读取：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;go readNext()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意不是一次开很多个 &lt;code&gt;readNext&lt;/code&gt;。同一个 stream 通常应该一个一个读，否则顺序会乱，SDK 内部也未必支持并发读。&lt;/p&gt;
&lt;h2&gt;记法&lt;/h2&gt;
&lt;p&gt;channel 代码先问四个问题：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;谁发？&lt;/li&gt;
&lt;li&gt;谁收？&lt;/li&gt;
&lt;li&gt;谁关？&lt;/li&gt;
&lt;li&gt;满了或空了会不会卡住？&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;code&gt;select&lt;/code&gt; 代码再问两个问题：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;我是不是要同时等多个信号？&lt;/li&gt;
&lt;li&gt;要不要支持取消或超时？&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;把这几个问题想清楚，channel 就不会只是背语法了。&lt;/p&gt;
</content:encoded></item><item><title>Go 并发与 goroutine</title><link>https://sanzenin.top/posts/obsidian/go%E5%B9%B6%E5%8F%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/go%E5%B9%B6%E5%8F%91/</guid><description>Go 里启动并发任务很轻： 这行代码表示：新开一个 goroutine 去跑 work()，当前函数继续往下走。 这两个词很容易混。 并发是：一段时间内，多个任务都在推进。 并行是：同一时刻，多个任务真的同时跑。 单核 CPU 也可以并发。它可以先跑一点任务 A，再跑一点任务 B，来回切换。 多核 CPU 才能并行。任</description><pubDate>Sat, 01 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Go 并发与 goroutine&lt;/h1&gt;
&lt;p&gt;Go 里启动并发任务很轻：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;go work()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这行代码表示：新开一个 goroutine 去跑 &lt;code&gt;work()&lt;/code&gt;，当前函数继续往下走。&lt;/p&gt;
&lt;h2&gt;并发和并行&lt;/h2&gt;
&lt;p&gt;这两个词很容易混。&lt;/p&gt;
&lt;p&gt;并发是：一段时间内，多个任务都在推进。&lt;/p&gt;
&lt;p&gt;并行是：同一时刻，多个任务真的同时跑。&lt;/p&gt;
&lt;p&gt;单核 CPU 也可以并发。它可以先跑一点任务 A，再跑一点任务 B，来回切换。&lt;/p&gt;
&lt;p&gt;多核 CPU 才能并行。任务 A 在一个核心上跑，任务 B 在另一个核心上跑。&lt;/p&gt;
&lt;p&gt;Go 代码里写 goroutine，表达的是并发。至于最后有没有并行，要看机器核心数、Go runtime 调度、任务是否阻塞等因素。&lt;/p&gt;
&lt;h2&gt;goroutine 和线程&lt;/h2&gt;
&lt;p&gt;可以先粗略这么理解：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;线程：操作系统调度，创建和切换成本更高
goroutine：Go runtime 调度，创建和切换成本更低
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;goroutine 不是系统线程本身。Go runtime 会把很多 goroutine 安排到少量系统线程上执行。&lt;/p&gt;
&lt;p&gt;所以你可以比较大胆地开 goroutine：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;for i := 0; i &amp;lt; 1000; i++ {
	go func(id int) {
		fmt.Println(id)
	}(i)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这不是说 goroutine 可以无限开。它也占内存，也会增加调度成本。只是相比系统线程，它轻很多。&lt;/p&gt;
&lt;h2&gt;普通调用和 go 调用&lt;/h2&gt;
&lt;p&gt;普通函数调用会等待函数执行完：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	work()
	fmt.Println(&quot;done&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;work()&lt;/code&gt; 不结束，&lt;code&gt;done&lt;/code&gt; 不会打印。&lt;/p&gt;
&lt;p&gt;加上 &lt;code&gt;go&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	go work()
	fmt.Println(&quot;done&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;main&lt;/code&gt; 不等 &lt;code&gt;work()&lt;/code&gt;，它会继续往下执行。&lt;/p&gt;
&lt;p&gt;所以这类代码不能假设输出顺序。多个 goroutine 同时跑时，谁先执行、谁后执行，都不稳定。&lt;/p&gt;
&lt;h2&gt;main 结束，程序就结束&lt;/h2&gt;
&lt;p&gt;很多新手第一次写 goroutine 会遇到这个问题：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	go fmt.Println(&quot;hello&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可能什么都不输出。&lt;/p&gt;
&lt;p&gt;原因是 &lt;code&gt;main&lt;/code&gt; 函数结束后，整个程序就退出了。后台 goroutine 没有“自动保活”的待遇。&lt;/p&gt;
&lt;p&gt;如果要等它执行完，需要同步。&lt;/p&gt;
&lt;h2&gt;WaitGroup&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;sync.WaitGroup&lt;/code&gt; 用来等待一组 goroutine 结束。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	var wg sync.WaitGroup

	wg.Add(1)
	go func() {
		defer wg.Done()
		fmt.Println(&quot;hello&quot;)
	}()

	wg.Wait()
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这三个方法经常一起出现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;wg.Add(1)  // 多了一个任务
wg.Done()  // 这个任务完成了
wg.Wait()  // 等所有任务完成
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;多个任务：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	var wg sync.WaitGroup

	for i := 1; i &amp;lt;= 3; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			fmt.Println(&quot;worker&quot;, id)
		}(i)
	}

	wg.Wait()
	fmt.Println(&quot;all done&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意这里把 &lt;code&gt;i&lt;/code&gt; 作为参数传进匿名函数：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;go func(id int) {
	// ...
}(i)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样每个 goroutine 拿到的是当次循环的值，代码也更清楚。&lt;/p&gt;
&lt;h2&gt;限制最大并行数&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;WaitGroup&lt;/code&gt; 只能等 goroutine 结束，它本身不能限制同时跑多少个。&lt;/p&gt;
&lt;p&gt;如果想“最多同时跑 3 个任务”，常见写法是 &lt;code&gt;WaitGroup&lt;/code&gt; 配合带缓冲 channel。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	var wg sync.WaitGroup
	limit := make(chan bool, 3)

	for i := 1; i &amp;lt;= 10; i++ {
		wg.Add(1)

		go func(id int) {
			defer wg.Done()

			limit &amp;lt;- true
			defer func() {
				&amp;lt;-limit
			}()

			fmt.Println(&quot;start&quot;, id)
			time.Sleep(time.Second)
			fmt.Println(&quot;done&quot;, id)
		}(i)
	}

	wg.Wait()
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;limit&lt;/code&gt; 的容量是 3，所以最多只有 3 个 goroutine 能成功写入：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;limit &amp;lt;- true
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;第 4 个会卡住，直到前面某个任务执行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;-limit
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;腾出一个位置。&lt;/p&gt;
&lt;p&gt;这里 &lt;code&gt;WaitGroup&lt;/code&gt; 负责等所有任务结束，&lt;code&gt;limit&lt;/code&gt; 负责控制同时运行的数量。两个东西分工不同。&lt;/p&gt;
&lt;h2&gt;goroutine 什么时候阻塞&lt;/h2&gt;
&lt;p&gt;goroutine 跑到需要等待的地方，就会阻塞。&lt;/p&gt;
&lt;p&gt;常见阻塞点：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;从 channel 接收，但没人发&lt;/li&gt;
&lt;li&gt;往无缓冲 channel 发送，但没人收&lt;/li&gt;
&lt;li&gt;往满的有缓冲 channel 发送&lt;/li&gt;
&lt;li&gt;从空的有缓冲 channel 接收&lt;/li&gt;
&lt;li&gt;&lt;code&gt;select&lt;/code&gt; 的所有 case 都没准备好&lt;/li&gt;
&lt;li&gt;网络读取&lt;/li&gt;
&lt;li&gt;文件读取&lt;/li&gt;
&lt;li&gt;数据库查询&lt;/li&gt;
&lt;li&gt;&lt;code&gt;time.Sleep&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;例子：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	ch := make(chan string)
	msg := &amp;lt;-ch
	fmt.Println(msg)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里会一直等，因为没人往 &lt;code&gt;ch&lt;/code&gt; 里发数据。&lt;/p&gt;
&lt;p&gt;再看网络流式读取：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stream.Next()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它是在等服务端发下一条数据。服务端迟迟不发，或者连接半死不活，这个调用就可能卡住。&lt;/p&gt;
&lt;p&gt;阻塞的是当前 goroutine，不一定是整个程序。只要别的 goroutine 还在跑，程序就还能处理别的事。&lt;/p&gt;
&lt;h2&gt;goroutine 和共享变量&lt;/h2&gt;
&lt;p&gt;并发代码里最容易出问题的是共享变量。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;count := 0

for i := 0; i &amp;lt; 1000; i++ {
	go func() {
		count++
	}()
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这段代码有数据竞争。多个 goroutine 同时改 &lt;code&gt;count&lt;/code&gt;，结果不可靠。&lt;/p&gt;
&lt;p&gt;可以用锁：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;var mu sync.Mutex
count := 0

for i := 0; i &amp;lt; 1000; i++ {
	go func() {
		mu.Lock()
		defer mu.Unlock()
		count++
	}()
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;也可以用 channel，把修改集中到一个 goroutine 里。具体看 &lt;a href=&quot;/posts/obsidian/go-channel-%E4%B8%8E-select/&quot;&gt;Go Channel 与 select&lt;/a&gt;。&lt;/p&gt;
&lt;h2&gt;goroutine 里的 panic&lt;/h2&gt;
&lt;p&gt;goroutine 里 panic，如果这个 goroutine 自己没有 recover，程序会崩。&lt;/p&gt;
&lt;p&gt;外层 goroutine 捕不到它。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;go func() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println(&quot;recover:&quot;, r)
		}
	}()

	work()
}()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;写后台任务时，可以在 goroutine 的入口放一个 recover。这样至少能记录错误，不至于整个程序直接退出。&lt;/p&gt;
&lt;h2&gt;放到 code agent 里看&lt;/h2&gt;
&lt;p&gt;一个 code agent 调模型时，经常要处理流式输出。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;stream.Next()&lt;/code&gt; 可能阻塞，所以可以让后台 goroutine 去等：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;readNext := func() {
	nextCh &amp;lt;- stream.Next()
}

go readNext()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;主 goroutine 不直接卡在 &lt;code&gt;stream.Next()&lt;/code&gt;，它还可以同时处理取消和超时。&lt;/p&gt;
&lt;p&gt;这就是 goroutine 在这种场景里的用法：把可能等待很久的工作放到后台，主流程保留控制权。&lt;/p&gt;
&lt;h2&gt;记法&lt;/h2&gt;
&lt;p&gt;启动 goroutine 很容易，难的是后面几个问题：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;它什么时候结束？&lt;/li&gt;
&lt;li&gt;main 要不要等它？&lt;/li&gt;
&lt;li&gt;它阻塞了怎么办？&lt;/li&gt;
&lt;li&gt;它 panic 了谁处理？&lt;/li&gt;
&lt;li&gt;它和别的 goroutine 怎么传数据？&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这些想清楚，并发代码就不会乱成一团。&lt;/p&gt;
</content:encoded></item><item><title>Go panic 和 recover</title><link>https://sanzenin.top/posts/obsidian/panic-recover/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/panic-recover/</guid><description>Go 平时处理错误主要用 error，不是用 panic。 比如文件不存在、请求失败、参数不合法，这些都应该返回错误： panic 更像是程序说：“这个状态我没法继续了。” 手动触发 panic： 程序会停止当前的正常执行流程，然后打印调用栈。 常见 panic： - 切片越界 - 空指针 - 类型断言失败 - 重复关</description><pubDate>Sat, 01 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Go panic 和 recover&lt;/h1&gt;
&lt;p&gt;Go 平时处理错误主要用 &lt;code&gt;error&lt;/code&gt;，不是用 &lt;code&gt;panic&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;比如文件不存在、请求失败、参数不合法，这些都应该返回错误：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func loadConfig(path string) error {
	if path == &quot;&quot; {
		return errors.New(&quot;empty path&quot;)
	}
	return nil
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;panic&lt;/code&gt; 更像是程序说：“这个状态我没法继续了。”&lt;/p&gt;
&lt;h2&gt;panic 会发生什么&lt;/h2&gt;
&lt;p&gt;手动触发 panic：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	panic(&quot;boom&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;程序会停止当前的正常执行流程，然后打印调用栈。&lt;/p&gt;
&lt;p&gt;常见 panic：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;切片越界&lt;/li&gt;
&lt;li&gt;空指针&lt;/li&gt;
&lt;li&gt;类型断言失败&lt;/li&gt;
&lt;li&gt;重复关闭 channel&lt;/li&gt;
&lt;li&gt;手动 &lt;code&gt;panic&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;例子：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;nums := []int{1, 2, 3}
fmt.Println(nums[10])
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;下标越界，程序会 panic。&lt;/p&gt;
&lt;h2&gt;panic 时 defer 仍然会执行&lt;/h2&gt;
&lt;p&gt;这一点很重要。panic 发生后，当前函数里已经登记的 defer 会继续执行。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	defer fmt.Println(&quot;cleanup&quot;)
	panic(&quot;boom&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;输出里会先看到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;cleanup
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后程序再崩。&lt;/p&gt;
&lt;p&gt;这也是为什么释放资源适合用 defer。就算中途 panic，清理代码仍然有机会跑。&lt;/p&gt;
&lt;p&gt;panic 会沿着调用栈往上传：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func a() {
	defer fmt.Println(&quot;defer a&quot;)
	b()
}

func b() {
	defer fmt.Println(&quot;defer b&quot;)
	panic(&quot;boom&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;调用 &lt;code&gt;a()&lt;/code&gt; 后，会先执行 &lt;code&gt;b&lt;/code&gt; 的 defer，再执行 &lt;code&gt;a&lt;/code&gt; 的 defer。一路没人处理，程序最后退出。&lt;/p&gt;
&lt;h2&gt;recover 怎么用&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;recover&lt;/code&gt; 可以把 panic 接住，让程序恢复。&lt;/p&gt;
&lt;p&gt;但它必须写在 defer 函数里才有效：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println(&quot;recovered:&quot;, r)
		}
	}()

	panic(&quot;boom&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;recovered: boom
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样程序不会继续崩。&lt;/p&gt;
&lt;p&gt;下面这种没用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	recover()
	panic(&quot;boom&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为调用 &lt;code&gt;recover()&lt;/code&gt; 时，还没有正在处理的 panic。&lt;/p&gt;
&lt;p&gt;还有一个点容易漏：&lt;code&gt;recover&lt;/code&gt; 不只接当前函数里直接写的 &lt;code&gt;panic&lt;/code&gt;。只要 panic 是在这个 defer 登记之后、同一个 goroutine 的调用链里发生的，它也能接住。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println(&quot;recovered:&quot;, r)
		}
	}()

	run()
}

func run() {
	step1()
}

func step1() {
	panic(&quot;boom in step1&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里 &lt;code&gt;panic&lt;/code&gt; 是在 &lt;code&gt;step1()&lt;/code&gt; 里发生的，但调用链是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;main -&amp;gt; run -&amp;gt; step1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;main&lt;/code&gt; 里提前登记好的 defer 仍然会在 panic 往上传的时候执行，所以能 recover 到这个 panic。&lt;/p&gt;
&lt;h2&gt;recover 放在哪里合适&lt;/h2&gt;
&lt;p&gt;不要在普通业务逻辑里到处 recover。那样很容易把 bug 吞掉，最后只剩下一堆“不知道为什么不对”的状态。&lt;/p&gt;
&lt;p&gt;比较合适的位置是边界：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;HTTP 请求入口&lt;/li&gt;
&lt;li&gt;goroutine 启动处&lt;/li&gt;
&lt;li&gt;命令行程序最外层&lt;/li&gt;
&lt;li&gt;框架调用用户代码的地方&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;比如 HTTP 中间件：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func recovery(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if v := recover(); v != nil {
				http.Error(w, &quot;internal server error&quot;, 500)
			}
		}()

		next.ServeHTTP(w, r)
	})
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;它不是鼓励里面的业务随便 panic，而是防止一个请求把整个服务进程带崩。&lt;/p&gt;
&lt;h2&gt;goroutine 里的 panic&lt;/h2&gt;
&lt;p&gt;goroutine 里的 panic，要在同一个 goroutine 里 recover。&lt;/p&gt;
&lt;p&gt;外层捕不到：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println(&quot;main recover:&quot;, r)
		}
	}()

	go func() {
		panic(&quot;boom&quot;)
	}()

	time.Sleep(time.Second)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;main 里的 recover 不会接住子 goroutine 的 panic。&lt;/p&gt;
&lt;p&gt;应该这样：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;go func() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println(&quot;worker recover:&quot;, r)
		}
	}()

	panic(&quot;boom&quot;)
}()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;写后台任务、任务池、agent 工具执行器时，这一点很实用。只要你启动了 goroutine，就要想一下：它里面如果 panic，谁负责兜住。&lt;/p&gt;
&lt;h2&gt;什么时候用 panic&lt;/h2&gt;
&lt;p&gt;适合 panic：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;初始化时配置缺失，程序无法启动&lt;/li&gt;
&lt;li&gt;代码走到了理论上不该出现的分支&lt;/li&gt;
&lt;li&gt;内部状态被破坏，继续跑只会更乱&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;不适合 panic：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;用户输入错了&lt;/li&gt;
&lt;li&gt;文件不存在&lt;/li&gt;
&lt;li&gt;网络失败&lt;/li&gt;
&lt;li&gt;模型接口返回错误&lt;/li&gt;
&lt;li&gt;JSON 解析失败&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这些更适合返回 &lt;code&gt;error&lt;/code&gt;，交给调用方决定怎么处理。&lt;/p&gt;
&lt;h2&gt;记法&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;panic&lt;/code&gt; 是异常退出。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;defer&lt;/code&gt; 会在 panic 展开时执行。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;recover&lt;/code&gt; 只能在 defer 函数里接住 panic。&lt;/p&gt;
&lt;p&gt;goroutine 里的 panic 不会被其他 goroutine 的 recover 接住。&lt;/p&gt;
</content:encoded></item><item><title>Go defer</title><link>https://sanzenin.top/posts/obsidian/defer/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/defer/</guid><description>defer 做的事情很简单：把一句函数调用放到当前函数快结束的时候再执行。 它最常出现在“打开了什么，就要关掉什么”的地方： 文件打开成功后，马上写 defer f.Close()。后面代码就算提前 return，也不会忘记关文件。 多个 defer 不是按出现顺序执行，而是反着来。 输出： 可以当成一个栈：最后登记的</description><pubDate>Fri, 31 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Go defer&lt;/h1&gt;
&lt;p&gt;&lt;code&gt;defer&lt;/code&gt; 做的事情很简单：把一句函数调用放到当前函数快结束的时候再执行。&lt;/p&gt;
&lt;p&gt;它最常出现在“打开了什么，就要关掉什么”的地方：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func readFile(path string) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()

	// 这里开始读文件
	return nil
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;文件打开成功后，马上写 &lt;code&gt;defer f.Close()&lt;/code&gt;。后面代码就算提前 &lt;code&gt;return&lt;/code&gt;，也不会忘记关文件。&lt;/p&gt;
&lt;h2&gt;执行顺序&lt;/h2&gt;
&lt;p&gt;多个 &lt;code&gt;defer&lt;/code&gt; 不是按出现顺序执行，而是反着来。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	defer fmt.Println(&quot;first&quot;)
	defer fmt.Println(&quot;second&quot;)
	defer fmt.Println(&quot;third&quot;)
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;third
second
first
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;可以当成一个栈：最后登记的 defer，最先执行。&lt;/p&gt;
&lt;p&gt;资源释放时这个顺序挺合理：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mu.Lock()
defer mu.Unlock()

f, err := os.Open(&quot;data.txt&quot;)
if err != nil {
	return err
}
defer f.Close()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;退出时先关文件，再解锁。&lt;/p&gt;
&lt;h2&gt;defer 和 return&lt;/h2&gt;
&lt;p&gt;Go 里遇到 &lt;code&gt;return&lt;/code&gt; 时，不是马上跳出函数。大概分三步：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;先算返回值&lt;/li&gt;
&lt;li&gt;再执行 defer&lt;/li&gt;
&lt;li&gt;最后真正返回&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;看这个例子：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func test() int {
	num := 10
	defer func() {
		num++
	}()
	return num
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;返回值是 &lt;code&gt;10&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;因为执行到 &lt;code&gt;return num&lt;/code&gt; 时，Go 已经先把 &lt;code&gt;num&lt;/code&gt; 当前的值算出来了，也就是 &lt;code&gt;10&lt;/code&gt;。之后 defer 里的 &lt;code&gt;num++&lt;/code&gt; 改的是局部变量 &lt;code&gt;num&lt;/code&gt;，不是已经准备好的返回值。&lt;/p&gt;
&lt;p&gt;可以粗略想成：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func test() int {
	num := 10
	ret := num

	func() {
		num++
	}()

	return ret
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;所以最后还是 &lt;code&gt;10&lt;/code&gt;。&lt;/p&gt;
&lt;h2&gt;命名返回值&lt;/h2&gt;
&lt;p&gt;如果函数写了命名返回值，情况会变。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func test() (num int) {
	num = 10
	defer func() {
		num++
	}()
	return
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个返回 &lt;code&gt;11&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;这里的 &lt;code&gt;num&lt;/code&gt; 不只是普通局部变量，它就是返回值本身。defer 改了 &lt;code&gt;num&lt;/code&gt;，调用方拿到的也是改完之后的值。&lt;/p&gt;
&lt;p&gt;这个也返回 &lt;code&gt;11&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func test() (num int) {
	num = 10
	defer func() {
		num++
	}()
	return num
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;刚开始学时，重点不是学会这样写，而是别被面试题绕住。实际写项目时，用 defer 修改命名返回值要谨慎，读代码的人容易停下来想半天。&lt;/p&gt;
&lt;h2&gt;参数什么时候确定&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;defer&lt;/code&gt; 后面如果直接跟函数调用，参数会在这一行就确定下来。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	num := 10
	defer fmt.Println(num)
	num = 20
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;10
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因为 &lt;code&gt;defer fmt.Println(num)&lt;/code&gt; 执行到这一行时，&lt;code&gt;num&lt;/code&gt; 已经作为参数取值了。&lt;/p&gt;
&lt;p&gt;但闭包不一样：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;func main() {
	num := 10
	defer func() {
		fmt.Println(num)
	}()
	num = 20
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;输出：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;20
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;闭包读的是变量本身。等函数退出、defer 真正执行时，&lt;code&gt;num&lt;/code&gt; 已经变成 &lt;code&gt;20&lt;/code&gt; 了。&lt;/p&gt;
&lt;p&gt;对比一下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;defer fmt.Println(num) // 现在就把 num 的值拿出来

defer func() {
	fmt.Println(num) // 退出时再读 num
}()
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;常见用法&lt;/h2&gt;
&lt;p&gt;关闭文件：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;f, err := os.Open(path)
if err != nil {
	return err
}
defer f.Close()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;释放锁：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mu.Lock()
defer mu.Unlock()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;取消 context：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;关闭 HTTP 响应体：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;resp, err := http.Get(url)
if err != nil {
	return err
}
defer resp.Body.Close()
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;记法&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;defer&lt;/code&gt; 可以先按这几句记：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;当前函数退出前执行&lt;/li&gt;
&lt;li&gt;多个 defer 反着执行&lt;/li&gt;
&lt;li&gt;return 先算返回值，再跑 defer&lt;/li&gt;
&lt;li&gt;普通参数马上求值，闭包变量退出时再读&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;写代码时，拿到资源后马上 defer 清理，一般就不会错得太离谱。&lt;/p&gt;
</content:encoded></item><item><title>Kruskal 重构树</title><link>https://sanzenin.top/posts/obsidian/kruskal-%E9%87%8D%E6%9E%84%E6%A0%91/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/kruskal-%E9%87%8D%E6%9E%84%E6%A0%91/</guid><description>Kruskal 重构树用于处理和边权限制有关的连通性问题。它保留了 Kruskal 合并连通块的过程，把“两个点在什么边权下连通”转化成树上的 LCA。 初始时，原图中的 个点就是重构树的 个叶子，编号为 。用并查集维护当前的连通块。 将原图中的边按题目需要排序，然后依次处理。对于一条边 ： 1. 找到 当前所在连通块</description><pubDate>Sun, 19 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Kruskal 重构树&lt;/h1&gt;
&lt;p&gt;Kruskal 重构树用于处理和边权限制有关的连通性问题。它保留了 Kruskal 合并连通块的过程，把“两个点在什么边权下连通”转化成树上的 LCA。&lt;/p&gt;
&lt;h2&gt;构造&lt;/h2&gt;
&lt;p&gt;初始时，原图中的 $n$ 个点就是重构树的 $n$ 个叶子，编号为 $1\sim n$。用并查集维护当前的连通块。&lt;/p&gt;
&lt;p&gt;将原图中的边按题目需要排序，然后依次处理。对于一条边 $(u,v,w)$：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;找到 $u,v$ 当前所在连通块的根 $r_u,r_v$。&lt;/li&gt;
&lt;li&gt;如果 $r_u=r_v$，说明两个连通块已经合并，跳过这条边。&lt;/li&gt;
&lt;li&gt;否则新建节点 $p$，令 $val[p]=w$。&lt;/li&gt;
&lt;li&gt;将 $r_u,r_v$ 设为 $p$ 的两个儿子。&lt;/li&gt;
&lt;li&gt;在并查集中令 $r_u,r_v$ 的父亲都指向 $p$，由 $p$ 代表合并后的新连通块。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;核心代码只有下面几行：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;int tot = n;
for (auto [w, u, v] : edges) {
    int ru = find(u);
    int rv = find(v);
    if (ru == rv)
        continue;
    ++tot;
    val[tot] = w;
    pa[tot] = tot;
    pa[ru] = pa[rv] = tot;
    son[tot].push_back(ru);
    son[tot].push_back(rv);
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每次有效合并都会减少一个连通块，因此最多发生 $n-1$ 次合并。重构树最多有：&lt;/p&gt;
&lt;p&gt;$$
n+(n-1)=2n-1
$$&lt;/p&gt;
&lt;p&gt;个节点。&lt;/p&gt;
&lt;p&gt;如果原图连通，最后新建的节点就是整棵重构树的根；如果原图不连通，得到的是一片重构树森林。&lt;/p&gt;
&lt;h2&gt;性质&lt;/h2&gt;
&lt;h3&gt;1. 原图节点都是叶子&lt;/h3&gt;
&lt;p&gt;编号 $1\sim n$ 的节点对应原图中的点。其余节点都由一次连通块合并产生，只表示合并过程，不是原图中的真实节点。&lt;/p&gt;
&lt;h3&gt;2. 每个新节点恰好有两个儿子&lt;/h3&gt;
&lt;p&gt;一次有效合并连接两个不同的连通块，因此每个新节点都有两个儿子。若原图连通，最终得到一棵有 $n$ 个叶子的二叉树。&lt;/p&gt;
&lt;h3&gt;3. 一棵子树对应一个连通块&lt;/h3&gt;
&lt;p&gt;新节点 $p$ 的子树中，包含的正是这次合并后连通块内的所有原图节点。于是判断两个点何时进入同一个连通块，就等价于寻找它们在重构树上的最近公共祖先。&lt;/p&gt;
&lt;h3&gt;4. LCA 的点权是两点第一次连通时的边权&lt;/h3&gt;
&lt;p&gt;设原图中两点 $u,v$ 的最近公共祖先为 $p$。在建立 $p$ 之前，$u,v$ 属于两个不同的连通块；建立 $p$ 时，这两个连通块第一次合并。&lt;/p&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;p&gt;$$
val[\operatorname{LCA}(u,v)]
$$&lt;/p&gt;
&lt;p&gt;就是 Kruskal 扫描过程中使 $u,v$ 第一次连通的那条边的边权。&lt;/p&gt;
&lt;h3&gt;5. 点权具有单调性&lt;/h3&gt;
&lt;p&gt;排序方向决定重构树上的点权单调性。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;处理顺序&lt;/th&gt;
&lt;th&gt;父节点与儿子的点权&lt;/th&gt;
&lt;th&gt;对应问题&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;边权从小到大&lt;/td&gt;
&lt;td&gt;父节点点权不小于儿子&lt;/td&gt;
&lt;td&gt;最大边权的最小值&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;边权从大到小&lt;/td&gt;
&lt;td&gt;父节点点权不大于儿子&lt;/td&gt;
&lt;td&gt;最小边权的最大值&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;边权从小到大时：&lt;/p&gt;
&lt;p&gt;$$
\min_{P:u\leadsto v}\ \max_{e\in P}w_e
=val[\operatorname{LCA}(u,v)]
$$&lt;/p&gt;
&lt;p&gt;边权从大到小时：&lt;/p&gt;
&lt;p&gt;$$
\max_{P:u\leadsto v}\ \min_{e\in P}w_e
=val[\operatorname{LCA}(u,v)]
$$&lt;/p&gt;
&lt;p&gt;前者可以理解为逐渐放宽允许经过的最大边权；后者可以理解为逐渐降低允许经过的最小边权。两点第一次连通时的阈值就是答案。&lt;/p&gt;
&lt;h2&gt;LCA 与复杂度&lt;/h2&gt;
&lt;p&gt;重构树建好后，预处理每个节点的深度和倍增父亲。每次询问求原图两点在重构树上的 LCA，再读取 LCA 的点权即可。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;边排序：$O(m\log m)$&lt;/li&gt;
&lt;li&gt;并查集合并：$O(m\alpha(n))$&lt;/li&gt;
&lt;li&gt;LCA 预处理：$O(n\log n)$&lt;/li&gt;
&lt;li&gt;单次询问：$O(\log n)$&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;总复杂度为：&lt;/p&gt;
&lt;p&gt;$$
O(m\log m+n\log n+q\log n)
$$&lt;/p&gt;
&lt;p&gt;新建节点时最好分开写：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;++tot;
pa[tot] = tot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不要写成 &lt;code&gt;pa[++tot]=tot&lt;/code&gt;。同一表达式中既修改又读取 &lt;code&gt;tot&lt;/code&gt;，容易产生求值顺序问题。&lt;/p&gt;
&lt;hr /&gt;
&lt;h2&gt;P1967 [NOIP 2013 提高组] 货车运输&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/P1967&quot;&gt;题目链接&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;一条运输路线能承受的重量，由路径上限重最小的边决定。题目要求最大化这个最小值，因此将边按权值从大到小处理。&lt;/p&gt;
&lt;p&gt;原图可能不连通。查询前先用并查集判断两点是否连通，不连通时输出 &lt;code&gt;-1&lt;/code&gt;。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m;
    vector&amp;lt;tuple&amp;lt;int, int, int&amp;gt;&amp;gt; edges;
    for (int i = 0; i &amp;lt; m; ++i) {
        int u, v, w;
        cin &amp;gt;&amp;gt; u &amp;gt;&amp;gt; v &amp;gt;&amp;gt; w;
        edges.push_back({w, u, v});
    }
    sort(edges.begin(), edges.end(), greater&amp;lt;&amp;gt;());
    const int LOG = 21;
    int tot = n;
    vector&amp;lt;int&amp;gt; pa(2 * n + 5);
    vector&amp;lt;int&amp;gt; val(2 * n + 5);
    vector&amp;lt;int&amp;gt; dep(2 * n + 5);
    vector&amp;lt;array&amp;lt;int, LOG&amp;gt;&amp;gt; fa(2 * n + 5);
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; son(2 * n + 5);
    iota(pa.begin(), pa.end(), 0);
    auto find = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; int {
        return pa[x] == x ? x : pa[x] = self(self, pa[x]);
    };
    for (auto [w, u, v] : edges) {
        int ru = find(find, u);
        int rv = find(find, v);
        if (ru == rv)
            continue;
        ++tot;
        val[tot] = w;
        pa[tot] = tot;
        pa[ru] = pa[rv] = tot;
        son[tot].push_back(ru);
        son[tot].push_back(rv);
    }
    auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int father) -&amp;gt; void {
        dep[x] = dep[father] + 1;
        fa[x][0] = father;
        for (int i = 1; i &amp;lt; LOG; ++i)
            fa[x][i] = fa[fa[x][i - 1]][i - 1];
        for (int y : son[x])
            self(self, y, x);
    };
    for (int i = 1; i &amp;lt;= tot; ++i)
        if (pa[i] == i)
            dfs(dfs, i, 0);
    auto lca = [&amp;amp;](int x, int y) {
        if (dep[x] &amp;lt; dep[y])
            swap(x, y);
        for (int i = LOG - 1; i &amp;gt;= 0; --i)
            if (dep[fa[x][i]] &amp;gt;= dep[y])
                x = fa[x][i];
        if (x == y)
            return x;
        for (int i = LOG - 1; i &amp;gt;= 0; --i) {
            if (fa[x][i] != fa[y][i]) {
                x = fa[x][i];
                y = fa[y][i];
            }
        }
        return fa[x][0];
    };
    int q;
    cin &amp;gt;&amp;gt; q;
    while (q--) {
        int u, v;
        cin &amp;gt;&amp;gt; u &amp;gt;&amp;gt; v;
        if (find(find, u) != find(find, v))
            cout &amp;lt;&amp;lt; -1 &amp;lt;&amp;lt; &apos;\n&apos;;
        else
            cout &amp;lt;&amp;lt; val[lca(u, v)] &amp;lt;&amp;lt; &apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;U201076 [BZOJ 3732] Network&lt;/h2&gt;
&lt;p&gt;&lt;a href=&quot;https://www.luogu.com.cn/problem/U201076&quot;&gt;题目链接&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;题目要求最小化一条路径上的最大边权，因此将边按权值从小到大处理。两点在重构树上的 LCA 点权，就是它们之间的最小瓶颈。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;
using namespace std;
using ll = long long;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m, q;
    cin &amp;gt;&amp;gt; n &amp;gt;&amp;gt; m &amp;gt;&amp;gt; q;
    vector&amp;lt;tuple&amp;lt;ll, int, int&amp;gt;&amp;gt; edges;
    for (int i = 0; i &amp;lt; m; ++i) {
        int u, v;
        ll w;
        cin &amp;gt;&amp;gt; u &amp;gt;&amp;gt; v &amp;gt;&amp;gt; w;
        edges.push_back({w, u, v});
    }
    sort(edges.begin(), edges.end());
    const int LOG = 21;
    int tot = n;
    vector&amp;lt;int&amp;gt; pa(2 * n + 5);
    vector&amp;lt;ll&amp;gt; val(2 * n + 5);
    vector&amp;lt;int&amp;gt; dep(2 * n + 5);
    vector&amp;lt;array&amp;lt;int, LOG&amp;gt;&amp;gt; fa(2 * n + 5);
    vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt; son(2 * n + 5);
    iota(pa.begin(), pa.end(), 0);
    auto find = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x) -&amp;gt; int {
        return pa[x] == x ? x : pa[x] = self(self, pa[x]);
    };
    for (auto [w, u, v] : edges) {
        int ru = find(find, u);
        int rv = find(find, v);
        if (ru == rv)
            continue;
        ++tot;
        val[tot] = w;
        pa[tot] = tot;
        pa[ru] = pa[rv] = tot;
        son[tot].push_back(ru);
        son[tot].push_back(rv);
    }
    auto dfs = [&amp;amp;](auto &amp;amp;&amp;amp;self, int x, int father) -&amp;gt; void {
        dep[x] = dep[father] + 1;
        fa[x][0] = father;
        for (int i = 1; i &amp;lt; LOG; ++i)
            fa[x][i] = fa[fa[x][i - 1]][i - 1];
        for (int y : son[x])
            self(self, y, x);
    };
    for (int i = 1; i &amp;lt;= tot; ++i)
        if (pa[i] == i)
            dfs(dfs, i, 0);
    auto lca = [&amp;amp;](int x, int y) {
        if (dep[x] &amp;lt; dep[y])
            swap(x, y);
        for (int i = LOG - 1; i &amp;gt;= 0; --i)
            if (dep[fa[x][i]] &amp;gt;= dep[y])
                x = fa[x][i];
        if (x == y)
            return x;
        for (int i = LOG - 1; i &amp;gt;= 0; --i) {
            if (fa[x][i] != fa[y][i]) {
                x = fa[x][i];
                y = fa[y][i];
            }
        }
        return fa[x][0];
    };
    while (q--) {
        int u, v;
        cin &amp;gt;&amp;gt; u &amp;gt;&amp;gt; v;
        cout &amp;lt;&amp;lt; val[lca(u, v)] &amp;lt;&amp;lt; &apos;\n&apos;;
    }
    return 0;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;相关&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A4%A7%E5%85%A8/#5-2-%E5%B9%B6%E6%9F%A5%E9%9B%86-disjoint-set-union&quot;&gt;并查集&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A4%A7%E5%85%A8/#5-8-%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88-lca-%E5%80%8D%E5%A2%9E%E5%AE%9E%E7%8E%B0&quot;&gt;最近公共祖先&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/%E7%AE%97%E6%B3%95%E7%AB%9E%E8%B5%9B%E6%A8%A1%E6%9D%BF%E5%A4%A7%E5%85%A8/#5-5-%E6%9C%80%E5%B0%8F%E7%94%9F%E6%88%90%E6%A0%91-kruskal&quot;&gt;最小生成树&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded></item><item><title>Core Dumped 操作系统笔记目录</title><link>https://sanzenin.top/posts/obsidian/00-%E7%9B%AE%E5%BD%95/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/00-%E7%9B%AE%E5%BD%95/</guid><description>这组笔记按“硬件保护机制 -&gt; 进程抽象 -&gt; 上下文切换 -&gt; 线程 -&gt; 进程间通信 -&gt; 跨系统兼容”的顺序阅读。阅读时注意一个主线：操作系统不是只提供功能接口，它还依赖硬件保护机制来限制普通程序能做什么。 1. 01 系统完整性：用户态、内核态与系统调用 2. 02 进程：地址空间、PCB 与上下文 3. 03</description><pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Core Dumped 操作系统笔记目录&lt;/h1&gt;
&lt;p&gt;这组笔记按“硬件保护机制 -&amp;gt; 进程抽象 -&amp;gt; 上下文切换 -&amp;gt; 线程 -&amp;gt; 进程间通信 -&amp;gt; 跨系统兼容”的顺序阅读。阅读时注意一个主线：操作系统不是只提供功能接口，它还依赖硬件保护机制来限制普通程序能做什么。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/01-%E7%B3%BB%E7%BB%9F%E5%AE%8C%E6%95%B4%E6%80%A7-%E7%94%A8%E6%88%B7%E6%80%81-%E5%86%85%E6%A0%B8%E6%80%81%E4%B8%8E%E7%B3%BB%E7%BB%9F%E8%B0%83%E7%94%A8/&quot;&gt;01 系统完整性：用户态、内核态与系统调用&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/02-%E8%BF%9B%E7%A8%8B-%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4-pcb-%E4%B8%8E%E4%B8%8A%E4%B8%8B%E6%96%87/&quot;&gt;02 进程：地址空间、PCB 与上下文&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/03-%E7%A1%AC%E4%BB%B6%E4%B8%8E%E5%A4%9A%E4%BB%BB%E5%8A%A1-%E4%B8%AD%E6%96%AD-%E5%AF%84%E5%AD%98%E5%99%A8%E5%92%8C%E4%B8%8A%E4%B8%8B%E6%96%87%E5%88%87%E6%8D%A2/&quot;&gt;03 硬件与多任务：中断、寄存器和上下文切换&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/04-%E7%BA%BF%E7%A8%8B-%E5%85%B1%E4%BA%AB%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4%E4%B8%8E%E5%B9%B6%E5%8F%91%E6%89%A7%E8%A1%8C/&quot;&gt;04 线程：共享地址空间与并发执行&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/05-%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1-%E5%85%B1%E4%BA%AB%E5%86%85%E5%AD%98-%E6%B6%88%E6%81%AF%E4%BC%A0%E9%80%92%E4%B8%8E-socket/&quot;&gt;05 进程间通信：共享内存、消息传递与 Socket&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;/posts/obsidian/06-%E8%B7%A8%E7%B3%BB%E7%BB%9F%E8%BF%90%E8%A1%8C-cpu-%E6%9E%B6%E6%9E%84-abi-%E4%B8%8E%E5%8F%AF%E6%89%A7%E8%A1%8C%E6%96%87%E4%BB%B6%E6%A0%BC%E5%BC%8F/&quot;&gt;06 跨系统运行：CPU 架构、ABI 与可执行文件格式&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;主题关系&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;flowchart TD
    A[系统完整性] --&amp;gt; B[进程抽象]
    B --&amp;gt; C[中断与上下文切换]
    C --&amp;gt; D[线程]
    D --&amp;gt; E[进程间通信]
    A --&amp;gt; F[跨系统运行]
    B --&amp;gt; F
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>系统完整性：用户态、内核态与系统调用</title><link>https://sanzenin.top/posts/obsidian/01-%E7%B3%BB%E7%BB%9F%E5%AE%8C%E6%95%B4%E6%80%A7-%E7%94%A8%E6%88%B7%E6%80%81-%E5%86%85%E6%A0%B8%E6%80%81%E4%B8%8E%E7%B3%BB%E7%BB%9F%E8%B0%83%E7%94%A8/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/01-%E7%B3%BB%E7%BB%9F%E5%AE%8C%E6%95%B4%E6%80%A7-%E7%94%A8%E6%88%B7%E6%80%81-%E5%86%85%E6%A0%B8%E6%80%81%E4%B8%8E%E7%B3%BB%E7%BB%9F%E8%B0%83%E7%94%A8/</guid><description>系统完整性要解决的问题是：普通程序可以运行，但不能随意破坏操作系统、硬件和其他进程。 核心手段有三类： - CPU 运行模式； - 特权指令； - 内存管理和中断机制。 先把这一节的边界说清楚：这里的“中断”在视频里有时被泛化使用，实际教材里通常会区分 interrupt、trap、fault、system call。</description><pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;系统完整性：用户态、内核态与系统调用&lt;/h1&gt;
&lt;p&gt;系统完整性要解决的问题是：普通程序可以运行，但不能随意破坏操作系统、硬件和其他进程。&lt;/p&gt;
&lt;p&gt;核心手段有三类：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;CPU 运行模式；&lt;/li&gt;
&lt;li&gt;特权指令；&lt;/li&gt;
&lt;li&gt;内存管理和中断机制。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;先把这一节的边界说清楚：这里的“中断”在视频里有时被泛化使用，实际教材里通常会区分 interrupt、trap、fault、system call。它们都会让 CPU 转入内核控制流，但触发原因和返回语义并不完全一样。&lt;/p&gt;
&lt;h2&gt;指令集和特权指令&lt;/h2&gt;
&lt;p&gt;CPU 指令集中有些指令太危险，不能让普通程序随便执行。例如：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;修改页表；&lt;/li&gt;
&lt;li&gt;关闭中断；&lt;/li&gt;
&lt;li&gt;设置定时器；&lt;/li&gt;
&lt;li&gt;直接访问 I/O 设备；&lt;/li&gt;
&lt;li&gt;切换运行模式；&lt;/li&gt;
&lt;li&gt;修改内核关键寄存器。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这些指令叫 privileged instructions。为了限制它们，硬件必须支持不同运行模式。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/System&apos;s%20Integrity-1783963805309.webp&quot; alt=&quot;System&apos;s Integrity-1783963805309&quot; /&gt;&lt;/p&gt;
&lt;p&gt;普通应用运行在用户态，只能执行安全的普通指令，例如移动数据、复制数据、算术运算、浮点运算、位运算、条件跳转和循环。&lt;/p&gt;
&lt;h2&gt;用户态和内核态&lt;/h2&gt;
&lt;p&gt;CPU 内部会有某种模式位或特权级字段，用来表示当前处于用户态还是内核态。不同架构叫法不同，但思想一致。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;模式&lt;/th&gt;
&lt;th&gt;能做什么&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;User Mode&lt;/td&gt;
&lt;td&gt;运行普通程序，不能直接控制硬件和关键系统结构&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kernel Mode&lt;/td&gt;
&lt;td&gt;运行操作系统内核，可以执行特权指令&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/System&apos;s%20Integrity-1783963877664.webp&quot; alt=&quot;System&apos;s Integrity-1783963877664&quot; /&gt;&lt;/p&gt;
&lt;p&gt;这种隔离不是操作系统单方面约定出来的，而是硬件执行指令时就会检查权限。用户态程序如果执行特权指令，CPU 会触发异常，把控制权交给内核。&lt;/p&gt;
&lt;h2&gt;中断、异常和陷入&lt;/h2&gt;
&lt;p&gt;CPU 执行程序时，程序计数器指向下一条要执行的指令。某些事件发生后，CPU 会暂停当前执行流，跳转到预先设置好的内核入口。&lt;/p&gt;
&lt;p&gt;这些事件常见地分为：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;类型&lt;/th&gt;
&lt;th&gt;来源&lt;/th&gt;
&lt;th&gt;例子&lt;/th&gt;
&lt;th&gt;特点&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Interrupt&lt;/td&gt;
&lt;td&gt;外部硬件&lt;/td&gt;
&lt;td&gt;定时器、键盘、磁盘、网卡&lt;/td&gt;
&lt;td&gt;和当前指令流不一定有关，通常是异步的&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Trap&lt;/td&gt;
&lt;td&gt;程序主动进入内核&lt;/td&gt;
&lt;td&gt;系统调用、断点&lt;/td&gt;
&lt;td&gt;当前程序有意触发，通常是同步的&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fault&lt;/td&gt;
&lt;td&gt;当前指令执行出问题&lt;/td&gt;
&lt;td&gt;缺页、除零、非法访问&lt;/td&gt;
&lt;td&gt;内核处理后可能重试这条指令，也可能杀死进程&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;定时器中断让操作系统能够周期性重新获得 CPU 控制权。没有定时器中断，用户程序如果进入死循环，抢占式调度就很难成立。&lt;/p&gt;
&lt;h2&gt;MMU 和内存保护&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/System&apos;s%20Integrity-1783964054820.webp&quot; alt=&quot;System&apos;s Integrity-1783964054820&quot; /&gt;&lt;/p&gt;
&lt;p&gt;MMU 是 Memory Management Unit，负责把虚拟地址转换成物理地址，并检查访问权限。&lt;/p&gt;
&lt;p&gt;内核通过特权指令配置 MMU：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;哪些虚拟地址映射到哪些物理页；&lt;/li&gt;
&lt;li&gt;哪些页可读、可写、可执行；&lt;/li&gt;
&lt;li&gt;哪些页只允许内核访问；&lt;/li&gt;
&lt;li&gt;用户态是否允许访问某段内存。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这就是为什么普通进程不能覆盖中断处理程序。中断处理代码所在页面属于内核地址空间，用户态访问会被 MMU 拦下。&lt;/p&gt;
&lt;p&gt;如果用户进程能直接改中断处理程序，它就可以在下一次中断时劫持内核控制流，整个系统安全性会崩掉。&lt;/p&gt;
&lt;h2&gt;系统调用&lt;/h2&gt;
&lt;p&gt;普通程序不能直接操作硬件，但它确实需要读文件、分配内存、创建进程、访问网络。解决方法是系统调用。&lt;/p&gt;
&lt;p&gt;还要区分两个层次：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;API：程序员调用的库函数，例如 C 标准库或 POSIX 函数；&lt;/li&gt;
&lt;li&gt;system call：真正进入内核的二进制接口。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;很多 API 会包装系统调用，但不是每个库函数都会进入内核。例如 &lt;code&gt;printf&lt;/code&gt; 可能先写用户态缓冲区，缓冲区刷新时才调用 &lt;code&gt;write&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/System&apos;s%20Integrity-1783964156512.webp&quot; alt=&quot;System&apos;s Integrity-1783964156512&quot; /&gt;
&lt;img src=&quot;/obsidian/System&apos;s%20Integrity-1783964187746.webp&quot; alt=&quot;System&apos;s Integrity-1783964187746&quot; /&gt;
&lt;img src=&quot;/obsidian/System&apos;s%20Integrity-1783964251121.webp&quot; alt=&quot;System&apos;s Integrity-1783964251121&quot; /&gt;&lt;/p&gt;
&lt;p&gt;系统调用的基本流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sequenceDiagram
    participant U as User Program
    participant CPU as CPU
    participant K as Kernel
    U-&amp;gt;&amp;gt;CPU: 准备系统调用号和参数
    U-&amp;gt;&amp;gt;CPU: 执行 syscall / trap / svc 等入口指令
    CPU-&amp;gt;&amp;gt;K: 切换到内核态并跳转入口
    K-&amp;gt;&amp;gt;K: 检查参数和权限
    K-&amp;gt;&amp;gt;K: 执行内核服务
    K-&amp;gt;&amp;gt;CPU: 返回用户态
    CPU-&amp;gt;&amp;gt;U: 用户程序继续运行
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;系统调用是受控入口。用户程序不是直接进入任意内核代码，而是只能进入操作系统暴露的固定入口，由内核检查参数、权限和资源状态。&lt;/p&gt;
&lt;h2&gt;驱动程序&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/System&apos;s%20Integrity-1783964595832.webp&quot; alt=&quot;System&apos;s Integrity-1783964595832&quot; /&gt;&lt;/p&gt;
&lt;p&gt;驱动程序是控制特定硬件的软件。因为控制硬件通常需要特权指令、DMA、I/O 端口或 MMIO 权限，传统驱动一般运行在内核态。&lt;/p&gt;
&lt;p&gt;现代系统也存在用户态驱动或微内核式驱动模型，但它们仍然需要内核授予受控权限，不能绕过硬件保护机制。&lt;/p&gt;
&lt;p&gt;用户程序需要硬件时，不直接操作设备，而是调用操作系统接口。内核再通过对应驱动完成实际操作。&lt;/p&gt;
&lt;p&gt;例如读磁盘文件：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;user program
  -&amp;gt; read() system call
  -&amp;gt; kernel VFS
  -&amp;gt; filesystem
  -&amp;gt; block device driver
  -&amp;gt; disk controller
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这样做的意义是把硬件细节和危险权限收在内核里。普通程序只拿到受限制的接口，不能随意改设备寄存器或破坏其他进程的数据。&lt;/p&gt;
</content:encoded></item><item><title>进程：地址空间、PCB 与上下文</title><link>https://sanzenin.top/posts/obsidian/02-%E8%BF%9B%E7%A8%8B-%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4-pcb-%E4%B8%8E%E4%B8%8A%E4%B8%8B%E6%96%87/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/02-%E8%BF%9B%E7%A8%8B-%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4-pcb-%E4%B8%8E%E4%B8%8A%E4%B8%8B%E6%96%87/</guid><description>程序是一个静态对象：一组已经写好的指令、数据和可执行文件格式。它本身不会“运行”，只是存放在磁盘或内存里的内容。 进程是程序的一次运行实例。程序被操作系统加载后，拥有了自己的执行位置、寄存器状态、地址空间、打开文件、I/O 资源和调度状态，这时它才变成一个活的执行实体。 可以这样区分： | 概念 | 含义 | |---</description><pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;进程：地址空间、PCB 与上下文&lt;/h1&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/PROCESS-1783962057039.webp&quot; alt=&quot;PROCESS-1783962057039&quot; /&gt;
&lt;img src=&quot;/obsidian/PROCESS-1783962124132.webp&quot; alt=&quot;PROCESS-1783962124132&quot; /&gt;&lt;/p&gt;
&lt;h2&gt;程序和进程&lt;/h2&gt;
&lt;p&gt;程序是一个静态对象：一组已经写好的指令、数据和可执行文件格式。它本身不会“运行”，只是存放在磁盘或内存里的内容。&lt;/p&gt;
&lt;p&gt;进程是程序的一次运行实例。程序被操作系统加载后，拥有了自己的执行位置、寄存器状态、地址空间、打开文件、I/O 资源和调度状态，这时它才变成一个活的执行实体。&lt;/p&gt;
&lt;p&gt;可以这样区分：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;概念&lt;/th&gt;
&lt;th&gt;含义&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Program&lt;/td&gt;
&lt;td&gt;静态代码和数据&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Process&lt;/td&gt;
&lt;td&gt;正在运行的程序实例&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Address Space&lt;/td&gt;
&lt;td&gt;该进程能看到的虚拟内存范围&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CPU State&lt;/td&gt;
&lt;td&gt;程序计数器、寄存器、栈指针、标志位等执行现场&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2&gt;地址空间&lt;/h2&gt;
&lt;p&gt;操作系统通常会给每个进程分配一个独立的虚拟地址空间。进程内部看到的是一套从低地址到高地址组织起来的虚拟地址；这些虚拟地址最终由 MMU 和页表映射到真实物理内存。&lt;/p&gt;
&lt;p&gt;这里的“独立”不是说进程之间永远没有共享。共享库、共享内存、&lt;code&gt;mmap&lt;/code&gt; 文件、父子进程的 copy-on-write 页面，都可能让多个地址空间映射到同一批物理页。隔离的意思是：进程不能越过页表权限随便访问没有映射给自己的内存。&lt;/p&gt;
&lt;p&gt;地址空间通常包含：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;text：程序机器码，通常只读；&lt;/li&gt;
&lt;li&gt;data/bss：全局变量和静态变量；&lt;/li&gt;
&lt;li&gt;heap：动态分配内存，例如 &lt;code&gt;malloc&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;mmap 区：共享库、文件映射、匿名映射；&lt;/li&gt;
&lt;li&gt;stack：线程调用栈、局部变量、返回地址。一个进程有多个线程时，每个线程都有自己的用户栈。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;隔离地址空间的好处是：一个普通进程不能随便读写另一个进程的内存，也不能直接覆盖内核代码或中断处理程序。&lt;/p&gt;
&lt;h2&gt;CPU 如何在多个进程之间切换&lt;/h2&gt;
&lt;p&gt;单核 CPU 在同一时刻只能真正执行一个进程。多任务的效果来自操作系统调度：把就绪进程放入队列，让它们轮流获得 CPU。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/PROCESS-1783962891892.webp&quot; alt=&quot;PROCESS-1783962891892&quot; /&gt;&lt;/p&gt;
&lt;p&gt;当一个进程被中断或主动让出 CPU 时，操作系统要保存它当前的 CPU 状态，再恢复另一个进程之前保存的 CPU 状态。这个过程就是上下文切换。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sequenceDiagram
    participant P1 as Process A
    participant OS as Kernel Scheduler
    participant P2 as Process B

    P1-&amp;gt;&amp;gt;OS: timer interrupt / system call
    OS-&amp;gt;&amp;gt;OS: 保存 A 的寄存器、PC、SP
    OS-&amp;gt;&amp;gt;OS: 选择下一个可运行进程
    OS-&amp;gt;&amp;gt;P2: 恢复 B 的寄存器、PC、SP
    P2-&amp;gt;&amp;gt;P2: 从上次停止处继续执行
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意：上下文切换不是只换一条指令地址，而是换掉“CPU 正在以什么身份运行”的整套上下文。&lt;/p&gt;
&lt;h2&gt;PCB：操作系统眼中的进程&lt;/h2&gt;
&lt;p&gt;进程控制块 PCB 是操作系统维护进程的核心数据结构。视频里给出的简化结构如下：&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/PROCESS-1783963390688.webp&quot; alt=&quot;PROCESS-1783963390688&quot; /&gt;&lt;/p&gt;
&lt;p&gt;真实操作系统里的 PCB 会更复杂，但核心思想一样：操作系统必须能从 PCB 中知道这个进程是谁、在哪里运行到一半、占用了哪些资源、下一次如何恢复。&lt;/p&gt;
&lt;p&gt;一个简化版 PCB 可以包括：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ProcessControlBlock {
    pid,
    state,
    program_counter,
    registers,
    stack_pointer,
    memory_limits / address_space,
    open_files,
    io_devices,
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;进程切换时，旧任务的寄存器、程序计数器、栈指针等执行现场会保存到内核管理的数据结构中；新任务的对应现场再被加载回 CPU。教材里把这类结构统称 PCB，Linux 中则分散在 &lt;code&gt;task_struct&lt;/code&gt;、内核栈、架构相关的 &lt;code&gt;thread_struct&lt;/code&gt; 等位置。&lt;/p&gt;
&lt;h2&gt;创建新进程时操作系统要知道什么&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/PROCESS-1783963440813.webp&quot; alt=&quot;PROCESS-1783963440813&quot; /&gt;&lt;/p&gt;
&lt;p&gt;新进程不是简单复制一个文件。以 Unix/Linux 为例，&lt;code&gt;fork()&lt;/code&gt; 和 &lt;code&gt;exec()&lt;/code&gt; 做的事情还不一样：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;fork()&lt;/code&gt; 更像复制当前进程的执行环境，现代系统通常用 copy-on-write 推迟真实内存复制；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;exec()&lt;/code&gt; 把当前进程的地址空间替换成新程序。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;操作系统至少要做这些事：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;分配 PID；&lt;/li&gt;
&lt;li&gt;创建内核中的进程描述结构；&lt;/li&gt;
&lt;li&gt;准备新的地址空间，或者根据创建参数共享父进程的部分资源；&lt;/li&gt;
&lt;li&gt;建立页表；&lt;/li&gt;
&lt;li&gt;初始化用户栈和内核栈；&lt;/li&gt;
&lt;li&gt;设置程序计数器，让它从入口点开始执行；&lt;/li&gt;
&lt;li&gt;将进程放入调度队列。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;如果系统不知道已有进程的地址空间和资源占用情况，就无法安全地给新进程分配内存、文件描述符、信号处理信息等资源。&lt;/p&gt;
&lt;h2&gt;Linux 源码中的对应关系&lt;/h2&gt;
&lt;p&gt;Linux 没有一个直接叫 &lt;code&gt;PCB&lt;/code&gt; 的结构，最接近的是 &lt;code&gt;task_struct&lt;/code&gt;。它定义在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;include/linux/sched.h
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;task_struct&lt;/code&gt; 代表一个可调度实体。Linux 的“进程”和“线程”在内核里都用 &lt;code&gt;task_struct&lt;/code&gt; 表示，区别主要看它们共享了哪些资源。&lt;/p&gt;
&lt;p&gt;几个关键字段可以这样理解：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Linux 字段&lt;/th&gt;
&lt;th&gt;含义&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;pid&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;这个 task 自己的 ID&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;tgid&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;线程组 ID；同一进程内线程通常共享同一个 &lt;code&gt;tgid&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;__state&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;睡眠、停止等任务状态；是否正在 CPU 上运行还要结合调度器运行队列判断&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;mm&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;用户态地址空间，指向 &lt;code&gt;mm_struct&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;active_mm&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;当前 CPU 切换地址空间时使用的 &lt;code&gt;mm_struct&lt;/code&gt;；内核线程没有自己的 &lt;code&gt;mm&lt;/code&gt; 时会借用&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;files&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;打开的文件描述符表&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;fs&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;当前工作目录、根目录等文件系统上下文&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;signal&lt;/code&gt; / &lt;code&gt;sighand&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;信号相关信息&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;thread&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;架构相关的 CPU 上下文，例如寄存器保存位置&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;地址空间对应 &lt;code&gt;mm_struct&lt;/code&gt;，定义在：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;include/linux/mm_types.h
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;里面有 &lt;code&gt;pgd&lt;/code&gt;、&lt;code&gt;mmap&lt;/code&gt;、&lt;code&gt;start_code&lt;/code&gt;、&lt;code&gt;start_brk&lt;/code&gt;、&lt;code&gt;brk&lt;/code&gt;、&lt;code&gt;start_stack&lt;/code&gt; 等字段，分别描述页表、内存映射、代码段、堆和栈的位置。&lt;/p&gt;
&lt;p&gt;进程创建主要走：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;kernel/fork.c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中 &lt;code&gt;copy_process()&lt;/code&gt; 会创建新的 &lt;code&gt;task_struct&lt;/code&gt;，再根据 &lt;code&gt;clone_flags&lt;/code&gt; 决定哪些资源复制、哪些资源共享。例如：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;普通 &lt;code&gt;fork()&lt;/code&gt;：多数资源逻辑上复制，地址空间采用写时复制；&lt;/li&gt;
&lt;li&gt;线程创建：带 &lt;code&gt;CLONE_VM&lt;/code&gt;、&lt;code&gt;CLONE_THREAD&lt;/code&gt; 等标志，共享地址空间和线程组；&lt;/li&gt;
&lt;li&gt;内核线程：没有普通用户态地址空间。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;所以从 Linux 的角度看，进程不是一个单独字段能描述完的东西，而是一组相互连接的内核结构：&lt;code&gt;task_struct&lt;/code&gt; 管身份和调度，&lt;code&gt;mm_struct&lt;/code&gt; 管地址空间，&lt;code&gt;files_struct&lt;/code&gt; 管打开文件，调度器再根据这些结构决定什么时候运行它。&lt;/p&gt;
&lt;p&gt;一个容易混淆的点是：Linux 调度的是 task，不是传统意义上的“进程对象”。同一线程组里的多个 task 共享地址空间时，用户态把它们看作一个多线程进程；内核调度器仍然逐个调度这些 task。&lt;/p&gt;
</content:encoded></item><item><title>线程：共享地址空间与并发执行</title><link>https://sanzenin.top/posts/obsidian/04-%E7%BA%BF%E7%A8%8B-%E5%85%B1%E4%BA%AB%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4%E4%B8%8E%E5%B9%B6%E5%8F%91%E6%89%A7%E8%A1%8C/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/04-%E7%BA%BF%E7%A8%8B-%E5%85%B1%E4%BA%AB%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4%E4%B8%8E%E5%B9%B6%E5%8F%91%E6%89%A7%E8%A1%8C/</guid><description>这一节里有四个基础概念经常一起出现：stack、heap、concurrency、process。线程就是为了让同一进程内部可以有多个执行流。 CPU 调度最直接的目的，是让多个任务轮流使用处理器；另一个更实际的目的，是尽量不要让 CPU 闲着。 例如服务器处理客户端请求。传统做法是： 1. 主进程监听请求； 2. 每</description><pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;线程：共享地址空间与并发执行&lt;/h1&gt;
&lt;p&gt;这一节里有四个基础概念经常一起出现：stack、heap、concurrency、process。线程就是为了让同一进程内部可以有多个执行流。&lt;/p&gt;
&lt;h2&gt;为什么需要线程&lt;/h2&gt;
&lt;p&gt;CPU 调度最直接的目的，是让多个任务轮流使用处理器；另一个更实际的目的，是尽量不要让 CPU 闲着。&lt;/p&gt;
&lt;p&gt;例如服务器处理客户端请求。传统做法是：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;主进程监听请求；&lt;/li&gt;
&lt;li&gt;每来一个客户端，就创建一个新进程；&lt;/li&gt;
&lt;li&gt;新进程专门服务这个客户端。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Threads-1784018677141.webp&quot; alt=&quot;Threads-1784018677141&quot; /&gt;&lt;/p&gt;
&lt;p&gt;这个模型能工作，但代价很高。因为进程是一个完整上下文：它有自己的地址空间、文件表、寄存器状态、内核管理结构等。客户端数量上来后，为每个连接创建完整进程会浪费大量内存和创建时间。&lt;/p&gt;
&lt;p&gt;线程的思路是：不要把程序计数器直接绑定在“进程”这个整体上，而是在同一个进程内部创建多个可调度的执行流。进程更像资源容器，线程才是实际被调度执行的控制流。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Threads-1784018865659.webp&quot; alt=&quot;Threads-1784018865659&quot; /&gt;&lt;/p&gt;
&lt;p&gt;一个进程可以有多个线程。每个线程都有自己的程序计数器和运行现场，但它们共享同一个进程的大部分资源。&lt;/p&gt;
&lt;h2&gt;线程共享什么，独占什么&lt;/h2&gt;
&lt;p&gt;线程共享：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;同一个地址空间；&lt;/li&gt;
&lt;li&gt;text 段代码；&lt;/li&gt;
&lt;li&gt;heap；&lt;/li&gt;
&lt;li&gt;全局变量；&lt;/li&gt;
&lt;li&gt;打开的文件描述符表，具体取决于操作系统和创建参数；&lt;/li&gt;
&lt;li&gt;进程级权限和资源。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;线程独占：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;程序计数器；&lt;/li&gt;
&lt;li&gt;寄存器现场；&lt;/li&gt;
&lt;li&gt;用户栈和内核栈；&lt;/li&gt;
&lt;li&gt;调度状态；&lt;/li&gt;
&lt;li&gt;线程局部存储。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Threads-1784018957236.webp&quot; alt=&quot;Threads-1784018957236&quot; /&gt;&lt;/p&gt;
&lt;p&gt;线程本身不“包含代码”。代码在进程的 text section 中，线程只是通过自己的 program counter 指向下一条要执行的指令。&lt;/p&gt;
&lt;h2&gt;每个线程为什么要有自己的栈&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Threads-1784032484218.webp&quot; alt=&quot;Threads-1784032484218&quot; /&gt;&lt;/p&gt;
&lt;p&gt;函数调用需要栈保存返回地址、局部变量、临时值和调用链。如果多个线程共用同一个栈，线程 A 调用函数时压入的返回地址可能被线程 B 覆盖，程序会很快失控。&lt;/p&gt;
&lt;p&gt;所以每个线程必须有自己的栈。&lt;/p&gt;
&lt;p&gt;但要注意：这些用户栈仍然位于同一个进程地址空间里。从硬件权限上说，一个线程可以读写另一个线程的用户栈，只是正常程序不应该这么做。很多运行时会在线程栈边界放 guard page，用来尽早发现栈溢出，但这不是线程之间的安全隔离。&lt;/p&gt;
&lt;p&gt;线程间共享数据时，heap 通常比栈更合适：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;栈适合线程自己的临时状态；&lt;/li&gt;
&lt;li&gt;heap 适合多个线程共同访问的对象；&lt;/li&gt;
&lt;li&gt;共享 heap 数据必须配合同步机制。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;如果一个线程正在读某块 heap 内存，另一个线程同时写同一块内存，结果可能是不确定的。这和 &lt;a href=&quot;/posts/obsidian/05-%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1-%E5%85%B1%E4%BA%AB%E5%86%85%E5%AD%98-%E6%B6%88%E6%81%AF%E4%BC%A0%E9%80%92%E4%B8%8E-socket/#race-condition&quot;&gt;05 进程间通信：共享内存、消息传递与 Socket&lt;/a&gt; 是同一个本质问题。&lt;/p&gt;
&lt;h2&gt;多线程下的内核结构&lt;/h2&gt;
&lt;p&gt;从“一个进程一个执行流”变成“一个进程多个执行流”后，原来的 PCB 也要拆分理解。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Threads-1784032734548.webp&quot; alt=&quot;Threads-1784032734548&quot; /&gt;&lt;/p&gt;
&lt;p&gt;进程级信息包括地址空间、打开文件、权限等；线程级信息包括程序计数器、寄存器、栈和调度状态。&lt;/p&gt;
&lt;p&gt;Linux 中没有单独把“进程 PCB”和“线程 TCB”完全分成两套结构。Linux 用 &lt;code&gt;task_struct&lt;/code&gt; 表示一个可调度实体，进程和线程都对应一个 &lt;code&gt;task_struct&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;差异体现在创建时的共享标志上：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;标志&lt;/th&gt;
&lt;th&gt;含义&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CLONE_VM&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;共享地址空间&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CLONE_FILES&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;共享文件描述符表&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CLONE_FS&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;共享文件系统上下文&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CLONE_SIGHAND&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;共享信号处理表&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;CLONE_THREAD&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;放入同一线程组&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;普通 &lt;code&gt;fork()&lt;/code&gt; 创建的是新进程；&lt;code&gt;pthread_create()&lt;/code&gt; 底层通常通过 &lt;code&gt;clone()&lt;/code&gt; 创建共享资源更多的新 &lt;code&gt;task_struct&lt;/code&gt;。所以在 Linux 内核里，线程更像是“和其他 task 共享大量资源并属于同一线程组的 task”。&lt;/p&gt;
&lt;h2&gt;Main Thread&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Threads-1784032846027.webp&quot; alt=&quot;Threads-1784032846027&quot; /&gt;&lt;/p&gt;
&lt;p&gt;对普通用户态进程来说，进程启动后会先有一个初始线程。程序入口点开始执行的那条执行流通常称为 main thread。&lt;/p&gt;
&lt;p&gt;后续创建线程时，操作系统会把新线程加入调度体系。调度器不关心它是不是“主线程”，它只关心这个线程是否可运行、优先级如何、应该放在哪个 CPU 核心上执行。&lt;/p&gt;
&lt;h2&gt;线程、代码和运行时数据&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/Threads-1784033050870.webp&quot; alt=&quot;Threads-1784033050870&quot; /&gt;&lt;/p&gt;
&lt;p&gt;线程执行的代码位于进程的 text section。线程特有的运行时信息主要在：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;CPU 寄存器中；&lt;/li&gt;
&lt;li&gt;线程自己的栈上；&lt;/li&gt;
&lt;li&gt;内核保存的线程上下文中；&lt;/li&gt;
&lt;li&gt;线程局部存储中。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这也是为什么同一进程内的线程切换通常比跨进程切换轻：地址空间不变，很多情况下不需要切换页表，也不需要让地址转换缓存付出同样的代价。不过调度器、寄存器保存、内核栈切换等成本仍然存在。&lt;/p&gt;
&lt;h2&gt;并发和并行&lt;/h2&gt;
&lt;p&gt;并发 concurrency：多个任务交替推进，看起来像同时发生。单核心系统也能并发，因为操作系统可以快速切换线程。&lt;/p&gt;
&lt;p&gt;并行 parallelism：多个任务在同一时刻真正同时执行。必须有多个 CPU 核心或多个硬件执行单元。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flowchart TB
    subgraph SingleCore[单核：并发]
      A1[Thread A] --&amp;gt; B1[Thread B] --&amp;gt; C1[Thread A] --&amp;gt; D1[Thread C]
    end
    subgraph MultiCore[多核：并行]
      A2[Core 0: Thread A]
      B2[Core 1: Thread B]
      C2[Core 2: Thread C]
    end
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;单核系统上，线程只是轮流运行；多核系统上，多个线程可以被调度到不同核心上同时运行。&lt;/p&gt;
&lt;h2&gt;多核处理器上的多线程&lt;/h2&gt;
&lt;p&gt;处理器相关术语：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;术语&lt;/th&gt;
&lt;th&gt;含义&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;CPU&lt;/td&gt;
&lt;td&gt;物理芯片或处理器封装&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Core&lt;/td&gt;
&lt;td&gt;CPU 内部独立执行指令的核心&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Hardware Thread&lt;/td&gt;
&lt;td&gt;同一核心暴露出的硬件执行上下文，例如 SMT/超线程&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;操作系统通常把可调度的硬件执行位置识别为 logical CPU。线程能否真正同时运行，取决于系统有多少 logical CPU 可用，以及调度器如何分配。&lt;/p&gt;
&lt;p&gt;多核下线程的优势是：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;I/O 阻塞时，其他线程可以继续占用 CPU；&lt;/li&gt;
&lt;li&gt;多个独立任务可以同时运行；&lt;/li&gt;
&lt;li&gt;程序不需要为不同核心数重新编译，调度器会根据机器情况安排线程；&lt;/li&gt;
&lt;li&gt;核心不足时仍可退化为分时并发。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;并行上限受硬件限制。一个有 N 个可用 logical CPU 的系统，在同一瞬间最多运行 N 个可执行线程；更多线程只能排队、抢占、阻塞或等待。这里的 logical CPU 包括物理核心暴露出的 SMT/超线程上下文，它们能并行发射工作，但性能不等同于 N 个完整物理核心。&lt;/p&gt;
&lt;h2&gt;数据并行和任务并行&lt;/h2&gt;
&lt;p&gt;数据并行是把同一种运算拆到多份数据上。例如把一个大数组分成 4 段，4 个线程分别检查每段里的质数。&lt;/p&gt;
&lt;p&gt;任务并行是让不同线程做不同工作。例如同一份数组上，一个线程求最大值，一个线程求平均值，一个线程搜索某个元素。&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;类型&lt;/th&gt;
&lt;th&gt;拆分对象&lt;/th&gt;
&lt;th&gt;例子&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Data Parallelism&lt;/td&gt;
&lt;td&gt;数据&lt;/td&gt;
&lt;td&gt;大数组分片计算&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Task Parallelism&lt;/td&gt;
&lt;td&gt;工作&lt;/td&gt;
&lt;td&gt;UI、网络、文件写入分别由不同线程负责&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;多线程并不保证线性加速。线程创建、同步、缓存一致性、任务拆分和结果合并都会产生开销。真正能加速的，是那些独立性强、共享写入少、计算量足够大的任务。&lt;/p&gt;
</content:encoded></item><item><title>进程间通信：共享内存、消息传递与 Socket</title><link>https://sanzenin.top/posts/obsidian/05-%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1-%E5%85%B1%E4%BA%AB%E5%86%85%E5%AD%98-%E6%B6%88%E6%81%AF%E4%BC%A0%E9%80%92%E4%B8%8E-socket/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/05-%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1-%E5%85%B1%E4%BA%AB%E5%86%85%E5%AD%98-%E6%B6%88%E6%81%AF%E4%BC%A0%E9%80%92%E4%B8%8E-socket/</guid><description>IPC 是 Inter-Process Communication，也就是进程间通信。进程默认被地址空间隔离，一个进程不能随便读写另一个进程的内存；如果两个进程需要交换数据，就必须通过操作系统提供的机制或由操作系统授权的共享映射。 常见 IPC 可以粗略分成两类： - shared memory：让多个进程映射同一块内</description><pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;进程间通信：共享内存、消息传递与 Socket&lt;/h1&gt;
&lt;p&gt;IPC 是 Inter-Process Communication，也就是进程间通信。进程默认被地址空间隔离，一个进程不能随便读写另一个进程的内存；如果两个进程需要交换数据，就必须通过操作系统提供的机制或由操作系统授权的共享映射。&lt;/p&gt;
&lt;p&gt;常见 IPC 可以粗略分成两类：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;shared memory：让多个进程映射同一块内存；&lt;/li&gt;
&lt;li&gt;message passing：由内核或通信端点转发消息。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;Shared Memory&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/IPC-1783965352433.webp&quot; alt=&quot;IPC-1783965352433&quot; /&gt;
&lt;img src=&quot;/obsidian/IPC-1783965438305.webp&quot; alt=&quot;IPC-1783965438305&quot; /&gt;&lt;/p&gt;
&lt;p&gt;共享内存通常通过系统调用创建。更准确地说，内核维护一个可共享的内存对象，多个进程再把它映射到各自的虚拟地址空间里。System V shared memory 里常说 &lt;code&gt;attach&lt;/code&gt;，POSIX shared memory 和 &lt;code&gt;mmap&lt;/code&gt; 则更常说 &lt;code&gt;map&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;关键点是：这块内存在物理上可以是同一份，但每个进程看到的是自己地址空间中的一段虚拟地址。两个进程中的虚拟地址不必相同，真正共享的是背后的物理页或内核对象。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flowchart LR
    A[Process A Address Space] --&amp;gt; M[Shared Memory Region]
    B[Process B Address Space] --&amp;gt; M
    OS[Kernel] -. create / attach .-&amp;gt; M
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/IPC-1783965570876.webp&quot; alt=&quot;IPC-1783965570876&quot; /&gt;&lt;/p&gt;
&lt;p&gt;共享内存只解决“两个进程能看到同一块数据”的问题，不解决“谁先读、谁先写、写到哪里”的问题。具体的内存布局、读写位置、数据格式都由进程自己约定。&lt;/p&gt;
&lt;p&gt;因此共享内存通常还要搭配同步机制：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;mutex；&lt;/li&gt;
&lt;li&gt;semaphore；&lt;/li&gt;
&lt;li&gt;condition variable；&lt;/li&gt;
&lt;li&gt;futex；&lt;/li&gt;
&lt;li&gt;文件锁或其他内核同步对象。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;Race Condition&lt;/h2&gt;
&lt;p&gt;竞争条件指的是：程序结果依赖多个执行流的相对时序，而这个时序又不受程序控制。它既会发生在线程之间，也会发生在多个进程通过共享内存通信时。&lt;/p&gt;
&lt;p&gt;最简单的例子是两个进程同时修改共享变量 &lt;code&gt;x&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Process A: read x = 10
Process B: read x = 10
Process A: write x = 11
Process B: write x = 11
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;两个进程都做了一次 &lt;code&gt;x++&lt;/code&gt;，但最终结果不是 12，而是 11。问题不在共享内存本身，而在“读-改-写”不是一个原子操作。&lt;/p&gt;
&lt;p&gt;共享内存速度快，但它把同步责任交给了程序员。如果没有锁或原子操作，数据结构很容易被写坏。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/IPC-1783965763349.webp&quot; alt=&quot;IPC-1783965763349&quot; /&gt;
&lt;img src=&quot;/obsidian/IPC-1783965789885.webp&quot; alt=&quot;IPC-1783965789885&quot; /&gt;&lt;/p&gt;
&lt;h2&gt;Message Passing&lt;/h2&gt;
&lt;p&gt;消息传递的思路是：进程不直接共享可写数据结构，而是通过内核维护的通道或受控端点交换消息。&lt;/p&gt;
&lt;p&gt;常见形式包括：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;pipes；&lt;/li&gt;
&lt;li&gt;message queues；&lt;/li&gt;
&lt;li&gt;sockets；&lt;/li&gt;
&lt;li&gt;remote procedure calls；&lt;/li&gt;
&lt;li&gt;Mach ports。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/IPC-1783965934597.webp&quot; alt=&quot;IPC-1783965934597&quot; /&gt;&lt;/p&gt;
&lt;p&gt;视频里的 mailbox 可以理解成内核管理的消息队列。A 发送消息给 B，不是直接写 B 的内存，而是调用内核的 &lt;code&gt;send&lt;/code&gt;；B 再通过 &lt;code&gt;receive&lt;/code&gt; 从 mailbox 里取出消息。具体实现未必真的把所有数据长期放在“内核地址空间的一段队列”里，但权限、排队、阻塞唤醒由内核掌控。&lt;/p&gt;
&lt;p&gt;一个双向 mailbox 可以由两个队列实现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;flowchart LR
    A[Process A] --&amp;gt;|send| AB[A to B Queue]
    AB --&amp;gt;|receive| B[Process B]
    B --&amp;gt;|send| BA[B to A Queue]
    BA --&amp;gt;|receive| A
    subgraph Kernel Address Space
      AB
      BA
    end
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;为什么进程不能直接访问 mailbox？&lt;/h3&gt;
&lt;p&gt;因为 mailbox 位于内核地址空间。普通进程运行在用户态，页表和权限位会阻止它直接访问内核内存。&lt;/p&gt;
&lt;p&gt;这样做有几个原因：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;防止进程伪造、篡改或删除别人的消息；&lt;/li&gt;
&lt;li&gt;防止一个 bug 写坏内核维护的队列结构；&lt;/li&gt;
&lt;li&gt;让内核可以统一处理阻塞、唤醒、权限检查、消息复制或零拷贝转交；&lt;/li&gt;
&lt;li&gt;保持进程隔离，避免 IPC 通道变成任意内存写入口。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;所以 message passing 至少需要两个系统调用：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;send&lt;/code&gt;：把消息交给内核；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;receive&lt;/code&gt;：从内核维护的队列中取消息，必要时阻塞等待。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/IPC-1783966035335.webp&quot; alt=&quot;IPC-1783966035335&quot; /&gt;&lt;/p&gt;
&lt;h2&gt;Mach：task 和 port&lt;/h2&gt;
&lt;p&gt;Mach 系统里，&lt;code&gt;task&lt;/code&gt; 更接近资源容器，&lt;code&gt;thread&lt;/code&gt; 才是执行流，通信端点是 &lt;code&gt;port&lt;/code&gt;。需要注意的是：消息不是“发给进程”，而是发给 port。&lt;/p&gt;
&lt;p&gt;一个 task 可以持有多个 port：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;listening port：接收连接请求；&lt;/li&gt;
&lt;li&gt;private port：建立后的私有通信通道；&lt;/li&gt;
&lt;li&gt;service port：暴露某种系统服务。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这种设计的好处是通信能力可以被当成一种权限对象来传递。谁持有某个 port 的 send right，谁就能向它发送消息；谁持有 receive right，谁才有资格接收该 port 上的消息。&lt;/p&gt;
&lt;h2&gt;Socket&lt;/h2&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/IPC-1783966191946.webp&quot; alt=&quot;IPC-1783966191946&quot; /&gt;&lt;/p&gt;
&lt;p&gt;Socket 是更通用的通信接口，既能用于同一台机器上的进程通信，也能用于网络通信。&lt;/p&gt;
&lt;p&gt;在 client-server 架构里，服务端通常这样工作：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;socket()
bind()
listen()
accept()
read()/write()
close()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;客户端通常是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;socket()
connect()
read()/write()
close()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本机进程通信可以使用 Unix domain socket，包括 &lt;code&gt;socketpair()&lt;/code&gt; 这种直接创建一对已连接端点的方式；跨机器通信通常使用 TCP/UDP socket。&lt;/p&gt;
&lt;p&gt;Socket 的核心抽象是“端点”。进程通过文件描述符操作 socket，内核负责缓冲、路由、阻塞唤醒、网络协议栈处理等细节。&lt;/p&gt;
&lt;h2&gt;Shared Memory 和 Message Passing 的性能差异&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;方式&lt;/th&gt;
&lt;th&gt;优点&lt;/th&gt;
&lt;th&gt;缺点&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Shared Memory&lt;/td&gt;
&lt;td&gt;数据不用来回复制，吞吐量高，适合大块数据&lt;/td&gt;
&lt;td&gt;同步复杂，容易出现 race condition&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Message Passing&lt;/td&gt;
&lt;td&gt;接口清晰，隔离性好，内核可管理权限和阻塞&lt;/td&gt;
&lt;td&gt;通常需要系统调用和数据复制，小消息更合适；部分系统可通过共享页、文件描述符传递等方式减少复制&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;大块数据传输常用共享内存，小控制消息常用消息传递。实际系统里两者经常组合使用：先用 socket 或 port 协商，再把大数据放进共享内存。&lt;/p&gt;
</content:encoded></item><item><title>跨系统运行：CPU 架构、ABI 与可执行文件格式</title><link>https://sanzenin.top/posts/obsidian/06-%E8%B7%A8%E7%B3%BB%E7%BB%9F%E8%BF%90%E8%A1%8C-cpu-%E6%9E%B6%E6%9E%84-abi-%E4%B8%8E%E5%8F%AF%E6%89%A7%E8%A1%8C%E6%96%87%E4%BB%B6%E6%A0%BC%E5%BC%8F/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/06-%E8%B7%A8%E7%B3%BB%E7%BB%9F%E8%BF%90%E8%A1%8C-cpu-%E6%9E%B6%E6%9E%84-abi-%E4%B8%8E%E5%8F%AF%E6%89%A7%E8%A1%8C%E6%96%87%E4%BB%B6%E6%A0%BC%E5%BC%8F/</guid><description>直觉上很容易把问题归结为 CPU 架构不同：Windows 电脑长期以 x86-64 为主，Mac 现在以 ARM64 为主。但这只解释了一部分。 更关键的是：程序依赖的不只是 CPU 指令集，还依赖操作系统提供的二进制接口。 2019 年之前有大量 Intel Mac，CPU 架构和很多 Windows 电脑一样，但</description><pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;跨系统运行：CPU 架构、ABI 与可执行文件格式&lt;/h1&gt;
&lt;p&gt;直觉上很容易把问题归结为 CPU 架构不同：Windows 电脑长期以 x86-64 为主，Mac 现在以 ARM64 为主。但这只解释了一部分。&lt;/p&gt;
&lt;p&gt;更关键的是：程序依赖的不只是 CPU 指令集，还依赖操作系统提供的二进制接口。&lt;/p&gt;
&lt;p&gt;2019 年之前有大量 Intel Mac，CPU 架构和很多 Windows 电脑一样，但 Windows &lt;code&gt;.exe&lt;/code&gt; 依然不能直接当作 macOS 程序运行。同样，Linux 和 Windows 即使都在 x86-64 上，普通二进制也不能互相直接运行。&lt;/p&gt;
&lt;h2&gt;CPU 架构只是第一层&lt;/h2&gt;
&lt;p&gt;CPU 架构决定机器码长什么样。例如：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;x86-64 程序不能直接在 ARM CPU 上执行；&lt;/li&gt;
&lt;li&gt;ARM64 程序不能直接在 x86-64 CPU 上执行。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;但即使 CPU 指令集一样，程序仍然需要操作系统配合。因为程序运行时会不断请求系统服务：创建进程、读写文件、分配内存、访问网络、加载动态库、处理异常等。&lt;/p&gt;
&lt;p&gt;这些服务的入口和规则由 OS 定义。&lt;/p&gt;
&lt;h2&gt;用户态、内核态和系统调用&lt;/h2&gt;
&lt;p&gt;普通程序运行在用户态，不能直接控制硬件、页表、磁盘、网卡和定时器。需要这些能力时，它必须通过系统调用进入内核。&lt;/p&gt;
&lt;p&gt;这里讲的是“系统调用 ABI”，不是程序员平时直接写的高级 API。Windows 程序常调用 Win32 API，例如 &lt;code&gt;CreateProcess&lt;/code&gt;；这些 API 再进入 Windows 内核提供的更低层服务。Linux 程序常通过 libc 包装 &lt;code&gt;syscall&lt;/code&gt;，而不是手写系统调用指令。&lt;/p&gt;
&lt;p&gt;系统调用的一般流程是：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;用户程序把系统调用号放入约定寄存器；&lt;/li&gt;
&lt;li&gt;把参数放入约定寄存器或栈中；&lt;/li&gt;
&lt;li&gt;执行特殊入口指令，例如 x86-64 上常见的 &lt;code&gt;syscall&lt;/code&gt;，ARM64 上常见的 &lt;code&gt;svc&lt;/code&gt;；&lt;/li&gt;
&lt;li&gt;CPU 切换到内核态；&lt;/li&gt;
&lt;li&gt;操作系统读取系统调用号和参数，查表执行对应服务；&lt;/li&gt;
&lt;li&gt;内核返回用户态。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;问题在于：不同操作系统的系统调用集合、编号、参数规则都不同。&lt;/p&gt;
&lt;h2&gt;ABI：真正卡住二进制兼容的地方&lt;/h2&gt;
&lt;p&gt;ABI 是 Application Binary Interface，应用二进制接口。它规定的是“已经编译好的机器码如何和系统以及其他二进制模块打交道”。&lt;/p&gt;
&lt;p&gt;ABI 包括：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;系统调用编号；&lt;/li&gt;
&lt;li&gt;系统调用参数放在哪些寄存器里；&lt;/li&gt;
&lt;li&gt;函数调用约定；&lt;/li&gt;
&lt;li&gt;栈如何对齐；&lt;/li&gt;
&lt;li&gt;返回值放在哪里；&lt;/li&gt;
&lt;li&gt;动态链接规则；&lt;/li&gt;
&lt;li&gt;结构体布局；&lt;/li&gt;
&lt;li&gt;异常处理和线程局部存储规则；&lt;/li&gt;
&lt;li&gt;可执行文件格式。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;所以跨系统不兼容并不是“CPU 不认识这条加法指令”，而是“程序请求系统服务的方式和当前 OS 不匹配”。&lt;/p&gt;
&lt;h2&gt;Windows 和 Unix 创建进程的差异&lt;/h2&gt;
&lt;p&gt;Windows 提供 &lt;code&gt;CreateProcess&lt;/code&gt; 这类 Win32 API：一个主要 API 就能指定新程序路径、参数、环境、句柄继承等信息，然后创建新进程。它不是简单的一条 CPU 指令，也不是本文重点讨论的“系统调用编号”，而是 Windows 用户态 API 和内核服务共同形成的进程创建模型。&lt;/p&gt;
&lt;p&gt;Unix/Linux 传统上常见的是 &lt;code&gt;fork + exec&lt;/code&gt; 两步：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;fork()&lt;/code&gt;：复制当前进程，得到一个子进程；&lt;/li&gt;
&lt;li&gt;&lt;code&gt;exec()&lt;/code&gt;：在子进程中把当前程序映像替换成另一个程序。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这不是语法差异，而是进程模型差异。现代 Unix-like 系统也常提供 &lt;code&gt;posix_spawn()&lt;/code&gt;，它在语义上更接近“一步创建并执行新程序”，但底层仍要遵守该系统自己的 ABI 和加载规则。&lt;/p&gt;
&lt;h2&gt;fork 详解&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;fork()&lt;/code&gt; 调用后，会出现两个几乎一样的进程：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;父进程继续从 &lt;code&gt;fork()&lt;/code&gt; 返回处往下执行；&lt;/li&gt;
&lt;li&gt;子进程也从同一个位置往下执行；&lt;/li&gt;
&lt;li&gt;父进程中 &lt;code&gt;fork()&lt;/code&gt; 返回子进程 PID；&lt;/li&gt;
&lt;li&gt;子进程中 &lt;code&gt;fork()&lt;/code&gt; 返回 0。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;示意：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;pid_t pid = fork();

if (pid == 0) {
    // child
} else {
    // parent
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现代 Linux 不会在 &lt;code&gt;fork()&lt;/code&gt; 时立刻把父进程所有内存完整复制一份。它通常使用 copy-on-write：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;父子进程先共享同一批物理页；&lt;/li&gt;
&lt;li&gt;页表标记为只读；&lt;/li&gt;
&lt;li&gt;谁要写某页，触发缺页异常；&lt;/li&gt;
&lt;li&gt;内核这时才复制该页，让写入方拥有自己的副本。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这样 &lt;code&gt;fork()&lt;/code&gt; 可以很快，尤其适合马上接 &lt;code&gt;exec()&lt;/code&gt; 的场景。&lt;/p&gt;
&lt;h2&gt;exec 详解&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;exec()&lt;/code&gt; 不是创建新进程，而是替换当前进程的程序映像。&lt;/p&gt;
&lt;p&gt;执行 &lt;code&gt;exec()&lt;/code&gt; 后：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;PID 通常不变；&lt;/li&gt;
&lt;li&gt;当前地址空间被新程序替换；&lt;/li&gt;
&lt;li&gt;text/data/heap/stack 重新建立；&lt;/li&gt;
&lt;li&gt;程序从新可执行文件入口点开始；&lt;/li&gt;
&lt;li&gt;打开的文件描述符默认可以保留，除非设置了 close-on-exec；&lt;/li&gt;
&lt;li&gt;原来的代码不会继续往下执行，除非 &lt;code&gt;exec()&lt;/code&gt; 失败。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;典型 shell 执行命令的流程：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sequenceDiagram
    participant Shell
    participant Child
    participant Kernel

    Shell-&amp;gt;&amp;gt;Kernel: fork()
    Kernel--&amp;gt;&amp;gt;Shell: 返回 child pid
    Kernel--&amp;gt;&amp;gt;Child: 返回 0
    Child-&amp;gt;&amp;gt;Kernel: execve(&quot;/bin/ls&quot;, ...)
    Kernel-&amp;gt;&amp;gt;Child: 替换地址空间，跳到 ls 入口
    Shell-&amp;gt;&amp;gt;Kernel: waitpid(child)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;为什么要拆成两步？因为子进程在 &lt;code&gt;fork()&lt;/code&gt; 和 &lt;code&gt;exec()&lt;/code&gt; 之间可以做准备工作，例如重定向标准输入输出、设置环境变量、关闭文件描述符、改变工作目录等。&lt;/p&gt;
&lt;h2&gt;可执行文件格式不同&lt;/h2&gt;
&lt;p&gt;即使系统调用问题解决了，OS 也要能加载这个文件。&lt;/p&gt;
&lt;p&gt;常见格式：&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;系统&lt;/th&gt;
&lt;th&gt;可执行文件格式&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Windows&lt;/td&gt;
&lt;td&gt;PE / Portable Executable&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Linux&lt;/td&gt;
&lt;td&gt;ELF / Executable and Linkable Format&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;macOS&lt;/td&gt;
&lt;td&gt;Mach-O&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;可执行文件不只是机器码，还包含：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;入口点；&lt;/li&gt;
&lt;li&gt;代码段和数据段布局；&lt;/li&gt;
&lt;li&gt;动态库依赖；&lt;/li&gt;
&lt;li&gt;重定位信息；&lt;/li&gt;
&lt;li&gt;符号表；&lt;/li&gt;
&lt;li&gt;调试信息；&lt;/li&gt;
&lt;li&gt;权限和加载元数据。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;操作系统的加载器只认识自己支持的格式。Windows loader 不会按 ELF 规则加载普通 Linux 程序，Linux loader 也不会按 PE 规则运行普通 &lt;code&gt;.exe&lt;/code&gt;。Linux 可以通过 &lt;code&gt;binfmt_misc&lt;/code&gt; 把某些外来格式转交给解释器或兼容层，但那已经不是“内核原生直接运行这个二进制”。&lt;/p&gt;
&lt;h2&gt;运行时和跨平台语言&lt;/h2&gt;
&lt;p&gt;Python、JavaScript、Java 这类语言看起来更容易跨平台，是因为中间多了一层运行时：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Python 代码由对应平台的 Python 解释器执行；&lt;/li&gt;
&lt;li&gt;Java 字节码由 JVM 执行；&lt;/li&gt;
&lt;li&gt;JavaScript 由浏览器或 Node.js 执行。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;真正和操作系统 ABI 打交道的是解释器或虚拟机，而不是源码本身。&lt;/p&gt;
&lt;p&gt;但这不等于完全没有兼容问题。如果程序依赖平台专属模块、原生扩展、系统路径、动态库或外部命令，仍然可能只能在特定系统上运行。&lt;/p&gt;
&lt;h2&gt;Wine、虚拟机和容器分别解决什么&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;方案&lt;/th&gt;
&lt;th&gt;解决方式&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Wine&lt;/td&gt;
&lt;td&gt;在 Unix-like 系统上实现一层 Windows API/ABI 兼容层&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;虚拟机&lt;/td&gt;
&lt;td&gt;模拟一整套硬件环境，在里面运行另一个 OS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;容器&lt;/td&gt;
&lt;td&gt;共享宿主机内核，只隔离用户态环境；通常要求同一内核 ABI&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rosetta / QEMU&lt;/td&gt;
&lt;td&gt;做 CPU 指令集翻译&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;它们解决的问题不同。Wine 主要处理 Windows API 和 PE 加载；虚拟机直接带上完整 Windows；容器共享宿主机内核，所以 Linux 容器本质上仍运行 Linux 用户态程序；指令翻译只能解决 CPU 架构差异，不能自动解决 OS ABI 差异。&lt;/p&gt;
&lt;p&gt;一句话：二进制程序能不能跨系统运行，取决于 CPU 指令集、可执行文件格式、系统调用 ABI、动态链接和运行时环境是否全部匹配。&lt;/p&gt;
</content:encoded></item><item><title>cpu_scheduling</title><link>https://sanzenin.top/posts/obsidian/cpu-scheduling/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/cpu-scheduling/</guid><description>when a program is executed, it becomes a process and the operating system reserves a memory block for it. within this block, there&apos;s a memory segment called the</description><pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;/obsidian/cpu_scheduling-1784049668912.webp&quot; alt=&quot;cpu_scheduling-1784049668912&quot; /&gt;
&lt;img src=&quot;/obsidian/cpu_scheduling-1784049815339.webp&quot; alt=&quot;cpu_scheduling-1784049815339&quot; /&gt;
when a program is executed, it becomes a process and the operating system reserves a memory block for it. within this block, there&apos;s a memory segment called the text section which contains the executable code for the program.
&lt;img src=&quot;/obsidian/cpu_scheduling-1784049895199.webp&quot; alt=&quot;cpu_scheduling-1784049895199&quot; /&gt;
we know that the cpu contains a special register called the address register, also known as the program counter. this register points to the next instruction to be executed.
&lt;img src=&quot;/obsidian/cpu_scheduling-1784050437099.webp&quot; alt=&quot;cpu_scheduling-1784050437099&quot; /&gt;
but remember that what enters the queue isn&apos;t actually a process, but its process control block.&lt;/p&gt;
&lt;p&gt;but many applications such as servers or background services are designed to run indefinitely. if we allocate the cpu to a process that never ends, all subsequent processes would be indefinitely waiting in the queue. if we assume that a process can only get the cpu  fact is that programs in execution don&apos;t use the cpu continuously.&lt;/p&gt;
&lt;p&gt;eventually the final cpu burst ends with a system request to terminate execution.
&lt;img src=&quot;/obsidian/cpu_scheduling-1784050656308.webp&quot; alt=&quot;cpu_scheduling-1784050656308&quot; /&gt;
&lt;img src=&quot;/obsidian/cpu_scheduling-1784050697656.webp&quot; alt=&quot;cpu_scheduling-1784050697656&quot; /&gt;
the scheduler should allocate it only until the process&apos;s current cpu burst ends.
&lt;img src=&quot;/obsidian/cpu_scheduling-1784051033396.webp&quot; alt=&quot;cpu_scheduling-1784051033396&quot; /&gt;
so even though it is now ready to continue running, it must wait for its turn.for most of their lifetime, processes cycle between these three states: ready, running, and waiting.
&lt;img src=&quot;/obsidian/cpu_scheduling-1784051335794.webp&quot; alt=&quot;cpu_scheduling-1784051335794&quot; /&gt;
after making a system call to exit, the operating system must free allocated resources, including memory.
&lt;img src=&quot;/obsidian/cpu_scheduling-1784051506060.webp&quot; alt=&quot;cpu_scheduling-1784051506060&quot; /&gt;
dispatcher.when a running process enters an io waiting state and the cpu becomes available the dispatcher steps in with one single purpose.allocate the cpu to the process at the head of the ready q.
in other words, perform the context switch.&lt;/p&gt;
</content:encoded></item><item><title>Agent 学习：从 Tool Call 到 ReAct 与 Multi-Agent</title><link>https://sanzenin.top/posts/obsidian/agent%E5%AD%A6%E4%B9%A0-%E4%BB%8Etool-call%E5%88%B0react%E4%B8%8Emulti-agent/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/agent%E5%AD%A6%E4%B9%A0-%E4%BB%8Etool-call%E5%88%B0react%E4%B8%8Emulti-agent/</guid><description>写 Agent 之前，先把一件事想清楚：模型本身只会生成内容。它能“查天气”“移动文件”“写代码文件”，靠的是程序把这些能力包装成工具，再让模型在合适的时候选择工具。 本篇文章的完整学习路线为：先学 LangChain 的基本代码，再手写 Tool Call 协议，然后切到 LangChain 原生工具调用，再把一次工</description><pubDate>Mon, 13 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Agent 学习：从 Tool Call 到 ReAct 与 Multi-Agent&lt;/h1&gt;
&lt;p&gt;写 Agent 之前，先把一件事想清楚：模型本身只会生成内容。它能“查天气”“移动文件”“写代码文件”，靠的是程序把这些能力包装成工具，再让模型在合适的时候选择工具。&lt;/p&gt;
&lt;p&gt;本篇文章的完整学习路线为：先学 LangChain 的基本代码，再手写 Tool Call 协议，然后切到 LangChain 原生工具调用，再把一次工具调用扩展成 ReAct 循环，最后用 LangGraph 管理状态图和 Multi-Agent。&lt;/p&gt;
&lt;p&gt;整体路线是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph LR
    A[LangChain 基础] --&amp;gt; B[手写 Tool Call]
    B --&amp;gt; C[LangChain 原生 Tool Call]
    C --&amp;gt; D[While Loop ReAct]
    D --&amp;gt; E[LangGraph ReAct]
    E --&amp;gt; F[Reflection]
    F --&amp;gt; G[Plan + Execute]
    G --&amp;gt; H[Multi-Agent]
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;1. 先会用 LangChain 调模型&lt;/h2&gt;
&lt;p&gt;LangChain 里最基础的模型调用，就是创建一个 chat model，然后传入一组 messages。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import os
from pathlib import Path

from dotenv import load_dotenv
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
from pydantic import SecretStr


def load_llm() -&amp;gt; ChatOpenAI:
    load_dotenv(Path(&quot;.venv&quot;) / &quot;.env&quot;)
    return ChatOpenAI(
        model=os.getenv(&quot;MODEL&quot;, &quot;deepseek-chat&quot;),
        base_url=os.getenv(&quot;BASE_URL&quot;, &quot;https://api.deepseek.com&quot;),
        api_key=SecretStr(os.getenv(&quot;API_KEY&quot;, &quot;&quot;)),
        temperature=0,
    )


messages = [
    SystemMessage(content=&quot;你是一个助手。&quot;),
    HumanMessage(content=&quot;你好，介绍一下 LangChain。&quot;),
]

response = load_llm().invoke(messages)
print(response.content)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里先记三个点。&lt;/p&gt;
&lt;p&gt;第一，&lt;code&gt;ChatOpenAI&lt;/code&gt; 不只可以调 OpenAI，也可以调兼容 OpenAI API 协议的模型服务。关键参数是 &lt;code&gt;model&lt;/code&gt;、&lt;code&gt;base_url&lt;/code&gt;、&lt;code&gt;api_key&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;第二，LangChain 把上下文拆成消息对象。&lt;code&gt;SystemMessage&lt;/code&gt; 放规则，&lt;code&gt;HumanMessage&lt;/code&gt; 放用户输入，模型返回的是一条 AI 消息。&lt;/p&gt;
&lt;p&gt;第三，&lt;code&gt;messages&lt;/code&gt; 后面会变成 Agent 的记忆。工具调用、工具结果、反思建议，都会不断追加到这条消息链里。&lt;/p&gt;
&lt;h2&gt;2. 再会用 LangChain 定义工具&lt;/h2&gt;
&lt;p&gt;工具就是普通 Python 函数，只是加上了 LangChain 的 &lt;code&gt;@tool&lt;/code&gt; 装饰器。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from langchain_core.tools import tool


@tool
def get_weather(city: str) -&amp;gt; str:
    &quot;&quot;&quot;Get the weather for a city.&quot;&quot;&quot;
    weather = {
        &quot;Beijing&quot;: &quot;晴天，25 度&quot;,
        &quot;Shanghai&quot;: &quot;多云，28 度&quot;,
        &quot;Hangzhou&quot;: &quot;小雨，22 度&quot;,
    }
    return f&quot;{city} 的天气是：{weather.get(city, &apos;未知天气&apos;)}&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;函数名会变成工具名。参数类型会变成工具参数 schema。docstring 会变成工具描述。&lt;/p&gt;
&lt;p&gt;绑定工具的代码是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;llm = load_llm().bind_tools([get_weather])
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这一步的意思是：把工具列表告诉模型。模型下一次生成时，就可以返回结构化的工具调用。&lt;/p&gt;
&lt;p&gt;工具执行完以后，要用 &lt;code&gt;ToolMessage&lt;/code&gt; 把结果放回上下文。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from langchain_core.messages import ToolMessage


messages.append(response)
messages.append(
    ToolMessage(
        content=result,
        name=tool_call[&quot;name&quot;],
        tool_call_id=tool_call[&quot;id&quot;],
    )
)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这段是 LangChain Agent 的基础。模型决定调用工具，Python 执行工具，工具结果通过 &lt;code&gt;ToolMessage&lt;/code&gt; 回到模型上下文。&lt;/p&gt;
&lt;h2&gt;3. 简单手写 Tool Call&lt;/h2&gt;
&lt;p&gt;第一段学习代码先绕开 LangChain 原生 tool calling，手写了一个工具协议。&lt;/p&gt;
&lt;p&gt;模型被要求输出固定格式：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;Tool&amp;gt;get_weather&amp;lt;/Tool&amp;gt;
&amp;lt;Args&amp;gt;{&quot;city&quot;:&quot;Beijing&quot;}&amp;lt;/Args&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;程序用正则把工具名和参数解析出来：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import json
import re


def parse_tool_call(text: str) -&amp;gt; dict[str, object] | None:
    tool_match = re.search(r&quot;&amp;lt;Tool&amp;gt;(.*?)&amp;lt;/Tool&amp;gt;&quot;, text, re.DOTALL)
    args_match = re.search(r&quot;&amp;lt;Args&amp;gt;(.*?)&amp;lt;/Args&amp;gt;&quot;, text, re.DOTALL)

    if not tool_match:
        return None

    args = json.loads(args_match.group(1)) if args_match else {}
    return {
        &quot;tool&quot;: tool_match.group(1).strip(),
        &quot;args&quot;: args,
    }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后根据工具名调用真实函数：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;call = parse_tool_call(model_text)

if call[&quot;tool&quot;] == &quot;get_weather&quot;:
    result = get_weather(**call[&quot;args&quot;])
else:
    result = f&quot;未知工具：{call[&apos;tool&apos;]}&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;模型没有真的执行工具。模型只输出了一个动作描述。Python 程序读取这个描述，再决定调用哪个函数。&lt;/p&gt;
&lt;p&gt;这也是后面所有 Agent 框架的底层逻辑。不过框架做得更标准，但本质上仍然是“模型给动作，程序执行动作”。&lt;/p&gt;
&lt;h2&gt;4. LangChain 原生 Tool Call：把协议交给框架&lt;/h2&gt;
&lt;p&gt;手写 XML 协议可以帮助理解原理，但格式太容易漂。第二段学习代码换成了 LangChain 原生工具调用。&lt;/p&gt;
&lt;p&gt;先定义两个工具：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;@tool
def get_weather(city: str) -&amp;gt; str:
    &quot;&quot;&quot;Get the weather for a city.&quot;&quot;&quot;
    return f&quot;{city} 的天气是：晴天，25 度&quot;


@tool
def get_time(city: str) -&amp;gt; str:
    &quot;&quot;&quot;Get the current time for a city.&quot;&quot;&quot;
    return f&quot;{city} 的当前时间是：14:00&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;再把工具绑定到模型：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;llm = load_llm().bind_tools([get_weather, get_time])
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在模型返回的结果里会有 &lt;code&gt;tool_calls&lt;/code&gt;：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;response = llm.invoke(messages)

print(response.content)
print(response.tool_calls)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每个 &lt;code&gt;tool_call&lt;/code&gt; 大概包含这些信息：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;tool_call[&quot;name&quot;]  # 工具名
tool_call[&quot;args&quot;]  # 工具参数
tool_call[&quot;id&quot;]    # 本次工具调用的 ID
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;执行工具时，一般会先做一个工具映射表：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;tools = {
    &quot;get_weather&quot;: get_weather,
    &quot;get_time&quot;: get_time,
}

for tool_call in response.tool_calls:
    selected_tool = tools[tool_call[&quot;name&quot;]]
    result = selected_tool.invoke(tool_call[&quot;args&quot;])
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后把工具结果写回消息链：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;messages.append(response)
messages.append(
    ToolMessage(
        content=result,
        name=tool_call[&quot;name&quot;],
        tool_call_id=tool_call[&quot;id&quot;],
    )
)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最后再调用一次模型，让模型根据工具结果组织最终回答：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;final_response = llm.invoke(messages)
print(final_response.content)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;总结就是 LangChain 负责工具 schema 和结构化 tool call，开发者仍然要负责执行工具和回填 Tool Message。&lt;/p&gt;
&lt;h2&gt;5. While Loop ReAct：把一次工具调用扩展成多轮执行&lt;/h2&gt;
&lt;p&gt;一次 Tool Call 只能处理一步。真实任务通常要多步执行，比如先查看目录，再移动文件，再检查结果。&lt;/p&gt;
&lt;p&gt;ReAct 的写法就是加一个循环：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph TD
    A[初始化 messages] --&amp;gt; B[模型生成下一步]
    B --&amp;gt; C{是否有 tool_calls}
    C --&amp;gt;|有| D[执行一个工具]
    D --&amp;gt; E[追加 ToolMessage]
    E --&amp;gt; B
    C --&amp;gt;|无| F[输出最终回答]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;核心代码可以写成这样：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;messages = [
    SystemMessage(content=SYSTEM_PROMPT),
    HumanMessage(content=TASK_PROMPT),
]

tools = [move_file, list_files]
tool_map = {tool.name: tool for tool in tools}
model = load_llm().bind_tools(tools)

for _ in range(7):
    response = model.invoke(messages)
    messages.append(response)

    if not response.tool_calls:
        print(response.content)
        break

    tool_call = response.tool_calls[0]
    selected_tool = tool_map[tool_call[&quot;name&quot;]]
    result = selected_tool.invoke(tool_call[&quot;args&quot;])

    messages.append(
        ToolMessage(
            content=str(result),
            name=tool_call[&quot;name&quot;],
            tool_call_id=tool_call[&quot;id&quot;],
        )
    )
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里有两个重点。&lt;/p&gt;
&lt;p&gt;第一，&lt;code&gt;messages&lt;/code&gt; 是整个 Agent 的运行记录。模型每次都能看到前面发生了什么。&lt;/p&gt;
&lt;p&gt;第二，循环一定要有限制。示例里最多跑 7 轮，每轮最多执行一个工具。这样即使模型判断不稳定，也不会无限调用工具。&lt;/p&gt;
&lt;p&gt;LangChain 在这里负责模型调用、工具声明和 Tool Message。控制流还在普通 Python 循环里。&lt;/p&gt;
&lt;h2&gt;6. LangGraph ReAct：把循环改成状态图&lt;/h2&gt;
&lt;p&gt;while loop 跑通以后，下一步就是把 ReAct 改写成 LangGraph。&lt;/p&gt;
&lt;p&gt;LangGraph 的三个基本概念是：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;state：保存当前任务状态。&lt;/li&gt;
&lt;li&gt;node：读取 state，返回更新后的 state。&lt;/li&gt;
&lt;li&gt;edge：决定下一个节点。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;先定义状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from typing import TypedDict
from langchain_core.messages import BaseMessage


class AgentState(TypedDict):
    messages: list[BaseMessage]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;再定义 Agent 节点：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def agent_node(state: AgentState) -&amp;gt; AgentState:
    response = model.invoke([
        SystemMessage(content=SYSTEM_PROMPT),
        *state[&quot;messages&quot;],
    ])

    return {
        **state,
        &quot;messages&quot;: [*state[&quot;messages&quot;], response],
    }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Tools 节点负责执行模型返回的工具调用：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from langchain_core.messages import AIMessage, ToolMessage


def tools_node(state: AgentState) -&amp;gt; AgentState:
    response = state[&quot;messages&quot;][-1]
    new_messages = list(state[&quot;messages&quot;])

    if not isinstance(response, AIMessage):
        return state

    for tool_call in response.tool_calls:
        result = tool_map[tool_call[&quot;name&quot;]].invoke(tool_call[&quot;args&quot;])
        new_messages.append(
            ToolMessage(
                content=str(result),
                name=tool_call[&quot;name&quot;],
                tool_call_id=tool_call[&quot;id&quot;],
            )
        )

    return {**state, &quot;messages&quot;: new_messages}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;条件函数决定是否继续：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from langgraph.graph import END


def should_continue(state: AgentState) -&amp;gt; str:
    response = state[&quot;messages&quot;][-1]
    return &quot;tools&quot; if getattr(response, &quot;tool_calls&quot;, None) else END
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最后把节点连成图：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from langgraph.graph import START, StateGraph


graph = StateGraph(AgentState)
graph.add_node(&quot;agent&quot;, agent_node)
graph.add_node(&quot;tools&quot;, tools_node)

graph.add_edge(START, &quot;agent&quot;)
graph.add_conditional_edges(
    &quot;agent&quot;,
    should_continue,
    {&quot;tools&quot;: &quot;tools&quot;, END: END},
)
graph.add_edge(&quot;tools&quot;, &quot;agent&quot;)

app = graph.compile()
final_state = app.invoke({&quot;messages&quot;: messages})
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这时 ReAct 的结构就从“隐藏在循环里”变成了“画在图上”。&lt;/p&gt;
&lt;p&gt;LangChain 仍然负责工具和模型。LangGraph 负责流程：先到 Agent，判断是否去 Tools，Tools 执行完再回 Agent。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph TD
    START([START]) --&amp;gt; Agent[agent]
    Agent --&amp;gt; Decide{should_continue}
    Decide --&amp;gt;|tools| Tools[tools]
    Tools --&amp;gt; Agent
    Decide --&amp;gt;|END| END([END])
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;7. Reflection：在图里插入 reviewer 节点&lt;/h2&gt;
&lt;p&gt;ReAct 有时会出现一个问题：任务已经完成了，模型还想继续调用工具。&lt;/p&gt;
&lt;p&gt;解决办法是加一个 Reflection 节点，让 reviewer 根据最近的工具结果给 executor 一句建议。&lt;/p&gt;
&lt;p&gt;状态里多一个字段：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class AgentState(TypedDict):
    messages: list[BaseMessage]
    reflection: str
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Agent 节点调用模型时，把 reflection note 拼进 prompt：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def agent_node(state: AgentState) -&amp;gt; AgentState:
    prompt = SYSTEM_PROMPT

    if state[&quot;reflection&quot;]:
        prompt += f&quot;\n\nReflection note: {state[&apos;reflection&apos;]}&quot;

    response = model.invoke([
        SystemMessage(content=prompt),
        *state[&quot;messages&quot;],
    ])

    return {
        **state,
        &quot;messages&quot;: [*state[&quot;messages&quot;], response],
    }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Reflection 节点只看最近几条消息：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def reflection_node(state: AgentState) -&amp;gt; AgentState:
    recent_messages = state[&quot;messages&quot;][-4:]
    transcript = &quot;\n&quot;.join(str(message.content) for message in recent_messages)

    note = base_llm.invoke([
        SystemMessage(content=REFLECTION_PROMPT),
        HumanMessage(content=transcript),
    ])

    return {**state, &quot;reflection&quot;: str(note.content)}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;图结构也只多了一段：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph.add_edge(&quot;tools&quot;, &quot;reflection&quot;)
graph.add_edge(&quot;reflection&quot;, &quot;agent&quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;对应的图是：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph TD
    START([START]) --&amp;gt; Agent[agent]
    Agent --&amp;gt; Decide{是否调用工具}
    Decide --&amp;gt;|是| Tools[tools]
    Tools --&amp;gt; Reflection[reflection]
    Reflection --&amp;gt; Agent
    Decide --&amp;gt;|否| END([END])
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这一步开始体现 LangGraph 的优势了。加 reviewer 不需要重写主循环，只是在图里加一个节点，再改两条边。&lt;/p&gt;
&lt;h2&gt;8. Plan + Execute：先生成计划，再按计划执行&lt;/h2&gt;
&lt;p&gt;再往后，可以在执行前加一个 Planner 节点。&lt;/p&gt;
&lt;p&gt;Planner 负责把用户任务拆成步骤：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;PLANNER_PROMPT = &quot;&quot;&quot;
你是一个任务规划助手。请根据用户任务制定一个清晰的执行计划。
请按顺序输出具体步骤，每步一行，使用 &quot;1. &quot; 编号。
只输出计划步骤，不要输出额外解释。
&quot;&quot;&quot;.strip()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;状态继续扩展：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class AgentState(TypedDict):
    task: str
    plan: list[str]
    messages: list[BaseMessage]
    reflection: str
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Planner 节点生成计划，并把计划写入 state：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def planner_node(state: AgentState) -&amp;gt; AgentState:
    response = base_llm.invoke([
        SystemMessage(content=PLANNER_PROMPT),
        HumanMessage(content=state[&quot;task&quot;]),
    ])

    plan = parse_plan(str(response.content))
    plan_text = &quot;\n&quot;.join(
        f&quot;{index}. {step}&quot;
        for index, step in enumerate(plan, start=1)
    )

    plan_message = HumanMessage(
        content=f&quot;用户任务：{state[&apos;task&apos;]}\n\n计划：\n{plan_text}&quot;
    )

    return {
        **state,
        &quot;plan&quot;: plan,
        &quot;messages&quot;: [*state[&quot;messages&quot;], plan_message],
    }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Executor 节点把计划放进 prompt：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def agent_node(state: AgentState) -&amp;gt; AgentState:
    plan_text = &quot;\n&quot;.join(
        f&quot;{index}. {step}&quot;
        for index, step in enumerate(state[&quot;plan&quot;], start=1)
    )

    prompt = f&quot;{SYSTEM_PROMPT}\n\n计划：\n{plan_text}&quot;

    if state[&quot;reflection&quot;]:
        prompt += f&quot;\n\nReflection note: {state[&apos;reflection&apos;]}&quot;

    response = tool_llm.invoke([
        SystemMessage(content=prompt),
        *state[&quot;messages&quot;],
    ])

    return {
        **state,
        &quot;messages&quot;: [*state[&quot;messages&quot;], response],
    }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;完整图如下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph TD
    START([START]) --&amp;gt; Planner[planner]
    Planner --&amp;gt; Agent[agent]
    Agent --&amp;gt; Decide{should_continue}
    Decide --&amp;gt;|tools| Tools[tools]
    Tools --&amp;gt; Reflection[reflection]
    Reflection --&amp;gt; Agent
    Decide --&amp;gt;|END| END([END])
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这版里 LangChain 有两个角色：普通 LLM 用来规划和反思，绑定工具的 LLM 用来执行。LangGraph 把这些角色拆成不同节点。&lt;/p&gt;
&lt;p&gt;这个结构比纯 ReAct 更稳。模型先有一个路线图，再根据工具结果一步步调整。&lt;/p&gt;
&lt;h2&gt;9. Multi-Agent 第一版：把 specialist agent 包成工具&lt;/h2&gt;
&lt;p&gt;Multi-Agent 的第一种写法，是先创建几个 specialist agent，再把它们包装成 supervisor 可以调用的工具。&lt;/p&gt;
&lt;p&gt;先创建两个职责窄的 agent：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;from langchain.agents import create_agent


file_agent = create_agent(
    model=llm,
    tools=[list_files, move_file],
    system_prompt=FILE_AGENT_PROMPT,
    name=&quot;file_agent&quot;,
)

code_agent = create_agent(
    model=llm,
    tools=[write_file],
    system_prompt=CODE_AGENT_PROMPT,
    name=&quot;code_agent&quot;,
)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;再把 agent 包装成工具：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;@tool
def call_file_agent(instruction: str) -&amp;gt; str:
    &quot;&quot;&quot;Delegate a file-management task to file_agent.&quot;&quot;&quot;
    response = file_agent.invoke({
        &quot;messages&quot;: [{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: instruction}]
    })
    return str(response[&quot;messages&quot;][-1].content)


@tool
def call_code_agent(instruction: str) -&amp;gt; str:
    &quot;&quot;&quot;Delegate a code-generation task to code_agent.&quot;&quot;&quot;
    response = code_agent.invoke({
        &quot;messages&quot;: [{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: instruction}]
    })
    return str(response[&quot;messages&quot;][-1].content)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最后创建 supervisor：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;supervisor = create_agent(
    model=llm,
    tools=[call_file_agent, call_code_agent],
    system_prompt=SUPERVISOR_PROMPT,
    name=&quot;supervisor&quot;,
)

response = supervisor.invoke({
    &quot;messages&quot;: [{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: task}]
})
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这一版主要是 LangChain 的教学点：agent 也可以被包装成工具。supervisor 看起来只是在调用两个工具，工具背后其实各自跑了一个完整 agent。&lt;/p&gt;
&lt;p&gt;结构如下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph TD
    User[用户任务] --&amp;gt; Supervisor[supervisor]
    Supervisor --&amp;gt; CallFile[call_file_agent]
    Supervisor --&amp;gt; CallCode[call_code_agent]
    CallFile --&amp;gt; FileAgent[file_agent]
    CallCode --&amp;gt; CodeAgent[code_agent]
    FileAgent --&amp;gt; FileTools[list_files / move_file]
    CodeAgent --&amp;gt; CodeTools[write_file]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这种写法很适合快速实现 multi-agent。缺点也很明显：调用顺序主要靠 supervisor prompt 约束，状态结构没有显式展开。&lt;/p&gt;
&lt;h2&gt;10. Multi-Agent 第二版：把每个 agent 放进 LangGraph 节点&lt;/h2&gt;
&lt;p&gt;第二种写法更接近工程化 Multi-Agent：每个 agent 都是 LangGraph 里的一个节点。&lt;/p&gt;
&lt;p&gt;先定义状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class MultiAgentState(TypedDict):
    task: str
    next_agent: str
    file_report: str
    code_report: str
    final_answer: str
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;supervisor 节点负责决定下一步：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def supervisor_node(state: MultiAgentState) -&amp;gt; MultiAgentState:
    if not state[&quot;file_report&quot;]:
        next_agent = &quot;file_agent&quot;
    elif not state[&quot;code_report&quot;]:
        next_agent = &quot;code_agent&quot;
    else:
        next_agent = &quot;finish&quot;

    decision = llm.invoke([
        SystemMessage(content=SUPERVISOR_PROMPT),
        HumanMessage(content=f&quot;建议答案：{next_agent}&quot;),
    ]).content

    decision = str(decision).strip()
    if decision not in {&quot;file_agent&quot;, &quot;code_agent&quot;, &quot;finish&quot;}:
        decision = next_agent

    return {**state, &quot;next_agent&quot;: decision}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里有个很实用的兜底：先用代码推一个建议答案，再让 LLM 判断。如果 LLM 输出非法值，就回退到代码建议。&lt;/p&gt;
&lt;p&gt;specialist 节点只做自己的事，并把报告写回 state：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def file_agent_node(state: MultiAgentState) -&amp;gt; MultiAgentState:
    result = file_agent.invoke({
        &quot;messages&quot;: [{
            &quot;role&quot;: &quot;user&quot;,
            &quot;content&quot;: f&quot;只处理文件整理任务：{state[&apos;task&apos;]}&quot;,
        }]
    })

    return {
        **state,
        &quot;file_report&quot;: str(result[&quot;messages&quot;][-1].content),
    }
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;路由函数根据 &lt;code&gt;next_agent&lt;/code&gt; 决定下一步：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def route_next(state: MultiAgentState) -&amp;gt; str:
    if state[&quot;next_agent&quot;] == &quot;file_agent&quot;:
        return &quot;file_agent&quot;
    if state[&quot;next_agent&quot;] == &quot;code_agent&quot;:
        return &quot;code_agent&quot;
    return END
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;最后组图：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph = StateGraph(MultiAgentState)
graph.add_node(&quot;supervisor&quot;, supervisor_node)
graph.add_node(&quot;file_agent&quot;, file_agent_node)
graph.add_node(&quot;code_agent&quot;, code_agent_node)

graph.add_edge(START, &quot;supervisor&quot;)
graph.add_conditional_edges(&quot;supervisor&quot;, route_next)
graph.add_edge(&quot;file_agent&quot;, &quot;supervisor&quot;)
graph.add_edge(&quot;code_agent&quot;, &quot;supervisor&quot;)

app = graph.compile()
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;图结构如下：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;graph TD
    START([START]) --&amp;gt; Supervisor[supervisor]
    Supervisor --&amp;gt; Route{route_next}
    Route --&amp;gt;|file_agent| FileAgent[file_agent]
    Route --&amp;gt;|code_agent| CodeAgent[code_agent]
    Route --&amp;gt;|finish| END([END])
    FileAgent --&amp;gt; Supervisor
    CodeAgent --&amp;gt; Supervisor
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在这里,supervisor 不再只是 prompt 里的概念，它变成了图里的路由节点。每个 specialist agent 也有自己的节点和状态字段。&lt;/p&gt;
&lt;p&gt;这种写法更适合继续扩展。比如后面要加 research agent、review agent、human approval，只需要继续加节点和条件边。&lt;/p&gt;
&lt;h2&gt;11. 小结&lt;/h2&gt;
&lt;p&gt;以上大致内容可以压缩成一句话：先让模型会表达工具调用，再让程序执行工具，最后用图把多轮执行和多 agent 协作管起来。&lt;/p&gt;
&lt;p&gt;LangChain 解决的是“模型、消息、工具”这层问题。你用它定义工具、绑定工具、读取 &lt;code&gt;tool_calls&lt;/code&gt;、回填 &lt;code&gt;ToolMessage&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;LangGraph 解决的是“流程、状态、路由”这层问题。先定义 state、node、edge，把 ReAct、Reflection、Plan、Multi-Agent 都放进同一套状态图里。&lt;/p&gt;
</content:encoded></item><item><title>System&apos;s Integrity</title><link>https://sanzenin.top/posts/obsidian/system-s-integrity/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/system-s-integrity/</guid><description>System&apos;s Integrity，来自 Obsidian 的操作系统笔记。</description><pubDate>Mon, 13 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
</content:encoded></item><item><title>PDE上机</title><link>https://sanzenin.top/posts/obsidian/pde%E4%B8%8A%E6%9C%BA/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/pde%E4%B8%8A%E6%9C%BA/</guid><description>真实解: 其中拉普拉斯算子 精确解析解： 五点差分 解析解: 求前向,后向,CN 精确解析解： 4的ADI 控制方程： 边界条件（双端固定）： 初始条件（给定初始位移与初始速度）： 精确解析解： tao=0.05,h=0.1 tao=0.1,h=0.1 控制方程： 初始条件： 边界条件：右边界 （左边界无边界条件，通过</description><pubDate>Wed, 17 Jun 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h3&gt;1. 程序一：一维变系数常微分方程（两点边值问题）的中心差分求解&lt;/h3&gt;
&lt;p&gt;$$ \begin{cases} -\displaystyle \frac{d}{dx}\left(x \frac{du}{dx}\right) + x^2 \frac{du}{dx} - x,u = (x^2-1)\cos x,\quad 0&amp;lt;x&amp;lt;\pi\[6pt] u(0)=0,\quad u(\pi)=0 \end{cases} $$ &lt;strong&gt;真实解&lt;/strong&gt;:
$$u(x)=\sin(x)$$&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;clear; clc; close all;
a=0
b=pi
N=1000
h=pi/N
x_all=linspace(a,b,N+1)
x=x_all(2:end-1)&apos;
mid=2*x./(h^2)-x;
up=-x/(h^2)-1/(2*h)+x.^2/(2*h)%推导要正确
low=-x/(h^2)+1/(2*h)-x.^2/(2*h)
low=[low(2:end);0]%注意spdiags会从头开始取
up=[0;up(1:end-1)]
A=spdiags([low,mid,up],[-1,0,1],N-1,N-1)
f=@(x)(x.^2-1).*cos(x)%两个向量之间用.*
u_exact=sin(x)
f_val=f(x)
u_cal=A\f_val
plot(x,u_exact,&apos;r-&apos;,LineWidth=2)
hold on
plot(x,u_cal,&apos;b--&apos;,LineWidth=3)
hold on
grid on
xlabel(&quot;x&quot;)
ylabel(&quot;u&quot;)
legend(&quot;实际解&quot;,&quot;数值解&quot;)
err=max(abs(u_cal-u_exact))
fprintf(&quot;最大误差 %.10f&quot;,err);
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2. 程序二：二维泊松方程的五点差分与 Kronecker 积直接法求解&lt;/h3&gt;
&lt;p&gt;$$ \begin{cases} \displaystyle \Delta u = 2\pi^2 e^{\pi(x+y)}\big(\sin\pi x \cos\pi y + \cos\pi x \sin\pi y\big),\quad (x,y)\in G=(0,1)\times(0,1)\[6pt] u(x,y)=0,\quad (x,y)\in \partial G \end{cases} $$ 其中拉普拉斯算子 $\displaystyle \Delta u=\frac{\partial^2 u}{\partial x^2}+\frac{\partial^2 u}{\partial y^2}$
&lt;strong&gt;精确解析解&lt;/strong&gt;： $$ u(x,y)=e^{\pi(x+y)}\sin\pi x \sin\pi y $$
五点差分&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;clear; clc;
hs=[1/64,1/128];
a=0;
b=1;
for id=1:length(hs)
    h=hs(id);
    N=round(1/h);
    r=1/(h^2);
    grid1d=linspace(a,b,N+1);
    grid1d=grid1d(2:end-1);%一定要截掉断点
    [X,Y]=ndgrid(grid1d,grid1d);%注意是ndgrid
    x=X(:);
    y=Y(:);
    u_exact=exp((x+y).*pi).*sin(x*pi).*sin(y*pi);
    f=2*(pi^2)*exp((x+y).*pi).*(sin((x+y).*pi));
    I=speye(N-1);
    e=ones(N-1,1);
    Tx=spdiags([r*e,-2*r*e,r*e],[-1,0,1],N-1,N-1);
    Ty=spdiags([r*e,-2*r*e,r*e],[-1,0,1],N-1,N-1);
    A=kron(I,Tx)+kron(Ty,I);
    u=A\f;
    err=max(abs(u-u_exact));
    fprintf(&quot;现在步长%.4f 误差%.10f\n&quot;,h,err);
end
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3. 程序三：一维热传导方程的三种经典时间步进格式对比&lt;/h3&gt;
&lt;p&gt;$$ \frac{\partial u}{\partial t} = \frac{\partial^2 u}{\partial x^2} + \sin t, \quad 0 &amp;lt; x &amp;lt; 1, \quad t &amp;gt; 0 $$
$$ u_x(0, t) = u_x(1, t) = 0 $$
$$ u(0, x) = \cos(\pi x)$$
&lt;strong&gt;解析解&lt;/strong&gt;:
$$ u_{\text{}}(x,t) = e^{-\pi^2 t}\cos(\pi x) + 1 - \cos t $$
求前向,后向,CN&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;clear;
clc;
a=0;
b=1;
J=40;
N=3200;
h=1/J;
tao=1/N;
r=tao/(h^2);
x=linspace(0,1,J+1)&apos;;
t=linspace(0,1,N+1)&apos;;
e=ones(J+1,1);
del=spdiags([r*e,-2*r*e,r*e],[-1,0,1],J+1,J+1);
del(1,2)=2*r;
del(end,end-1)=2*r;


A_f=speye(J+1)+del;
u_f=cos(pi*x);
err=0;
for i=2:length(t)
    tim=t(i);
    u_exact=exp(-pi^2*tim)*cos(pi*x)+1-cos(tim);
    u_f=A_f*u_f+tao*sin(t(i-1));%注意sin要乘以tao
    err=max(err,max(abs(u_exact-u_f)));
end
fprintf(&quot;前向 最大误差%.10f\n&quot;,err);


A_b=speye(J+1)-del;
u_b=cos(pi*x);
err=0;
for i=2:length(t)
    tim=t(i);
    u_exact=exp(-pi^2*tim)*cos(pi*x)+1-cos(tim);
    u_b=A_b\(u_b+tao*sin(tim));
    err=max(err,max(abs(u_exact-u_b)));
end
fprintf(&quot;后向 最大误差%.10f\n&quot;,err);


A_cn=speye(J+1)-del/2;
B_cn=speye(J+1)+del/2;
u_cn=cos(pi*x);
err=0;
for i=2:length(t)
    tim=t(i);
    u_exact=exp(-pi^2*tim)*cos(pi*x)+1-cos(tim);
    u_cn=A_cn\(B_cn*u_cn+tao*0.5*(sin(tim)+sin(t(i-1))));
    err=max(err,max(abs(u_exact-u_cn)));
end
fprintf(&quot;CN 最大误差%.10f\n&quot;,err);
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4. 程序四：二维热传导方程在混合边界条件下的 Crank-Nicolson 格式求解&lt;/h3&gt;
&lt;p&gt;$$ \begin{cases} \displaystyle \frac{\partial u}{\partial t} = 4^{-2}\left(\frac{\partial^2 u}{\partial x^2}+\frac{\partial^2 u}{\partial y^2}\right),\quad (x,y)\in G=(0,1)\times(0,1),\ t&amp;gt;0\[6pt] u(0,y,t)=u(1,y,t)=0,\quad 0&amp;lt;y&amp;lt;1,\ t&amp;gt;0\[6pt] \displaystyle \frac{\partial u}{\partial y}(x,0,t)=\frac{\partial u}{\partial y}(x,1,t)=0,\quad 0&amp;lt;x&amp;lt;1,\ t&amp;gt;0\[6pt] u(x,y,0)=\sin \pi x \cos \pi y,\quad (x,y)\in \overline{G} \end{cases} $$
&lt;strong&gt;精确解析解&lt;/strong&gt;：
$$ u(x,y,t) = \sin\pi x \cos\pi y \exp\left(-\frac{\pi^2}{8}t\right) $$&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;a=1/16;
N=1600;
left=0;
right=1;
J=40;
K=40;
x=linspace(left,right,J+1);
y=linspace(left,right,K+1);
h=1/J;
tao=1/N;
r=a*tao/(h^2);
t=linspace(0,1,N+1)&apos;;
e_x=ones(J-1,1);
e_y=ones(K+1,1);
Tx=spdiags([r*e_x,-2*r*e_x,r*e_x],[-1,0,1],J-1,J-1);
Ty=spdiags([r*e_y,-2*r*e_y,r*e_y],[-1,0,1],K+1,K+1);
Ty(1,2)=2*r;
Ty(K+1,K)=2*r;
delta2d=kron(speye(K+1),Tx)+kron(Ty,speye(J-1));%不要记反
I=speye((J-1)*(K+1));
A=I-delta2d/2;
B=I+delta2d/2;
[X,Y]=ndgrid(x(2:end-1),y);
u=sin(pi*X).*cos(pi*Y);
u=u(:);
err=0;
for i=2:length(t)
    tim=t(i);
    u_exact=sin(pi*X).*cos(pi*Y)*exp(-(pi^2/8)*tim);
    u_exact=u_exact(:);
    u=A\(B*u);
    err=max(abs(u_exact-u));
end
fprintf(&quot;二维CN全局最大误差 %.10f&quot;,err);

&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;5. 程序五：二维热传导方程求解效率对比（CN 全隐式 vs ADI 维数分裂）&lt;/h3&gt;
&lt;p&gt;4的ADI&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;clear;
clc;
a=1/16;
J=40;
K=40;
N=1600;
h=1/J;
tao=1/N;
r=a*tao/(h^2);
t=linspace(0,1,N+1)&apos;;
x=linspace(0,1,J+1)&apos;;
x=x(2:end-1);
y=linspace(0,1,K+1)&apos;;
[X,Y]=ndgrid(x,y);
X=X(:);
Y=Y(:);
ex=ones(J-1,1);
ey=ones(K+1,1);
delx=spdiags([r*ex,-2*r*ex,r*ex],[-1,0,1],J-1,J-1);
dely=spdiags([r*ey,-2*r*ey,r*ey],[-1,0,1],K+1,K+1);
dely(1,2)=2*r;
dely(end,end-1)=2*r;
I=speye((K+1)*(J-1));
Ax=I-kron(speye(K+1),delx)/2;
By=I+kron(dely,speye(J-1))/2;
Ay=I-kron(dely,speye(J-1))/2;
Bx=I+kron(speye(K+1),delx)/2;
err=0;
u_adi=sin(pi*X).*cos(pi*Y);
for i=2:length(t)
    tim=t(i);
    u_exact=exp(-pi^2/8*tim)*sin(pi*X).*cos(pi*Y);
    u_half=Ax\(By*u_adi);
    u_adi=Ay\(Bx*u_half);
    err=max(err,max(abs(u_exact-u_adi)));
end
fprintf(&quot;adi 最大误差%.10f\n&quot;,err);
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;6. 程序六：一维二阶波动方程的经典三层显式格式求解&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;控制方程&lt;/strong&gt;：
$$\frac{\partial^2 u}{\partial t^2} = \frac{\partial^2 u}{\partial x^2}, \quad x \in (0, 1), \quad t &amp;gt; 0$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;边界条件&lt;/strong&gt;（双端固定）：
$$u(0, t) = 0, \quad u(1, t) = 0$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;初始条件&lt;/strong&gt;（给定初始位移与初始速度）：
$$u(x, 0) = \sin(\pi x)$$
$$\frac{\partial u}{\partial t}(x, 0) = -\sin(\pi x)$$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;精确解析解&lt;/strong&gt;：
$$u(x, t) = \sin(\pi x) \cos(\pi t) - \frac{1}{\pi} \sin(\pi x) \sin(\pi t)$$
tao=0.05,h=0.1
tao=0.1,h=0.1&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;u1=cal(0.05,0.1);
u2=cal(0.1,0.1);
function [u_num]=cal(tao,h)
    J=(1/h);
    N=(2/tao);
    a=1;
    x=linspace(0,1,J+1)&apos;;
    x=x(2:end-1);
    t=linspace(0,2,N+1)&apos;;
    e=ones(J-1,1);
    r=(a^2*tao^2)/(h^2);
    A=spdiags([r*e,(2-2*r)*e,r*e],[-1,0,1],J-1,J-1);
    u_pre=sin(pi*x);
    u_num=-sin(pi*x)*tao+u_pre;
    err=0;
    for i=3:length(t)
        tim=t(i);
        u_exact=sin(pi*x)*cos(pi*tim)-sin(pi*x)*sin(pi*tim)/pi;
        tmp=u_num;
        u_num=A*u_num-u_pre;
        u_pre=tmp;
        err=max(err,max(abs(u_exact-u_num)));
    end
    fprintf(&quot;%.10f&quot;,err)
end
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;7. 程序七：一维一阶对流方程（负波速）的显/隐式迎风格式对比&lt;/h3&gt;
&lt;h4&gt;数学模型&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;控制方程&lt;/strong&gt;：$\frac{\partial u}{\partial t} - 2 \frac{\partial u}{\partial x} = 0 \quad (x \in [0, 1], ; t &amp;gt; 0)$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;初始条件&lt;/strong&gt;：$u(x,0) = 1 + \sin(2\pi x)$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;边界条件&lt;/strong&gt;：右边界 $u(1,t) = 1$（左边界无边界条件，通过差分格式直接计算递推）
tao=0.02,h=0.1显隐,求t=0.1,0.5&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;clear; clc; close all;
a=-2;
tao=0.02;
h=0.1;
N=0.5/tao;
J=1/h;
x=linspace(0,1,J+1)&apos;;
t=linspace(0,0.5,N+1)&apos;;
e=ones(J+1,1);
r=(a*tao/h);
A=spdiags([zeros(J+1,1),(1+r)*e,-r*e],[-1,0,1],J+1,J+1);
B=spdiags([zeros(J+1,1),(1-r)*e,r*e],[-1,0,1],J+1,J+1);
A(end,end)=1;%边界条件
B(end,end)=1;
u_num_ex=1+sin(2*pi*x);%显式
u_num_im=1+sin(2*pi*x);%隐式
for i=2:length(t)
    tim=t(i);
    u_num_ex=A*u_num_ex;
    u_num_im=B\u_num_im;
    if tim==0.1 || tim==0.5
        figure
        plot(x,u_num_ex,&quot;b--&quot;);
        hold on;
        plot(x,u_num_im,&quot;r--o&quot;);
        legend(&quot;显式迎风&quot;,&quot;隐式迎风&quot;);
        grid on;
        title(sprintf(&quot;t=%.1f&quot;,tim));
    end
end
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;8. 程序八：一维一阶对流方程（正波速）在不同稳定性条件下的对流行为对比&lt;/h3&gt;
&lt;h4&gt;数学模型&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;控制方程&lt;/strong&gt;：$\frac{\partial u}{\partial t} + \frac{\partial u}{\partial x} = 0 \quad (0 &amp;lt; x &amp;lt; \infty, ; t &amp;gt; 0)$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;初始条件&lt;/strong&gt;：$u(x,0) = |x-1|$&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;边界条件&lt;/strong&gt;：左边界 $u(0,t) = 1$（右边界无边界条件，直接递推）&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;内容说明&lt;/strong&gt;：求解一阶线性对流方程（波速为正值，代表物理信号自左向右传播），左边界为入口边界条件。
tao=0.5,h=0.5显式
tao=1,h=0.5隐式
t=1,2,3,4,5&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;clear; clc; close all;
tao=0.5;
h=0.5;
fprintf(&quot;tao=%.1f,h=%.1f\n&quot;,tao,h);
J=10/h;
N=5/tao;
a=1;
r=a*tao/h;
x=linspace(0,10,J+1)&apos;;
t=linspace(0,5,N+1)&apos;;
e=ones(J+1,1);
A=spdiags([r*e,(1-r)*e,zeros(J+1,1)],[-1,0,1],J+1,J+1);
A(1,1)=1;
u_num_ex=abs(x-ones(J+1,1));
for i=2:length(t)
    tim=t(i);
    u_num_ex=A*u_num_ex;
    if tim==1||tim==2||tim==3||tim==4||tim==5
        plot(x,u_num_ex,&apos;DisplayName&apos;,sprintf(&quot;t=%.1f&quot;,tim));
        hold on;
    end
end
legend;

clear; clc; close all;
tao=1;
h=0.5;
fprintf(&quot;tao=%.1f,h=%.1f\n&quot;,tao,h);
J=10/h;
N=5/tao;
a=1;
r=a*tao/h;
x=linspace(0,10,J+1)&apos;;
t=linspace(0,5,N+1)&apos;;
e=ones(J+1,1);
B=spdiags([-r*e,(1+r)*e,zeros(J+1,1)],[-1,0,1],J+1,J+1);
B(1,1)=1;
u_num_im=abs(x-ones(J+1,1));
for i=2:length(t)
    tim=t(i);
    u_num_im=B\u_num_im;
    if tim==1||tim==2||tim==3||tim==4||tim==5
        plot(x,u_num_im,&apos;DisplayName&apos;,sprintf(&quot;t=%.1f&quot;,tim));
        hold on;
    end
end
legend;
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Go 新手入门：用 Gin + GORM 写第一个 CRUD 服务</title><link>https://sanzenin.top/posts/obsidian/gin-gorm%E6%80%BB%E7%BB%93/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/gin-gorm%E6%80%BB%E7%BB%93/</guid><description>从零搭建一个用户注册/更新/删除的 HTTP 服务，适合刚学完 Go 基础语法的纯新手。 做一个最简单的用户管理系统，三个接口：/user/register（注册）、/user/update（修改密码）、/user/delete（删除用户）。 请求用 POST 表单，返回 JSON，数据存 MySQL。 技术栈：Gin</description><pubDate>Wed, 27 May 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Go 新手入门：用 Gin + GORM 写第一个 CRUD 服务&lt;/h1&gt;
&lt;blockquote&gt;
&lt;p&gt;从零搭建一个用户注册/更新/删除的 HTTP 服务，适合刚学完 Go 基础语法的纯新手。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2&gt;一、前言：我们要做什么&lt;/h2&gt;
&lt;p&gt;做一个最简单的用户管理系统，三个接口：&lt;code&gt;/user/register&lt;/code&gt;（注册）、&lt;code&gt;/user/update&lt;/code&gt;（修改密码）、&lt;code&gt;/user/delete&lt;/code&gt;（删除用户）。&lt;/p&gt;
&lt;p&gt;请求用 POST 表单，返回 JSON，数据存 MySQL。&lt;/p&gt;
&lt;p&gt;技术栈：&lt;strong&gt;Gin&lt;/strong&gt;（HTTP 框架） + &lt;strong&gt;GORM&lt;/strong&gt;（ORM 框架） + &lt;strong&gt;MySQL&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;代码分为两个学习阶段：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;class2&lt;/strong&gt;：用 GORM 直接操作数据库，理解 Go 的 struct、指针、错误处理&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;class3&lt;/strong&gt;：加入 Gin 框架，拆成 controller → services → dao 三层架构&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;二、class2：GORM 入门，直接用代码操作数据库&lt;/h2&gt;
&lt;h3&gt;2.1 完整代码&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;
package main



import (

    &quot;fmt&quot;

    &quot;time&quot;

    &quot;gorm.io/driver/mysql&quot;

    &quot;gorm.io/gorm&quot;

)



type User struct {

    ID        uint      `gorm:&quot;primaryKey&quot;`

    UserName  string    `gorm:&quot;size:64;uniqueIndex;not null&quot;`

    Password  string    `gorm:&quot;size:128&quot;`

    CreatedAt time.Time `gorm:&quot;autoCreateTime&quot;`

}



func main() {

    dsn := &quot;root:123456@tcp(127.0.0.1:3306)/testdb?charset=utf8mb4&amp;amp;parseTime=True&amp;amp;loc=Local&quot;

    db, err := gorm.Open(mysql.Open(dsn), &amp;amp;gorm.Config{})

    if err != nil {

        panic(&quot;数据库连接失败: &quot; + err.Error())

    }

    db.AutoMigrate(&amp;amp;User{})



    // Create 创建

    newUser := User{UserName: &quot;wlz&quot;, Password: &quot;wlz&quot;}

    db.Create(&amp;amp;newUser)

    fmt.Println(&quot;创建成功, ID:&quot;, newUser.ID)



    // Read 查询

    var user User

    db.Where(&quot;user_name=?&quot;, &quot;wlz&quot;).First(&amp;amp;user)

    fmt.Printf(&quot;查询结果: %+v\n&quot;, user)



    // Update 更新

    db.Model(&amp;amp;user).Update(&quot;Password&quot;, &quot;123&quot;)

    fmt.Printf(&quot;更新后: %+v\n&quot;, user)



    // Delete 删除

    db.Delete(&amp;amp;user)

}

&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;2.2 逐段讲解&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;struct 和 tag&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
type User struct {

    ID        uint      `gorm:&quot;primaryKey&quot;`

    UserName  string    `gorm:&quot;size:64;uniqueIndex;not null&quot;`

    Password  string    `gorm:&quot;size:128&quot;`

    CreatedAt time.Time `gorm:&quot;autoCreateTime&quot;`

}

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;struct&lt;/code&gt; 是 Go 里的&quot;数据类&quot;，把多个字段打包在一起。字段名大写开头表示&quot;导出&quot;（跨包可见）。&lt;/p&gt;
&lt;p&gt;反引号 &lt;code&gt;`&lt;/code&gt; 里的是 &lt;strong&gt;tag&lt;/strong&gt;（标签），它不影响编译，是运行时的&quot;元数据&quot;。GORM 靠反射读到这些 tag，自动把 &lt;code&gt;UserName&lt;/code&gt; 映射为数据库的 &lt;code&gt;user_name&lt;/code&gt; 列，&lt;code&gt;primaryKey&lt;/code&gt; 表示主键，&lt;code&gt;uniqueIndex&lt;/code&gt; 表示唯一索引。没有 tag 也行，GORM 会用默认规则（蛇形命名）推断列名。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;连接数据库&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
dsn := &quot;root:123456@tcp(127.0.0.1:3306)/testdb?charset=utf8mb4&amp;amp;parseTime=True&amp;amp;loc=Local&quot;

db, err := gorm.Open(mysql.Open(dsn), &amp;amp;gorm.Config{})

if err != nil {

    panic(&quot;数据库连接失败: &quot; + err.Error())

}

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;DSN 就是一串连接信息，格式固定为 &lt;code&gt;用户名:密码@tcp(IP:端口)/数据库名?参数&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;gorm.Open&lt;/code&gt; 返回两个值：&lt;code&gt;*gorm.DB&lt;/code&gt; 类型的数据库句柄和 &lt;code&gt;error&lt;/code&gt;。Go 没有 try-catch，错误就是普通的返回值，约定放在最后一位。&lt;strong&gt;这里必须检查 err&lt;/strong&gt;：如果数据库没启动或密码错了，&lt;code&gt;db&lt;/code&gt; 是 &lt;code&gt;nil&lt;/code&gt;，后面任何 &lt;code&gt;db.xxx&lt;/code&gt; 调用都会 panic（空指针异常）。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;AutoMigrate 自动建表&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
db.AutoMigrate(&amp;amp;User{})

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;GORM 读取 &lt;code&gt;User&lt;/code&gt; struct 的定义，自动在数据库里创建对应的 &lt;code&gt;users&lt;/code&gt; 表（表名 = 结构体名变为蛇形复数）。如果表已存在但结构变了（比如加了个字段），会自动添加新列。&lt;strong&gt;不会删除已有列&lt;/strong&gt;，所以是安全的。&lt;/p&gt;
&lt;p&gt;注意传的是 &lt;code&gt;&amp;amp;User{}&lt;/code&gt;——一个空结构体的&lt;strong&gt;指针&lt;/strong&gt;。在 Go 里，&lt;code&gt;&amp;amp;x&lt;/code&gt; 取变量 x 的内存地址，得到的是一个指针。GORM 需要指针来把查询结果写回变量。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;CRUD 四个操作&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
// Create：传入指针，GORM 会把自增 ID 回写到 newUser.ID

db.Create(&amp;amp;newUser)



// Read：Where 指定条件，First 查第一条，结果写入 user

var user User

db.Where(&quot;user_name=?&quot;, &quot;wlz&quot;).First(&amp;amp;user)



// Update：Model 指定要改哪条记录，Update 改单个字段

db.Model(&amp;amp;user).Update(&quot;Password&quot;, &quot;123&quot;)



// Delete：按主键删

db.Delete(&amp;amp;user)

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;重点：&lt;code&gt;Where(&quot;user_name=?&quot;, &quot;wlz&quot;)&lt;/code&gt; 里的 &lt;code&gt;?&lt;/code&gt; 是&lt;strong&gt;占位符&lt;/strong&gt;，GORM 会自动把 &lt;code&gt;&quot;wlz&quot;&lt;/code&gt; 转义后填入，防止 SQL 注入。&lt;strong&gt;第一个参数里的列名必须是数据库的真实列名&lt;/strong&gt;（&lt;code&gt;user_name&lt;/code&gt;），不是 Go 的字段名（&lt;code&gt;UserName&lt;/code&gt;）。这是新手最容易踩的坑：GORM 映射规则是大驼峰 → 蛇形，&lt;code&gt;UserName&lt;/code&gt; → &lt;code&gt;user_name&lt;/code&gt;，写 &lt;code&gt;name&lt;/code&gt; 就报错。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;First(&amp;amp;user)&lt;/code&gt; 这里 &lt;code&gt;user&lt;/code&gt; 已经声明为 &lt;code&gt;User&lt;/code&gt; 类型，传 &lt;code&gt;&amp;amp;user&lt;/code&gt; 是正确的一级取址（得到 &lt;code&gt;*User&lt;/code&gt;）。后面 class3 会看到传错的情况。&lt;/p&gt;
&lt;h2&gt;三、class3：引入 Gin 框架，拆成三层架构&lt;/h2&gt;
&lt;p&gt;class2 把 SQL 逻辑和业务逻辑全混在 &lt;code&gt;main.go&lt;/code&gt; 里，真实项目不会这样写。class3 把它拆成三层：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
HTTP 请求 → controller（接收请求、返回 JSON）

                ↓

            services（业务逻辑：检查用户是否存在、校验密码）

                ↓

            dao（纯数据库 CRUD，封装 GORM）

&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.1 dao 层 — 封装数据库操作&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;
package dao



import &quot;gorm.io/gorm&quot;



type User struct {

    ID       int    `gorm:&quot;primaryKey&quot;`

    UserName string `gorm:&quot;size:64;uniqueIndex&quot;`

    Password string `gorm:&quot;size:64&quot;`

}



var DB *gorm.DB



func Create(usr *User) error {

    return DB.Create(usr).Error

}

func GetByName(name *string) (Usr *User, err error) {

    err = DB.Where(&quot;user_name = ?&quot;, name).First(&amp;amp;Usr).Error  // 注意这里的 bug

    return

}

func DeleteByname(name *string) error {

    return DB.Where(&quot;user_name = ?&quot;, name).Delete(&amp;amp;User{}).Error

}

func Update(usr *User) error {

    return DB.Save(usr).Error

}

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;dao 包只做一件事：把 GORM 操作封装成函数，对外隐藏 SQL 细节。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;var DB *gorm.DB&lt;/code&gt; 是一个包级变量，&lt;code&gt;main.go&lt;/code&gt; 连接数据库后把句柄赋给它（&lt;code&gt;dao.DB = db&lt;/code&gt;），这叫&lt;strong&gt;依赖注入&lt;/strong&gt;——dao 不自己连数据库，靠外部&quot;注射&quot;进来。好处是 main 里只连一次，各层共享同一个连接池。坏处是全局变量不利于单元测试，但对学习项目足够了。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;命名返回值&lt;/strong&gt; &lt;code&gt;(Usr *User, err error)&lt;/code&gt; 值得注意：返回值在函数签名里就起了名字，函数体内直接 &lt;code&gt;return&lt;/code&gt; 就行，Go 自动返回这两个变量的当前值。另一个写法是 &lt;code&gt;return usr, err&lt;/code&gt; 显式返回，效果一样。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;指针 bug 现场&lt;/strong&gt;：&lt;code&gt;First(&amp;amp;Usr)&lt;/code&gt; 这里 &lt;code&gt;Usr&lt;/code&gt; 声明时已经是 &lt;code&gt;*User&lt;/code&gt;（指向 User 的指针），再取址 &lt;code&gt;&amp;amp;Usr&lt;/code&gt; 就变成了 &lt;code&gt;**User&lt;/code&gt;（指向指针的指针）。GORM 的 &lt;code&gt;First&lt;/code&gt; 期望 &lt;code&gt;*User&lt;/code&gt;，传 &lt;code&gt;**User&lt;/code&gt; 会出错。正确写法是 &lt;code&gt;First(Usr)&lt;/code&gt;。为什么 class2 里 &lt;code&gt;var user User; First(&amp;amp;user)&lt;/code&gt; 是对的？因为 &lt;code&gt;user&lt;/code&gt; 是 &lt;code&gt;User&lt;/code&gt; 值类型，取址一次得到 &lt;code&gt;*User&lt;/code&gt;，刚好匹配。这个区别是 Go 新手最容易搞混的地方之一。&lt;/p&gt;
&lt;h3&gt;3.2 services 层 — 业务逻辑&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;
package services



import (

    &quot;class3/dao&quot;

    &quot;errors&quot;

)



func Register(name, passwd string) error {

    if _, err := dao.GetByName(&amp;amp;name); err == nil {

        return errors.New(&quot;用户已存在&quot;)

    }

    return dao.Create(&amp;amp;dao.User{UserName: name, Password: passwd})

}

func UpdatePasswd(name, NewPasswd string) error {

    usr, err := dao.GetByName(&amp;amp;name)

    if err != nil {

        return errors.New(&quot;用户不存在&quot;)

    }

    usr.Password = NewPasswd

    return dao.Update(usr)

}

func Delete(name, passwd string) error {

    return dao.DeleteByname(&amp;amp;name)

}

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;services 是&quot;业务规则层&quot;，它不碰 HTTP 也不碰 GORM。以 &lt;code&gt;Register&lt;/code&gt; 为例：先调用 &lt;code&gt;dao.GetByName&lt;/code&gt; 查用户是否存在，如果 &lt;strong&gt;err == nil&lt;/strong&gt;（没报错，说明查到了），就返回&quot;用户已存在&quot;；如果 &lt;strong&gt;err != nil&lt;/strong&gt;（查询失败/没找到），就调用 &lt;code&gt;dao.Create&lt;/code&gt; 创建。注意 &lt;code&gt;if _, err := ...&lt;/code&gt; 里的 &lt;code&gt;_&lt;/code&gt; 是空白标识符，表示&quot;这个返回值我不需要&quot;，这里我们只关心 err 不关心查到的 User 对象。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;errors.New(&quot;...&quot;)&lt;/code&gt; 是 Go 标准库创建错误的方式，返回一个 &lt;code&gt;error&lt;/code&gt; 接口类型的值。&lt;/p&gt;
&lt;h3&gt;3.3 controller 层 — 接收 HTTP 请求&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;
package controller



import (

    &quot;class3/services&quot;

    &quot;github.com/gin-gonic/gin&quot;

)



func Register(g *gin.Context) {

    name, passwd := g.PostForm(&quot;name&quot;), g.PostForm(&quot;pwd&quot;)

    if err := services.Register(name, passwd); err != nil {

        g.JSON(400, gin.H{&quot;error&quot;: err.Error()})

        return  // 必须 return！否则会继续执行下面的 g.JSON(200, ...)

    }

    g.JSON(200, gin.H{&quot;message&quot;: &quot;注册成功&quot;})

}

func Update(g *gin.Context) {

    name, passwd := g.PostForm(&quot;name&quot;), g.PostForm(&quot;pwd&quot;)

    if err := services.UpdatePasswd(name, passwd); err != nil {

        g.JSON(400, gin.H{&quot;error&quot;: err.Error()})

        return

    }

    g.JSON(200, gin.H{&quot;message&quot;: &quot;更新密码成功&quot;})

}

func Delete(g *gin.Context) {

    name, passwd := g.PostForm(&quot;name&quot;), g.PostForm(&quot;pwd&quot;)

    if err := services.Delete(name, passwd); err != nil {

        g.JSON(400, gin.H{&quot;error&quot;: err.Error()})

        return

    }

    g.JSON(200, gin.H{&quot;message&quot;: &quot;删除成功&quot;})

}

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每个 handler 函数签名为 &lt;code&gt;func HandlerName(c *gin.Context)&lt;/code&gt;，&lt;code&gt;*gin.Context&lt;/code&gt; 是 Gin 封装的&quot;一次请求-响应&quot;上下文，通过它可以读请求参数、写响应。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;g.PostForm(&quot;name&quot;)&lt;/code&gt; 读取 HTTP POST 表单中 &lt;code&gt;name&lt;/code&gt; 字段的值。表单格式是 &lt;code&gt;application/x-www-form-urlencoded&lt;/code&gt;，即 &lt;code&gt;key1=val1&amp;amp;key2=val2&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;g.JSON(200, gin.H{...})&lt;/code&gt; 把 Go 的 map 序列化为 JSON 写回客户端。&lt;code&gt;gin.H&lt;/code&gt; 其实就是 &lt;code&gt;map[string]any&lt;/code&gt; 的类型别名，&lt;code&gt;any&lt;/code&gt; 是 &lt;code&gt;interface{}&lt;/code&gt; 的别名（Go 1.18+），表示任意类型。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;最重要的细节&lt;/strong&gt;：每个错误分支的 &lt;code&gt;g.JSON(400, ...)&lt;/code&gt; 后面必须跟 &lt;code&gt;return&lt;/code&gt;。Go 不像 Python/Ruby 那样一个 &lt;code&gt;return&lt;/code&gt; 就退出函数，如果没有 &lt;code&gt;return&lt;/code&gt;，程序会继续走到后面的 &lt;code&gt;g.JSON(200, ...)&lt;/code&gt;，往同一个响应里写两次数据，Gin 会报 warning 且客户端收到的内容不可预期。&lt;/p&gt;
&lt;h3&gt;3.4 main.go — 组装启动&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;
package main



import (

    &quot;class3/controller&quot;

    &quot;class3/dao&quot;

    &quot;github.com/gin-gonic/gin&quot;

    &quot;gorm.io/driver/mysql&quot;

    &quot;gorm.io/gorm&quot;

)



func main() {

    dsn := &quot;root:123456@tcp(127.0.0.1:3306)/testdb?parseTime=true&quot;

    db, err := gorm.Open(mysql.Open(dsn), &amp;amp;gorm.Config{})

    if err != nil {

        panic(err)

    }

    db.AutoMigrate(&amp;amp;dao.User{})

    dao.DB = db



    r := gin.Default()

    r.POST(&quot;/user/register&quot;, controller.Register)

    r.POST(&quot;/user/update&quot;, controller.Update)

    r.POST(&quot;/user/delete&quot;, controller.Delete)

    r.Run(&quot;:8080&quot;)

}

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;main.go&lt;/code&gt; 是&quot;组装车间&quot;：连数据库 → 自动建表 → 把 db 注入 dao → 注册路由 → 启动服务。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;gin.Default()&lt;/code&gt; 创建一个路由引擎，自带 Logger（打印每个请求）和 Recovery（handler panic 时自动恢复，不会崩进程）两个中间件。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;r.POST(&quot;/user/register&quot;, controller.Register)&lt;/code&gt; 意思是：当收到 &lt;code&gt;POST /user/register&lt;/code&gt; 时，调用 &lt;code&gt;controller.Register&lt;/code&gt; 函数。&lt;strong&gt;这里只传函数名不调用它&lt;/strong&gt;（没有括号），因为把函数本身注册给了 Gin，Gin 会在请求到来时帮我们调用。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;r.Run(&quot;:8080&quot;)&lt;/code&gt; 启动 HTTP 服务器监听 8080 端口，这是一个阻塞调用，函数不会返回直到进程被终止。&lt;/p&gt;
&lt;h2&gt;四、用 wget 测试接口&lt;/h2&gt;
&lt;p&gt;服务启动后，用 wget 发 POST 请求测试：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
# 注册（需绕过本地代理）

wget --no-proxy --content-on-error -qO- --post-data=&apos;name=tom&amp;amp;pwd=123456&apos; http://127.0.0.1:8080/user/register

# 更新密码

wget --no-proxy --content-on-error -qO- --post-data=&apos;name=tom&amp;amp;pwd=newpass&apos; http://127.0.0.1:8080/user/update

# 删除用户

wget --no-proxy --content-on-error -qO- --post-data=&apos;name=tom&amp;amp;pwd=123456&apos; http://127.0.0.1:8080/user/delete

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;参数解释：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;--post-data=&apos;key=val&amp;amp;...&apos;&lt;/code&gt;：发送 POST 表单（&lt;code&gt;application/x-www-form-urlencoded&lt;/code&gt;），和 Gin 的 &lt;code&gt;PostForm&lt;/code&gt; 对应&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;--no-proxy&lt;/code&gt;：绕过系统代理（有的机器开了 Clash，127.0.0.1 也被代理劫持了）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;--content-on-error&lt;/code&gt;：4xx/5xx 也输出 body（默认 wget 收到错误码就不显示内容）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;-qO-&lt;/code&gt;：q 安静模式（不打印进度），O 输出到文件，&lt;code&gt;-&lt;/code&gt; 是 stdout&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;五、常见坑点速查&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;连接失败但 panic 空指针&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
db, _ := gorm.Open(...)   // 用 _ 吞掉错误，连接失败 db 就是 nil

db.AutoMigrate(&amp;amp;User{})   // nil.AutoMigrate() → panic

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;永远不要用 &lt;code&gt;_&lt;/code&gt; 丢掉 &lt;code&gt;gorm.Open&lt;/code&gt; 的错误。写 &lt;code&gt;db, err := ...; if err != nil { panic(err) }&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;列名写错&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;GORM 把 &lt;code&gt;UserName&lt;/code&gt; 映射为 &lt;code&gt;user_name&lt;/code&gt;，不是 &lt;code&gt;name&lt;/code&gt;。写 SQL 条件时用数据库列名：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
DB.Where(&quot;user_name = ?&quot;, name)  // 对

DB.Where(&quot;name = ?&quot;, name)       // 错：数据库里没有 name 列

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;嫌列名太长可以加 tag 手动指定：&lt;code&gt;gorm:&quot;column:name&quot;&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;指针取址层次搞混&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
var user User

DB.First(&amp;amp;user)       // user 是值类型, &amp;amp;user → *User ✓



var usr *User

DB.First(&amp;amp;usr)        // usr 是指针, &amp;amp;usr → **User ✗

DB.First(usr)         // 直接传, usr 已经是 *User ✓

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;判断方法：看变量声明时有没有 &lt;code&gt;*&lt;/code&gt;。有 &lt;code&gt;*&lt;/code&gt; 就不再加 &lt;code&gt;&amp;amp;&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;controller 里忘记 return&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
g.JSON(400, gin.H{&quot;error&quot;: &quot;xxx&quot;})  // 写完 400

// 没有 return，继续往下走

g.JSON(200, gin.H{&quot;message&quot;: &quot;ok&quot;})  // 又写了 200，冲突

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;每次 &lt;code&gt;g.JSON&lt;/code&gt; 后如果不想继续执行，必须加 &lt;code&gt;return&lt;/code&gt;。&lt;/p&gt;
</content:encoded></item><item><title>go学习prompt</title><link>https://sanzenin.top/posts/obsidian/go%E5%AD%A6%E4%B9%A0prompt/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/go%E5%AD%A6%E4%B9%A0prompt/</guid><description>太棒了，你的直觉非常准确！对于刚接触后端的选手来说，直接上手DDD和微服务确实容易“走火入魔”。“先用单体架构跑通增删改查，再去搞微服务拆分”是最科学的学习路径。 算法选手学东西极快，我们不需要看冗长的文档，直接通过 AI 用“类比法”加上“极简Demo”来吃透后端最核心的三剑客：Gin（Web框架） + GORM（数</description><pubDate>Tue, 21 Apr 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;太棒了，你的直觉非常准确！对于刚接触后端的选手来说，直接上手DDD和微服务确实容易“走火入魔”。**“先用单体架构跑通增删改查，再去搞微服务拆分”**是最科学的学习路径。&lt;/p&gt;
&lt;p&gt;算法选手学东西极快，我们不需要看冗长的文档，直接通过 AI 用**“类比法”&lt;strong&gt;加上&lt;/strong&gt;“极简Demo”**来吃透后端最核心的三剑客：&lt;strong&gt;Gin（Web框架） + GORM（数据库框架） + go-redis（缓存框架）&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;我为你优化了流程，专门设计了**“基础框架速通五部曲”**的 AI 提示词（Prompt）。请你在 Cursor 或 ChatGPT/Claude 中依次发送以下提示词：&lt;/p&gt;
&lt;hr /&gt;
&lt;h3&gt;第 1 步：速通 HTTP 与 Gin 框架（网络层）&lt;/h3&gt;
&lt;p&gt;算法题的输入输出是 &lt;code&gt;cin&lt;/code&gt;/&lt;code&gt;cout&lt;/code&gt; 或 &lt;code&gt;scanf&lt;/code&gt;/&lt;code&gt;printf&lt;/code&gt;，而后端的输入输出是 HTTP 协议（Request 和 Response）。Gin 是 Go 最火的框架，它的底层路由其实就是一棵&lt;strong&gt;前缀树（Trie树）&lt;/strong&gt;。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;🗣️ &lt;strong&gt;发给 AI 的 Prompt：&lt;/strong&gt;
“我是一名打过算法竞赛的选手，现在要在 Go 语言中学习后端开发。
请教我使用 Gin 框架。由于我懂算法，请结合‘前缀树’的原理简单告诉我 Gin 的路由是怎么匹配的。
然后，请给我写一个极简的 Gin 单文件代码示例，包含以下功能：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;一个 GET 接口：接收 URL 中的参数（如 &lt;code&gt;?name=abc&lt;/code&gt;），返回一段 JSON。&lt;/li&gt;
&lt;li&gt;一个 POST 接口：接收一个 JSON 格式的请求体（包含用户名和年龄），校验年龄必须大于 0，并返回接收成功的 JSON。
请在代码中写明详细的中文注释，并告诉我如何使用 &lt;code&gt;curl&lt;/code&gt; 或 Postman 来测试这两个接口。”&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h3&gt;第 2 步：速通 MySQL 与 GORM 框架（持久化层）&lt;/h3&gt;
&lt;p&gt;算法题的数据存放在内存（数组、Map）里，程序运行结束就销毁了。后端需要把数据存在硬盘里（MySQL）。GORM 是一个 ORM 框架，它的作用就是&lt;strong&gt;把 Go 里的结构体（Struct）自动映射成数据库里的表（Table）&lt;/strong&gt;。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;🗣️ &lt;strong&gt;发给 AI 的 Prompt：&lt;/strong&gt;
“我现在需要学习 Go 如何操作 MySQL 数据库。我不喜欢写繁琐的 SQL 语句，听说 GORM 可以把结构体映射为数据库表。
请给我一段使用 GORM 的单文件 Go 代码示例，要求：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;定义一个 &lt;code&gt;User&lt;/code&gt; 结构体（包含 ID, 用户名, 密码, 创建时间）。&lt;/li&gt;
&lt;li&gt;连接本地的 MySQL 数据库，并自动根据结构体建表（AutoMigrate）。&lt;/li&gt;
&lt;li&gt;演示完整的 CRUD（增、删、改、查）操作，特别是如何根据‘用户名’查找到对应的数据。
请重点给我解释一下：在结构体标签（Struct Tag）中，GORM 是如何控制数据库字段属性的（比如主键、唯一索引）？”&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h3&gt;第 3 步：把 Gin 和 GORM 结合（真正的后端雏形）&lt;/h3&gt;
&lt;p&gt;现在要把前面两步连起来：通过网络接收请求 -&amp;gt; 处理数据 -&amp;gt; 存入数据库。同时，我们要开始&lt;strong&gt;摆脱单文件代码&lt;/strong&gt;，引入后端经典的&lt;strong&gt;三层架构&lt;/strong&gt;。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;🗣️ &lt;strong&gt;发给 AI 的 Prompt：&lt;/strong&gt;
“我已经了解了 Gin 和 GORM 的基本用法。现在请教我后端经典的‘三层架构’（Controller层、Service层、Dao/Repository层）。
结合我的算法背景，是不是可以这样理解：Controller 负责处理输入输出（类似 &lt;code&gt;cin&lt;/code&gt;/&lt;code&gt;cout&lt;/code&gt; 和格式校验），Service 负责核心算法逻辑，Dao 负责把数据结构持久化？
请帮我用 Go 写一个极简的‘用户注册与查询’ API 项目，并拆分成这三个文件/层级。让我看看正确的工程结构应该是怎样的。”&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h3&gt;第 4 步：速通 Redis 缓存（性能优化层）&lt;/h3&gt;
&lt;p&gt;关系型数据库存硬盘，速度慢。当遇到高并发时，我们需要在数据库前面挡一层内存缓存。Redis 本质上就是一个&lt;strong&gt;支持网络访问的超级数据结构库&lt;/strong&gt;（支持哈希表、跳表、队列等）。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;🗣️ &lt;strong&gt;发给 AI 的 Prompt：&lt;/strong&gt;
“我是算法选手，我知道内存访问远快于磁盘。现在我要学习 Redis 以及 Go 的 &lt;code&gt;go-redis&lt;/code&gt; 库。
请用算法中的‘记忆化搜索（Memoization）’思想，向我解释后端缓存的作用。
请给我写一段 Gin + GORM + Redis 的组合代码示例：
场景：实现一个 &lt;code&gt;GET /user/:id&lt;/code&gt; 的接口。
逻辑：先去 Redis 里（内存字典）查找用户数据；如果没找到（Cache Miss），再去 MySQL（GORM）里查，查到之后存入 Redis，并设置 60 秒的过期时间，最后返回给用户。
请提供完整的 Go 代码实现。”&lt;/p&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h3&gt;第 5 步：中间件（Middleware）与上下文（Context）&lt;/h3&gt;
&lt;p&gt;这是 Go 后端独有的、必须跨越的门槛。在处理一个请求的过程中，我们需要做一些“通用”的事情，比如：验证用户有没有登录、记录请求耗时、发生 panic 时拦截报错不让程序崩溃。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;🗣️ &lt;strong&gt;发给 AI 的 Prompt：&lt;/strong&gt;
“在 Gin 框架中，经常听到‘中间件 (Middleware)’和‘上下文 (gin.Context)’这两个概念。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;请结合 AOP（面向切面编程）或简单的‘洋葱模型’，向我解释中间件是什么？&lt;/li&gt;
&lt;li&gt;请给我写两个 Gin 中间件的实战代码：
&lt;ul&gt;
&lt;li&gt;第一个是‘耗时统计中间件’：记录每个接口的运行时间（类似算法题测算函数耗时）。&lt;/li&gt;
&lt;li&gt;第二个是‘全局异常捕获中间件’：当我的接口代码里发生数组越界导致 panic 时，拦截它，并给用户返回 500 JSON，保证服务器不挂掉。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;请简述一下 &lt;code&gt;gin.Context&lt;/code&gt; 里面除了携带请求参数，还能用来做什么？”&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;
&lt;hr /&gt;
&lt;h3&gt;💡 学习建议：&lt;/h3&gt;
&lt;p&gt;经过这 5 个步骤，你就会在脑海中建立起一个清晰的单体后端链路：
&lt;strong&gt;客户端请求 -&amp;gt; [中间件(捕获异常/日志)] -&amp;gt; Gin(路由分发) -&amp;gt; Controller(参数校验) -&amp;gt; Service(业务逻辑) -&amp;gt; Redis(缓存) -&amp;gt; GORM(数据库映射) -&amp;gt; MySQL(磁盘)&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;此时，如果你想动手练一练，可以让 Cursor 给你出个题：
&lt;strong&gt;“请帮我设计一个带积分功能的极简答题系统 API 需求，让我自己用上面学的框架写一遍。”&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;等你把这个流程跑通、写顺了，再去看你发的那张微服务架构图，你会发现：所谓的微服务，其实就是把这个单体系统里的 Service 层切开，分别扔到不同的服务器上，然后用 gRPC 或消息队列把它们再缝合起来。&lt;/p&gt;
&lt;p&gt;快去试试第一步的 Prompt 吧！遇到看不懂的代码，直接让大模型“逐行解释”。&lt;/p&gt;
</content:encoded></item><item><title>访问操作系统中的对象</title><link>https://sanzenin.top/posts/obsidian/%E8%AE%BF%E9%97%AE%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E4%B8%AD%E7%9A%84%E5%AF%B9%E8%B1%A1/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E8%AE%BF%E9%97%AE%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E4%B8%AD%E7%9A%84%E5%AF%B9%E8%B1%A1/</guid><description>访问操作系统中的对象，来自 Obsidian 的操作系统笔记。</description><pubDate>Mon, 09 Mar 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
</content:encoded></item><item><title>程序和进程</title><link>https://sanzenin.top/posts/obsidian/%E7%A8%8B%E5%BA%8F%E5%92%8C%E8%BF%9B%E7%A8%8B/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/%E7%A8%8B%E5%BA%8F%E5%92%8C%E8%BF%9B%E7%A8%8B/</guid><description>strace 追踪系统调用 grep系统搜索 a | b unix管道功能 将a的输出作为b的输入</description><pubDate>Thu, 19 Feb 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;strace 追踪系统调用
grep系统搜索
a | b unix管道功能 将a的输出作为b的输入&lt;/p&gt;
</content:encoded></item><item><title>CSES  DP合集</title><link>https://sanzenin.top/posts/obsidian/cses-dp%E5%90%88%E9%9B%86/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/cses-dp%E5%90%88%E9%9B%86/</guid><description>O：Removal Game 我们令 为在 区间先手能取得的最大收益,我们显然根据可以从以 和 区间转移过来.也算是一个trick,如果从最后一局倒序看一场游戏,最后一把为最后一个人先手开始游戏,然后倒数第二把可以看作另一个人先手开一把游戏然后另一个人再进行最后一把 代码</description><pubDate>Sun, 25 Jan 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;https://vjudge.net/problem/CSES-1097&quot;&gt;O：Removal Game&lt;/a&gt;&lt;/p&gt;
&lt;h6&gt;思路&lt;/h6&gt;
&lt;p&gt;我们令$f(i,j)$为在$(i,j)$区间先手能取得的最大收益,我们显然根据可以从以$(i+1,j)$和$(i,j-1)$区间转移过来.也算是一个trick,如果从最后一局倒序看一场游戏,最后一把为最后一个人先手开始游戏,然后倒数第二把可以看作另一个人先手开一把游戏然后另一个人再进行最后一把
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;

#define N 1000005

#define pr pair&amp;lt;int,int&amp;gt;

#define ll long long

#define inf 100000000000

using namespace std;

ll n,m,ans;

const ll mod=1e9+7;

int main()

{

    ios::sync_with_stdio(0);

    cin.tie(nullptr);

    cout.tie(nullptr);

    cin&amp;gt;&amp;gt;n;

    vector&amp;lt;ll&amp;gt;s(n+5,0);

    vector&amp;lt;ll&amp;gt;pre(n+5,0);

    for(int i=1;i&amp;lt;=n;i++)

    {

        cin&amp;gt;&amp;gt;s[i];

        pre[i]=pre[i-1]+s[i];

    }

    vector&amp;lt;vector&amp;lt;ll&amp;gt;&amp;gt;dp(n+5,vector&amp;lt;ll&amp;gt;(n+5,-1e16));

    for(int i=1;i&amp;lt;=n;i++) dp[i][i]=s[i];

    for(int i=n;i&amp;gt;=1;i--)

    {

        int len=i;

        for(int j=i;j&amp;lt;=n;j++)

        {

            if(i==j) continue;

            dp[i][j]=max({dp[i][j],pre[j]-pre[i-1]-dp[i+1][j],pre[j]-pre[i-1]-dp[i][j-1]});

        }  

    }

    cout&amp;lt;&amp;lt;dp[1][n];

    return 0;

}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>CSES Geometry</title><link>https://sanzenin.top/posts/obsidian/cses-geometry/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/cses-geometry/</guid><description>先使用快速排斥实验,然后再判断一下另一条线段的两个端点是否在这条直线的两端,对于两条直线都需要判断一次(比如两条直线垂直但不相交的时候就会判断失误) 代码 一个是可以考虑把一个多边形划分为多个三角形,每个三角形的面积可以用叉积计算,最后加起来取abs 然后ai告诉我也可以这样算 ,注意第一个点和最后一个点也算相邻 代码</description><pubDate>Sun, 25 Jan 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h3&gt;问题 B：Line Segment Intersection&lt;/h3&gt;
&lt;p&gt;先使用快速排斥实验,然后再判断一下另一条线段的两个端点是否在这条直线的两端,对于两条直线都需要判断一次(比如两条直线垂直但不相交的时候就会判断失误)
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;
#include &amp;lt;bits/stdc++.h&amp;gt;

#define N 1000005

#define pr pair&amp;lt;ll,ll&amp;gt;

#define ll long long

#define inf 100000000000

using namespace std;

ll n,m,ans,x;

const ll mod=1e9+7;

int main()

{

    ios::sync_with_stdio(0);

    cin.tie(nullptr);

    cout.tie(nullptr);

    cin&amp;gt;&amp;gt;n;

    auto check=[](pr a,pr b)-&amp;gt;bool

    {

        if(max(a.first,a.second)&amp;lt;min(b.first,b.second)) return 1;

        swap(a,b);

        if(max(a.first,a.second)&amp;lt;min(b.first,b.second)) return 1;

        return 0;

    };    

    auto cal=[](pr a,pr b)

    {

        return a.first*b.second-a.second*b.first;

    };  

    auto sgn=[&amp;amp;](ll x)

    {

        if(!x) return 0;

        return x&amp;lt;0?-1:1;

    };

    while(n--)

    {

        ll x1,y1,x2,y2,x3,y3,x4,y4;

        cin&amp;gt;&amp;gt;x1&amp;gt;&amp;gt;y1&amp;gt;&amp;gt;x2&amp;gt;&amp;gt;y2&amp;gt;&amp;gt;x3&amp;gt;&amp;gt;y3&amp;gt;&amp;gt;x4&amp;gt;&amp;gt;y4;

        if(check({x1,x2},{x3,x4}) || check({y1,y2},{y3,y4}))

        {

            cout&amp;lt;&amp;lt;&quot;NO\n&quot;;

        }

        else

        {

            if(sgn(cal({x2-x1,y2-y1},{x3-x1,y3-y1}))*sgn(cal({x2-x1,y2-y1},{x4-x1,y4-y1}))&amp;lt;=0 &amp;amp;&amp;amp; sgn(cal({x4-x3,y4-y3},{x1-x3,y1-y3}))*sgn(cal({x4-x3,y4-y3},{x2-x3,y2-y3}))&amp;lt;=0)

            {

                cout&amp;lt;&amp;lt;&quot;YES\n&quot;;

            }else cout&amp;lt;&amp;lt;&quot;NO\n&quot;;

        }



    }

    return 0;

}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h4&gt;问题 C：Polygon Area&lt;/h4&gt;
&lt;p&gt;一个是可以考虑把一个多边形划分为多个三角形,每个三角形的面积可以用叉积计算,最后加起来取abs
然后ai告诉我也可以这样算$S=\sum (x_y,y_i) \times (x_{i+1},y_{i+1})$,注意第一个点和最后一个点也算相邻
&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;

#include &amp;lt;bits/stdc++.h&amp;gt;

#include &amp;lt;type_traits&amp;gt;

#include &amp;lt;unordered_map&amp;gt;

#include &amp;lt;utility&amp;gt;

#define N 1000005

#define pr pair&amp;lt;ll,ll&amp;gt;

#define ll long long

#define inf 100000000000

using namespace std;

ll n,m,ans,x;

const ll mod=1e9+7;

int main()

{

    ios::sync_with_stdio(0);

    cin.tie(nullptr);

    cout.tie(nullptr);

    cin&amp;gt;&amp;gt;n;

    auto cal=[](pr a,pr b)

    {

        return a.first*b.second-a.second*b.first;

    };    

    ll x,y;

    ll prex,prey;

    for(int i=1;i&amp;lt;=n;i++)

    {

        ll a,b;

        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;

        if(i==1)

        {

            x=a,y=b;

        }else if(i==2)

        {

            prex=a,prey=b;

        }else {

            ans+=(cal({a-x,b-y},{prex-x,prey-y}));

            prex=a,prey=b;

        }

    }

    cout&amp;lt;&amp;lt;abs(ans);

    return 0;

}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>问题 T：Planets Queries II</title><link>https://sanzenin.top/posts/obsidian/cses-graph%E5%90%88%E9%9B%86/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/cses-graph%E5%90%88%E9%9B%86/</guid><description>直接用floyed跑全源最短路显然会超时.注意到本题的图是一颗基环树森林,因此可以分类讨论,尝试将最值问题转换为判定问题.我们先用tarjan预处理出所有环,再求出所有结点最近的环上的点以及到这个点的距离. - 当a,b均不在环上,当且仅当b是a的祖先可以到达,我们求出a,b之间的距离,如果a向上走这些距离走到b,那么</description><pubDate>Thu, 22 Jan 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;问题 T：Planets Queries II&lt;/h1&gt;
&lt;h3&gt;思路&lt;/h3&gt;
&lt;p&gt;直接用floyed跑全源最短路显然会超时.注意到本题的图是一颗基环树森林,因此可以分类讨论,尝试将最值问题转换为判定问题.我们先用tarjan预处理出所有环,再求出所有结点最近的环上的点以及到这个点的距离.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;当a,b均不在环上,当且仅当b是a的祖先可以到达,我们求出a,b之间的距离,如果a向上走这些距离走到b,那么ans就是dis[a]-dis[b].判定过程可以使用倍增优化.&lt;/li&gt;
&lt;li&gt;当a,b均在环上,直接求出两者之间距离&lt;/li&gt;
&lt;li&gt;当a在树上,b在环上,让a跳到离a最近的环上祖先,转换为第二种情况.
&amp;lt;small&amp;gt;*处理环也可以用拓扑排序&amp;lt;/small&amp;gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;

#include &amp;lt;iterator&amp;gt;

#include &amp;lt;queue&amp;gt;

#include &amp;lt;set&amp;gt;

#include &amp;lt;unordered_map&amp;gt;

#define N 100005

#define inf 0x3f3f3f3f3f3f3f3f

#define ll long long

#define pr pair&amp;lt;ll,ll&amp;gt;

using namespace std;

int n,m,q;

vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;map1;

vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;fa;

vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;ring;



vector&amp;lt;ll&amp;gt;scc;

vector&amp;lt;ll&amp;gt;siz;

vector&amp;lt;ll&amp;gt;dis;

vector&amp;lt;ll&amp;gt;ancestor;

vector&amp;lt;ll&amp;gt;priority;



const ll mod=1e9+7;

int main()

{

    ios::sync_with_stdio(0);

    cin.tie(nullptr);

    cout.tie(nullptr);

    cin&amp;gt;&amp;gt;n&amp;gt;&amp;gt;q;



    map1.assign(n+5,{});      

    ring.assign(n+5,{});      

    fa.assign(n+5,vector&amp;lt;int&amp;gt;(30,0));      

    scc.assign(n+5,0);

    priority.assign(n+5,0);

    ancestor.assign(n+5,0); //在环上的祖先

    siz.assign(n+5,0);

    dis.assign(n+5,0);

    for(int i=1;i&amp;lt;=n;i++)

    {

        ll x;

        cin&amp;gt;&amp;gt;x;

        fa[i][0]=x;

        map1[i].push_back(x);

    }

    for(int j=1;j&amp;lt;=25;j++)

    {

        for(int i=1;i&amp;lt;=n;i++)

        {

            fa[i][j]=fa[fa[i][j-1]][j-1];

        }

    }

    auto tarjan=[&amp;amp;]()

    {

        int tim=0;

        stack&amp;lt;int&amp;gt;st;

        vector&amp;lt;ll&amp;gt;dfn(n+5,0);vector&amp;lt;ll&amp;gt;low(n+5,0);

        vector&amp;lt;bool&amp;gt;insta(n+5,0);



        auto dfs=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x)-&amp;gt;void

        {

            dfn[x]=low[x]=++tim;

            st.push(x);

            insta[x]=1;

            for(auto v:map1[x])

            {

                if(!dfn[v])

                {

                    self(self,v);

                    low[x]=min(low[x],low[v]);

                }else if(insta[v])

                {

                    low[x]=min(low[x],dfn[v]);

                }

            }

            if(low[x]==dfn[x])

            {

                int y=-1;

                while(y!=x)

                {

                    y=st.top(),st.pop();

                    insta[y]=0;

                    scc[y]=x,ring[x].push_back(y);

                    priority[y]=(++siz[scc[y]]);

                }

            }

        };

        auto dfs2=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x)-&amp;gt;void

        {

            if(ancestor[x]) return ;

            auto v=map1[x][0];

            self(self,v);

            ancestor[x]=ancestor[v];

            dis[x]=dis[v]+1;

        };

        for(int i=1;i&amp;lt;=n;i++)

        {

            if(!dfn[i]) dfs(dfs,i);

        }

        for(int i=1;i&amp;lt;=n;i++)

        {

            if(map1[i][0]==i) ancestor[i]=i;

            else if(ring[i].size()&amp;gt;1)

            {

                for(auto x:ring[i]) ancestor[x]=x;

            }

        }

        for(int i=1;i&amp;lt;=n;i++) dfs2(dfs2,i);

    };

    auto query=[&amp;amp;](int a,int b)

    {

        auto query=[&amp;amp;](int x,int k)

        {

            if(k&amp;lt;=0) return x;

            for(int i=25;i&amp;gt;=0;i--)

            {

                if((k&amp;gt;&amp;gt;i)&amp;amp;1)

                {

                    x=fa[x][i];

                }

            }

            return x;

        };

        int ans=-1;

        if(scc[ancestor[a]]!=scc[ancestor[b]]) return -1;

        if(ancestor[a]==a &amp;amp;&amp;amp; ancestor[b]!=b) return -1; //a在环上 b在树上

        else if(ancestor[a]!=a &amp;amp;&amp;amp; ancestor[b]!=b) //都在树上

        {

            ans=dis[a]-dis[b];

            if(query(a, ans)==b) return ans;

            else return -1;

        }

        else

        {

            ans=dis[a]-dis[ancestor[a]];

            a=ancestor[a];

            ll tem=(priority[a]-priority[b]+siz[scc[a]])%siz[scc[a]];

            ans+=tem;

            return ans;

        }

    };

    tarjan();

    while(q--)

    {

        ll a,b;

        cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;

        cout&amp;lt;&amp;lt;query(a, b)&amp;lt;&amp;lt;&apos;\n&apos;;

    }



    return 0;

}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;h1&gt;问题 U：Planets Cycles&lt;/h1&gt;
&lt;h3&gt;思路&lt;/h3&gt;
&lt;p&gt;类似于上一题,找每个点最近的环,距离就是到环的距离+环大小&lt;/p&gt;
&lt;p&gt;&lt;em&gt;代码&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;bits/stdc++.h&amp;gt;

#include &amp;lt;iterator&amp;gt;

#include &amp;lt;queue&amp;gt;

#include &amp;lt;set&amp;gt;

#include &amp;lt;unordered_map&amp;gt;

#define N 100005

#define inf 0x3f3f3f3f3f3f3f3f

#define ll long long

#define pr pair&amp;lt;ll,ll&amp;gt;

using namespace std;

int n,m,q;

vector&amp;lt;vector&amp;lt;int&amp;gt;&amp;gt;map1;



vector&amp;lt;ll&amp;gt;scc;

vector&amp;lt;ll&amp;gt;din;

vector&amp;lt;ll&amp;gt;siz;

vector&amp;lt;ll&amp;gt;dis;

vector&amp;lt;ll&amp;gt;ancestor;

vector&amp;lt;ll&amp;gt;priority;



const ll mod=1e9+7;

int main()

{

    ios::sync_with_stdio(0);

    cin.tie(nullptr);

    cout.tie(nullptr);

    cin&amp;gt;&amp;gt;n;



    map1.assign(n+5,{});      

    scc.assign(n+5,0);

    priority.assign(n+5,0);

    ancestor.assign(n+5,0); //在环上的祖先

    siz.assign(n+5,0);

    dis.assign(n+5,0);

    din.assign(n+5,0);

    for(int i=1;i&amp;lt;=n;i++)

    {

        ll x;

        cin&amp;gt;&amp;gt;x;

        map1[i].push_back(x);

        din[x]++;

    }



    auto toop=[&amp;amp;]()

    {

        queue&amp;lt;int&amp;gt;q;

        for(int i=1;i&amp;lt;=n;i++)

        {

            if(!din[i]) q.push(i);

        }

        while(q.size())

        {

            auto x=q.front();

            q.pop();

            for(auto v:map1[x])

            {

                if(!(--din[v])) q.push(v);

            }

        }

    };

    auto init=[&amp;amp;]()

    {

        toop();

        auto dfs=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x,int fa)

        {

            if(ancestor[x]) return ;

            ancestor[x]=x;

            scc[x]=fa;

            siz[fa]++;

            self(self,map1[x][0],fa);

        };  

        auto dfs2=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x)-&amp;gt;void

        {

            if(ancestor[x]) return ;

            auto v=map1[x][0];

            self(self,v);

            ancestor[x]=ancestor[v];

            dis[x]=dis[v]+1;

        };

        for(int i=1;i&amp;lt;=n;i++)

        {

            if(din[i] &amp;amp;&amp;amp; !ancestor[i]) dfs(dfs,i,i);

        }  

        for(int i=1;i&amp;lt;=n;i++)

        {

            if(!ancestor[i]) dfs2(dfs2,i);

        }

    };

    init();

    for(int i=1;i&amp;lt;=n;i++)

    {

        cout&amp;lt;&amp;lt;dis[i]+siz[scc[ancestor[i]]]&amp;lt;&amp;lt;&apos; &apos;;

    }



    return 0;

}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;a&gt; AF：Knight&apos;s Tour&lt;/a&gt;
剪枝优化,按照出度从小到大排序,从贪心来看就是先把难走的走完,最后走好走的&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#include &amp;lt;algorithm&amp;gt;

#include &amp;lt;bits/stdc++.h&amp;gt;

#include &amp;lt;iterator&amp;gt;

#include &amp;lt;queue&amp;gt;

#include &amp;lt;set&amp;gt;

#include &amp;lt;unordered_map&amp;gt;

#define N 100005

#define inf 0x3f3f3f3f3f3f3f3f

#define ll long long

#define pr pair&amp;lt;int,int&amp;gt;

using namespace std;

int n,m,q,ma,ans,x,y;

vector&amp;lt;vector&amp;lt;pr&amp;gt;&amp;gt;map1;

const ll mod=1e9+7;

int vis[20][20];

int main()

{

    ios::sync_with_stdio(0);

    cin.tie(nullptr);

    cout.tie(nullptr);

    n=8;

    pr mv[8]={{2,1},{-2,1},{2,-1},{-2,-1},{1,2},{1,-2},{-1,2},{-1,-2}};

    auto check=[&amp;amp;](int x,int y)

    {

        if(vis[x][y] || x&amp;lt;1 || y&amp;lt;1 || y&amp;gt;n || x&amp;gt;n) return 0;

        return 1;

    };

    auto cal=[&amp;amp;](int x,int y)

    {

        int tem=0;

        for(auto [dx,dy]:mv)

        {

            auto xx=x+dx;

            auto yy=y+dy;

            if(!check(xx,yy)) continue;

            tem++;

        }

        return tem;

    };

    auto dfs=[&amp;amp;](auto &amp;amp;&amp;amp;self,int x,int y,int cnt)-&amp;gt;bool

    {

        vis[x][y]=cnt;

        if(cnt==64)

        {

            return 1;

        }

        vector&amp;lt;tuple&amp;lt;int,int,int&amp;gt;&amp;gt;tem;

        for(auto [dx,dy]:mv)

        {

            auto xx=x+dx;

            auto yy=y+dy;

            if(!check(xx, yy)) continue;

            tem.push_back({cal(xx,yy),xx,yy});

        }

        sort(tem.begin(),tem.end());

        for(auto [_,xx,yy]:tem)

        {

            if(self(self,xx,yy,cnt+1))

            {

                return 1;

            }

        }

        vis[x][y]=0;

        return 0;

    };

    cin&amp;gt;&amp;gt;y&amp;gt;&amp;gt;x;

    dfs(dfs,x,y,1);

    for(int i=1;i&amp;lt;=n;i++ &amp;amp;&amp;amp; cout&amp;lt;&amp;lt;&apos;\n&apos;)

    {

        for(int j=1;j&amp;lt;=n;j++)

        {

            cout&amp;lt;&amp;lt;vis[i][j]&amp;lt;&amp;lt;&apos; &apos;;

        }

    }
    return 0;

}
&lt;/code&gt;&lt;/pre&gt;
</content:encoded></item><item><title>Next Prime</title><link>https://sanzenin.top/posts/obsidian/cses-mathmatics%E5%90%88%E9%9B%86/</link><guid isPermaLink="true">https://sanzenin.top/posts/obsidian/cses-mathmatics%E5%90%88%E9%9B%86/</guid><description>Next Prime，来自 Obsidian 的算法笔记。</description><pubDate>Mon, 19 Jan 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&amp;lt;!-- 由 scripts/sync-obsidian.mjs 从 Obsidian Vault 生成，请勿直接编辑。 --&amp;gt;&lt;/p&gt;
&lt;h1&gt;Next Prime&lt;/h1&gt;
</content:encoded></item></channel></rss>