{ "version": "https://jsonfeed.org/version/1", "title": "Yuukoの小屋", "description": "Amor che nella mente mi regiona.", "home_page_url": "https://yuukowww.github.io", "items": [ { "id": "https://yuukowww.github.io/2026/04/17/CS/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/%E6%9F%A5%E6%89%BE/", "url": "https://yuukowww.github.io/2026/04/17/CS/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/%E6%9F%A5%E6%89%BE/", "title": "查找", "date_published": "2026-04-17T16:00:00.000Z", "content_html": "

查找

\n

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

\n\n
\n

查找的相关概念

\n\n

ASL=∑i=1nPiCi\\text{ASL} = \\sum_{i=1}^n P_iC_i\nASL=i=1∑n​Pi​Ci​

\n
\n

查找方式

\n

顺序查找

\n

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

\n

一般顺序表的查找

\n

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

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

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

\n

ASL成功=∑i=1n(n−i+1)Pi\\text{ASL}_\\text{成功} = \\sum_{i=1}^n (n-i+1)P_i\nASL成功​=i=1∑n​(n−i+1)Pi​

\n

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

\n

ASL成功=∑i=1nn−i+1n=n+12\\text{ASL}_\\text{成功} = \\sum_{i=1}^n \\frac{n-i+1}{n} = \\frac{n+1}{2}\nASL成功​=i=1∑n​nn−i+1​=2n+1​

\n

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

\n

ASL失败=∑i=1n(n+1)Pi=n+1\\text{ASL}_\\text{失败} = \\sum_{i=1}^n (n+1)P_i =n+1\nASL失败​=i=1∑n​(n+1)Pi​=n+1

\n

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

\n

有序顺序表的查找

\n

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

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

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

\n

ASL失败=∑i=1n(li−1)Pi=1+⋯+n+nn+1=n2+nn+1\\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}\nASL失败​=i=1∑n​(li​−1)Pi​=n+11+⋯+n+n​=2n​+n+1n​

\n

二分查找

\n

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

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

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

\n

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

\n

2h−1−1<n≤2h−12^{h-1} - 1 < n \\leq 2^{h} - 1\n2h−1−1<n≤2h−1

\n

h=⌈log⁡2(n+1)⌉h = \\left \\lceil \\log_2(n+1) \\right \\rceil \nh=⌈log2​(n+1)⌉

\n

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

\n

ASL成功=1n∑i=1nli=∑j=1hj×ajn≃满二叉树n+1nlog⁡2(n+1)−1≃log⁡2(n+1)−1\\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\nASL成功​=n1​i=1∑n​li​=j=1∑h​nj×aj​​≃满二叉树nn+1​log2​(n+1)−1≃log2​(n+1)−1

\n

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

\n

ASL失败=(2ah−1−ah)(h−1)+2ahhn+1\\text{ASL}_\\text{失败}= \\frac{(2a_{h-1}-a_h)(h-1)+2a_{h}h}{n+1}\nASL失败​=n+1(2ah−1​−ah​)(h−1)+2ah​h​

\n

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

\n

h=⌈log⁡2(n+1)⌉h = \\lceil \\log_2(n+1)\\rceil\nh=⌈log2​(n+1)⌉

\n

分块查找

\n

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

\n

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

\n

ASL=LI+LS\\text{ASL} = L_I+L_S\nASL=LI​+LS​

\n

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

\n

ASL=b+12+s+12=s2+2s+n2s=s2+n2s+1≥n+1\\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\nASL=2b+1​+2s+1​=2ss2+2s+n​=2s​+2sn​+1≥n​+1

\n

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

\n

树形查找

\n

二叉排序树(BST)

\n

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

\n

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

\n\n

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

\n

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

\n

Cn=(2nn)n+1C_n = \\frac{\\binom{2n}{n}}{n+1}\nCn​=n+1(n2n​)​

\n
二叉排序树的查找
\n

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

\n
二叉排序树的构建
\n

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

\n

平衡二叉树(AVL树)

\n

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

\n

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

\n
平衡二叉树的旋转
\n

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

\n
\n

LL 平衡旋转

\n

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

\n
\n
\n

RR 平衡旋转

\n

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

\n
\n

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

\n
\n

LR平衡旋转

\n

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

\n
\n
\n

RL平衡旋转

\n

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

\n
\n
平衡二叉树的删除
\n

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

\n

红黑树

\n

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

\n

红黑树满足如下性质:

\n\n

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

\n
\n

红黑树的最大深度差为 bhbhbh

\n
\n

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

\n

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

\n
\n

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

\n

h≤2log⁡2(n+1)h\\leq 2\\log_2(n+1)\nh≤2log2​(n+1)

\n
\n

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

\n

bh≥h2bh\\geq \\frac{h}{2}\nbh≥2h​

\n

因此

\n

n≥2h2−1n\\geq 2^{\\frac{h}{2}}-1\nn≥22h​−1

\n

即

\n

h≤2log⁡2(n+1)h\\leq 2\\log_2(n+1)\nh≤2log2​(n+1)

\n
红黑树的插入
\n

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

\n

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

\n
\n

LR旋转

\n

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

\n
\n
\n

LL旋转

\n

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

\n
\n

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

\n
红黑树的删除
\n
红黑树的优势
\n

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

\n

B树

\n

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

\n

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

\n

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

\n\n
B树的高度
\n

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

\n\n
\n

情况1

\n

n≤(m−1)(1+m+⋯+mh−1)=mh−1n \\leq (m-1)(1+m+\\cdots+m^{h-1}) = m^h-1\nn≤(m−1)(1+m+⋯+mh−1)=mh−1

\n

即

\n

hmin=log⁡m(n+1)h_\\text{min}=\\log_m(n+1)\nhmin​=logm​(n+1)

\n
\n
\n

情况2

\n

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

\n

n+1≥2(m2)h−1n+1 \\geq 2\\left(\\frac{m}{2}\\right)^{h-1}\nn+1≥2(2m​)h−1

\n

即

\n

hmax=log⁡⌈m2⌉(n+12)+1 h_\\text{max} = \\log_{\\lceil \\frac{m}{2}\\rceil}(\\frac{n+1}{2}) +1\nhmax​=log⌈2m​⌉​(2n+1​)+1

\n
\n

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

\n
B树的构建与插入
\n

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

\n

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

\n

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

\n
B树的删除
\n

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

\n

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

\n

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

\n\n

B+树

\n

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

\n

B+树的遍历查找方式:

\n\n

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

\n

Hash表

\n

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

\n

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

\n

Hash 函数通常将

\n", "tags": [ "数据结构", "算法", "图论" ] }, { "id": "https://yuukowww.github.io/2026/04/11/CS/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/%E5%9B%BE/", "url": "https://yuukowww.github.io/2026/04/11/CS/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/%E5%9B%BE/", "title": "图", "date_published": "2026-04-11T16:00:00.000Z", "content_html": "

图

\n

常见概念

\n
\n

顶点的度

\n\n
\n

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

\n
\n

强连通图与强连通分量

\n

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

\n

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

\n
\n
\n

生成树

\n

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

\n
\n
\n

稠密图与稀疏图

\n

一般认为图GGG满足

\n

∣E∣<∣V∣log⁡2∣V∣|E|<|V|\\log_2|V|\n∣E∣<∣V∣log2​∣V∣

\n

可视为稀疏图

\n
\n\n

图的存储方式

\n

邻接矩阵

\n

A[i][j]={1(vi,vj)∈E0(vi,vj)∉EA[i][j] = \\begin{cases}\n1&(v_i,v_j)\\in E\\\\\n0&(v_i,v_j)\\notin E\n\\end{cases}\nA[i][j]={10​(vi​,vj​)∈E(vi​,vj​)∈/E​

\n

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

\n

A[i][j]={wij(vi,vj)∈E0 or ∞(vi,vj)∉EA[i][j] = \\begin{cases}\nw_{ij}&(v_i,v_j)\\in E\\\\\n0\\,\\text{or}\\,\\infty&(v_i,v_j)\\notin E\n\\end{cases}\nA[i][j]={wij​0or∞​(vi​,vj​)∈E(vi​,vj​)∈/E​

\n
\n

Corollary: 设图GGG的邻接矩阵为AAA， AnA^nAn的元素An[i][j]A^n[i][j]An[i][j] 代表从顶点iii到顶点jjj的，长度为nnn的路径数量

\n
\n

A2[i][j]=∑k∈Vδikδkj A^2[i][j] = \\sum_{k\\in V}\\delta_{ik}\\delta_{kj}\nA2[i][j]=k∈V∑​δik​δkj​

\n

代表从顶点iii到 途经点kkk再到顶点jjj 的有效路径个数

\n

An[i][j]=∑k1,⋯ ,kn−1∈Vδik1(∏δkrks)δknj 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}\nAn[i][j]=k1,⋯,kn−1​∈V∑​δik1​​(∏δkr​ks​​)δkn​j​

\n\n

邻接表

\n

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

\n\n

十字链表

\n

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

\n\n

邻接多重表

\n

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

\n

图的遍历

\n

广度优先搜索(BFS)

\n

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

\n

BFS的实现思路为:

\n\n

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

\n

BFS可以实现的算法

\n\n

深度优先搜索(DFS)

\n

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

\n\n

图的应用

\n

最小生成树算法

\n

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

\n

最小生成树有以下特征:

\n\n

Prim 算法

\n

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

\n

Kruskal算法

\n

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

\n

最短路径问题

\n
\n

松弛化操作:

\n

对于图，寻找到一个顶点满足两弧之和小于第三弧，再进行最短距离更新到操作，称为松弛化。

\n
d[i][j] = std::min(d[i][j], d[i][k] + d[k][j]);
\n
\n

Dijkstra算法

\n

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

\n

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

\n

Floyd算法

\n

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

\n

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

\n

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

\n

有向无环图(DAG)

\n

二叉树与DAG的转换

\n

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

\n

拓扑排序

\n

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

\n\n

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

\n\n

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

\n

DFS实现拓扑排序

\n

关键路径

\n

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

\n

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

\n\n

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

\n\n", "tags": [ "数据结构", "算法", "图论" ] }, { "id": "https://yuukowww.github.io/2026/04/05/CS/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/%E6%A0%91/", "url": "https://yuukowww.github.io/2026/04/05/CS/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/%E6%A0%91/", "title": "树与二叉树", "date_published": "2026-04-05T16:00:00.000Z", "content_html": "

树

\n
\n

无根树

\n

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

\n
\n

关于树的定义:

\n\n

关于有根树的定义:

\n\n

树的存储结构

\n

双亲表示法

\n

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

\n

双亲表示法的存储结构为

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

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

\n

孩子表示法

\n

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

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

孩子兄弟表示法

\n

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

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

二叉树

\n

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

\n

二叉树的性质

\n
\n

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

\n
\n

Proof:

\n

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

\n
\n

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

\n
\n

Proof:

\n

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

\n

∑i=1k2i−1=2k−1\\sum_{i=1}^k 2^{i-1} = 2^k-1 \ni=1∑k​2i−1=2k−1

\n
\n

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

\n
\n

Proof:

\n

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

\n

n=n0+n1+n2n = n_0+n_1+n_2\nn=n0​+n1​+n2​

\n

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

\n

n=2n2+n1+1n = 2n_2+n_1+1\nn=2n2​+n1​+1

\n

故

\n

n0=n2+1n_0 = n_2+1\nn0​=n2​+1

\n
\n

性质4: nnn个结点的完全二叉树的深度为⌊log⁡2n⌋+1\\left \\lfloor \\log_2n \\right \\rfloor +1⌊log2​n⌋+1

\n
\n

Proof:

\n

完全二叉树满足:

\n

2k−1−1<n≤2k−12^{k-1}-1<n\\leq 2^{k}-1\n2k−1−1<n≤2k−1

\n

即

\n

2k−1≤n<2k2^{k-1}\\leq n < 2^k\n2k−1≤n<2k

\n

k−1≤log⁡2n<kk-1\\leq \\log_2 n < k\nk−1≤log2​n<k

\n

因此

\n

k=⌊log⁡2n⌋+1k = \\lfloor\\log_2n\\rfloor+1\nk=⌊log2​n⌋+1

\n

二叉树的存储结构

\n

顺序存储结构

\n

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

\n

链式存储结构

\n

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

\n\n

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

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

二叉树的应用

\n

遍历二叉树

\n

树的DFS有三种形式

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

线索二叉树

\n

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

\n

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

\n

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

\n

森林

\n

树、二叉树与森林的转换

\n

树与二叉树的转换

\n

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

\n

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

\n

森林与二叉树的转换

\n

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

\n

二叉树转换为森林

\n

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

\n

Huffman树

\n

Huffman树的定义

\n
\n

带权路径长度WPL

\n

定义每一个结点的权重为 wiw_iwi​, 距离根结点的图距离为 lil_ili​, 则带权路径长度定义为

\n

WPL=∑i=1nwili \\mathrm{WPL} =\\sum_{i=1}^n w_il_i\nWPL=i=1∑n​wi​li​

\n

加权平均长度定义为

\n

Lˉ=WPL∑i=1nwi \\bar{L} =\\frac{\\mathrm{WPL}}{\\sum_{i=1}^n w_i}\nLˉ=∑i=1n​wi​WPL​

\n
\n

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

\n

Huffman树的构建

\n

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

\n

并查集

\n

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

\n

并查集的操作

\n
\n

集合结构

\n

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

\n
\n
\n

集合并运算

\n

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

\n
\n
\n

集合查找运算

\n

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

\n
\n", "tags": [ "数据结构", "算法", "图论" ] }, { "id": "https://yuukowww.github.io/2026/03/30/KMP/", "url": "https://yuukowww.github.io/2026/03/30/KMP/", "title": "串的模式匹配与KMP算法", "date_published": "2026-03-30T16:00:00.000Z", "content_html": "

问题定义

\n

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

\n

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

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

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

\n

前缀函数

\n
\n

串的前缀与后缀

\n

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

\n
\n

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

\n

π[i](s)={0i=0max⁡k{k:φk(s)=ψk(s)}i≠0\\pi[i](s) = \\begin{dcases}\n0 & i = 0\\\\\n\\max_{k}\\{k : \\varphi_k(s)=\\psi_k(s)\\} & i\\neq 0\n\\end{dcases}\nπ[i](s)={0kmax​{k:φk​(s)=ψk​(s)}​i=0i=0​

\n

π(s)=[π(i)[s]]\\pi(s) = [\\pi(i)[s]]\nπ(s)=[π(i)[s]]

\n

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

\n\n

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

\n

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

\n
#include<vector>\nusing namespace std;\n\nint prefix_func_item(string s, int i){\n    int res = -1;\n    int n = (int) s.length();\n    for (int j = i; j >= 0; j--){\n            if (s.substr(0,j) == s.substr(i-j+1,j)){\n                res = j;\n                break;\n            }\n        }\n    return res;\n}\n\nvector<int> prefix_func(string s){\n    int n = (int) s.length();\n    vector<int> pi(n);\n    for (int i = 0; i < n; i++){\n        pi[i] = prefix_func_item(s,i);\n    }\n    return pi;\n}
\n

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

\n

优化

\n

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

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

优化1

\n

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

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

优化2

\n

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

\n

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

\n

j(n)=π(j(n−1)−1)j^{(n)} = \\pi(j^{(n-1)}-1)\nj(n)=π(j(n−1)−1)

\n
\n

例子

\n

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

\n\n
\n

实现

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

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

\n

KMP算法

\n

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

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

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

\n", "tags": [ "数据结构", "算法" ] }, { "id": "https://yuukowww.github.io/2026/03/22/CS/AI/LLM%E5%BA%94%E7%94%A8%E6%8C%87%E5%8C%97/", "url": "https://yuukowww.github.io/2026/03/22/CS/AI/LLM%E5%BA%94%E7%94%A8%E6%8C%87%E5%8C%97/", "title": "LLM应用指北", "date_published": "2026-03-22T16:00:00.000Z", "content_html": "

常见的国内外AI

\n
\n

国内AI

\n\n
\n
\n

外国AI

\n\n
\n

常见工具

\n
\n\n
\n

常见问题与实现

\n

Codex WSL login 遇到 NAT 通信阻拦

\n

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

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

Gemini CLI 登陆失败问题

\n

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

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

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

\n

Antigravity-Proxy

\n

Codex 异步multi-agent实现

\n

VSCode Codex

\n

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

\n

参见项目

\n

Codex 上下文长度修改

\n

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

\n
vim ~/.codex/config.toml
\n
model_context_window = 1000000  # 上下文修改为1M\nmodel_auto_compact_token_limit = 500000 # 当上下文到达500K后压缩上下文
\n", "tags": [ "LLM", "日常工作" ] }, { "id": "https://yuukowww.github.io/2026/03/20/leetcode/3-%E6%97%A0%E9%87%8D%E5%A4%8D%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E9%95%BF%E5%AD%97%E4%B8%B2/", "url": "https://yuukowww.github.io/2026/03/20/leetcode/3-%E6%97%A0%E9%87%8D%E5%A4%8D%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E9%95%BF%E5%AD%97%E4%B8%B2/", "title": "LeetCode-无重复字符的最长字串", "date_published": "2026-03-20T16:00:00.000Z", "content_html": "

无重复字符的最长字串

\n

题目描述

\n

\"描述\"

\n

题解

\n

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

\n
#include<iostream>\n#include<string>\n#include<vector>\n#include<algorithm>\nclass Solution {\npublic:\n    int lengthOfLongestSubstring(string s) {\n        int l = 0;\n        int r = 0;\n        int max_len = 0;\n        std::vector<bool> window(128,false);\n        while( r < s.length())\n        {\n            char right_char = s[r];\n            while ( window[right_char] == true)\n            {\n                char left_char = s[l];\n                window[left_char] = false;\n                l++;\n            }\n            window[right_char] = true;\n            max_len = std::max(max_len, r - l + 1);\n            r++;\n        }\n        return max_len;\n    }\n};\n
\n", "tags": [ "算法", "前后指针", "Leetcode" ] }, { "id": "https://yuukowww.github.io/2026/03/10/CS/AI/ML/", "url": "https://yuukowww.github.io/2026/03/10/CS/AI/ML/", "title": "传统机器学习", "date_published": "2026-03-10T16:00:00.000Z", "content_html": "

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

\n

线性模型与支持向量机

\n

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

\n
\n

问题定义:

\n\n
\n

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

\n

yi^=fi(ui)=ωi,1xi,1+ωi,2xi,2+⋯+ωi,dxi,d+b=ωTui+b:Rd→R\\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}\nyi​^​=fi​(ui​)=ωi,1​xi,1​+ωi,2​xi,2​+⋯+ωi,d​xi,d​+b=ωTui​+b:Rd→R

\n

最小二乘法满足

\n

(ω∗,b∗)=arg min⁡ω,b∑i∥yi−yi^∥2=arg min⁡ω,b∑i∥yi−ωui−b∥(\\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\\|\n(ω∗,b∗)=ω,bargmin​i∑​∥yi​−yi​^​∥2=ω,bargmin​i∑​∥yi​−ωui​−b∥

\n

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

\n

L(w,b)=1n∑i=1n(yi−yi^)2=1n∑i=1n(yi−ωui−b)2L(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\nL(w,b)=n1​i=1∑n​(yi​−yi​^​)2=n1​i=1∑n​(yi​−ωui​−b)2

\n

正则化

\n
\n

Lasso 正则化

\n
\n
\n

岭正则化

\n
\n

贝叶斯决策

\n

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

\n

Y={c1,c2,⋯ ,cn}\\mathcal{Y} = \\left\\{c_1,c_2,\\cdots, c_n\\right\\}\nY={c1​,c2​,⋯,cn​}

\n

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

\n
\n

损失函数

\n

贝叶斯决策中的损失函数定义为将样本cic_ici​分类为cjc_jcj​的损失

\n

λi,j:Y×Y→[0,1]\\lambda_{i,j}:\\mathcal{Y}\\times\\mathcal{Y}\\to [0,1]\nλi,j​:Y×Y→[0,1]

\n

通常使用0-1损失

\n

λi,j=δi,j={0i=j1i≠j\\lambda_{i,j} = \\delta_{i,j} = \\begin{cases}\n0&i = j\\\\\n1&i \\neq j\n\\end{cases}\nλi,j​=δi,j​={01​i=ji=j​

\n
\n

总损失期望

\n

R(ci∣x)=∑j=1nλi,jP(cj∣x)R(c_i\\big| \\bm{x}) = \\sum_{j=1}^n \\lambda_{i,j} P(c_j\\big | \\bm{x})\nR(ci​​x)=j=1∑n​λi,j​P(cj​​x)

\n

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

\n

h:X→Yh:\\mathcal{X}\\to \\mathcal{Y}\nh:X→Y

\n

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

\n

R(h)=Ex∈X[R(h(x)∣x)]R(h)=E_{\\bm{x}\\in \\mathcal{X}}\\left[R(h(\\bm{x})\\big|\\bm{x})\\right]\nR(h)=Ex∈X​[R(h(x)​x)]

\n

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

\n

h∗(x)=arg min⁡c∈yR(c∣x)h^\\ast(\\bm{x}) = \\argmin_{c\\in\\mathcal{y}} R(c\\big| \\bm{x})\nh∗(x)=c∈yargmin​R(c​x)

\n

贝叶斯分类器的训练

\n", "tags": [ "机器学习" ] }, { "id": "https://yuukowww.github.io/2026/02/27/%E9%9A%8F%E6%9C%BA%E7%9F%A9%E9%98%B5/", "url": "https://yuukowww.github.io/2026/02/27/%E9%9A%8F%E6%9C%BA%E7%9F%A9%E9%98%B5/", "title": "随机矩阵", "date_published": "2026-02-27T16:00:00.000Z", "content_html": "

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

\n

随机矩阵

\n
\n

Theorem:\\mathrm{Theorem:}Theorem: 随机矩阵作用期望保距
\nRRR是 k×dk\\times dk×d 矩阵, Rij∼i.i.dN(0,1)R_{ij}\\overset{i.i.d}{\\sim}\\mathcal{N}(0,1)Rij​∼i.i.dN(0,1), ∀u∈Rd\\forall \\mathbf{u}\\in \\mathbb{R}^d∀u∈Rd， 取 v=1kR⋅u\\mathbf{v}=\\frac{1}{\\sqrt{k}}R\\cdot \\mathbf{u}v=k​1​R⋅u, 则

\n
\n

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

\n

Proof:\\mathrm{Proof:}Proof:

\n

vi=1k∑j=1dRijujv_i=\\frac{1}{\\sqrt{k}}\\sum_{j=1}^d R_{ij}u_j\nvi​=k​1​j=1∑d​Rij​uj​

\n

E[∥v∥2]=E[∑i=1kvi2]=E[∑i=1k1k∑j=1dRijuj∑r=1dRirur]=∑i=1k1k∑j,rujurE[RijRir]=∑i=1k1k∑j,rujurδjr=∑juj2=∥u∥2\\begin{aligned}\n\\mathbb{E}[\\|\\mathbf{v}\\|^2]&=\\mathbb{E}\\left[\\sum_{i=1}^k v_i^2 \\right]\\\\\n&=\\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]\\\\\n&=\\sum_{i=1}^k\\frac{1}{k}\\sum_{j,r}u_ju_r\\mathbb{E}\\left[R_{ij}R_{ir}\\right]\\\\\n&=\\sum_{i=1}^k\\frac{1}{k}\\sum_{j,r}u_ju_r\\delta_{jr}\\\\\n&=\\sum_{j}u_j^2\\\\\n&=\\|\\mathbf{u}\\|^2\n\\end{aligned}\nE[∥v∥2]​=E[i=1∑k​vi2​]=E[i=1∑k​k1​j=1∑d​Rij​uj​r=1∑d​Rir​ur​]=i=1∑k​k1​j,r∑​uj​ur​E[Rij​Rir​]=i=1∑k​k1​j,r∑​uj​ur​δjr​=j∑​uj2​=∥u∥2​

\n", "tags": [] }, { "id": "https://yuukowww.github.io/2026/02/23/CS/AI/Markov/", "url": "https://yuukowww.github.io/2026/02/23/CS/AI/Markov/", "title": "Markov 过程", "date_published": "2026-02-23T16:00:00.000Z", "content_html": "

Markov Decision Process

\n
\n

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

\n\n
\n

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

\n

记

\n

As={a∣s→as′,∀s′∈St+1}{\\mathcal{A}_s}=\\left\\{a\\mid s\\overset{a}{\\to}s', \\forall s'\\in S_{t+1}\\right\\}\nAs​={a∣s→as′,∀s′∈St+1​}

\n

为状态 sss 的动作空间

\n

Markov Property

\n

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

\n

p(St+1=s′,Rt+1=r∣St,At)=p(St+1=s′,Rt+1=r∣St,At,St−1,At−1,⋯ )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)\np(St+1​=s′,Rt+1​=r∣St​,At​)=p(St+1​=s′,Rt+1​=r∣St​,At​,St−1​,At−1​,⋯)

\n

MDP的奖励返回

\n\n

Agent Policy 智能体策略

\n
\n

Goal of RL Agent

\n

To find a behavior policy that maximises the expected return GtG_tGt​

\n
\n

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

\n
\n

Policy 智能体策略

\n
\n\n

策略数学表达为

\n

π:S→P(A)⊂[0,1],π(a∣s)=p(At=a∣St=s)\\pi:\\mathcal{S}\\to P(\\mathcal{A})\\subset [0,1],\\quad \\pi(a\\mid s)=p(A_t=a\\mid S_t=s)\nπ:S→P(A)⊂[0,1],π(a∣s)=p(At​=a∣St​=s)

\n

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

\n

πθ(a∣s)\\pi_\\theta(a\\mid s)\nπθ​(a∣s)

\n

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

\n

∑a∈Asπθ(a∣s)=1\\sum_{a\\in \\mathcal{A}_s} \\pi_\\theta(a\\mid s)=1\na∈As​∑​πθ​(a∣s)=1

\n

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

\n

∫a∈Asπθ(a∣s) da=1\\int_{a\\in\\mathcal{A}_s}\\pi_\\theta(a\\mid s)\\,\\mathrm{d}a=1\n∫a∈As​​πθ​(a∣s)da=1

\n

Value Function 价值函数

\n

vπ(s)=E(Gt∣St=s,π)v_\\pi(s)=\\mathbb{E}(G_t\\mid S_t=s,\\pi)\nvπ​(s)=E(Gt​∣St​=s,π)

\n

Q Function

\n

Q Function 指的是在状态St=sS_t=sSt​=s，执行动作At=aA_t=aAt​=a下的价值期望函数

\n

qπ(s,a)=E(Gt∣St=s,At=a,π)=E(∑k=0∞γkRt+k+1∣St=s,At=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)\nqπ​(s,a)=E(Gt​∣St​=s,At​=a,π)=E(k=0∑∞​γkRt+k+1​∣St​=s,At​=a,π)

\n

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

\n

vπ(s)=∑a∈Asπ(a∣s)qπ(s,a)v_\\pi(s)=\\sum_{a\\in \\mathcal{A}_s} \\pi(a\\mid s)q_\\pi(s,a)\nvπ​(s)=a∈As​∑​π(a∣s)qπ​(s,a)

\n

Optimal Value Function 最优化价值函数

\n
\n

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

\n
\n

v∗(s)=max⁡πvπ(s)v^\\ast(s)=\\max_{\\pi} v_\\pi (s)\nv∗(s)=πmax​vπ​(s)

\n
\n

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

\n
\n

q∗(s,a)=max⁡πqπ(s,a)q^\\ast(s,a)=\\max_{\\pi}q_\\pi (s,a)\nq∗(s,a)=πmax​qπ​(s,a)

\n

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

\n

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

\n

π′≥π⟺∀s∈S, vπ′(s)≥vπ(s)\\pi'\\geq \\pi \\Longleftrightarrow \\forall s\\in\\mathcal{S},\\, v_{\\pi'}(s)\\geq v_\\pi(s)\nπ′≥π⟺∀s∈S,vπ′​(s)≥vπ​(s)

\n

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

\n
\n

Optimal policy 最优策略

\n
\n

最优策略π∗\\pi^\\astπ∗满足

\n

∀π∈Π,π≤π∗\\forall \\pi \\in \\Pi, \\pi\\leq \\pi^\\ast\n∀π∈Π,π≤π∗

\n

Bellman Equation

\n
\n

Action Value Function 的时间步展开

\n
\n

qπ(s,a)=E(Gt∣ST=s,At=a,π)=E(Rt+1+γvπ(St+1)∣St=s,At∈π(St),π)=∑r∈Rt+1∑s′∈St+1p(r,s′∣s,a)(r+γvπ(s′))=∑a∈A(s)π(a∣s)∑r∈Rt+1∑s′∈St+1p(r,s′∣s,a)(r+γ∑a′∈A(s′)(π(a′∣s′)qπ(s′,a′)))\\begin{aligned}\nq_\\pi(s,a)&=\\mathbb{E}(G_t\\mid S_T=s,A_t=a,\\pi)\\\\\n&=\\mathbb{E}\\left(R_{t+1}+\\gamma v_\\pi(S_{t+1})\\mid S_t=s, A_t\\in\\pi(S_t),\\pi\\right)\\\\\n&=\\sum_{r\\in R_{t+1}}\\sum_{s'\\in \\mathcal{S}_{t+1}}p(r,s'\\mid s,a)(r+\\gamma v_\\pi(s'))\\\\\n&=\\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')))\n\\end{aligned}\nqπ​(s,a)​=E(Gt​∣ST​=s,At​=a,π)=E(Rt+1​+γvπ​(St+1​)∣St​=s,At​∈π(St​),π)=r∈Rt+1​∑​s′∈St+1​∑​p(r,s′∣s,a)(r+γvπ​(s′))=a∈A(s)∑​π(a∣s)r∈Rt+1​∑​s′∈St+1​∑​p(r,s′∣s,a)(r+γa′∈A(s′)∑​(π(a′∣s′)qπ​(s′,a′)))​

\n
\n

Value Function 的时间步展开

\n
\n

vπ(s)=∑aπ(a∣s)qπ(s,a)=∑a∈A(s)π(a∣s)∑r∈Rt+1∑s′∈St+1p(r,s′∣s,a)(r+γvπ(s′))\\begin{aligned}\nv_\\pi(s)&=\\sum_{a}\\pi(a\\mid s)q_\\pi(s,a)\\\\\n&=\\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'))\n\\end{aligned}\nvπ​(s)​=a∑​π(a∣s)qπ​(s,a)=a∈A(s)∑​π(a∣s)r∈Rt+1​∑​s′∈St+1​∑​p(r,s′∣s,a)(r+γvπ​(s′))​

\n
\n

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

\n
\n

vπ(s)=∑a∈A(s)π(a∣s)∑r∈Rt+1∑s′∈St+1p(r,s′∣s,a)(r+γvπ(s′))qπ(s,a)=∑a∈A(s)π(a∣s)∑r∈Rt+1∑s′∈St+1p(r,s′∣s,a)(r+γ∑a′∈A(s′)(π(a′∣s′)qπ(s′,a′)))\\begin{align}\nv_\\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} \\\\\nq_\\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}\n\\end{align}\nvπ​(s)qπ​(s,a)​=a∈A(s)∑​π(a∣s)r∈Rt+1​∑​s′∈St+1​∑​p(r,s′∣s,a)(r+γvπ​(s′))=a∈A(s)∑​π(a∣s)r∈Rt+1​∑​s′∈St+1​∑​p(r,s′∣s,a)(r+γa′∈A(s′)∑​(π(a′∣s′)qπ​(s′,a′)))​(1)(2)​

\n", "tags": [] }, { "id": "https://yuukowww.github.io/2026/02/15/math/%E9%AB%98%E6%96%AF%E5%90%91%E9%87%8F/", "url": "https://yuukowww.github.io/2026/02/15/math/%E9%AB%98%E6%96%AF%E5%90%91%E9%87%8F/", "title": "随机高斯向量的单位模引理与正交性定理", "date_published": "2026-02-15T16:00:00.000Z", "content_html": "

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

\n

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

\n

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

\n

预备定理

\n
\n

Markov 不等式

\n

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

\n

P(∣X−μ∣≥ε)≤σ2ε2P(|X-\\mu|\\geq \\varepsilon)\\leq \\frac{\\sigma^2}{\\varepsilon^2}\nP(∣X−μ∣≥ε)≤ε2σ2​

\n

Proof:\\mathbf{Proof}:Proof:

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

即

\n

P(∣x−μ∣≥ε)≤σ2ε2P(|x-\\mu|\\geq \\varepsilon)\\leq \\frac{\\sigma^2}{\\varepsilon^2}\nP(∣x−μ∣≥ε)≤ε2σ2​

\n
\n
\n

Cramér-Chernoff方法

\n

∀λ>0\\forall \\lambda > 0∀λ>0, 有

\n

∣x−μ∣≥ε⟺eλ∣x−μ∣≥eλε|x-\\mu|\\geq \\varepsilon\\Longleftrightarrow e^{\\lambda |x-\\mu|}\\geq e^{\\lambda \\varepsilon}\n∣x−μ∣≥ε⟺eλ∣x−μ∣≥eλε

\n

因此有

\n

P(∣x−μ∣≥ε)=P(eλ∣x−μ∣≥eλε)≤e−λaE(eλ∣x−μ∣)⟺P(∣x−μ∣≥ε)≤min⁡λ>0e−λaE(eλ∣x−μ∣)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|})\nP(∣x−μ∣≥ε)=P(eλ∣x−μ∣≥eλε)≤e−λaE(eλ∣x−μ∣)⟺P(∣x−μ∣≥ε)≤λ>0min​e−λaE(eλ∣x−μ∣)

\n

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

\n
\n

Key Concept

\n

随机高斯向量定义为

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

单位模引理

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

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

\n

P(∣∥u∥2−1∣≥ε)≤min⁡λ>0e−λεE(eλ∣∥u∥2−1∣)P(|\\|u\\|^2-1|\\geq \\varepsilon )\\leq \\min_{\\lambda>0}e^{-\\lambda\\varepsilon}E(e^{\\lambda|\\|u\\|^2-1|})\nP(∣∥u∥2−1∣≥ε)≤λ>0min​e−λεE(eλ∣∥u∥2−1∣)

\n

当∥u∥2≥1\\|u\\|^2\\geq 1∥u∥2≥1时：

\n

P(∥u∥2−1≥ε)=P(∥u∥2≥1+ε)≤min⁡λ>0e−λ(ε+1)E(eλ∥u∥2)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})\nP(∥u∥2−1≥ε)=P(∥u∥2≥1+ε)≤λ>0min​e−λ(ε+1)E(eλ∥u∥2)

