Yuukoの小屋

查找

2026-04-17T16:00:00.000Z

查找

从数据集合中寻找某个数据元素的过程称为查找。查找结果分为:

成功: 找到符合的元素
失败: 数据集合不存在指定元素

查找的相关概念

查找表与静态查找表: 用于查找的集合，通常的操作有插查询与增删，支持增删元素的查找表称为动态查找表，只支持查询元素的查找表称为静态查找表

关键字: 用以唯一对应元素的某个数据项的值

平均查找长度: 一次查找的长度指中的比较关键字的次数，平均查找长度为对于当前的查找表的查找长度期望

$\text{ASL} = \sum_{i=1}^n P_iC_i$

查找方式

顺序查找

顺序查找是对于线性表的查找，可对于关键字有序与无序的线性表进行查找。

一般顺序表的查找

一般顺序表的查找即遍历整个线性表的查找方式。在查找中，逆序查找目标元素，同时人为设定表头为目标元素作为"哨兵"避免越界判断，

struct SSTable{
    ElemType *elem;
    int Len;
}

int Search_seq(SSTable ST,ElemType key){
    int i;
    ST.elem[0] = key;
    for i = ST.Len; ST.elem[i] != key ; i--);
    return i;
}

使用一般顺序表的查找方式的查找成功的平均查找长度为

$\text{ASL}_\text{成功} = \sum_{i=1}^n (n-i+1)P_i$

当查找每一个元素为等概率事件时

$\text{ASL}_\text{成功} = \sum_{i=1}^n \frac{n-i+1}{n} = \frac{n+1}{2}$

查找失败的平均查找长度为

$\text{ASL}_\text{失败} = \sum_{i=1}^n (n+1)P_i =n+1$

时间复杂度显然为 $\mathcal{O}(n)$

有序顺序表的查找

有序顺序表相比一般顺序表的遍历方式，可以通过有序条件判断进行二叉决策，可以在查找中就判断出查找失败而不是遍历完全表才查找失败，从而降低失败的平均查找长度。

struct STable {
    ElemType *elem;
    int Len;
};

int Search_seq_for(STable ST, ElemType key) {
    for (int i = 0; i < ST.Len; i++) {
        if (ST.elem[i] == key) {
            return i;
        }
        if (ST.elem[i] > key) {
            return -1; 
        }
    }
    return -1; 
}

我们可以将表元素的间的失败区间视为一个新的“黑“表，因此搜索失败相当于对”黑“表的搜索成功，同时，黑表的最后两项的搜索长度都为n。对于有序线性表的查找失败的平均查找长度为

$\text{ASL}_\text{失败} = \sum_{i=1}^n (l_i-1)P_i = \frac{1+\cdots+n+n}{n+1} = \frac{n}{2}+\frac{n}{n+1}$

二分查找

二分查找只适用于关键字有序的顺序表(原理上对于双向链表也适用，但是因为链表遍历的时间开销，整体时间复杂度不会被优化)

int Binary_Search(STable ST, ElemType key){
    int low = 0;
    int high = ST.Len - 1; 
    int mid;
    while(low <= high){
        mid = (low + high) / 2;
        if (ST.elem[mid] == key){
            return mid;
        }
        else if (ST.elem[mid] > key){
            high = mid - 1;
        }
        else {
            low = mid + 1;
        }
    }
    return -1;
}

对于静态的有序顺序表，执行二分查找的过程等价于在一棵平衡的二叉排序树上进行搜索；
对于无序的数据集合，如果想要在不移动大量元素的前提下获得对数级别 $\mathcal{O}(\log n)$ 的查找效率，不能直接使用二分查找，而必须在物理结构上将其构建为一棵平衡二叉排序树。

二分查找的比较次数不超过判定树高度。在等概率查找的条件下满足

$2^{h-1} - 1 < n \leq 2^{h} - 1$

$h = \left \lceil \log_2(n+1) \right \rceil$

设二叉平衡树的每一层元素个数为 $a_h$ ,则查找成功的平均查找长度为

$\text{ASL}_\text{成功}= \frac{1}{n}\sum_{i=1}^n l_i = \sum_{j=1}^h\frac{j\times a_j}{n} \overset{\text{满二叉树}}{\simeq} \frac{n+1}{n}\log_2(n+1) -1 \simeq \log_2(n+1)-1$

查找失败的平均查找长度为

$\text{ASL}_\text{失败}= \frac{(2a_{h-1}-a_h)(h-1)+2a_{h}h}{n+1}$

查找失败也只有两种可能性，树的高度与树的高度-1，因此关键词比较次数最多等于树的高度

$h = \lceil \log_2(n+1)\rceil$

分块查找

分块查找是将整个大的顺序表分为若干个小块，小块内部可以没有顺序，小块之间有顺序。基于最大关键字与块起始地址建立块间索引。进行分块查找首先查找在哪一个块中，再对子块进行顺序表查找。

分块查找的平均查找长度等于块间索引查找长度与块内查找的长度和

$\text{ASL} = L_I+L_S$

如果将分块等分为 $b$ 块,每一块包含 $s$ 个元素，每一个元素被查找遵循等可能原则，则平均查找长度为

$\text{ASL} = \frac{b+1}{2}+\frac{s+1}{2} = \frac{s^2+2s+n}{2s} = \frac{s}{2} +\frac{n}{2s}+1\geq \sqrt{n}+1$

当 $s = \sqrt{n}$ 时 $\text{ASL}$ 取最小

树形查找

二叉排序树(BST)

构建二叉排列树的目的是作为动态查找表，利用其有序结构更加高效的进行动态查找、增删。

二叉排序树的构建满足如下原则：

若左子树非空，则左子树的所有结点的关键字均小于左子树根结点
若右子树非空，则右子树的所有结点的关键字均大于右子树根结点
左右子树也是二叉排序树

二叉排序树中序遍历可以得到一个递增的有序关键字序列。

对于n个结点的有序表构建二叉排序树，二叉排序树的可能数目为Catalan数

$C_n = \frac{\binom{2n}{n}}{n+1}$

二叉排序树的查找

二叉排序树的拓扑结构和二分查找的判定树是相似的。二叉排序树的查找是从根结点出发，逐层向下比较并选择左/右子树的过程。当二叉排序树的结构是几乎平衡时，二叉排序树的查找的时间复杂度为 $\mathcal{O}(\log n)$ , 当二叉排序树的结构几乎为一条没有分支的树时，时间复杂度为 $\mathcal{O}(n)$ .

二叉排序树的构建

对于一个选定的结点，将比它小的添加在它的左孩子结点，比它大的添加在它的右孩子结点。

平衡二叉树(AVL树)

AVL树是二叉排序树平衡化的结果，它要求任意结点的左右子树高度差绝对值不小于1。

定义结点的左子树与右子树的高度差为平衡因子，平衡二叉树的平衡因子只能是 $\pm 1, 0$

平衡二叉树的旋转

基本旋转为向右旋转与向左旋转两种

LL 平衡旋转

左子树更深的时候，将左子树根结点提升到整树根结点，将原树根结点向右下降为右子树根结点

RR 平衡旋转

右子树更深的时候，将右子树根结点提升到整树根结点，将原树根结点向左下降为左子树根结点

基于这两种旋转的复合，有:

LR平衡旋转

将左子树的右子树的根结点，先向左旋转再向右旋转提升为整树根结点

RL平衡旋转

将右子树的左子树的根结点，先向右旋转再向左旋转提升为整树根结点

平衡二叉树的删除

平衡二叉树的删除和增加的旋转类似，都遵循“哪边子树深度更浅，向哪边旋转的原则”，旋转到平衡为止。

红黑树

AVL树的每一次增删几乎都需要进行平衡性校验与旋转以改变整体拓扑结构，代价较大。红黑树在AVL树的基础上放宽了条件要求。

红黑树满足如下性质:

红黑树是二叉排序树
红黑树的每一个结点都是红色/黑色的
红黑树的根结点是黑色的
叶结点(虚构外结点/NULL结点)都是黑色的
红结点的父结点与子结点都是黑色的，不存在相邻的红结点
每一个结点到任意叶结点的路径的简单路径的黑色结点数量相等。由此性质，定义这样的(不含该结点的)简单路径的黑结点总数为黑高，根结点的黑高称为红黑树的黑高

红黑树的一个黑结点的子结点既可以是红结点，也可以是黑结点，在同一黑结点也可以存在红/黑两个不同色的子结点。且只需要满足左右子树的黑高相等就能构成红黑树。

红黑树的最大深度差为 $bh$

全黑子树的深度为 $bh$ , 红黑交替的子树的深度最大为 $2bh$ ,因此最大深度差为 $2bh-bh = bh$ 。

而AVL树的最大深度差仅为 $1$ ，红结点的引入极大松弛了整体拓扑结构。

Corollary: 有 $n$ 个内部结点的红黑树的高度

$h\leq 2\log_2(n+1)$

一个简单路径至少一半为黑结点

$bh\geq \frac{h}{2}$

因此

$n\geq 2^{\frac{h}{2}}-1$

即

$h\leq 2\log_2(n+1)$

红黑树的插入

红黑树的插入元素初始化必须为红色结点, 否则插入后必然破坏红黑树的黑高平衡，只会在插入后，其父结点与子结点均为红结点时出现问题，需要进红黑树的旋转。

当插入结点的父结点为红且叔结点为黑时:

LR旋转

与AVL树的LR旋转类似，当左子树的根结点与其右孩子都为红色时，将该右孩子旋转为上一级树的根结点并染黑，将原上一级树的根结点向右旋转并染为红, 保证了左右子树的黑高平衡。

