fix: 数学公式修复

docs/.vitepress/config/shared.ts

@@ -58,6 +58,10 @@ export default defineConfig({
     externalLinkIcon: true,
   },
 
+  markdown: {
+    math: true
+  },
+
   vite: {
     plugins: [
       // ...

docs/en/notes/数据库01/06关系数据理论(重点).md

@@ -74,23 +74,23 @@ X称为决定因素或决定属性集
 
 ### 完全函数依赖
 
-- 在关系模式R（U）中，如果X→Y，并且对于X的任何一个真子集X’，都有 X’→ Y，则称Y完全函数依赖于X，记作$$X\overset{F}{\rightarrow}Y$$
-- 若X→Y，但Y不完全函数依赖于X，则称Y部分函数依赖于X，记作$$X\overset{P}{\rightarrow}Y$$
+- 在关系模式R（U）中，如果X→Y，并且对于X的任何一个真子集X’，都有 X’→ Y，则称Y完全函数依赖于X，记作$X\overset{F}{\rightarrow}Y$
+- 若X→Y，但Y不完全函数依赖于X，则称Y部分函数依赖于X，记作$X\overset{P}{\rightarrow}Y$
 
 【例】如在关系R1（ENO，SaleDate，SaleAmount）中，由于`ENO  !=> SaleAmount，  SaleDate !=> SaleAmount，`
 
-因此$$(ENO, SaleDate)\overset{F}{\rightarrow}SaleAmount$$
+因此$(ENO, SaleDate)\overset{F}{\rightarrow}SaleAmount$
 
 ### 传递函数依赖
 
 •	在关系模式R（U）中，如果X→Y，Y→Z，且Y  ⊈ X，Y→X，递
-则称Z传递函数依赖于X，记作$$X\overset{传递}{\rightarrow}Z$$
+则称Z传递函数依赖于X，记作$X\overset{传递}{\rightarrow}Z$
 
-【例】如在销售关系R（ENO，SaleDate，SaleAmount，Group， GName）中，各属性分别为员工编号，日期，销售量，分组，组长，存在语义每个员工只能属于一个分组，每个分组只有一个组长，由于ENO→Group，Group→GName，则$$ENO\overset{传递}{\rightarrow}GName$$
+【例】如在销售关系R（ENO，SaleDate，SaleAmount，Group， GName）中，各属性分别为员工编号，日期，销售量，分组，组长，存在语义每个员工只能属于一个分组，每个分组只有一个组长，由于ENO→Group，Group→GName，则$ENO\overset{传递}{\rightarrow}GName$
 
 ## 码
 
-设K为R（U，F）中的属性或属性组合。若$$K\overset{F}{\rightarrow}U$$则K为R的**候选码**。若候选码多于一个，则选定其中的一个作为主码。
+设K为R（U，F）中的属性或属性组合。若$K\overset{F}{\rightarrow}U$则K为R的**候选码**。若候选码多于一个，则选定其中的一个作为主码。
 
 说明：
 - 候选码可以唯一地识别关系的元组

docs/en/notes/算法与数据结构/10算法概述.md

@@ -158,36 +158,36 @@ end function
 
 ### 渐进符号
 
-##### 上界$$O$$的定义
+##### 上界$O$的定义
 
-> 如果存在大于0的常数 $$c$$ 和非负整数 $$n_0$$ ，使得 $$\forall n > n_0，t(n) \leqslant cg(n)$$，我们称函
-> 数 $$t(n)$$ 包含在 $$O(g(n))$$ 中，记作 $$t(n)\in O(g(n))$$。
+> 如果存在大于0的常数 $c$ 和非负整数 $n_0$ ，使得 $\forall n > n_0，t(n) \leqslant cg(n)$，我们称函
+> 数 $t(n)$ 包含在 $O(g(n))$ 中，记作 $t(n)\in O(g(n))$。
 
 ![image-20211103170022182](https://oss.justin3go.com/blogs/image-20211103170022182-16359300259821.png)
 
 <img src="https://oss.justin3go.com/blogs/image-20211103193252564.png" alt="image-20211103193252564" style="zoom:67%;" />
 
-##### 下界$$\Omega$$的定义
+##### 下界$\Omega$的定义
 
-> 如果存在大于0的常数c和非负整数$$n_0$$，使得$$\forall n > n_0$$，$$t(n) > cg(n)$$，我们称函数 $$t(n) $$ 包含在 $$\Omega(g(n))$$ 中，记作 $$t(n) \in \Omega(g(n))$$。
+> 如果存在大于0的常数c和非负整数$n_0$，使得$\forall n > n_0$，$t(n) > cg(n)$，我们称函数 $t(n) $ 包含在 $\Omega(g(n))$ 中，记作 $t(n) \in \Omega(g(n))$。
 
 ![image-20211103170131152](https://oss.justin3go.com/blogs/image-20211103170131152-16359300926532.png)
 
 <img src="https://oss.justin3go.com/blogs/image-20211103193233499.png" alt="image-20211103193233499" style="zoom: 67%;" />
 
-##### $$\theta$$的定义
+##### $\theta$的定义
 
-> 若存在大于0的常数$$c1,c2$$和非负整数$$n_0,\forall n > n_0,c_1g(n) \leqslant t(n) \leqslant c_2g(n)$$,我们称函数t(n)包含在 $$\theta(g(n))$$ 中，记作 $$t(n) \in \theta(g(n))$$。
+> 若存在大于0的常数$c1,c2$和非负整数$n_0,\forall n > n_0,c_1g(n) \leqslant t(n) \leqslant c_2g(n)$,我们称函数t(n)包含在 $\theta(g(n))$ 中，记作 $t(n) \in \theta(g(n))$。
 
 ![image-20211103170141063](https://oss.justin3go.com/blogs/image-20211103170141063-16359301029343.png)
 
 <img src="https://oss.justin3go.com/blogs/image-20211103193311881.png" alt="image-20211103193311881" style="zoom:67%;" />
 
 ### 算法的三种效率
 
-- 最差效率$$C_{worst}(n)$$：输入规模为n时，算法在最坏输入下的效率；
-- 最优效率$$C_{best}(n)$$：输入规模为n时，算法在最好输入下的效率；
-- 平均效率$$C_{avg}(n)$$：输入规模为n时，算法在随机输入下的效率；
+- 最差效率$C_{worst}(n)$：输入规模为n时，算法在最坏输入下的效率；
+- 最优效率$C_{best}(n)$：输入规模为n时，算法在最好输入下的效率；
+- 平均效率$C_{avg}(n)$：输入规模为n时，算法在随机输入下的效率；
 
 ### 选择排序算法效率分析
 

docs/en/notes/算法与数据结构/11递归与分治.md

@@ -6,13 +6,13 @@
 
 ## 递归方程求解--替换法
 
-> 如例1：使用 $$W(n-1)= W(n-2)+n-1$$来替换  $$W(n-1)$$ 
+> 如例1：使用 $W(n-1)= W(n-2)+n-1$来替换  $W(n-1)$ 
 
 <img src="https://oss.justin3go.com/blogs/image-20211103210625932-16359448129018.png" alt="image-20211103210625932" style="zoom: 80%;" />
 
 ## 递归方程求解--主定理
 
-> 主定理：设 $$T(n)$$ 是一个非递归函数，并且满足递推式
+> 主定理：设 $T(n)$ 是一个非递归函数，并且满足递推式
 > $$
 > T(n)=\alpha T(n/b)+f(n), 其中n=b^k,k=1,2,......
 > $$
@@ -21,11 +21,11 @@
 > T(1)=c
 > $$
 >
-> 其中 $$a \geqslant 1, b \geqslant  2, c > 0$$如果 $$f(n) \in \theta (n^d), d \geqslant 0$$，那么
+> 其中 $a \geqslant 1, b \geqslant  2, c > 0$如果 $f(n) \in \theta (n^d), d \geqslant 0$，那么
 >
-> - 当 $$a<b^d$$   时，  $$T(n) \in \theta (n^d)$$
-> -  当 $$a=b^d$$   时，  $$T(n) \in \theta (n^dlogn)$$
-> - 当 $$a>b^d$$   时，  $$T(n) \in \theta (n^{log_ba})$$
+> - 当 $a<b^d$   时，  $T(n) \in \theta (n^d)$
+> -  当 $a=b^d$   时，  $T(n) \in \theta (n^dlogn)$
+> - 当 $a>b^d$   时，  $T(n) \in \theta (n^{log_ba})$
 
 
 
@@ -41,7 +41,7 @@ $$
 
 ##### 减常因子算法
 
-> 规模为n的实例化简为一个规模为 $$n/b$$ 的给定实例来求解（折半查找）
+> 规模为n的实例化简为一个规模为 $n/b$ 的给定实例来求解（折半查找）
 
 $$
 T(n)=T(n/b)+f(n)
@@ -153,7 +153,7 @@ def merge_sort(numberlist):
   C(n)=2C(n/2)+C_{merge}(n),C(0)=1,其中n=2^k
   $$
 
-- 最坏情况下,  $$C_{merge}(n)=n-1$$;
+- 最坏情况下,  $C_{merge}(n)=n-1$;
 
 - 最坏情况下效率：
   $$
@@ -164,7 +164,7 @@ def merge_sort(numberlist):
   \end{matrix}\right.
   $$
 
-- 根据主定理可得$$C_{worst}(n)=\theta (nlogn)$$
+- 根据主定理可得$C_{worst}(n)=\theta (nlogn)$
 
 - 合并排序在最坏情况下的比较次数十分接近基于比较的排序算法的理论上能够达到的最少比较次数
 
@@ -237,14 +237,14 @@ def heap_sort(numberlist):
 
 **算法效率分析**
 
-- 第一阶段（构造堆--自底向上）复杂度为$$O(n)$$;
+- 第一阶段（构造堆--自底向上）复杂度为$O(n)$;
 
 - 第二阶段（删除最大键）键值比较次数：
   $$
   C(n) \leq 2log_2(n-1)+2log_2(n-2)+...+2log_21 \leq 2nlog_2n
   $$
 
-- 总的效率为$$O(nlogn)$$（任何情况），且无需额外的存储空间
+- 总的效率为$O(nlogn)$（任何情况），且无需额外的存储空间
 
 - 对于随机的输入，堆排序比快速排序运行的慢
 
@@ -268,12 +268,12 @@ def insert_sort(data):
 
 | 算法     | 最好效率  | 最差效率  | 平均效率  |
 | -------- | --------- | --------- | --------- |
-| 选择排序 | $$n^2$$   | $$n^2$$   | $$n^2$$   |
-| 冒泡排序 | $$n^2$$   | $$n^2$$   | $$n^2$$   |
-| 插入排序 | $$n$$     | $$n^2$$   | $$n^2$$   |
-| 合并排序 | $$nlogn$$ | $$nlogn$$ | $$nlogn$$ |
-| 快速排序 | $$nlogn$$ | $$n^2$$   | $$nlogn$$ |
-| 堆排序   | $$nlogn$$ | $$nlogn$$ | $$nlogn$$ |
+| 选择排序 | $n^2$   | $n^2$   | $n^2$   |
+| 冒泡排序 | $n^2$   | $n^2$   | $n^2$   |
+| 插入排序 | $n$     | $n^2$   | $n^2$   |
+| 合并排序 | $nlogn$ | $nlogn$ | $nlogn$ |
+| 快速排序 | $nlogn$ | $n^2$   | $nlogn$ |
+| 堆排序   | $nlogn$ | $nlogn$ | $nlogn$ |
 
 *前面还有常数*
 
@@ -286,22 +286,22 @@ def insert_sort(data):
 ##### 选最大最小
 
 - 调用顺序比较找最大和最小算法，先找出最大，然后把最大从L中删除，继续找出最小；
-- 比较次数：$$W(n)=n-1+n-2=2n-3$$
+- 比较次数：$W(n)=n-1+n-2=2n-3$
 
 ##### 找第二大
 
 - 调用顺序比较找最大算法，先找出最大，然后把最大从L中删除，继续找出最大；
-- 比较次数：$$W(n)=n-1+n-2=2n-3$$
+- 比较次数：$W(n)=n-1+n-2=2n-3$
 
 ##### 选择第K小-快速选择
 
 分治法求解思路
 
 - 用某个元素m*作为比较标准将S划分成S1与S2；
-- 如果$$k \leq |S1|$$，则在S1中找第k小；
-- 如果$$k = |S1| + 1$$，则在m*是第k小；
-- 如果$$k > |S1| + 1$$，则在S2中找第$$k − |S1| − 1$$小；
-- 如此重复划分过程，直到$$k = |S1| + 1$$；
+- 如果$k \leq |S1|$，则在S1中找第k小；
+- 如果$k = |S1| + 1$，则在m*是第k小；
+- 如果$k > |S1| + 1$，则在S2中找第$k − |S1| − 1$小；
+- 如此重复划分过程，直到$k = |S1| + 1$；
 - 划分方法：Lomuto算法，Hoare划分方法；
 
 实例：寻找9个数的中位数（k=5）

docs/en/notes/算法与数据结构/12动态规划.md

@@ -61,7 +61,7 @@ CoinRow2(test_coin, len(test_coin)-1)
 
 > m种币值，找零金额为n，求最少使用多少枚币
 >
-> 获取n的途径只能是：在总金额为$$n-d_j$$的一堆硬币加入一个面值为$$d_j$$的硬币，其中$$j=1,2,...,m,$$并且$$n \geq d_j$$。因此我们只需考虑所有满足上述要求的$$d_j$$并选择使得$$F(n-d_j)+1$$最小的$$d_j$$即可。由于1是常量，我们显然可以先找出最小的$$F(n-d_j)$$，然后加1即可，公式：
+> 获取n的途径只能是：在总金额为$n-d_j$的一堆硬币加入一个面值为$d_j$的硬币，其中$j=1,2,...,m,$并且$n \geq d_j$。因此我们只需考虑所有满足上述要求的$d_j$并选择使得$F(n-d_j)+1$最小的$d_j$即可。由于1是常量，我们显然可以先找出最小的$F(n-d_j)$，然后加1即可，公式：
 > $$
 > \left \{\begin{matrix}
 > F(n)= \underset{j:n \geq d_j}{min} \{ F(n-d_j) \}+1& n>0\\ 

docs/en/notes/算法与数据结构/13贪心算法.md

@@ -18,11 +18,11 @@
 
 > 基本概念：生成树、最小生成树
 >
-> 算法核心：从连通$$V_T$$和$$V-V_T$$的边中挑选一条权重最小的边。
+> 算法核心：从连通$V_T$和$V-V_T$的边中挑选一条权重最小的边。
 
-- 任意选一点$$v_0$$，集合V被分割成两个集合$$V_T=\{v_0\}$$和$$V-V_T$$；
-- 从连通$$V_T$$和$$V-V_T$$的边中挑选一条权重最小的边$$e^*=(v^*,u^*),v^* \in V_T,u^* \in V-V_T$$，将$$u^*$$加入$$V_T$$中，从$$V - V_T$$删除$$u^*$$;
-- 重复步骤2，直到集合$$V-V_T$$为空；
+- 任意选一点$v_0$，集合V被分割成两个集合$V_T=\{v_0\}$和$V-V_T$；
+- 从连通$V_T$和$V-V_T$的边中挑选一条权重最小的边$e^*=(v^*,u^*),v^* \in V_T,u^* \in V-V_T$，将$u^*$加入$V_T$中，从$V - V_T$删除$u^*$;
+- 重复步骤2，直到集合$V-V_T$为空；
 
 <img src="https://oss.justin3go.com/blogs/image-20211105160655381.png" alt="image-20211105160655381" style="zoom:67%;" />
 
@@ -58,7 +58,7 @@ def prim(graph, init_node):
 
 - 按照权重非递减顺序对途中的边E进行排序；
 - 烧苗已排序的列表，如果下一条边加入当前的子图中不导致一个回路，则加入该边到子图中，否则跳过该边；
-- 重复步骤2，直到子图中有$$|V|-1$$条边；
+- 重复步骤2，直到子图中有$|V|-1$条边；
 
 <img src="https://oss.justin3go.com/blogs/image-20211105161446850.png" alt="image-20211105161446850" style="zoom:67%;" />
 
@@ -112,17 +112,17 @@ def kruskal(graph):
 
 ##### 要点
 
-- 按照权重$$w(e_1) \leq ... \leq w(e_{|E|})$$的非递增顺序对集合E排序；
-- 判断$$find(a)$$是否等于$$find(b)$$，如果不相等，union(a,b);
+- 按照权重$w(e_1) \leq ... \leq w(e_{|E|})$的非递增顺序对集合E排序；
+- 判断$find(a)$是否等于$find(b)$，如果不相等，union(a,b);
 
 ##### 算法效率分析
 
-- 第一步的时间复杂度为$$O(|E|log|E|)$$（快速排序）;
-- 第二步$$find(x)$$和$$union(a, b)$$的复杂度取决于实现方式；
-- 快速查找：$$T(find) \in O(1),T(union) \in O(nlogn)$$（所有合并）;
-- 快速求并：$$T(find) \in O(logn),T(union) \in O(1)$$；
-- 快速查找下总的效率为$$O(|E|log|E|)+O(m+|V|log|V|)$$；
-- 快速求并下总的效率为$$O(|E|log|E| + O(mlog|V|+|V|))$$；
+- 第一步的时间复杂度为$O(|E|log|E|)$（快速排序）;
+- 第二步$find(x)$和$union(a, b)$的复杂度取决于实现方式；
+- 快速查找：$T(find) \in O(1),T(union) \in O(nlogn)$（所有合并）;
+- 快速求并：$T(find) \in O(logn),T(union) \in O(1)$；
+- 快速查找下总的效率为$O(|E|log|E|)+O(m+|V|log|V|)$；
+- 快速求并下总的效率为$O(|E|log|E| + O(mlog|V|+|V|))$；
 
 ### Dijkstra
 

docs/en/notes/算法与数据结构/14回溯与分支界限.md

@@ -57,7 +57,7 @@ TODO
 - 价值上界：对于给定实例中的物品，按照降序对”价值/重量“比排序；
 
 - 依次装入还未装入背包价值最大的物品；
-- 若已经选的物品总价值为$$v$$，重量为$$w$$，后续装入物品后总结之的上界$$ub=背包剩余重量(W-w)*剩下物品最佳单位价值v_{i+1}/w_{i+1}$$；
+- 若已经选的物品总价值为$v$，重量为$w$，后续装入物品后总结之的上界$ub=背包剩余重量(W-w)*剩下物品最佳单位价值v_{i+1}/w_{i+1}$；
 
 <img src="https://oss.justin3go.com/blogs/image-20211106095257591.png" alt="image-20211106095257591" style="zoom:80%;" />
 

docs/en/posts/2023/02/04Vue3相关原理梳理.md

@@ -434,7 +434,7 @@ const oldNodes = [11,12,13,14,15,16,17]
 **2）降低算法复杂度**
 
 值得注意的是：同样这里也是通过遍历这两个数组来填充`newIndexToOldIndexMap`，即暴力解法的算法复杂度为:
-$$O(n^2)$$
+$O(n^2)$
 所以为了优化这里利用了**空间换时间**思想。使用`keyToNewIndexMap`先存储了新节点数组的关键信息：
 
 ```js
@@ -443,7 +443,7 @@ const keyToNewIndexMap = {(14=>0),(11=>1),(12=>2),(16=>3),(13=>4),(15=>5),(18=>6
 ```
 
 之后在遍历旧结点数组时，就可以在`O(1)`的复杂度通过旧结点的key直接获取新结点的位置，而非每次都在内部嵌套循环遍历新结点数组去重新获取对应新节点位置，最终构造`newIndexToOldIndexMap`的算法复杂度降到了
-$$O(n)$$
+$O(n)$
 
 **3）代码实现**
 

docs/en/posts/2023/08/17浅谈搜索引擎原理.md

@@ -156,7 +156,7 @@ PageRank的计算基于以下两个基本假设：
 ![](https://oss.justin3go.com/blogs/%E7%BD%91%E9%A1%B5%E9%93%BE%E6%8E%A5%E5%85%B3%E7%B3%BBpagerank.png)
 
 Pagerank的计算公式如下：
-$$PR(A) = (1-d) + d (PR(T_1)/C(T_1) + ... + PR(T_n)/C(T_n))$$
+$PR(A) = (1-d) + d (PR(T_1)/C(T_1) + ... + PR(T_n)/C(T_n))$
 
 其中：
 

docs/notes/数据库01/06关系数据理论(重点).md

@@ -74,23 +74,23 @@ X称为决定因素或决定属性集
 
 ### 完全函数依赖
 
-- 在关系模式R（U）中，如果X→Y，并且对于X的任何一个真子集X’，都有 X’→ Y，则称Y完全函数依赖于X，记作$$X\overset{F}{\rightarrow}Y$$
-- 若X→Y，但Y不完全函数依赖于X，则称Y部分函数依赖于X，记作$$X\overset{P}{\rightarrow}Y$$
+- 在关系模式R（U）中，如果X→Y，并且对于X的任何一个真子集X’，都有 X’→ Y，则称Y完全函数依赖于X，记作$X\overset{F}{\rightarrow}Y$
+- 若X→Y，但Y不完全函数依赖于X，则称Y部分函数依赖于X，记作$X\overset{P}{\rightarrow}Y$
 
 【例】如在关系R1（ENO，SaleDate，SaleAmount）中，由于`ENO  !=> SaleAmount，  SaleDate !=> SaleAmount，`
 
-因此$$(ENO, SaleDate)\overset{F}{\rightarrow}SaleAmount$$
+因此$(ENO, SaleDate)\overset{F}{\rightarrow}SaleAmount$
 
 ### 传递函数依赖
 
 •	在关系模式R（U）中，如果X→Y，Y→Z，且Y  ⊈ X，Y→X，递
-则称Z传递函数依赖于X，记作$$X\overset{传递}{\rightarrow}Z$$
+则称Z传递函数依赖于X，记作$X\overset{传递}{\rightarrow}Z$
 
-【例】如在销售关系R（ENO，SaleDate，SaleAmount，Group， GName）中，各属性分别为员工编号，日期，销售量，分组，组长，存在语义每个员工只能属于一个分组，每个分组只有一个组长，由于ENO→Group，Group→GName，则$$ENO\overset{传递}{\rightarrow}GName$$
+【例】如在销售关系R（ENO，SaleDate，SaleAmount，Group， GName）中，各属性分别为员工编号，日期，销售量，分组，组长，存在语义每个员工只能属于一个分组，每个分组只有一个组长，由于ENO→Group，Group→GName，则$ENO\overset{传递}{\rightarrow}GName$
 
 ## 码
 
-设K为R（U，F）中的属性或属性组合。若$$K\overset{F}{\rightarrow}U$$则K为R的**候选码**。若候选码多于一个，则选定其中的一个作为主码。
+设K为R（U，F）中的属性或属性组合。若$K\overset{F}{\rightarrow}U$则K为R的**候选码**。若候选码多于一个，则选定其中的一个作为主码。
 
 说明：
 - 候选码可以唯一地识别关系的元组

docs/notes/算法与数据结构/01基础概念.md

@@ -14,7 +14,7 @@ $$
 
 - **逻辑结构**：集合、**线性**结构、树形结构（**非线性**）、图形结构（**非线性**）。
 
-- **关系**：**\<a_i, a_j\>** 或 **（a_i, a_j）** ------前驱或弧尾<=>后续或弧头
+- **关系**：**\<$a_i, a_j$\>** 或 **（$a_i, a_j$）** ------前驱或弧尾<=>后续或弧头
 
 <img src="https://oss.justin3go.com/blogs/image-20210606203456322.png" alt="image-20210606203456322" style="zoom:50%;" />