\n\\begin{aligned}\n\\mathbb{E}(e^{\\lambda\\|u\\|^2})&=\\mathbb{E} (e^{\\lambda \\sum u_i ^2})\\\\\n&=\\prod_{i=1}^n \\mathbb{E}(e^{\\lambda u_i^2})\\\\\n&=\\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\\\\\n&=\\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\\\\\n&=\\left(\\sqrt{\\frac{n}{n-2\\lambda}}\\right)^n\n\\end{aligned}\n\n

即

\n

P(∥u∥−1≥ε)≤min⁡λ>0e−λ(ε+1)(nn−2λ)n2P(\\|u\\|-1\\geq \\varepsilon)\\leq \\min_{\\lambda>0}e^{-\\lambda(\\varepsilon+1)}\\left(\\frac{n}{n-2\\lambda}\\right)^\\frac{n}{2}\nP(∥u∥−1≥ε)≤λ>0min​e−λ(ε+1)(n−2λn​)2n​

\n

取f(λ)=e−λ(ε+1)(nn−2λ)n2f(\\lambda)=e^{-\\lambda(\\varepsilon+1)}\\left(\\frac{n}{n-2\\lambda}\\right)^\\frac{n}{2}f(λ)=e−λ(ε+1)(n−2λn​)2n​