LL旋转

当左子树的根结点与其左孩子都为红色时，旋转该根结点至上一级树的根结点，并染黑，原上一级树的根结点向右旋转并染为红。

当叔结点为红时: 将父结点与叔叔结点都染黑，将祖父结点染红，这样就保证了整体的黑高不变。如果祖父结点为根结点，则先染红再染回默认黑色，因为整体根结点的颜色不会影响黑高平衡。

红黑树的删除

红黑树的优势

红黑树相比AVL树，在大量增删的场景下对于全局拓扑结构的改变次数少，因此适合大量增删的场景；如果查找操作远多于增删操作，则AVL树更优。

B树

B树是面向大数据量的数据结构，其类似于分块查找，但是分层更深。

B树的每一个结点组成包含指向下一层结点的指针域与关键字域，其中关键字域和指针域是交替的, 因此指针域总比关键字域多1个

一棵 $m$ 阶B树满足如下条件:

$m$ 叉树
每个结点至多有 $m$ 棵子树，即至多包含 $m-1$ 个关键字。
根结点最少包含 $2$ 棵子树，最少包含 $1$ 个关键字
除了根结点外，所有非叶结点至少有 $\lceil \frac{n}{2}\rceil$ 棵子树，至少包含 $\lceil \frac{n}{2}\rceil -1$ 个关键字 -- 否则，再减少一个元素后，它与它的子树将“崩塌”为一个结点。
叶结点出现在同一层，对应指针为NULL，表示查找失败，因此叶结点只有 $n+1$ ge

B树的高度

B树的拓扑结构相当多样，在每一个结点都可以拓展多一半的空间。它的两个极限情况分别为:

每一个结点全部填满为 $m-1$ 个关键字
每一个结点只填充 $\lceil \frac{n}{2}\rceil -1$ 个关键字

情况1

$n \leq (m-1)(1+m+\cdots+m^{h-1}) = m^h-1$

即

$h_\text{min}=\log_m(n+1)$

情况2

由于外部结点总只有 $n+1$ 个，

$n+1 \geq 2\left(\frac{m}{2}\right)^{h-1}$

即

$h_\text{max} = \log_{\lceil \frac{m}{2}\rceil}(\frac{n+1}{2}) +1$

特殊情况: 对于3阶B树的情况2，每一个结点内的关键字个数为 $\lceil \frac{3}{2}\rceil -1 = 1$ ,相当于一个满二叉树.

B树的构建与插入

B树在大部分时刻插入时，结点都是未填满的状态(即 $\lceil\frac{m}{2} \rceil -1\leq i<m-1$ ), 此时直接添加不会改变B树的拓扑结构。

当添加时结点处于填满状态( $n = m-1$ )时，再插入一个元素会导致结点的分裂。将中间的关键字提升到父结点，整个结点的左侧和右侧分裂为两个结点，指向这两个结点的指针在父结点的数据域中排列在提升的关键字的左边与右边。如果父结点仍然满，就将父结点

B树的构建遵循自底而上的原则。先填充满 $n = m-1$ 个关键字的结点，再插入新关键字导致结点分裂，依此规则填满整个B树

B树的删除

删除关键字同样需要保证删除后结点内关键字不少于 $\lceil \frac{m}{2}\rceil-1$ , 否则触发结点的借位或合并。

如果删除的关键字属于非终端结点，删除后，相邻子结点的最靠近该关键字的关键字提升到父结点。

如果删除的关键字属于终端结点，则有三种情况:

如果删除该关键字后，结点内关键字数量仍然大于 $\lceil \frac{m}{2}\rceil-1$ , 则直接删除关键字
如果删除结点关键字量为 $\lceil \frac{m}{2}\rceil -1$ , 且兄弟结点的关键字数量大于 $\lceil \frac{m}{2}\rceil$ , 则将父结点的相邻关键字下降到被删除的关键字的位置，同时将相邻结点的关键字补回原来父结点关键字的位置。
如果删除结点关键字量为 $\lceil \frac{m}{2}\rceil -1$ , 但是兄弟结点的关键字数量都为 $\lceil \frac{m}{2}\rceil -1$ ，删除该关键字后，将两个兄弟结点以父结点中间的关键字合并为一个结点。

B+树

B+树的所有关键字都存储在叶结点中，相邻叶结点间存在指针相连，每一个结点的子树个数等于其关键字个数，关键字作为子结点的索引存在于子结点中。

B+树的遍历查找方式:

叶结点顺序遍历
根结点出发的类分块查找

第二种查找方式遇到了目标关键字后不会终止，而是需要访问到叶结点才终止查找。

Hash表

Hash函数将关键字映射以某种方式映射到存储地址，记为

$\text{Hash}(\text{key}) = \text{Addr}$

Hash 函数通常将

图

2026-04-11T16:00:00.000Z

图

常见概念

顶点的度

无向图的顶点的度定义为经由某顶点 $v$ 的边的数量

有向图的顶点的度分为入度与出度，分别定义为从顶点 $v$ 进入的有向边与离开的有向边的数量。度定义为入度 $\mathrm{ID}(v)$ 与出度 $\mathrm{OD}(v)$ 的和

无向图的顶点度之和等于边数的两倍，因为每一条边都占据了两侧顶点的度。

强连通图与强连通分量

对于有向图的顶点 $u,v$ ，如果从 $u$ 到 $v$ 与从 $v$ 到 $u$ 都有路径，则称这两个顶点是强连通的。如果一个图的任意顶点都强连通，则称这个有向图是强连通图。有向图的极大强连通子图称为强连通分量。

如果一个有向图存在某个顶点只有出度或者只有入度，那么这个顶点单独也构成一个强连通分量。

生成树

包含所有顶点的极小连通子图称为这个连通图的生成树

稠密图与稀疏图

一般认为图 $G$ 满足

$|E|<|V|\log_2|V|$

可视为稀疏图

完全无向图的度总边数:

假设 $n$ 阶完全图的总边数为 $A_n$ , 满足递推:

$\begin{cases} A_1 = 1 \\ A_n = A_{n-1} +n-1 \end{cases}$

求和得

$A_n = \frac{n(n-1)}{2}$

图的存储方式

邻接矩阵

$A[i][j] = \begin{cases} 1&(v_i,v_j)\in E\\ 0&(v_i,v_j)\notin E \end{cases}$

对于带权的图，通常将邻接矩阵的元存为权，将不含边的位置存为 $0$ 或 $\infty$

$A[i][j] = \begin{cases} w_{ij}&(v_i,v_j)\in E\\ 0\,\text{or}\,\infty&(v_i,v_j)\notin E \end{cases}$

Corollary: 设图 $G$ 的邻接矩阵为 $A$ ， $A^n$ 的元素 $A^n[i][j]$ 代表从顶点 $i$ 到顶点 $j$ 的，长度为 $n$ 的路径数量

$A^2[i][j] = \sum_{k\in V}\delta_{ik}\delta_{kj}$

代表从顶点 $i$ 到途经点 $k$ 再到顶点 $j$ 的有效路径个数

$A^n[i][j] = \sum_{k1,\cdots,k_{n-1}\in V}\delta_{ik_1}\left(\prod{\delta_{k_rk_s}}\right)\delta_{k_n j}$

有向图的邻接矩阵的出边对应行的元素，入边对应列的元素
邻接矩阵适合用于稠密图的存储。存储稀疏图时比较浪费空间。邻接矩阵的空间复杂度总为 $\mathcal{O}(|V|^2)$

邻接表

邻接表由顶点表与边表组成，顶点表是一个线性表，存储顶点信息与边表的头指针；边表是一个链表，两个指针域分别存储当前出边(无向表为经过顶点的边)指针与指向下一个出边的结点指针

对于稀疏图，邻接表可以极大节省空间复杂度，存储的空间负责度为 $\mathcal{O}(|V|+|E|)$ (有向图)， $\mathcal{O}(|V|+2|E|)$ (无向图)
邻接表的边删除，求顶点出度/入度等操作都需要遍历整个邻接表，时间复杂度为 $\mathcal{O}(|V|+|E|)$
建立邻接表的时间复杂度为 $\mathcal{O}(|V|+|E|)$

十字链表

十字链表是一种使用两个链表存储有向图的数据结构。分别为顶点链表与弧链表

顶点链表由data数据域、firstin指向第一个以该顶点为弧头的弧的指针、firstout指向第一个以该顶点为弧尾的弧的指针三个数据域构成。
弧指针由tailvex弧尾顶点、headvex弧头顶点、hlink指向相同弧头的弧的指针、tlink指向相同弧尾的指针、info存储弧的相关数据域五个数据域构成。

邻接多重表

邻接多重表的顶点表与邻接表类似，边表与十字链表类似。

图的遍历

广度优先搜索(BFS)

BFS类似于树的层序遍历，基本思想为以相邻结点作为"层"，从起始结点出发后依次访问相邻的结点，指导所有可达结点都访问完为止。

BFS的实现思路为:

暂存当前层的下一级相邻结点
访问当前层的结点
进入下一层

因此，BFS的时间复杂度为 $\mathcal{O}(V)$ ,空间复杂度在最坏的情况下是 $\mathcal{O}(|V|)$ 。如果使用邻接矩阵进行存储时，查询每个顶点的邻接点的时间复杂度为 $\mathcal{O}(|V|)$ ，总时间复杂度为 $\mathcal{O}(|V|^2)$

BFS可以实现的算法

单源最短路径问题
广度优先生成树

深度优先搜索(DFS)

DFS的实现方式类似于树的先序遍历，尽可能深的搜索并访问图。