\n\\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\n\n

根λ0=nε2(ε+1)\\lambda_0 = \\dfrac{n\\varepsilon}{2(\\varepsilon +1)}λ0​=2(ε+1)nε​

\n

故

\n

P(∥u∥−1≥ε)≤f(λ0)=e−nε2(1+ε)n2=en2(ln⁡(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 )}\nP(∥u∥−1≥ε)≤f(λ0​)=e−2nε​(1+ε)2n​=e2n​(ln(1+ε)−ε)

\n

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

\n

P(1−∥u∥2≤ε)≤min⁡λ>0e−λεE(eλ(1−∥u∥2))=min⁡λ>0e−λ(ε−1)E(e−λ∥u∥2)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})\nP(1−∥u∥2≤ε)≤λ>0min​e−λεE(eλ(1−∥u∥2))=λ>0min​e−λ(ε−1)E(e−λ∥u∥2)

\n\\begin{aligned}\n\\mathbb{E}(-\\lambda \\|u\\|^2)&= \\mathbb{E}(e^{-\\lambda \\sum u_i^2})\\\\\n&=\\prod_{i=1}^n \\mathbb{E}(e^{-\\lambda u_i^2})\\\\\n&=\\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\\\\\n&=\\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\\\\\n&=\\left(\\frac{n}{n+2\\lambda}\\right)^\\frac{n}{2}\n\\end{aligned}\n\n

即

\n

P(1−∥u∥2≤ε)≤min⁡λ>0e−λ(ε−1)(nn+2λ)n2P(1-\\|u\\|^2\\leq \\varepsilon)\\leq \\min_{\\lambda>0}e^{-\\lambda (\\varepsilon-1)}\\left(\\frac{n}{n+2\\lambda}\\right)^{\\frac{n}{2}}\nP(1−∥u∥2≤ε)≤λ>0min​e−λ(ε−1)(n+2λn​)2n​

\n

取λ0=εn2(1−ε)\\lambda_0 = \\dfrac{\\varepsilon n}{2(1-\\varepsilon)}λ0​=2(1−ε)εn​

\n

P(1−∥u∥2≤ε)≤eεn2(1−ε)n2=en2(ε+ln⁡(1−ε))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))}\nP(1−∥u∥2≤ε)≤e2εn​(1−ε)2n​=e2n​(ε+ln(1−ε))

\n

即

\n

{P(∥u∥2−1≥ε)≤en2(ln⁡(1+ε)−ε)P(1−∥u∥2≤ε)≤en2(ε+ln⁡(1−ε))\\begin{cases}\nP(\\|u\\|^2-1\\geq \\varepsilon)\\leq e^{\\frac{n}{2}(\\ln (1+\\varepsilon)-\\varepsilon )}\\\\\nP(1-\\|u\\|^2\\leq \\varepsilon)\\leq e^{\\frac{n}{2}(\\varepsilon+\\ln (1-\\varepsilon))}\n\\end{cases}\n{P(∥u∥2−1≥ε)≤e2n​(ln(1+ε)−ε)P(1−∥u∥2≤ε)≤e2n​(ε+ln(1−ε))​

\n

考虑

\n

ln⁡1+ε1−ε>2ε\\ln \\frac{1+\\varepsilon}{1-\\varepsilon}>2\\varepsilon\nln1−ε1+ε​>2ε

\n

ln⁡(1+ε)−ε<−ε2C\\ln (1+\\varepsilon)-\\varepsilon < -\\frac{\\varepsilon^2}{C}\nln(1+ε)−ε<−Cε2​

\n

C>max⁡ε∈(0,1)(ε2ε−ln⁡(1+ε))=11−ln⁡2≃3.26C>\\max_{\\varepsilon\\in(0,1)}\\left(\\frac{\\varepsilon^2}{\\varepsilon-\\ln(1+\\varepsilon)}\\right)=\\frac{1}{1-\\ln2}\\simeq 3.26\nC>ε∈(0,1)max​(ε−ln(1+ε)ε2​)=1−ln21​≃3.26

\n

通常取C=4C=4C=4，则

\n

{P(∥u∥2−1≥ε)≤e−nε28P(1−∥u∥2≤ε)≤e−nε28\\begin{cases}\nP(\\|u\\|^2-1\\geq \\varepsilon)\\leq e^{-\\frac{n\\varepsilon^2}{8}}\\\\\nP(1-\\|u\\|^2\\leq \\varepsilon)\\leq e^{-\\frac{n\\varepsilon^2}{8}}\n\\end{cases}\n{P(∥u∥2−1≥ε)≤e−8nε2​P(1−∥u∥2≤ε)≤e−8nε2​​

\n

P(∣∥u∥2−1∣≥ε)≤2e−nε28P(|\\|u\\|^2-1|\\geq \\varepsilon )\\leq 2e^{-\\frac{n\\varepsilon^2}{8}}\nP(∣∥u∥2−1∣≥ε)≤2e−8nε2​

\n
\n

正交性引理

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

Proof:\\mathbf{Proof:}Proof:
\nu,v∈Gu,v\\in\\mathcal{G}u,v∈G, 则 u+v2,u−v2∈G\\dfrac{u+v}{\\sqrt{2}},\\dfrac{u-v}{\\sqrt{2}}\\in \\mathcal{G}2​u+v​,2​u−v​∈G

\n

一方面

\n

P(∣<u,v>∣≥ε)≤P(∥u+v2∥2−1≥ε)+P(1−∥u−v2∥2≥ε)≤4exp⁡(−ε2n8)\\begin{aligned}\nP(|\\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)\\\\\n&\\leq 4\\exp(-\\frac{\\varepsilon^2 n}{8})\n\\end{aligned}\nP(∣⟨u,v⟩∣≥ε)​≤P(​2​u+v​​2−1≥ε)+P(1−​2​u−v​​2≥ε)≤4exp(−8ε2n​)​

\n

另一方面

\n

P(−<u,v>≥ε)≤P(1−∥u+v2∥2≥ε)+P(∥u−v2∥2−1≥ε)≤4exp⁡(−ε2n8)\\begin{aligned}\nP(-\\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)\\\\\n&\\leq 4\\exp(-\\frac{\\varepsilon^2n}{8})\n\\end{aligned}\nP(−⟨u,v⟩≥ε)​≤P(1−​2​u+v​​2≥ε)+P(​2​u−v​​2−1≥ε)≤4exp(−8ε2n​)​

\n

综上

\n

P(∣<u,v>∣≥ε)≤4exp⁡(−ε2n8)P(|\\left<u,v\\right>|\\geq \\varepsilon)\\leq 4\\exp(-\\frac{\\varepsilon^2n}{8})\nP(∣⟨u,v⟩∣≥ε)≤4exp(−8ε2n​)

\n

Chernoff Bound

\n
\n

Moment generating function 矩生成函数
\n随机变量XXX的矩生成函数定义为

\n

MX(t)=E(etX)=∫01etxdF(x)M_X(t)=\\mathbb{E}(e^{tX})=\\int_0^1 e^{tx}\\mathrm{d}F(x)\nMX​(t)=E(etX)=∫01​etxdF(x)

\n
\n
\n

Hoeffding lemma
\n对于随机变量XXX, a≤X≤ba\\leq X\\leq ba≤X≤b, E[X]=0,∀x,∣f(x)∣<∞\\mathbb{E}[X]=0, \\forall x, |f(x)|<\\inftyE[X]=0,∀x,∣f(x)∣<∞, 则

\n
\n

E(eλ(X−μ))≤exp⁡(λ(b−a)28)\\mathbb{E}(e^{\\lambda(X-\\mu)})\\leq\\exp\\left(\\frac{\\lambda(b-a)^2}{8}\\right)\nE(eλ(X−μ))≤exp(8λ(b−a)2​)

\n", "tags": [] }, { "id": "https://yuukowww.github.io/2026/02/14/CS/AI/Johnson%E2%80%93Lindenstrauss/", "url": "https://yuukowww.github.io/2026/02/14/CS/AI/Johnson%E2%80%93Lindenstrauss/", "title": "Johnson–Lindenstrauss 引理", "date_published": "2026-02-14T16:00:00.000Z", "content_html": "

Johnson-Lindenstrauss 引理

\n
\n

Johnson-Lindenstrauss 引理

\n

对于NNN个ddd维向量构成的集合A={x1,x2,⋯ ,xN∈Rd}A=\\left\\lbrace x_1,x_2,\\cdots,x_N\\in\\mathbb{R}^d\\right\\rbraceA={x1​,x2​,⋯,xN​∈Rd}，∀ε∈(0,1)\\forall\\varepsilon\\in(0,1)∀ε∈(0,1)，∃f:Rd→Rk\\exists f:\\mathbb{R}^d\\to\\mathbb{R}^k∃f:Rd→Rk，满足

\n

(1−ε)∥xi−xj∥2≤∥f(xi)−f(xj)∥2≤(1+ε)∥xi−xj∥2(1-\\varepsilon)\\|x_i-x_j\\|^2\\leq \\|f(x_i)-f(x_j)\\|^2\\leq (1+\\varepsilon)\\|x_i-x_j\\|^2\n(1−ε)∥xi​−xj​∥2≤∥f(xi​)−f(xj​)∥2≤(1+ε)∥xi​−xj​∥2

\n

其中

\n

k≥24log⁡N3ε2−2ε3≃O(log⁡Nε2)k\\geq \\frac{24\\log N}{3\\varepsilon^2-2\\varepsilon^3}\\simeq O(\\frac{\\log N}{\\varepsilon^2})\nk≥3ε2−2ε324logN​≃O(ε2logN​)

\n
\n

Proof:\\mathrm{Proof:}Proof:

\n

随机矩阵

\n

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

\n

取 u∈Rd\\mathbf{u}\\in \\mathbb{R}^du∈Rd, Rij∼i.i.dN(0,1)R_{ij}\\overset{i.i.d}{\\sim}\\mathcal{N}(0,1)Rij​∼i.i.dN(0,1), 随机投影向量 v=1kR⋅u\\mathbf{v}=\\frac{1}{\\sqrt{k}}R\\cdot \\mathbf{u}v=k​1​R⋅u

\n

根据随机矩阵期望保距

\n

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

\n

取 X=k∥u∥v=1∥u∥R⋅uX=\\frac{\\sqrt{k}}{\\|\\mathbf{u}\\|}\\mathbf{v}=\\frac{1}{\\|\\mathbf{u}\\|}R\\cdot \\mathbf{u}X=∥u∥k​​v=∥u∥1​R⋅u, x=∑i=1kxi2=k∥v∥2∥u∥2∼χ2(k)x=\\sum_{i=1}^k x_i^2 =\\frac{k\\|\\mathbf{v}\\|^2}{\\|\\mathbf{u}\\|^2}\\sim \\chi^2(k)x=∑i=1k​xi2​=∥u∥2k∥v∥2​∼χ2(k)

\n

E[eλxi2]=∫−∞+∞eλxi212πe−xi22 dxi=11−2λ\\begin{aligned}\n\\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}}\n\\end{aligned}\nE[eλxi2​]​=∫−∞+∞​eλxi2​2π​1​e−2xi2​​dxi​=1−2λ1​​​

\n

一方面

\n

P[∥v∥2≥(1+ε)∥u∥2]=P[x≥(1+ε)k]=P[eλx≥eλ(1+ε)k]≤inf⁡λ≥0E[eλx]eλ(1+ε)k=inf⁡λ≥0∏i=1kE[eλxi2]eλ(1+ε)k=inf⁡λ≥0(11−2λ eλ(1+ε))k=[(1+ε)e−ε]k2=exp⁡(k2(−ε+log⁡(1+ε)))≤exp⁡(k2(−ε22+ε33))\\begin{aligned}\nP[\\|\\mathbf{v}\\|^2\\geq(1+\\varepsilon)\\|\\mathbf{u}\\|^2]&=P[x\\geq(1+\\varepsilon)k]\\\\\n&=P[e^{\\lambda x}\\geq e^{\\lambda(1+\\varepsilon)k}]\\\\\n&\\leq \\inf_{\\lambda\\geq 0}\\frac{\\mathbb{E}[e^{\\lambda x}]}{e^{\\lambda(1+\\varepsilon)k}}\\\\\n&=\\inf_{\\lambda\\geq 0}\\frac{\\prod_{i=1}^k\\mathbb{E}[e^{\\lambda x_i^2}]}{e^{\\lambda(1+\\varepsilon)k}}\\\\\n&=\\inf_{\\lambda \\geq 0}\\left(\\frac{1}{\\sqrt{1-2\\lambda}\\,e^{\\lambda(1+\\varepsilon )}}\\right)^k\\\\\n&=\\left[(1+\\varepsilon)e^{-\\varepsilon}\\right]^{\\frac{k}{2}}\\\\\n&=\\exp\\left(\\frac{k}{2}(-\\varepsilon+\\log(1+\\varepsilon))\\right)\\\\\n&\\leq\\exp\\left(\\frac{k}{2}\\left(-\\frac{\\varepsilon^2}{2}+\\frac{\\varepsilon^3}{3}\\right)\\right)\n\\end{aligned}\nP[∥v∥2≥(1+ε)∥u∥2]​=P[x≥(1+ε)k]=P[eλx≥eλ(1+ε)k]≤λ≥0inf​eλ(1+ε)kE[eλx]​=λ≥0inf​eλ(1+ε)k∏i=1k​E[eλxi2​]​=λ≥0inf​(1−2λ​eλ(1+ε)1​)k=[(1+ε)e−ε]2k​=exp(2k​(−ε+log(1+ε)))≤exp(2k​(−2ε2​+3ε3​))​

\n

当 k2(−ε22+ε33)<−2log⁡N\\dfrac{k}{2}\\left(-\\dfrac{\\varepsilon^2}{2}+\\dfrac{\\varepsilon^3}{3}\\right)<-2\\log N2k​(−2ε2​+3ε3​)<−2logN, 即 k>24log⁡N3ε2−2ε3k>\\dfrac{24\\log N}{3\\varepsilon^2-2\\varepsilon^3}k>3ε2−2ε324logN​ 时，满足

\n

P[∥v∥2≥(1+ε)∥u∥2]≤N−2P\\left[\\|\\mathbf{v}\\|^2\\geq (1+\\varepsilon)\\|\\mathbf{u}\\|^2\\right]\\leq N^{-2}\nP[∥v∥2≥(1+ε)∥u∥2]≤N−2

\n

因此

\n

P[∥v2∥≤(1+ε)∥u∥2]≥1−N−2P\\left[\\|\\mathbf{v}^2\\|\\leq (1+\\varepsilon)\\|\\mathbf{u}\\|^2\\right]\\geq 1-N^{-2}\nP[∥v2∥≤(1+ε)∥u∥2]≥1−N−2

\n

另一方面

\n

P[∥v∥2≤(1−ε)∥u∥2]=P[x≤(1−ε)k]=P[e−λx≥e−λ(1−ε)k]≤inf⁡λ≥0E[e−λx]e−λ(1−ε)k=inf⁡λ≥0∏i=1kE[e−λxi2]e−λ(1−ε)k=inf⁡λ≥0(11+2λ e−λ(1−ε))k=[(1−ε)eε]k2=exp⁡(k2(ε+log⁡(1−ε)))≤exp⁡(−kε24)\\begin{aligned}\nP\\left[\\|\\mathbf{v}\\|^2\\leq(1-\\varepsilon)\\|\\mathbf{u}\\|^2\\right]&=P\\left[x\\leq (1-\\varepsilon)k\\right]\\\\\n&=P\\left[e^{-\\lambda x}\\geq e^{-\\lambda(1-\\varepsilon)k}\\right]\\\\\n&\\leq \\inf_{\\lambda\\geq 0}\\frac{\\mathbb{E}[e^{-\\lambda x}]}{e^{-\\lambda(1-\\varepsilon)k}}\\\\\n&=\\inf_{\\lambda\\geq 0} \\frac{\\prod_{i=1}^k\\mathbb{E}\\left[e^{-\\lambda x_i^2}\\right]}{e^{-\\lambda (1-\\varepsilon )k}}\\\\\n&=\\inf_{\\lambda \\geq 0}\\left(\\frac{1}{\\sqrt{1+2\\lambda}\\,e^{-\\lambda(1-\\varepsilon )}}\\right)^k\\\\\n&= \\left[(1-\\varepsilon)e^{\\varepsilon}\\right]^{\\frac{k}{2}}\\\\\n&= \\exp\\left(\\frac{k}{2}\\left(\\varepsilon+\\log(1-\\varepsilon)\\right)\\right)\\\\\n&\\leq \\exp \\left(-\\frac{k\\varepsilon^2}{4}\\right)\n\\end{aligned}\nP[∥v∥2≤(1−ε)∥u∥2]​=P[x≤(1−ε)k]=P[e−λx≥e−λ(1−ε)k]≤λ≥0inf​e−λ(1−ε)kE[e−λx]​=λ≥0inf​e−λ(1−ε)k∏i=1k​E[e−λxi2​]​=λ≥0inf​(1+2λ​e−λ(1−ε)1​)k=[(1−ε)eε]2k​=exp(2k​(ε+log(1−ε)))≤exp(−4kε2​)​

\n

当−kε24≤−2log⁡N-\\dfrac{k\\varepsilon^2}{4}\\leq -2\\log N−4kε2​≤−2logN时，即k≥8log⁡Nε2k\\geq \\dfrac{8\\log N}{\\varepsilon^2}k≥ε28logN​

\n

P[∥v∥2≤(1−ε)∥u∥2]≤N−2P\\left[\\|\\mathbf{v}\\|^2\\leq(1-\\varepsilon)\\|\\mathbf{u}\\|^2\\right]\\leq N^{-2}\nP[∥v∥2≤(1−ε)∥u∥2]≤N−2

\n

即

\n

P[∥v∥2≥(1−ε)∥u∥2]≥1−N−2P\\left[\\|\\mathbf{v}\\|^2\\geq(1-\\varepsilon)\\|\\mathbf{u}\\|^2\\right]\\geq 1- N^{-2}\n\nP[∥v∥2≥(1−ε)∥u∥2]≥1−N−2

\n

当

\n

k∈{k≥24log⁡N3ε2−2ε3}∩{k≥8log⁡Nε2}={k≥24log⁡N3ε2−2ε3}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\\}\nk∈{k≥3ε2−2ε324logN​}∩{k≥ε28logN​}={k≥3ε2−2ε324logN​}

\n

满足

\n

P[∥v∥2∉[(1−ε)∥u∥2,(1+ε)∥u∥2]]≤2N2P\\left[\\|\\mathbf{v}\\|^2\\not \\in\\left[(1-\\varepsilon)\\|\\mathbf{u}\\|^2,(1+\\varepsilon)\\|\\mathbf{u}\\|^2\\right]\\right]\\leq \\frac{2}{N^2}\nP[∥v∥2∈[(1−ε)∥u∥2,(1+ε)∥u∥2]]≤N22​

\n

进一步

\n

∀xi,xj∈A, P[∥f(xi)−f(xj)∥2∉[(1−ε)∥xi−xj∥2,(1+ε)∥xi−xj∥2]]≤2N2\\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}\n∀xi​,xj​∈A,P[∥f(xi​)−f(xj​)∥2∈[(1−ε)∥xi​−xj​∥2,(1+ε)∥xi​−xj​∥2]]≤N22​