DFS的实现思路为递归，空间复杂度最坏的情况下为 $\mathcal{O}(|V|)$ 。
不管是BFS还是DFS, 遍历整个图的时间与空间开销都是相同且取决于图存储方式的，使用邻接矩阵的总时间复杂度为 $\mathcal{O}(|V|^2)$ , 采用邻接表的总时间复杂度为 $\mathcal{O}(|V|+|E|)$ 。

图的应用

最小生成树算法

对于带权连通无向图 $G$ ，具有最小总权重的生成树称为图 $G$ 的最小生成树(MST)

最小生成树有以下特征:

如果图有权值相同的边，那么最小生成树可能不唯一；如果图的任意两条边权值都不同，那么最小生成树唯一。
不同的最小生成树的总权值仍相等且为最小值
最小生成树的边等于顶点数减一(树的性质)

Prim 算法

Prim算法 -- 从选定的一个顶点出发，基于贪婪算法选择已经过的顶点的相邻顶点的最短边相连

Kruskal算法

Kruskal算法 -- 按照最短边相连的原则将最短边相连，连接前判断是否构成环，如果不构成环就进行连接，如果构成了环就进行更长的边的连接。 Kruskal算法中的环检索不是通过DFS实现，而是通过并查集检索先序元素是否出现实现。

最短路径问题

松弛化操作:

对于图，寻找到一个顶点满足两弧之和小于第三弧，再进行最短距离更新到操作，称为松弛化。
d[i][j] = std::min(d[i][j], d[i][k] + d[k][j]);

Dijkstra算法

Dijkstra算法通过贪心算法+更新最短路径表实现，每一步走过当前结点的最短出边后更新最短路径表。

因此，Dijkstra不适用于负边权的图，存在负边权则无法发现最短边。

Floyd算法

Floyd算法维护了一个矩阵，在初始化的时候为邻接矩阵，再遍历所有点，每一个点都进行松弛化操作得到相对较短的路径，全部遍历完后的矩阵就是最短路径表。

Floyd算法能对于负边权图适用，但是不允许存在负边权环

两个算法的空间复杂度都为 $\mathcal{O}(|V|^3)$

有向无环图(DAG)

二叉树与DAG的转换

二叉树与DAG的转换相当于把相同的子树结构商去

拓扑排序

拓扑排序基于AOV网：不含权的有向无环图，每一个顶点代表一个活动，并使用有向边表示活动先后顺序。

每一个AOV网存在一个或者多个拓扑排序
有向环没有拓扑排序，只有DAG才能形成拓扑排序。

拓扑排序的执行思路为(Kahn算法):

选择入度为0的顶点进入队列
删除这个顶点与相连的边
进入下一轮

拓扑排序和其他图遍历的时间复杂度类似，都与图存储的形式相关。使用邻接表的时间复杂度为 $\mathcal{O}(|V|+|E|)$ , 使用邻接矩阵的时间复杂度为 $\mathcal{O}(|V|^2)$

DFS实现拓扑排序

关键路径

在带权有向图中，顶点代表事件，边权代表活动的时间开销。这类图称为AOE图. AOE图中通常只设置一个入度为0的点为源点，作为工程起点；一个出度为0的点为汇点，作为工程终点。

AOE图有六个个重要的概念，分别为:

事件 $v_k$ 的最早发生时间 $v_e(k)$ : 从源点到当前顶点的最长路径。
活动 $a_i$ 的最早发生时间 $e(i)$ : 对应弧起点的时间最早发生时间，相当于这个弧的前序最长距离。
关键路径: 从源点到汇点的最长距离。意味着整个工程的完结，时间不能短于这个总权值。关键路径上的活动称为关键活动

以下这两个DDL概念的定义是从关键路径反过来定义的

事件 $v_k$ 的最晚发生时间 $v_l(k)$ : 保证所有后继事件有足够时间发生的最晚时间。可以通过关键路径(总工程的DDL减去后继最长的路径进行计算)
对于活动也有相同的定义
活动 $a_l$ 的最晚发生时间 $l(i)$ : 定义为弧尾事件的最晚发生时间减去活动的耗时。也就是在最后DDL期限下，开始执行活动 $a_l$ 的时间。
活动 $a_l$ 的时间余量定义为活动的最晚发生时间与最早发生时间的差值 $d(i) = l(i)-e(i)$ 。如果时间余量为0，则说明只能在一个时间点执行，这种活动称为关键活动。

树与二叉树

2026-04-05T16:00:00.000Z

树

无根树

无根树是一个具有 $n$ 个结点, $n-1$ 条边的连通无向无环图。在无根树的基础上设定一个根节点，则形成一个有根树, 同时规定了树的结点的上下层关系。

关于树的定义:

森林(Forest): 每个连通分支为树的图结构。
生成树(Spanning tree): 基于一个连通无环无向图生成的树。生成的最小树称为最小生成树(Minimal Spanning Tree, MST)。
有序树与无序树: 如果兄弟节点的顺序是自左到右有次序的,则称为有序树,反之称为无序树。

关于有根树的定义:

父节点(Parent Node): 上一层结点,根节点没有父节点。
祖先(Ancestor): 从当前结点到根结点的除自身以外的所有结点。
子结点(Child Node): 下一层结点
结点深度(Depth): 从当前结点到根结点的图距离
树的深度(Height): 最深结点的结点深度
度(Degree): 不同于传统图论定义, 树的结点的度定义为连接的子结点个数
叶结点(Learf): 度为0的结点,同时是没有子结点的结点

树的存储结构

双亲表示法

双亲表示法使用一个顺序表存放树结点，每个结点由数据域与父结点的数组下标的"伪指针域"构成。

双亲表示法的存储结构为

struct PTNode{
    int data;
    int parent;
};
struct PTree{
    PTNode nodes[MAX_TREE_SIZE];
    int n;
};

双亲表示法寻找指定结点的父结点的时间复杂度和顺序表定位元素相同, 为 $\mathcal{O}(1)$ 。寻找指定结点的子结点的时间复杂度需要遍历整个顺序表，时间复杂度为 $\mathcal{O}(n)$ 。

孩子表示法

孩子表示法将所有结点存入一个顺序表，每个元素作为头结点，指向首元子结点指针，然后指向子结点的兄弟结点。

struct ChildPtr {
    int child;              
    ChildPtr* next;         
};
struct CTBox {
    int data;               
    ChildPtr* firstChild;   
};
struct CTree {
    CTBox<int> nodes[MAX_TREE_SIZE];
    int root;                      
    int numNodes;                  
};

孩子兄弟表示法

孩子兄弟表示法的每个结点有数据域、指向第一个孩子的指针与指向兄弟的指针，在每一层实现先向下后向右的指针移动方式。这个指针规则也成为左孩子-右兄弟原则

struct CSNode{
    int data;
    CSNode *firstchild;
    CSNode *nextsibling;
};

二叉树

二叉树是一种任何结点的度至多为 $2$ 的树。

二叉树的性质

性质1: 在二叉树的第 $i$ 层至多有 $2^{i-1}$ 个结点

Proof:

由归纳法，当 $i = 1$ 时，根结点个数为 $1$ 。假设当 $i= j-1$ 时，结点数至多为 $2^{j-2}$ , 则当 $i = j$ 时, 由于二叉树的结点度至多为 $2$ , 故第 $i$ 层的结点至多为 $2\times 2^{j-2} = 2^{j-1}$

性质2: 深度为 $k$ 的二叉树至多有 $2^{k}-1$ 个结点

Proof:

由性质1,总节点数至多为

$\sum_{i=1}^k 2^{i-1} = 2^k-1$

性质3: 对于任何一棵二叉树 $\mathcal{T}$ ，如果其叶结点数为 $n_0$ , 度为 $2$ 的结点数为 $n_2$ , 则 $n_0=n_2+1$

Proof:

二叉树由度为 $0,1,2$ 的结点构成，有

$n = n_0+n_1+n_2$

根据分支数计算总结点数, 每个度为 $2$ 的结点贡献 $2$ 个分支, 度为 $1$ 的结点贡献 $1$ 个分支, 最后加上根结点。

$n = 2n_2+n_1+1$

故

$n_0 = n_2+1$

性质4: $n$ 个结点的完全二叉树的深度为 $\left \lfloor \log_2n \right \rfloor +1$

Proof:

完全二叉树满足:

$2^{k-1}-1<n\leq 2^{k}-1$

即

$2^{k-1}\leq n < 2^k$

$k-1\leq \log_2 n < k$

因此

$k = \lfloor\log_2n\rfloor+1$

二叉树的存储结构

顺序存储结构

使用一维数组,按从上到下，从左到右的方式存储。对于完全二叉树,每一个节点都存入了元素,对于一般的二叉树, 存在节点需要存入Null或其他占位符。

链式存储结构

二叉树的链式存储结构分为

二叉链表
三叉链表

二叉链表为每个结点赋予左子指针与右子指针，用以指向下一个子结点。三叉链表的每一结点比二叉链表多一个前驱指针，用以实现类似于双向链表搜索前序元素的功能，

struct BTree{
    int data;
    BTree *LChild; 
    BTree *RChild;
    BTree *Parent; // 前驱指针
}

二叉树的应用

遍历二叉树

树的DFS有三种形式

先序遍历 -- 遵从从根结点到叶结点，从左到右的准则。
中序遍历 -- 遵从从左侧叶结点向右侧叶结点DFS，经过叶结点后返回分支的父结点，访问根结点后访问右子树的准则。
后序遍历 -- 遵从从左子树的叶结点后序遍历，经过根结点后后序遍历右子树。
也可以按照从上到下，从左到右的方式进行遍历。