\n

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

\n

P(∪Ei)≤∑P(Ei)≤N(N−1)22N2=1−1NP(\\cup E_i)\\leq\\sum P(E_i)\\leq\\frac{N(N-1)}{2}\\frac{2}{N^2}=1-\\frac{1}{N}\nP(∪Ei​)≤∑P(Ei​)≤2N(N−1)​N22​=1−N1​

\n

由此可以得出，当 k≥24log⁡N3ε2−2ε3k\\geq\\dfrac{24\\log N}{3\\varepsilon^2-2\\varepsilon^3}k≥3ε2−2ε324logN​时，将整个 AAA 几乎保距映入低维空间的映射fff存在的概率不为0

\n

Fast Johnson-Linderstrauss Transform

\n", "tags": [] }, { "id": "https://yuukowww.github.io/2025/08/19/math/real_analysis/measure/", "url": "https://yuukowww.github.io/2025/08/19/math/real_analysis/measure/", "title": "测度与Lebesgue测度", "date_published": "2025-08-19T16:00:00.000Z", "content_html": "

施工中

\n", "tags": [] }, { "id": "https://yuukowww.github.io/2025/06/19/math/%E5%B9%B3%E7%A8%B3%E5%BA%8F%E5%88%97/", "url": "https://yuukowww.github.io/2025/06/19/math/%E5%B9%B3%E7%A8%B3%E5%BA%8F%E5%88%97/", "title": "平稳序列", "date_published": "2025-06-19T16:00:00.000Z", "content_html": "