// 递归法
void pre_order_recursive(BTree *root) {
    if (root == NULL) return;
    func(root);                    
    pre_order_traversal_recursive(root->LChild);
    pre_order_traversal_recursive(root->RChild); 
}
// 迭代法
void pre_order_traversal_iterative(BTree *root){
    if (root == NULL) return;
    BTree *curr = root;
    BTree *prev = NULL;
    while (curr!=NULL){
        if(prev == curr->Parent){
            func(curr);
            if (curr->LChild != NULL){
                prev = curr;
                curr = curr->LChild;
            }
            else if (curr->RChild != NULL){
                prev = curr;
                curr = curr->RChild;
            }
            else{
                prev = curr;
                curr = curr->Parent;
            }
        }
        else if (prev == curr->LChild){
            if (curr->RChild != NULL){
                prev = curr;
                curr = curr->RChild;
            } 
            else{
                prev = curr;
                curr = curr->Parent;
            }
        }
        else{
            prev = curr;
            curr = curr->Parent;
        }
    }
}

线索二叉树

线索二叉树的单个结点含有五个对象

$\text{node = [LChild,LTag,data,RTag,RChild]}$

LChild/RChild作为指向子结点的指针还是前驱指针依赖于LTag/RTag的值, LTag/RTag称为二叉树的线索

森林

树、二叉树与森林的转换

树与二叉树的转换

遵循 左孩子右兄弟原则。树转换为二叉树将右侧兄弟接在右子树。

在树转换为二叉树的情况下，因为根结点没有兄弟结点，所以转换的二叉树没有右子树，

森林与二叉树的转换

将森林的每一棵树都转换为二叉树后，将后一个二叉树的根结点拼接在前一个二叉树的右子结点上，以此类推形成完整的二叉树。

二叉树转换为森林

和森林转换为二叉树的原则相对应。将二叉树的右子树拆解为新二叉树，新二叉树的左子树与右子树分别构成子树，以此类推形成森林。

Huffman树

Huffman树的定义

带权路径长度WPL

定义每一个结点的权重为 $w_i$ , 距离根结点的图距离为 $l_i$ , 则带权路径长度定义为

$\mathrm{WPL} =\sum_{i=1}^n w_il_i$

加权平均长度定义为

$\bar{L} =\frac{\mathrm{WPL}}{\sum_{i=1}^n w_i}$

称在含有 $n$ 个带权结点的二叉树中，具有最小 $\mathrm{WPL}$ 的二叉树为 哈夫曼(Huffman)树, 也称最优二叉树

Huffman树的构建

将权值最小的结点拼接为左右子树，作为一个整体结点再添加倒数第三大的结点作为左子树，以此原则遍历结点生成Huffman树

并查集

并查集是用于合并与查询集合元素的树结构工具。实现方式为树的双亲表示法。

并查集的操作

集合结构

原子元素的初始位置域为 $-1$ , 形成一个集合时，子结点元素指向父结点(代表元)，父结点的位置域存入集合元素的个数的相反数，子结点的位置域存入父结点的位置

集合并运算

，将并入的集合的代表元插入另外一个集合的代表元的子结点上，位置域存入那个集合的代表元的位置。

集合查找运算

沿着伪指针向上搜索根结点

串的模式匹配与KMP算法

2026-03-30T16:00:00.000Z

问题定义

子串的定位称为串的模式匹配，称子串T为模式串。

在串中匹配子串的最朴素的想法是移动子串头指针进行一一比对

// 起始点pos后的首个子串结束位置
int Index(std::string S, std::string T, int pos){
    int i = pos;
    int j = 0;
    while ( i <= S[0] && j <= T[0]){
        if ( S[i] == S[j] ){
            ++i;
            ++j;
        }
        else{
            i = i-j+1;
            j = 0;
        }
    }
    if ( j > T[0]){
        return i - T[0];
    }
    else return 0;
}

对于前序相同部分过长的串，这个算法的时间复杂度开销过大。比如对于模式串0001与主串00000001,需要反复遍历子串，时间复杂度为 $\mathcal{O}(m\times n)$

前缀函数

串的前缀与后缀

对于串 $s[0,\cdots,n]$ , 记 $\varphi_k(s)=[0,\cdots,k-1]$ 为前缀, 记 $\psi_k(s)=[n-k+1,\cdots,n]$ 为后缀

前缀函数定义为串 $s$ 的前i段子串的最长的真前缀与真后缀相等的长度

$\pi[i](s) = \begin{dcases} 0 & i = 0\\ \max_{k}\{k : \varphi_k(s)=\psi_k(s)\} & i\neq 0 \end{dcases}$

$\pi(s) = [\pi(i)[s]]$

比如对于字符串s[acbac],它的前缀函数为

$\pi[0]=0$
$\pi[1] = 0$ , 因为ac没有相等的真前缀/后缀
$\pi[2] = 0$ , 因为acb没有相等的真前缀/后缀
$\pi[3] = 1$ , 因为acba有相等的真前缀与后缀a
$\pi[4] = 2$ , 因为acbac有相等的真前缀与后缀ac

因此 $\pi(s)=[0,0,0,1,2]$

根据这个思路实现前缀函数

#include<vector>
using namespace std;

int prefix_func_item(string s, int i){
    int res = -1;
    int n = (int) s.length();
    for (int j = i; j >= 0; j--){
            if (s.substr(0,j) == s.substr(i-j+1,j)){
                res = j;
                break;
            }
        }
    return res;
}

vector<int> prefix_func(string s){
    int n = (int) s.length();
    vector<int> pi(n);
    for (int i = 0; i < n; i++){
        pi[i] = prefix_func_item(s,i);
    }
    return pi;
}

prefix_func_item的时间复杂度 $\mathcal{O}(n^2)$ ,prefix_func的时间复杂度为 $\mathcal{O}(n)$ ，总时间复杂度为 $\mathcal{O}(n^3)$ , 开销巨大，需要进行优化

优化

当prefix_func 遍历到 $i$ 个元素的子串的时候，子串尾部添加元素，对前缀函数值的影响有三种可能

$+1$ 当添加的正好是前一位前缀函数指定的前缀的后一位元素 (比如abca -> abcab)。翻译为数学语言: 满足 $s[i+1] = s[\pi[i](s)]$ 时, $\pi[i+1] = \pi[i]+1$
$-$ 当添加的元素破坏了前缀匹配 (比如abca -> abcac / acbac -> acbaca)
$=$ 保持不变

优化1

根据情况1分析，前缀函数实际比对的是前缀段与后缀段的一小部份的子串，中间的子串段可以不遍历。而这个片段的长度上界由情况1给出 -- $\pi[i-1]+1$

#include<vector>
#include<string>
using namespace std;

vector<int> prefix_func(string s){
    int n = (int) s.length();
    vector<int> pi(n);
    for (int i = 0; i < n ; i++){
        for (int j = pi[i-1]+1 ; j > 0 ; j--){
            if (s.substr(0,j) == s.substr(i-j+1,j)){
                res = j;
                break;
            }
        }
    } 
    return pi;
}

优化2

当 $s[i+1]\neq s[\pi[i]]$ 时，前缀函数的值肯定是减少的。当子串的前缀与后缀相同的时候，可能存在子前缀与子后缀作为更小的相同片段。计算下一位前缀函数时，如果下一个元素与最大前缀的后一位元素不匹配 (即 $s[i+1]\neq s[\pi[i]]$ 时), 能寻找子前缀的后一位元素分析是否匹配。

子前缀的计算是递归的。对于第 $n$ 阶子前缀的长度 $j^{(n)}$ ，根据上面的分析有

$j^{(n)} = \pi(j^{(n-1)}-1)$

例子

子串s[abcabaacabcab]相同的前缀段与后缀段为abcab,更小的子前缀/后缀段为ab(子前缀的是前缀段的相同的前缀/后缀串)。

当下一位元素为a, 符合 $s[i+1]= s[\pi[i]]$ , $\pi[i+1] = \pi[i]+1 = 6$

当下一位元素不为a时,符合 $s[i+1]\neq s[\pi[i]]$ , 子前缀串ab的下一位元素为c。如果子串的下一位元素为c则前缀函数 $\pi[i+1] = \max_{n}\{j^{(n)}+1: s[j^{(n)+1}] = s[i+1]\}$

实现

#include<vector>
#include<string>
using namespace std;
vector<int> prefix_func(string s){
    int n = (int) s.length();
    vector<int> pi(n);
    for (int i = 1; i < n; i++) {
        int j = pi[i - 1];
        while (j > 0 && s[i] != s[j]) {
            j = pi[j - 1];
        }
        if (s[i] == s[j]){
            j++;
        }
        pi[i] = j;
    }
    return pi;
}

前缀函数的时间复杂度优化到了 $\mathcal{O}(n)$

KMP算法

对于串 $s$ 与待检测子串 $t$ , 只需要将待检测子串 $t$ 作为前缀进行后缀匹配就可以实现子串匹配。

#include<string>
#include<vector>
using namespace std;
vector<int> KMP(string text, string pattern){
    string cur = pattern + '#' + text;
    int s1 = text.size();
    int s2 = pattern.size();
    vector<int> res;
    vector<int> pf = prefix_function(cur);
    for ( int i = s2+1 ; i <= s1+s2; i++ ){
        if (pf[i] == s2){
            res.push_bach(i - 2*s2);
        }
    }
    return res;
}

KMP算法只用 $\mathcal{O}(m+n)$ 的时间复杂度实现了子串在全串的匹配

LLM应用指北

2026-03-22T16:00:00.000Z

常见的国内外AI

国内AI

Deepseek: 官网 API

外国AI

Google Gemini 官网 AI Studio 薅羊毛:学生优惠(已失效)

ChatGPT 官网薅羊毛:大兵优惠(已失效)、Business(闲鱼5r)

Claude 官网

常见工具

Claude Code Claude 推出的 Coding Agent，CLI/VSCode插件贵

Codex ChatGPT 的 Coding Agent,平台 CLI/VSCode插件 + GUI(MacOS)，免费额度大，有Business account用不完夯

AntiGravity Google的 AI Coding IDE, 支持Gemini Claude ChatGPT 的大杯模型, 代理模式登陆困难, 有pro大杯

Cursor AI Coding IDE

Vscode Copilot VSCode 插件，学生验证后300次/月访问，之前夯现在中杯

常见问题与实现

Codex WSL login 遇到 NAT 通信阻拦

WSL默认NAT隔离内网，在Win11+WSL2中可以使用镜像模式，WSL可以共享宿主机的Localhost(如果使用Clash,通过127.0.0.1:7890)

cd $env:USERPROFILE
@"
[wsl2]
networkingMode=mirrored
"@ | Add-Content "$env:USERPROFILE\.wslconfig"
wsl --shutdown

Gemini CLI 登陆失败问题

设置VPN TUN模式，或者添加环境变量

export HTTPS_PROXY=http://127.0.0.1:7890 // Clash监听端口7890
export HTTP_PROXY=http://127.0.0.1:7890
export ALL_PROXY=http://127.0.0.1:7890

// # 默认监听7890端口
// cat <<'EOF' >> ~/.bashrc
// if nc -z 127.0.0.1 7890 2>/dev/null; then
//    export http_proxy="http://127.0.0.1:7890"
//    export https_proxy="http://127.0.0.1:7890"
//    export all_proxy="socks5://127.0.0.1:7890" 
//    echo "🟢 Clash Proxy is running (Port 7890)"
// else
//    unset http_proxy
//    unset https_proxy
//    unset all_proxy
// fi
// EOF
// source ~/.bashrc

Windows Antigravity 通过dll注入方式进行认证信息转发

Antigravity-Proxy

Codex 异步multi-agent实现

VSCode Codex

使用CODEX.md作为主Agent的执行规范，使用AGENT.md作为审核Agent的执行规范

参见项目

Codex 上下文长度修改

ChatGPT-5.4默认支持1M的上下文，但是Codex的设定默认上下文长度为256K。通过这个方式可以进行上下文长度的修改

vim ~/.codex/config.toml

model_context_window = 1000000  # 上下文修改为1M
model_auto_compact_token_limit = 500000 # 当上下文到达500K后压缩上下文

LeetCode-无重复字符的最长字串

2026-03-20T16:00:00.000Z

无重复字符的最长字串

题目描述

题解

重复的元素构成一个窗口，由两个指针确定。设定一个窗口，将右指针经过的元素都置true。当右指针经过了已经遍历过的元素，左指针一直移动到这个元素并设置为false。所有情况下的置为true的元素列表，去除右指针的位置的总元素个数 $r-l-1$ 为无重复元素字串的最长字串。

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int l = 0;
        int r = 0;
        int max_len = 0;
        std::vector<bool> window(128,false);
        while( r < s.length())
        {
            char right_char = s[r];
            while ( window[right_char] == true)
            {
                char left_char = s[l];
                window[left_char] = false;
                l++;
            }
            window[right_char] = true;
            max_len = std::max(max_len, r - l + 1);
            r++;
        }
        return max_len;
    }
};

传统机器学习

2026-03-10T16:00:00.000Z

本文用于复习机器学习基础, Follow 周志华《机器学习》

线性模型与支持向量机

线性模型的基础是线性映射与最小二乘法。

问题定义:

单个样本为一个 $d$ 维实向量 $u = (x_1,x_2,\cdots ,x_d), x_i\in\mathbb{R}$ 与对应的值 $y\in\mathbb{R}$

样本集 $D = \left\{(u_i,y_i)\big | \,1\leq i\leq n \right\}$ 是由多个样本构成的集合

线性模型: 样本集上的最小二乘拟合，线性回归的目的是求解出满足最小二乘法的参数矩阵与偏置向量

作用在单个数据上的线性映射

$\hat{y_i} = f_i(u_i) = \omega_{i,1} x_{i,1}+ \omega_{i,2} x_{i,2} +\cdots + \omega_{i,d} x_{i,d}+ b = \omega^Tu_i+b: \mathbb{R}^d\to \mathbb{R}$

最小二乘法满足

$(\omega^\ast,b^\ast) = \argmin_{\omega,b} \sum_i\|y_i-\hat{y_i}\|^2 = \argmin_{\omega,b} \sum_i \|y_i-\omega u_i - b\|$

最小二乘法约定的平方根误差也成为均方误差(Mean-Squared-Error)

$L(w,b) =\frac{1}{n}\sum_{i=1}^n (y_i-\hat{y_i})^2 = \frac{1}{n} \sum_{i=1}^n (y_i-\omega u_i-b)^2$

正则化

Lasso 正则化

岭正则化

贝叶斯决策

贝叶斯分析的分类类别集为一个 $n$ 元集合

$\mathcal{Y} = \left\{c_1,c_2,\cdots, c_n\right\}$

样本集合 $\mathcal{X}$ 内的元素具有类别集 $\mathcal{Y}$ 的属性。对于每个样本对象 $\bm{x}$

损失函数

贝叶斯决策中的损失函数定义为将样本 $c_i$ 分类为 $c_j$ 的损失

$\lambda_{i,j}:\mathcal{Y}\times\mathcal{Y}\to [0,1]$

通常使用0-1损失

$\lambda_{i,j} = \delta_{i,j} = \begin{cases} 0&i = j\\ 1&i \neq j \end{cases}$

总损失期望

$R(c_i\big| \bm{x}) = \sum_{j=1}^n \lambda_{i,j} P(c_j\big | \bm{x})$

贝叶斯决策目的是训练一个分类器，实现对于每一个样本的分类的优化

$h:\mathcal{X}\to \mathcal{Y}$

样本经过分类器 $h$ 分类后的的总体损失期望为

$R(h)=E_{\bm{x}\in \mathcal{X}}\left[R(h(\bm{x})\big|\bm{x})\right]$

分类器的求解的目的即获得一个映射 $h^\ast$ 满足对于某个样本分类

$h^\ast(\bm{x}) = \argmin_{c\in\mathcal{y}} R(c\big| \bm{x})$

贝叶斯分类器的训练

随机矩阵

2026-02-27T16:00:00.000Z

施工中的随机矩阵理论初步

随机矩阵

$\mathrm{Theorem:}$ 随机矩阵作用期望保距
$R$ 是 $k\times d$ 矩阵, $R_{ij}\overset{i.i.d}{\sim}\mathcal{N}(0,1)$ , $\forall \mathbf{u}\in \mathbb{R}^d$ ，取 $\mathbf{v}=\frac{1}{\sqrt{k}}R\cdot \mathbf{u}$ , 则

$\mathbb{E}[\|\mathbf{v}\|^2]=\|\mathbf{u}\|^2$

$\mathrm{Proof:}$

$v_i=\frac{1}{\sqrt{k}}\sum_{j=1}^d R_{ij}u_j$

$\begin{aligned} \mathbb{E}[\|\mathbf{v}\|^2]&=\mathbb{E}\left[\sum_{i=1}^k v_i^2 \right]\\ &=\mathbb{E}\left[\sum_{i=1}^k\frac{1}{k}\sum_{j=1}^d R_{ij}u_j\sum_{r=1}^dR_{ir}u_r\right]\\ &=\sum_{i=1}^k\frac{1}{k}\sum_{j,r}u_ju_r\mathbb{E}\left[R_{ij}R_{ir}\right]\\ &=\sum_{i=1}^k\frac{1}{k}\sum_{j,r}u_ju_r\delta_{jr}\\ &=\sum_{j}u_j^2\\ &=\|\mathbf{u}\|^2 \end{aligned}$

Markov 过程

2026-02-23T16:00:00.000Z

Markov Decision Process

一个Markov Desion Process(MDP) 是一个五元组 $(\mathcal{S},\mathcal{A},p,r,\gamma)$ , 满足

$\mathcal{S}$ 状态空间，是系统在每个时间步的状态集合

$\mathcal{A}$ 动作空间，是系统在每个状态下可以采取的动作的集合