自协方差函数

\n\n

Cov(X,Y)=E([X−μX][Y−μY])=E(XY−XμY−YμX+μXμY)=E(XY)−μYE(X)−μXE(X)+E(X)E(Y)=E(XY)−E(X)E(Y)\\begin{aligned}\n\\mathrm{Cov}(X,Y)&=\\mathbb{E}(\\left[ X-\\mu_X\\right]\\left[ Y-\\mu _Y\\right])\\\\\n&= \\mathbb{E}(XY-X\\mu_Y-Y\\mu_X+\\mu_X\\mu_Y)\\\\\n&= \\mathbb{E}(XY)-\\mu_Y\\mathbb{E}(X)-\\mu_X\\mathbb{E}(X)+\\mathbb{E}(X)\\mathbb{E}(Y)\\\\\n&= \\mathbb{E}(XY)-\\mathbb{E}(X)\\mathbb{E}(Y)\n\\end{aligned}\nCov(X,Y)​=E([X−μX​][Y−μY​])=E(XY−XμY​−YμX​+μX​μY​)=E(XY)−μY​E(X)−μX​E(X)+E(X)E(Y)=E(XY)−E(X)E(Y)​

\n\n

Γn=(γ0γ1⋯γn−1γ1γ0⋯γn−2⋮⋱γn−1γn−2⋯γ0)\\Gamma_n = \n\\begin{pmatrix}\n\\gamma_0&\\gamma_1&\\cdots&\\gamma_{n-1}\\\\\n\t\\gamma_1&\\gamma_0&\\cdots&\\gamma_{n-2}\\\\\n\t\\vdots&&\\ddots&\\\\\n\t\\gamma_{n-1}&\\gamma_{n-2}&\\cdots & \\gamma_0\n\\end{pmatrix}\nΓn​=​γ0​γ1​⋮γn−1​​γ1​γ0​γn−2​​⋯⋯⋱⋯​γn−1​γn−2​γ0​​​