$p(s'\mid s, a)$ 状态转移概率，从状态 $s$ 通过行为 $a$ 转移到状态 $s'$ 到概率

$r:\mathcal{S}\times \mathcal{A}\to \mathbb{R}=\mathbb{E}(R\mid s,a)$ 奖励函数，在状态 $s$ 下执行行为 $a$ 的全部奖励的期望

$\gamma\in[0,1]$ 衰减因子，每个时间步中的奖励衰减

MDP通常可可视化表示为一个有向图，每一个状态为一个点，所有的边的集合为动作空间 $\mathcal{A}$ . 边的权为奖励函数

记

${\mathcal{A}_s}=\left\{a\mid s\overset{a}{\to}s', \forall s'\in S_{t+1}\right\}$

为状态 $s$ 的动作空间

Markov Property

Markov特性指当前时间步的状态转移概率、奖励累计与前面时间步的对应量是相互独立的

$p(S_{t+1}=s', R_{t+1}=r\mid S_t,A_t )=p(S_{t+1}=s',R_{t+1}=r\mid S_t,A_t,S_{t-1},A_{t-1},\cdots)$

MDP的奖励返回

Undiscounted Return
不考虑衰减因子的总奖励
$G_t = \sum_{k=0}^{T-t-1}R_{t+k+1}$
Discounted Return
$G_t = \sum_{k=0}^{T-t-1}\gamma^k R_{t+k+1}$
Average Return
$G_t = \frac{1}{T-t-1}\sum_{k=0}^{t+k+1}R_{t+k+1}$

Agent Policy 智能体策略

Goal of RL Agent

To find a behavior policy that maximises the expected return $G_t$

智能体策略的精神是寻找到最大的奖励

Policy 智能体策略

宏观(全局定义)
由智能体主导的全局决策法则。在 MDP 的有向图结构中，它表现为从状态空间向动作空间发出的概率分配（边权）。它在面对环境给定的庞大图网络时，通过裁剪和概率倾斜，决定了智能体在图中游走的整体行为倾向。
微观(逐点定义)
智能体在状态 $s$ 下执行某一动作 $a$ 的概率

策略数学表达为

$\pi:\mathcal{S}\to P(\mathcal{A})\subset [0,1],\quad \pi(a\mid s)=p(A_t=a\mid S_t=s)$

如果存在可学习的参数 $\theta$ ，则记作

$\pi_\theta(a\mid s)$

对于离散动作空间，策略满足

$\sum_{a\in \mathcal{A}_s} \pi_\theta(a\mid s)=1$

对于连续动作空间，策略满足

$\int_{a\in\mathcal{A}_s}\pi_\theta(a\mid s)\,\mathrm{d}a=1$

Value Function 价值函数

$v_\pi(s)=\mathbb{E}(G_t\mid S_t=s,\pi)$

Q Function

Q Function 指的是在状态 $S_t=s$ ，执行动作 $A_t=a$ 下的价值期望函数

$q_\pi (s,a)=\mathbb{E}(G_t\mid S_t=s,A_t=a,\pi)=\mathbb{E}\left(\sum_{k=0}^\infty\gamma^k R_{t+k+1}\mid S_t=s,A_t=a,\pi\right)$

根据全概率公式，价值函数满足

$v_\pi(s)=\sum_{a\in \mathcal{A}_s} \pi(a\mid s)q_\pi(s,a)$

Optimal Value Function 最优化价值函数

Optimal state-value function 最优状态价值函数，是在所有策略中的最大状态价值函数

$v^\ast(s)=\max_{\pi} v_\pi (s)$

Optimal action-value function 最优动作价值函数,是在所有策略中的最大动作价值函数

$q^\ast(s,a)=\max_{\pi}q_\pi (s,a)$

Claim: 解决一个 MDP 的本质就是寻找最优策略. 一旦求解出最优价值函数，我们便称该马尔可夫决策过程（MDP）得到了解决（Solved）

在此基础上，我们定义策略的偏序关系

$\pi'\geq \pi \Longleftrightarrow \forall s\in\mathcal{S},\, v_{\pi'}(s)\geq v_\pi(s)$

根据Zorn Lemma,最优策略总存在

Optimal policy 最优策略

最优策略 $\pi^\ast$ 满足

$\forall \pi \in \Pi, \pi\leq \pi^\ast$

Bellman Equation

Action Value Function 的时间步展开

$\begin{aligned} q_\pi(s,a)&=\mathbb{E}(G_t\mid S_T=s,A_t=a,\pi)\\ &=\mathbb{E}\left(R_{t+1}+\gamma v_\pi(S_{t+1})\mid S_t=s, A_t\in\pi(S_t),\pi\right)\\ &=\sum_{r\in R_{t+1}}\sum_{s'\in \mathcal{S}_{t+1}}p(r,s'\mid s,a)(r+\gamma v_\pi(s'))\\ &=\sum_{a\in \mathcal{A}(s)}\pi(a\mid s)\sum_{r\in R_{t+1}}\sum_{s'\in \mathcal{S}_{t+1}}p(r,s'\mid s,a)(r+\gamma \sum_{a'\in \mathcal{A}(s')}(\pi(a'\mid s')q_\pi(s',a'))) \end{aligned}$

Value Function 的时间步展开

$\begin{aligned} v_\pi(s)&=\sum_{a}\pi(a\mid s)q_\pi(s,a)\\ &=\sum_{a\in \mathcal{A}(s)}\pi(a\mid s)\sum_{r\in R_{t+1}}\sum_{s'\in \mathcal{S}_{t+1}}p(r,s'\mid s,a)(r+\gamma v_\pi(s')) \end{aligned}$

Bellman Expectation Equation Bellman期望方程刻画了状态价值函数与行为价值函数的递归关系。
对于给定的MDP， $\mathcal{M}=(\mathcal{S},\mathcal{A},p,r,\gamma)$ , 对于任意策略 $\pi$ ，价值函数满足

$\begin{align} v_\pi(s) &= \sum_{a\in \mathcal{A}(s)}\pi(a\mid s)\sum_{r\in R_{t+1}}\sum_{s'\in \mathcal{S}_{t+1}}p(r,s'\mid s,a)(r+\gamma v_\pi(s')) \tag{1} \\ q_\pi(s,a) &= \sum_{a\in \mathcal{A}(s)}\pi(a\mid s)\sum_{r\in R_{t+1}}\sum_{s'\in \mathcal{S}_{t+1}}p(r,s'\mid s,a)(r+\gamma \sum_{a'\in \mathcal{A}(s')}(\pi(a'\mid s')q_\pi(s',a'))) \tag{2} \end{align}$

随机高斯向量的单位模引理与正交性定理

2026-02-15T16:00:00.000Z

$\newcommand{\bbR}{\mathbb{R}} \newcommand{\calG}{\mathcal{G}}$

$\newcommand{\rmd}{\,\mathrm{d}}$

随机高斯向量的单位模引理与正交性定理

预备定理

Markov 不等式

$X$ 为非负随机变量, $\varepsilon>0$ ， $\mu = E(X), \sigma^2 = V(X)$ , 则

$P(|X-\mu|\geq \varepsilon)\leq \frac{\sigma^2}{\varepsilon^2}$

$\mathbf{Proof}:$
\begin{aligned} \sigma^2 &= \int_{-\infty}^{\infty}(x-\mu)^2p(x)\rmd x\\ &\geq \int_{|x-\mu|\geq \varepsilon}(x-\mu)^2p(x)\rmd x\\ &\geq \varepsilon^2 \int_{|x-\mu|\geq \varepsilon}p(x)\rmd x\\ &=\varepsilon^2 P(|x-\mu|\geq\varepsilon) \end{aligned}
即

$P(|x-\mu|\geq \varepsilon)\leq \frac{\sigma^2}{\varepsilon^2}$

Cramér-Chernoff方法

$\forall \lambda > 0$ , 有

$|x-\mu|\geq \varepsilon\Longleftrightarrow e^{\lambda |x-\mu|}\geq e^{\lambda \varepsilon}$

因此有

$P(|x-\mu|\geq \varepsilon)=P(e^{\lambda |x-\mu|}\geq e^{\lambda \varepsilon})\leq e^{-\lambda a}\mathbb{E}(e^{\lambda |x-\mu|})\Longleftrightarrow P(|x-\mu|\geq \varepsilon)\leq \min_{\lambda>0}e^{-\lambda a}\mathbb{E}(e^{\lambda |x-\mu|})$

从而可以求解最优的概率 $P_{max}$ 以及对应的 $\lambda_0$ , 这个上界称为Chernoff Bound

Key Concept

随机高斯向量定义为

\calG=\left\{u\in \bbR^n\Big | u\sim \mathcal{N}(0,\frac{1}{n}I_n)\right\}

单位模引理
\forall u\in \calG,\forall \varepsilon \in (0,1), P(|\|u\|^2-1|\geq \varepsilon)\leq 2\exp(-\frac{\varepsilon^2 n}{8})

$\mathbf{Proof}:$
由Cramér-Chernoff方法

$P(|\|u\|^2-1|\geq \varepsilon )\leq \min_{\lambda>0}e^{-\lambda\varepsilon}E(e^{\lambda|\|u\|^2-1|})$

当 $\|u\|^2\geq 1$ 时：

$P(\|u\|^2-1\geq \varepsilon )=P(\|u\|^2\geq 1+\varepsilon)\leq\min_{\lambda>0}e^{-\lambda(\varepsilon +1)}\mathbb{E}(e^{\lambda\|u\|^2})$

\begin{aligned} \mathbb{E}(e^{\lambda\|u\|^2})&=\mathbb{E} (e^{\lambda \sum u_i ^2})\\ &=\prod_{i=1}^n \mathbb{E}(e^{\lambda u_i^2})\\ &=\prod_{i=1}^n \int_{-\infty}^{\infty}\frac{\sqrt{n}}{\sqrt{2\pi}}\exp (-\frac{nu_i^2}{2})\exp (\lambda u_i^2)\rmd u_i\\ &=\prod_{i=1}^n \int_{-\infty}^{\infty}\frac{1}{\sqrt{2\pi}}\exp\left(-\frac{n-2\lambda}{n}\frac{v_i^2}{2}\right)\rmd v_i\\ &=\left(\sqrt{\frac{n}{n-2\lambda}}\right)^n \end{aligned}

即

$P(\|u\|-1\geq \varepsilon)\leq \min_{\lambda>0}e^{-\lambda(\varepsilon+1)}\left(\frac{n}{n-2\lambda}\right)^\frac{n}{2}$

取 $f(\lambda)=e^{-\lambda(\varepsilon+1)}\left(\frac{n}{n-2\lambda}\right)^\frac{n}{2}$

\frac{\rmd f(\lambda)}{\rmd \lambda}=e^{-\lambda(\varepsilon+1)}\left[-(\varepsilon +1)\left(\frac{n}{n-2\lambda}\right)^{\frac{n}{2}}+\frac{n}{2}\left(\frac{n}{n-2\lambda}\right)^{\frac{n}{2}-1}\frac{2n}{(n-2\lambda)^2}\right]=0

根 $\lambda_0 = \dfrac{n\varepsilon}{2(\varepsilon +1)}$

故

$P(\|u\|-1\geq \varepsilon)\leq f(\lambda_0)=e^{-\frac{n\varepsilon }{2}}(1+\varepsilon)^{\frac{n}{2}}=e^{\frac{n}{2}(\ln (1+\varepsilon)-\varepsilon )}$

当 $\|u\|^2<1$ 时

$P(1-\|u\|^2\leq \varepsilon)\leq \min_{\lambda>0}e^{-\lambda\varepsilon}\mathbb{E}(e^{\lambda (1-\|u\|^2)})=\min_{\lambda>0}e^{-\lambda (\varepsilon-1)}E(e^{-\lambda \|u\|^2})$

\begin{aligned} \mathbb{E}(-\lambda \|u\|^2)&= \mathbb{E}(e^{-\lambda \sum u_i^2})\\ &=\prod_{i=1}^n \mathbb{E}(e^{-\lambda u_i^2})\\ &=\prod_{i=1}^n \int_{-\infty}^{\infty}\frac{\sqrt{n}}{\sqrt{2\pi}}\exp(-\frac{nu_i^2}{2})\exp(-\lambda u_i^2)\rmd u_i\\ &=\prod_{i=1}^n\int_{-\infty}^{\infty}\frac{1}{\sqrt{2\pi}}\exp (-\frac{n+2\lambda}{n}\frac{v_i^2}{2})\rmd v_i\\ &=\left(\frac{n}{n+2\lambda}\right)^\frac{n}{2} \end{aligned}

即

$P(1-\|u\|^2\leq \varepsilon)\leq \min_{\lambda>0}e^{-\lambda (\varepsilon-1)}\left(\frac{n}{n+2\lambda}\right)^{\frac{n}{2}}$

取 $\lambda_0 = \dfrac{\varepsilon n}{2(1-\varepsilon)}$

$P(1-\|u\|^2\leq \varepsilon)\leq e^{\frac{\varepsilon n}{2}}(1-\varepsilon)^\frac{n}{2}=e^{\frac{n}{2}(\varepsilon+\ln (1-\varepsilon))}$

即

$\begin{cases} P(\|u\|^2-1\geq \varepsilon)\leq e^{\frac{n}{2}(\ln (1+\varepsilon)-\varepsilon )}\\ P(1-\|u\|^2\leq \varepsilon)\leq e^{\frac{n}{2}(\varepsilon+\ln (1-\varepsilon))} \end{cases}$

考虑

$\ln \frac{1+\varepsilon}{1-\varepsilon}>2\varepsilon$

$\ln (1+\varepsilon)-\varepsilon < -\frac{\varepsilon^2}{C}$

$C>\max_{\varepsilon\in(0,1)}\left(\frac{\varepsilon^2}{\varepsilon-\ln(1+\varepsilon)}\right)=\frac{1}{1-\ln2}\simeq 3.26$

通常取 $C=4$ ，则

$\begin{cases} P(\|u\|^2-1\geq \varepsilon)\leq e^{-\frac{n\varepsilon^2}{8}}\\ P(1-\|u\|^2\leq \varepsilon)\leq e^{-\frac{n\varepsilon^2}{8}} \end{cases}$

$P(|\|u\|^2-1|\geq \varepsilon )\leq 2e^{-\frac{n\varepsilon^2}{8}}$

正交性引理
\forall u,v\in \calG, \forall \varepsilon \in(0,1), P(|\left|\geq \varepsilon)\leq 4\exp(-\frac{\varepsilon^2n}{8})

$\mathbf{Proof:}$
$u,v\in\mathcal{G}$ , 则 $\dfrac{u+v}{\sqrt{2}},\dfrac{u-v}{\sqrt{2}}\in \mathcal{G}$

一方面

$\begin{aligned} P(|\left<u,v\right>|\geq \varepsilon)&\leq P\left(\left\|\frac{u+v}{\sqrt{2}}\right\|^2-1\geq\varepsilon\right)+P\left(1-\left\|\frac{u-v}{\sqrt{2}}\right\|^2\geq \varepsilon\right)\\ &\leq 4\exp(-\frac{\varepsilon^2 n}{8}) \end{aligned}$

另一方面

$\begin{aligned} P(-\left<u,v\right>\geq \varepsilon)&\leq P\left(1-\left\|\frac{u+v}{\sqrt{2}}\right\|^2\geq \varepsilon\right)+P\left(\left\|\frac{u-v}{\sqrt{2}}\right\|^2-1\geq \varepsilon\right)\\ &\leq 4\exp(-\frac{\varepsilon^2n}{8}) \end{aligned}$

综上

$P(|\left<u,v\right>|\geq \varepsilon)\leq 4\exp(-\frac{\varepsilon^2n}{8})$

Chernoff Bound

Moment generating function 矩生成函数
随机变量 $X$ 的矩生成函数定义为

$M_X(t)=\mathbb{E}(e^{tX})=\int_0^1 e^{tx}\mathrm{d}F(x)$

Hoeffding lemma
对于随机变量 $X$ , $a\leq X\leq b$ , $\mathbb{E}[X]=0, \forall x, |f(x)|<\infty$ , 则

$\mathbb{E}(e^{\lambda(X-\mu)})\leq\exp\left(\frac{\lambda(b-a)^2}{8}\right)$

Johnson–Lindenstrauss 引理

2026-02-14T16:00:00.000Z

Johnson-Lindenstrauss 引理

Johnson-Lindenstrauss 引理

对于 $N$ 个 $d$ 维向量构成的集合 $A=\left\lbrace x_1,x_2,\cdots,x_N\in\mathbb{R}^d\right\rbrace$ ， $\forall\varepsilon\in(0,1)$ ， $\exists f:\mathbb{R}^d\to\mathbb{R}^k$ ，满足

$(1-\varepsilon)\|x_i-x_j\|^2\leq \|f(x_i)-f(x_j)\|^2\leq (1+\varepsilon)\|x_i-x_j\|^2$

其中

$k\geq \frac{24\log N}{3\varepsilon^2-2\varepsilon^3}\simeq O(\frac{\log N}{\varepsilon^2})$

$\mathrm{Proof:}$

随机矩阵

证明主要基于Cramér-Chernoff方法

取 $\mathbf{u}\in \mathbb{R}^d$ , $R_{ij}\overset{i.i.d}{\sim}\mathcal{N}(0,1)$ , 随机投影向量 $\mathbf{v}=\frac{1}{\sqrt{k}}R\cdot \mathbf{u}$

根据随机矩阵期望保距

$\mathbb{E}[\|\mathbf{v}\|^2]=\|\mathbf{u}\|^2$

取 $X=\frac{\sqrt{k}}{\|\mathbf{u}\|}\mathbf{v}=\frac{1}{\|\mathbf{u}\|}R\cdot \mathbf{u}$ , $x=\sum_{i=1}^k x_i^2 =\frac{k\|\mathbf{v}\|^2}{\|\mathbf{u}\|^2}\sim \chi^2(k)$

$\begin{aligned} \mathbb{E}[e^{\lambda x_i^2}]&=\int_{-\infty}^{+\infty}e^{\lambda x_i^2}\frac{1}{\sqrt{2\pi}}e^{-\frac{x_i^2}{2}}\,\mathrm{d}x_i=\sqrt{\frac{1}{1-2\lambda}} \end{aligned}$

一方面

$\begin{aligned} P[\|\mathbf{v}\|^2\geq(1+\varepsilon)\|\mathbf{u}\|^2]&=P[x\geq(1+\varepsilon)k]\\ &=P[e^{\lambda x}\geq e^{\lambda(1+\varepsilon)k}]\\ &\leq \inf_{\lambda\geq 0}\frac{\mathbb{E}[e^{\lambda x}]}{e^{\lambda(1+\varepsilon)k}}\\ &=\inf_{\lambda\geq 0}\frac{\prod_{i=1}^k\mathbb{E}[e^{\lambda x_i^2}]}{e^{\lambda(1+\varepsilon)k}}\\ &=\inf_{\lambda \geq 0}\left(\frac{1}{\sqrt{1-2\lambda}\,e^{\lambda(1+\varepsilon )}}\right)^k\\ &=\left[(1+\varepsilon)e^{-\varepsilon}\right]^{\frac{k}{2}}\\ &=\exp\left(\frac{k}{2}(-\varepsilon+\log(1+\varepsilon))\right)\\ &\leq\exp\left(\frac{k}{2}\left(-\frac{\varepsilon^2}{2}+\frac{\varepsilon^3}{3}\right)\right) \end{aligned}$

当 $\dfrac{k}{2}\left(-\dfrac{\varepsilon^2}{2}+\dfrac{\varepsilon^3}{3}\right)<-2\log N$ , 即 $k>\dfrac{24\log N}{3\varepsilon^2-2\varepsilon^3}$ 时，满足

$P\left[\|\mathbf{v}\|^2\geq (1+\varepsilon)\|\mathbf{u}\|^2\right]\leq N^{-2}$

因此

$P\left[\|\mathbf{v}^2\|\leq (1+\varepsilon)\|\mathbf{u}\|^2\right]\geq 1-N^{-2}$

另一方面

$\begin{aligned} P\left[\|\mathbf{v}\|^2\leq(1-\varepsilon)\|\mathbf{u}\|^2\right]&=P\left[x\leq (1-\varepsilon)k\right]\\ &=P\left[e^{-\lambda x}\geq e^{-\lambda(1-\varepsilon)k}\right]\\ &\leq \inf_{\lambda\geq 0}\frac{\mathbb{E}[e^{-\lambda x}]}{e^{-\lambda(1-\varepsilon)k}}\\ &=\inf_{\lambda\geq 0} \frac{\prod_{i=1}^k\mathbb{E}\left[e^{-\lambda x_i^2}\right]}{e^{-\lambda (1-\varepsilon )k}}\\ &=\inf_{\lambda \geq 0}\left(\frac{1}{\sqrt{1+2\lambda}\,e^{-\lambda(1-\varepsilon )}}\right)^k\\ &= \left[(1-\varepsilon)e^{\varepsilon}\right]^{\frac{k}{2}}\\ &= \exp\left(\frac{k}{2}\left(\varepsilon+\log(1-\varepsilon)\right)\right)\\ &\leq \exp \left(-\frac{k\varepsilon^2}{4}\right) \end{aligned}$

当 $-\dfrac{k\varepsilon^2}{4}\leq -2\log N$ 时，即 $k\geq \dfrac{8\log N}{\varepsilon^2}$

$P\left[\|\mathbf{v}\|^2\leq(1-\varepsilon)\|\mathbf{u}\|^2\right]\leq N^{-2}$

即

$P\left[\|\mathbf{v}\|^2\geq(1-\varepsilon)\|\mathbf{u}\|^2\right]\geq 1- N^{-2}$

当

$k\in \left\{k\geq\frac{24\log N}{3\varepsilon^2-2\varepsilon^3}\right\}\cap \left\{k\geq\frac{8\log N}{\varepsilon^2}\right\}=\left\{k\geq\frac{24\log N}{3\varepsilon^2-2\varepsilon^3}\right\}$

满足

$P\left[\|\mathbf{v}\|^2\not \in\left[(1-\varepsilon)\|\mathbf{u}\|^2,(1+\varepsilon)\|\mathbf{u}\|^2\right]\right]\leq \frac{2}{N^2}$

进一步

$\forall x_i, x_j\in A,\, P\left[\|f(x_i)-f(x_j)\|^2\not \in\left[(1-\varepsilon)\|x_i-x_j\|^2,(1+\varepsilon)\|x_i-x_j\|^2\right]\right]\leq\frac{2}{N^2}$

由Boole不等式，遍历集合 $A$ 的二元向量组

$P(\cup E_i)\leq\sum P(E_i)\leq\frac{N(N-1)}{2}\frac{2}{N^2}=1-\frac{1}{N}$

由此可以得出，当 $k\geq\dfrac{24\log N}{3\varepsilon^2-2\varepsilon^3}$ 时，将整个 $A$ 几乎保距映入低维空间的映射 $f$ 存在的概率不为0

Fast Johnson-Linderstrauss Transform

测度与Lebesgue测度

2025-08-19T16:00:00.000Z

施工中

平稳序列

2025-06-19T16:00:00.000Z

自协方差函数

协方差

$\begin{aligned} \mathrm{Cov}(X,Y)&=\mathbb{E}(\left[ X-\mu_X\right]\left[ Y-\mu _Y\right])\\ &= \mathbb{E}(XY-X\mu_Y-Y\mu_X+\mu_X\mu_Y)\\ &= \mathbb{E}(XY)-\mu_Y\mathbb{E}(X)-\mu_X\mathbb{E}(X)+\mathbb{E}(X)\mathbb{E}(Y)\\ &= \mathbb{E}(XY)-\mathbb{E}(X)\mathbb{E}(Y) \end{aligned}$

平稳随机序列
对于时间序列 $\{X_n\}$ ${X n }$ ，满足
- $(1)\,\forall t\in \mathbb{N}, \mathrm{D}(X_t)< \infty$
- $(2)\, \forall t\in \mathbb{N},\mathbb{E}(X_t)=\mu$
- $(3)\, \forall t,s \in \mathbb{N},\gamma_{t-s}:=\mathbb{E}(\left[X_t-\mu\right]\left[X_s-\mu\right])=\mathrm{Cov}(X_t,X_s)$ ，称为时间序列的自协反差函数。自协方差函数满足平移不变性： $\mathrm{Cov}(X_{t+x},X_{s+x})=\mathrm{Cov}(X_t,X_s)$
  自协方差函数满足如下三条性质
$(1)$ 对称性 $\gamma_k=\gamma_{-k}$
$(2)$ 非负定性

$\Gamma_n = \begin{pmatrix} \gamma_0&\gamma_1&\cdots&\gamma_{n-1}\\ \gamma_1&\gamma_0&\cdots&\gamma_{n-2}\\ \vdots&&\ddots&\\ \gamma_{n-1}&\gamma_{n-2}&\cdots & \gamma_0 \end{pmatrix}$

$\mathrm{Proof:}$

$\begin{aligned} \alpha^T\Gamma_n\alpha&=\sum_{i,j}a_ia_j\gamma_{i-j}\\ &=\sum_{i,j}a_ia_j\mathbb{E}(\left[X_i-\mu\right]\left[X_j-\mu\right])\\ &=\mathbb{E}\left(\sum_{i,j}a_ia_j\left(X_i-\mu\right)(X_j-\mu)\right)\\ &=\mathbb{E}\left(\sum_{i}a_i\left(X_i-\mu\right)\sum_ja_j(X_j-\mu)\right)\\ &=\mathbb{E}\left(\left[\sum_ia_i(X_i-\mu)\right]^2\right)\\ &=\mathrm{D}\left(\sum_{i}a_i(X_i-\mu)\right)\geq 0 \end{aligned}$

$(3)$ 有界性 $|\gamma_k|\leq |\gamma_0|<\infty$
$\mathrm{Proof:}$
取 $k=u-v$ ，则
$\begin{aligned} |\gamma_k|&=\left|\mathbb{E}\left[\left(X_u-\mu\right)(X_v-\mu)\right]\right|\\ &\leq \sqrt{\mathbb{E}[(X_u-\mu)]^2\,\mathbb{E}[(X_v-\mu)^2]}\\ &=\mathrm{D}(X_u-\mu)=\gamma_0 \end{aligned}$

白噪声

定义
白噪声是一列平稳序列 $\{\varepsilon_t\}$ ，满足:

我们可以逐点构造一个非平稳的正态时间序列，且不是正态白噪声
取定 $T$ ,假设

$\begin{align*} X_t(T)&=\frac{1}{\sqrt{2\pi}}\int_{\mathbb{R}}e^{-\tfrac{(t+T)^2}{2}}\mathrm{d}T\\ X_s(T)&=\frac{1}{\sqrt{2\pi}}\int_{\mathbb{R}}e^{-\tfrac{(s+T)^2}{2}}\mathrm{d}T\\ \end{align*}$

$\begin{align*} \mathrm{Cov}(X_t,X_s)&=\mathbb{E}(X_t,X_s)\\ &=\int_{\mathbb{R}}\frac{T}{2\pi}e^{-\tfrac{(t+T)^2}{2}-\tfrac{(s+T)^2}{2}}\mathrm{d}T\\ &=\frac{1}{\sqrt{2\pi}}\int_{\mathbb{R}}\frac{T}{\sqrt{2\pi}}e^{-\tfrac{2T^2+2(s+t)T+s^2+t^2}{2}}\mathrm{d}T\\ &=\frac{1}{\sqrt{2\pi}}e^{-\tfrac{s^2+t^2}{2}}\int_{\mathbb{R}}\frac{T}{\sqrt{2\pi}}e^{-T^2-(s+t)T}\mathrm{d}T\\ &=\frac{1}{\sqrt{2\pi}}e^{-\tfrac{s^2+t^2}{2}+\tfrac{(s+t)^2}{4}}\int_{\mathbb{R}}\frac{T}{\sqrt{2\pi}}e^{-(T+\tfrac{s+t}{2})^2}\mathrm{d}T\\ &=\frac{1}{\sqrt{\pi}}e^{-\tfrac{(s-t)^2}{4}}\,\mathbb{E}({\small N(-\frac{s+t}{2},\frac{1}{\sqrt{2}})})\\ &=-\frac{s+t}{2\pi}e^{-\tfrac{(s-t)^2}{4}}\neq0 \end{align*}$

我们人为的对正态随机变量设定了一个约束 -- 让不同时刻的随机变量取值的位置相对固定，这样子的时间序列就不是一个独立的时间序列，也就不是一个平稳序列。

组合数学

2025-02-18T16:00:00.000Z

容斥原理

Erdos-Szekeres定理
$(S,\prec)$ 是一个偏序集, $|S|=mn+1$ ,则 $S$ 中存在长为 $m+1$ 的链或 $n+1$ 的反链

Proof:
定义 $f:S\to \mathbb{N}$ $f(i)$ 为以 $x_i\in S$ 开头的最长递增子列的长度。如果最长子链的长度小于 $m+1$ , 则

$\mathcal{B} = \max f(S) = \left\{1,2,\cdots,m\right\}$

由容斥原理,由于 $|S|> mn$ , $\exists b\in \mathcal{B}$ , $|f^{-1}(b)|\geq n+1$ 。选择 $a_1,\cdots,a_{n+1}\in f^{-1}(b)$ , 总有 $i< j, a_i > a_j$ ,否则存在大于 $m$ 的递增列。故这样选出的 $\{a_i\}$ 是单调减的序列。