\n

Proof:\\mathrm{Proof:}Proof:

\n

αTΓnα=∑i,jaiajγi−j=∑i,jaiajE([Xi−μ][Xj−μ])=E(∑i,jaiaj(Xi−μ)(Xj−μ))=E(∑iai(Xi−μ)∑jaj(Xj−μ))=E([∑iai(Xi−μ)]2)=D(∑iai(Xi−μ))≥0\\begin{aligned}\n\\alpha^T\\Gamma_n\\alpha&=\\sum_{i,j}a_ia_j\\gamma_{i-j}\\\\\n\t\t&=\\sum_{i,j}a_ia_j\\mathbb{E}(\\left[X_i-\\mu\\right]\\left[X_j-\\mu\\right])\\\\\n\t\t&=\\mathbb{E}\\left(\\sum_{i,j}a_ia_j\\left(X_i-\\mu\\right)(X_j-\\mu)\\right)\\\\\n\t\t&=\\mathbb{E}\\left(\\sum_{i}a_i\\left(X_i-\\mu\\right)\\sum_ja_j(X_j-\\mu)\\right)\\\\\n\t\t&=\\mathbb{E}\\left(\\left[\\sum_ia_i(X_i-\\mu)\\right]^2\\right)\\\\\n\t\t&=\\mathrm{D}\\left(\\sum_{i}a_i(X_i-\\mu)\\right)\\geq 0\n\\end{aligned}\nαTΓn​α​=i,j∑​ai​aj​γi−j​=i,j∑​ai​aj​E([Xi​−μ][Xj​−μ])=E(i,j∑​ai​aj​(Xi​−μ)(Xj​−μ))=E(i∑​ai​(Xi​−μ)j∑​aj​(Xj​−μ))=E​[i∑​ai​(Xi​−μ)]2​=D(i∑​ai​(Xi​−μ))≥0​

\n\n

白噪声

\n\n

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

\n

Xt(T)=12π∫Re−(t+T)22dTXs(T)=12π∫Re−(s+T)22dT\\begin{align*}\nX_t(T)&=\\frac{1}{\\sqrt{2\\pi}}\\int_{\\mathbb{R}}e^{-\\tfrac{(t+T)^2}{2}}\\mathrm{d}T\\\\\nX_s(T)&=\\frac{1}{\\sqrt{2\\pi}}\\int_{\\mathbb{R}}e^{-\\tfrac{(s+T)^2}{2}}\\mathrm{d}T\\\\\n\\end{align*}\nXt​(T)Xs​(T)​=2π​1​∫R​e−2(t+T)2​dT=2π​1​∫R​e−2(s+T)2​dT​

\n

Cov(Xt,Xs)=E(Xt,Xs)=∫RT2πe−(t+T)22−(s+T)22dT=12π∫RT2πe−2T2+2(s+t)T+s2+t22dT=12πe−s2+t22∫RT2πe−T2−(s+t)TdT=12πe−s2+t22+(s+t)24∫RT2πe−(T+s+t2)2dT=1πe−(s−t)24 E(N(−s+t2,12))=−s+t2πe−(s−t)24≠0\\begin{align*}\n\\mathrm{Cov}(X_t,X_s)&=\\mathbb{E}(X_t,X_s)\\\\\n&=\\int_{\\mathbb{R}}\\frac{T}{2\\pi}e^{-\\tfrac{(t+T)^2}{2}-\\tfrac{(s+T)^2}{2}}\\mathrm{d}T\\\\\n&=\\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\\\\\n&=\\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\\\\\n&=\\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\\\\\n&=\\frac{1}{\\sqrt{\\pi}}e^{-\\tfrac{(s-t)^2}{4}}\\,\\mathbb{E}({\\small N(-\\frac{s+t}{2},\\frac{1}{\\sqrt{2}})})\\\\\n&=-\\frac{s+t}{2\\pi}e^{-\\tfrac{(s-t)^2}{4}}\\neq0\n\\end{align*}\nCov(Xt​,Xs​)​=E(Xt​,Xs​)=∫R​2πT​e−2(t+T)2​−2(s+T)2​dT=2π​1​∫R​2π​T​e−22T2+2(s+t)T+s2+t2​dT=2π​1​e−2s2+t2​∫R​2π​T​e−T2−(s+t)TdT=2π​1​e−2s2+t2​+4(s+t)2​∫R​2π​T​e−(T+2s+t​)2dT=π​1​e−4(s−t)2​E(N(−2s+t​,2​1​))=−2πs+t​e−4(s−t)2​=0​

\n

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

\n", "tags": [] }, { "id": "https://yuukowww.github.io/2025/02/18/math/discrete_math/discrete_math/", "url": "https://yuukowww.github.io/2025/02/18/math/discrete_math/discrete_math/", "title": "组合数学", "date_published": "2025-02-18T16:00:00.000Z", "content_html": "

容斥原理

\n
\n

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

\n
\n

Proof:
\n定义 f:S→Nf:S\\to \\mathbb{N}f:S→N f(i)f(i)f(i)为以xi∈Sx_i\\in Sxi​∈S开头的最长递增子列的长度。如果最长子链的长度小于m+1m+1m+1, 则

\n

B=max⁡f(S)={1,2,⋯ ,m}\\mathcal{B} = \\max f(S) = \\left\\{1,2,\\cdots,m\\right\\}\nB=maxf(S)={1,2,⋯,m}

\n

由容斥原理,由于∣S∣>mn|S|> mn∣S∣>mn, ∃b∈B\\exists b\\in \\mathcal{B}∃b∈B, ∣f−1(b)∣≥n+1|f^{-1}(b)|\\geq n+1∣f−1(b)∣≥n+1。选择 a1,⋯ ,an+1∈f−1(b)a_1,\\cdots,a_{n+1}\\in f^{-1}(b)a1​,⋯,an+1​∈f−1(b), 总有i<j,ai>aji< j, a_i > a_ji<j,ai​>aj​ ,否则存在大于mmm的递增列。故这样选出的 {ai}\\{a_i\\}{ai​}是单调减的序列。

\n", "tags": [] } ] }