fix part

OI-wiki · Aug 19, 2019 · d0d4b1d · d0d4b1d
1 parent 5d3151b
commit d0d4b1d
Show file tree

Hide file tree

Showing 32 changed files with 46 additions and 46 deletions.
diff --git a/docs/geometry/2d.md b/docs/geometry/2d.md
@@ -19,7 +19,7 @@
 -   向量（包括向量积）
 -   极坐标与极坐标系
 
-请先阅读 [OI Wiki - 数学 - 杂项](/math/misc.md) 。
+请先阅读 [OI Wiki - 数学 - 杂项](../math/misc.md) 。
 
 ## 图形的记录
 

diff --git a/docs/geometry/index.md b/docs/geometry/index.md
@@ -9,7 +9,7 @@
 
 首先你要有一点数学几何基础
 
-请先阅读 [数学杂项](/math/misc.md) 部分。
+请先阅读 [数学杂项](../math/misc.md) 部分。
 
 ### 以下是你可以在本部分找到的知识（部分未完成，待补充）
 

diff --git a/docs/geometry/scanning.md b/docs/geometry/scanning.md
@@ -33,7 +33,7 @@
 -   如图所示，我们可以把整个矩形分成如图各个颜色不同的小矩形，那么这个小矩形的高就是我们扫过的距离，那么剩下了一个变量，那就是矩形的长一直在变化。
 -   我们的线段树就是为了维护矩形的长，我们给每一个矩形的上下边进行标记，下面的边标记为 1，上面的边标记为 -1，每遇到一个矩形时，我们知道了标记为 1 的边，我们就加进来这一条矩形的长，等到扫描到 -1 时，证明这一条边需要删除，就删去，利用 1 和 -1 可以轻松的到这种状态。
 -   还要注意这里的线段树指的并不是线段的一个端点，而指的是一个区间，所以我们要计算的是 $r+1$ 和 $r-1$ 。
--   需要 [离散化](/misc/discrete.md) 。
+-   需要 [离散化](../misc/discrete.md) 。
 
 ### 代码
 

diff --git a/docs/graph/basic.md b/docs/graph/basic.md
@@ -88,13 +88,13 @@ cycle，也称为 `环` ，是起点和终点相同的路径。
 
 ### 点割集
 
-设图 $G = <V, E>$ ，若存在 $V' \subset V$ 且 $V' \neq \emptyset$ ，使得 $p(G-V') > p(G)$ ，而对于任意的 $V'' \subset V'$ ，均有 $p(G-V'')=p(G)$ ，则称 $V'$ 是 $G$ 的点割集。特别地，若 $V'$ 是 $G$ 的点割集，且 $V'$ 是单元集，即 $V'=\{v\}$ ，则称 $v$ 为 [割点](/graph/bridge.md) 。
+设图 $G = <V, E>$ ，若存在 $V' \subset V$ 且 $V' \neq \emptyset$ ，使得 $p(G-V') > p(G)$ ，而对于任意的 $V'' \subset V'$ ，均有 $p(G-V'')=p(G)$ ，则称 $V'$ 是 $G$ 的点割集。特别地，若 $V'$ 是 $G$ 的点割集，且 $V'$ 是单元集，即 $V'=\{v\}$ ，则称 $v$ 为 [割点](./bridge.md) 。
 
 （ $p(G)$ 表示图 G 的连通分支（连通块）的个数）
 
 ### 边割集
 
-设图 $G = <V, E>$ ，若存在 $E' \subset E$ 且 $E' \neq \emptyset$ ，使得 $ps(G-E') > p(G)$ ，而对于任意的 $E'' \subset E'$ ，均有 $p(G-E'')=p(G)$ ，则称 $E'$ 是 $G$ 的边割集（或简称为割集）。特别地，若 $E'$ 是 $G$ 的边割集，且 $E'$ 是单元集，即 $E'=\{e\}$ ，则称 $e$ 为 [桥](/graph/bridge.md) 。
+设图 $G = <V, E>$ ，若存在 $E' \subset E$ 且 $E' \neq \emptyset$ ，使得 $ps(G-E') > p(G)$ ，而对于任意的 $E'' \subset E'$ ，均有 $p(G-E'')=p(G)$ ，则称 $E'$ 是 $G$ 的边割集（或简称为割集）。特别地，若 $E'$ 是 $G$ 的边割集，且 $E'$ 是单元集，即 $E'=\{e\}$ ，则称 $e$ 为 [桥](./bridge.md) 。
 
 （ $p(G)$ 表示图 G 的连通分支（连通块）的个数）
 

diff --git a/docs/graph/bcc.md b/docs/graph/bcc.md
@@ -1,12 +1,12 @@
 ## 简介
 
-在阅读下列内容之前，请务必了解 [图论基础](/graph/basic.md) 部分。
+在阅读下列内容之前，请务必了解 [图论基础](./basic.md) 部分。
 
-相关阅读： [割点和桥](/graph/bridge.md) 
+相关阅读： [割点和桥](./bridge.md) 
 
 ## 定义
 
-割点和桥更严谨的定义参见 [图论基础](/graph/basic.md) 。
+割点和桥更严谨的定义参见 [图论基础](./basic.md) 。
 
 在一张连通的无向图中，对于两个点 $u$ 和 $v$ ，如果无论删去哪条边（只能删去一条）都不能使它们不连通，我们就说 $u$ 和 $v$  **边双连通** 。
 

diff --git a/docs/graph/bfs.md b/docs/graph/bfs.md
@@ -226,7 +226,7 @@ int main() {
 
 ## 优先队列 BFS
 
-优先队列，相当于一个二叉堆，STL 中提供了 [ `std::priority_queue` ](/ds/stl/priority_queue.md) ，可以方便我们使用优先队列。
+优先队列，相当于一个二叉堆，STL 中提供了 [ `std::priority_queue` ](../ds/stl/priority_queue.md) ，可以方便我们使用优先队列。
 
 在基于优先队列的 BFS 中，我们每次从队首取出代价最小的结点进行进一步搜索。容易证明这个贪心思想是正确的，因为从这个结点开始扩展的搜索，一定不会更新原来那些代价更高的结点。换句话说，其余那些代价更高的结点，我们不回去考虑更新它。
 

diff --git a/docs/graph/bridge.md b/docs/graph/bridge.md
@@ -1,6 +1,6 @@
-相关阅读： [双连通分量](/graph/bcc.md) ，
+相关阅读： [双连通分量](./bcc.md) ，
 
-割点和桥更严谨的定义参见 [图论基础](/graph/basic#_19) 。
+割点和桥更严谨的定义参见 [图论基础](./basic.md) 。
 
 ## 割点
 

diff --git a/docs/graph/flow/max-flow.md b/docs/graph/flow/max-flow.md
@@ -1,4 +1,4 @@
-网络流基本概念参见 [网络流简介](https://oi-wiki.org/graph/flow.md) 
+网络流基本概念参见 [网络流简介](../flow.md) 
 
 ## 概述
 

diff --git a/docs/graph/flow/min-cost.md b/docs/graph/flow/min-cost.md
@@ -1,4 +1,4 @@
-在看这篇文章前请先看 [网络流简介](https://oi-wiki.org/graph/flow.md) 这篇 wiki 的定义部分
+在看这篇文章前请先看 [网络流简介](../flow.md) 这篇 wiki 的定义部分
 
 ## 费用流
 

diff --git a/docs/graph/flow/node.md b/docs/graph/flow/node.md
@@ -1,4 +1,4 @@
-拆点是一种 ** [网络流](/graph/flow.md) ** 建模思想，用来处理 **点权或者点的流量限制** 的问题。这种思路同样可以用于其他的图论算法中（比较经典的有 **分层图** ）
+拆点是一种 ** [网络流](../flow.md) ** 建模思想，用来处理 **点权或者点的流量限制** 的问题。这种思路同样可以用于其他的图论算法中（比较经典的有 **分层图** ）
 
 ## 例题 经典问题 结点有流量限制的最大流
 

diff --git a/docs/graph/index.md b/docs/graph/index.md
@@ -76,7 +76,7 @@
 
 ## 特殊的图
 
-树：边数比结点数少一的连通图。更多内容，详见 [树相关基础](/graph/tree-basic.md) 。
+树：边数比结点数少一的连通图。更多内容，详见 [树相关基础](./tree-basic.md) 。
 
 森林：由 $m$ 棵（ $m\ge 0$ ）互不相交的树组成的图。
 

diff --git a/docs/graph/mst.md b/docs/graph/mst.md
@@ -16,7 +16,7 @@
 
 ### 前置知识
 
- [并查集](/ds/dsu.md) 、 [贪心](/basic/greedy.md) 、 [图的存储](/graph/basic.md) 。
+ [并查集](../ds/dsu.md) 、 [贪心](../basic/greedy.md) 、 [图的存储](./basic.md) 。
 
 ### 证明
 

diff --git a/docs/intro/spj.md b/docs/intro/spj.md
@@ -9,7 +9,7 @@
 
 ## Testlib
 
-Testlib 的介绍见 [Testlib/简介](/intro/testlib/index.md) 页面，用法见 [Testlib/Checker](/intro/testlib/checker.md) 页面。
+Testlib 的介绍见 [Testlib/简介](./testlib/index.md) 页面，用法见 [Testlib/Checker](./testlib/checker.md) 页面。
 
 必须使用 Testlib 做 spj 的 评测工具/OJ：Codeforces、洛谷、UOJ 等
 

diff --git a/docs/intro/testlib/index.md b/docs/intro/testlib/index.md
@@ -7,7 +7,7 @@ Testlib 的具体用途：
 -   编写 [Generator](./generator.md) ，即数据生成器。
 -   编写 [Validator](./validator.md) ，即数据校验器，判断生成数据是否符合题目要求，如数据范围、格式等。
 -   编写 [Interactor](./interactor.md) ，即交互器，用于交互题。
--   编写 [Checker](./checker.md) ，即 [Special Judge](/intro/spj.md) 。
+-   编写 [Checker](./checker.md) ，即 [Special Judge](../spj.md) 。
 
 Testlib 与 Codeforces 开发的 [Polygon](https://polygon.codeforces.com/) 出题平台完全兼容。
 

diff --git a/docs/lang/csl/bitset.md b/docs/lang/csl/bitset.md
@@ -122,7 +122,7 @@ bitset<1000> bs;  // a bitset with 1000 bits
 
 现在的问题是，如何通过一个可重集的约数构成的可重集得到该可重集中某个数的个数。
 
-令原可重集为 $A$ ，其约数构成的可重集为 $A'$ ，我们要求 $A$ 中 $x$ 的个数，用 [莫比乌斯反演](/math/mobius.md) 推一推：
+令原可重集为 $A$ ，其约数构成的可重集为 $A'$ ，我们要求 $A$ 中 $x$ 的个数，用 [莫比乌斯反演](../../math/mobius.md) 推一推：
 
 $$
 \begin{aligned}&\sum\limits_{i\in A}[\frac i x=1]\\=&\sum\limits_{i\in A}\sum\limits_{d|\frac i x}\mu(d)\\=&\sum\limits_{d\in A',x|d}\mu(\frac d x)\end{aligned}
@@ -215,7 +215,7 @@ $$
 
 ### 与树分块结合
 
- `bitset` 与树分块结合可以解决一类求树上多条路径信息并的问题，详见 [数据结构/树分块](/ds/tree-decompose.md) 。
+ `bitset` 与树分块结合可以解决一类求树上多条路径信息并的问题，详见 [数据结构/树分块](../../ds/tree-decompose.md) 。
 
 ### 计算高维偏序
 

diff --git a/docs/math/bezouts.md b/docs/math/bezouts.md
@@ -67,4 +67,4 @@
 
 由于：互质即为最大公因数为 $1$ ， $\gcd(0,x)=x$ 这两个定理，可以证明该算法的正确。选择优先队列优化 Dijkstra 求解。
 
-不过还有个问题，即为需要记录是否已经买过一个卡片，开数组标记由于数据范围达到 $10^9$ 会超出内存限制，可以想到使用 `unordered_map` （比普通的 `map` 更快地访问各个元素，迭代效率较低，详见 [STL-map](/ds/stl/map.md) ）
+不过还有个问题，即为需要记录是否已经买过一个卡片，开数组标记由于数据范围达到 $10^9$ 会超出内存限制，可以想到使用 `unordered_map` （比普通的 `map` 更快地访问各个元素，迭代效率较低，详见 [STL-map](../ds/stl/map.md) ）
diff --git a/docs/math/bsgs.md b/docs/math/bsgs.md
@@ -26,7 +26,7 @@ $$
 
 其中 $p$ 是个质数。
 
-该模型可以通过一系列的转化为成 **基础篇** 中的模型，你可能需要了解关于 [阶与原根](/math/primitive-root.md) 的知识。
+该模型可以通过一系列的转化为成 **基础篇** 中的模型，你可能需要了解关于 [阶与原根](./primitive-root.md) 的知识。
 
 由于式子中的模数 $p$ 是一个质数，那么 $p$ 一定存在一个原根 $g$ 。因此对于模 $p$ 意义下的任意的数 $x\ (0\le x<p)$ 有且仅有一个数 $i\ (0\le i<p-1)$ 满足 $x = g^i$ 。
 

diff --git a/docs/math/complex.md b/docs/math/complex.md
@@ -1,6 +1,6 @@
 如果您已经学习过复数相关知识，请跳过本页面。
 
-学习复数知识需要一部分向量基础，如果并未学习过向量知识请移步 [数学 - 杂项](/math/misc.md) 。
+学习复数知识需要一部分向量基础，如果并未学习过向量知识请移步 [数学 - 杂项](./misc.md) 。
 
 ## 复数的引入，定义和分类
 

diff --git a/docs/math/crt.md b/docs/math/crt.md
@@ -32,7 +32,7 @@ $$
 1.  计算所有模数的积 $n$ ；
 2.  对于第 $i$ 个方程：
  1.  计算 $m_i=\frac{n}{n_i}$ ；
- 2.  计算 $m_i$ 在模 $n_i$ 意义下的 [逆元](/math/inverse.md)  $m_i^{-1}$ ；
+ 2.  计算 $m_i$ 在模 $n_i$ 意义下的 [逆元](./inverse.md)  $m_i^{-1}$ ；
  3.  计算 $c_i=m_im_i^{-1}$ （ **不要对 $n_i$ 取模** ）。
 3.  方程组的唯一解为： $a=\sum_{i=1}^k a_ic_i \pmod n$ 。
 

diff --git a/docs/math/dictionary.md b/docs/math/dictionary.md
@@ -1,4 +1,4 @@
-在学习之前请先学习 [分块](/ds/square-root-decomposition.md) 。
+在学习之前请先学习 [分块](../ds/square-root-decomposition.md) 。
 
 打表大家都知道，就是在比赛时把答案都输出出来，然后开个数组，把答案直接存入数组里。于是你的代码时间复杂度就是 $O(1)$ 的了。
 

diff --git a/docs/math/euler.md b/docs/math/euler.md
@@ -18,7 +18,7 @@
 
 -    $n = \sum_{d | n}{\varphi(d)}$ 
 
- 利用 [莫比乌斯反演](/math/mobius.md) 相关知识可以得出。
+ 利用 [莫比乌斯反演](./mobius.md) 相关知识可以得出。
 
  也可以这样考虑：如果 $\gcd(k, n) = d$ ，那么 $\gcd(\frac{k}{d},\frac{n}{d}) = 1$ 。（ $k < n$ ）
 
@@ -70,4 +70,4 @@ a^{b\bmod\varphi(p)+\varphi(p)},&\gcd(a,\,p)\ne1,\,b\ge\varphi(p)
 \pmod p
 $$
 
-证明和 **习题** 详见 [欧拉定理](/math/fermat.md) 
+证明和 **习题** 详见 [欧拉定理](./fermat.md) 
diff --git a/docs/math/fermat.md b/docs/math/fermat.md
@@ -6,7 +6,7 @@
 
 ## 欧拉定理
 
-在了解欧拉定理（Euler's theorem）之前，请先了解 [欧拉函数](/math/euler.md) 。定理内容如下：
+在了解欧拉定理（Euler's theorem）之前，请先了解 [欧拉函数](./euler.md) 。定理内容如下：
 
 若 $\gcd(a, m) = 1$ ，则 $a^{\varphi(m)} \equiv 1 \pmod{m}$ 。
 

diff --git a/docs/math/gauss.md b/docs/math/gauss.md
@@ -255,7 +255,7 @@ $$
 
 一个无向图的生成树个数为邻接矩阵度数矩阵去一行一列的行列式。
 
-详见： [矩阵树定理](/graph/matrix-tree.md) 
+详见： [矩阵树定理](../graph/matrix-tree.md) 
 
 例如，一个正方形图的生成树个数
 

diff --git a/docs/math/inverse.md b/docs/math/inverse.md
@@ -19,11 +19,11 @@ void exgcd(int a, int b, int& x, int& y) {
 }
 ```
 
-扩展欧几里得法和求解 [线性同余方程](/math/linear-equation.md) 是一个原理，在这里不展开解释。
+扩展欧几里得法和求解 [线性同余方程](./linear-equation.md) 是一个原理，在这里不展开解释。
 
 ### 快速幂法
 
-这个要运用 [费马小定理](/math/fermat/) ：
+这个要运用 [费马小定理](./fermat.md) ：
 
 > 若 $p$ 为质数， $a$ 为正整数，且 $a$ 、 $p$ 互质，则 $a^{p-1} \equiv 1 \pmod p$ 。
 

diff --git a/docs/math/lucas.md b/docs/math/lucas.md
@@ -1,6 +1,6 @@
 ## Lucas 定理
 
-Lucas 定理用于求解大组合数取模的问题，其中 p 必须为素数。正常的组合数运算可以通过递推公式求解（详见 [排列组合](/math/combination.md) ），但当问题规模很大，而模数是一个不大的质数的时候，就不能简单地通过递推求解来得到答案，需要用到 Lucas 定理。
+Lucas 定理用于求解大组合数取模的问题，其中 p 必须为素数。正常的组合数运算可以通过递推公式求解（详见 [排列组合](./combination.md) ），但当问题规模很大，而模数是一个不大的质数的时候，就不能简单地通过递推求解来得到答案，需要用到 Lucas 定理。
 
 ### 求解方式
 

diff --git a/docs/math/matrix.md b/docs/math/matrix.md
@@ -12,7 +12,7 @@
 
  $A$ 的逆矩阵 $P$ 是使得 $A \times P = I$ 的矩阵。
 
-逆矩阵可以用 [高斯消元](/math/gauss.md) 的方式来求。
+逆矩阵可以用 [高斯消元](./gauss.md) 的方式来求。
 
 ## 运算
 
@@ -34,7 +34,7 @@ $$
 
 矩阵乘法满足结合律，不满足一般的交换律。
 
-利用结合律，矩阵乘法可以利用 [快速幂](/math/quick-pow.md) 的思想来优化。
+利用结合律，矩阵乘法可以利用 [快速幂](./quick-pow.md) 的思想来优化。
 
 在比赛中，由于线性递推式可以表示成矩阵乘法的形式，也通常用矩阵快速幂来求线性递推数列的某一项。
 

diff --git a/docs/math/quick-pow.md b/docs/math/quick-pow.md
@@ -111,7 +111,7 @@ long long binpow(long long a, long long b, long long m) {
 ???+note "问题描述"
     计算斐波那契数列第 $n$ 项 $F_n$ 。
 
-根据斐波那契数列的递推式 $F_n = F_{n-1} + F_{n-2}$ ，我们可以构建一个 $2\times 2$ 的矩阵来表示从 $F_i,F_{i+1}$ 到 $F_{i+1},F_{i+2}$ 的变换。于是在计算这个矩阵的 $n$ 次幂的时侯，我们使用快速幂的思想，可以在 $\Theta(\log n)$ 的时间内计算出结果。对于更多的细节参见 [斐波那契数列](/math/fibonacci.md) 。
+根据斐波那契数列的递推式 $F_n = F_{n-1} + F_{n-2}$ ，我们可以构建一个 $2\times 2$ 的矩阵来表示从 $F_i,F_{i+1}$ 到 $F_{i+1},F_{i+2}$ 的变换。于是在计算这个矩阵的 $n$ 次幂的时侯，我们使用快速幂的思想，可以在 $\Theta(\log n)$ 的时间内计算出结果。对于更多的细节参见 [斐波那契数列](./fibonacci.md) 。
 
 ### 多次置换
 
@@ -206,7 +206,7 @@ $$
 ???+note "问题描述"
     给一个有向图（边权为 1），求任意两点 $u,v$ 间从 $u$ 到 $v$ ，长度为 $k$ 的路径的条数。
 
-我们把该图的邻接矩阵 M 取 k 次幂，那么 $M_{i,j}$ 就表示从 $i$ 到 $j$ 长度为 $k$ 的路径的数目。该算法的复杂度是 $O(n^3 \log_2 k)$ 。有关该算法的细节请参见 [矩阵](/math/matrix.md) 页面。
+我们把该图的邻接矩阵 M 取 k 次幂，那么 $M_{i,j}$ 就表示从 $i$ 到 $j$ 长度为 $k$ 的路径的数目。该算法的复杂度是 $O(n^3 \log_2 k)$ 。有关该算法的细节请参见 [矩阵](./matrix.md) 页面。
 
 ### 模意义下大整数乘法
 
@@ -227,7 +227,7 @@ $$
 ### 高精度快速幂
 
 ??? note "前置技能"
-    请先学习 [高精度](/math/bignum.md) 
+    请先学习 [高精度](./bignum.md) 
 
 ???+note " 例题【NOIP2003 普及组改编·麦森数】（[原题在此](https://www.luogu.org/problemnew/show/P1045)）"
     题目大意：从文件中输入 P（1000&lt;P&lt;3100000），计算 $2^P−1$ 的最后 100 位数字（用十进制高精度数表示），不足 100 位时高位补 0。

diff --git a/docs/misc/expression.md b/docs/misc/expression.md
@@ -18,7 +18,7 @@ author: Ir1d, Anguei, hsfzLZH1, siger-young, HeRaNO
 
 ## 非递归
 
-非递归的方法是定义两个 [栈](/ds/stack.md) 来分别存储运算符和运算数。每当遇到一个数直接放进数的栈；每当遇到一个操作符时，要查找之前运算符栈中的元素，按照预先定义好的优先级来进行适当的弹出操作（弹出的同时求出对应的子表达式的值）。
+非递归的方法是定义两个 [栈](../ds/stack.md) 来分别存储运算符和运算数。每当遇到一个数直接放进数的栈；每当遇到一个操作符时，要查找之前运算符栈中的元素，按照预先定义好的优先级来进行适当的弹出操作（弹出的同时求出对应的子表达式的值）。
 
 我们要知道：算术表达式分为三种，分别是前缀表达式、中缀表达式、后缀表达式。其中，中缀表达式是我们日常生活中最常用的表达式；后缀表达式是计算机最容易理解的表达式。为什么说后缀表达式最容易被计算机理解呢？因为后缀表达式不需要括号表示，它的运算顺序是唯一确定的。举个例子：在后缀表达式 $3 2 * 1 -$ 中，首先计算 $3 \times 2 = 6$ （使用最后一个运算符，即栈顶运算符），然后计算 $6 - 1 = 5$ 。可以看到：对于一个后缀表达式，只需要 **维护一个数字栈，每次遇到一个运算符，就取出两个栈顶元素，将运算结果重新压入栈中** 。最后，栈中唯一一个元素就是改后缀表达式的运算结果时间复杂度 $O(n)$ 。
 

diff --git a/docs/misc/hill-climbing.md b/docs/misc/hill-climbing.md
@@ -138,4 +138,4 @@
 
 ## 劣势
 
-其实爬山算法的劣势上文已经提及：它容易陷入一个局部最优解。当目标函数不是单峰函数时，这个劣势是致命的。因此我们要引进 [ **模拟退火** ](/misc/simulated-annealing.md) 。
+其实爬山算法的劣势上文已经提及：它容易陷入一个局部最优解。当目标函数不是单峰函数时，这个劣势是致命的。因此我们要引进 [ **模拟退火** ](./simulated-annealing.md) 。
diff --git a/docs/misc/simulated-annealing.md b/docs/misc/simulated-annealing.md
@@ -6,7 +6,7 @@
 
 ## 实现
 
-根据 [爬山算法](/misc/hill-climbing.md) 的过程，我们发现：对于一个当前最优解附近的非最优解，爬山算法直接舍去了这个解。而很多情况下，我们需要去接受这个非最优解从而跳出这个局部最优解，即为模拟退火算法。
+根据 [爬山算法](./hill-climbing.md) 的过程，我们发现：对于一个当前最优解附近的非最优解，爬山算法直接舍去了这个解。而很多情况下，我们需要去接受这个非最优解从而跳出这个局部最优解，即为模拟退火算法。
 
 >  **什么是退火？** （选自百度百科）
 >

diff --git a/docs/search/index.md b/docs/search/index.md
@@ -2,25 +2,25 @@
 
 ## 深度优先搜索 (DFS)
 
-主条目： [DFS（搜索）](/search/dfs.md) 
+主条目： [DFS（搜索）](./dfs.md) 
 
 ## 宽度优先搜索 (BFS)
 
-主条目： [BFS（搜索）](/search/bfs.md) 
+主条目： [BFS（搜索）](./bfs.md) 
 
 ### 双向宽度优先搜索
 
-主条目： [双向广搜](/search/dbfs.md) 
+主条目： [双向广搜](./dbfs.md) 
 
 从状态图上起点和终点同时开始进行宽度优先搜索，如果发现相遇了，那么可以认为是获得了可行解。
 
 ## A\*搜索
 
-主条目： [A\*](/search/astar.md) 
+主条目： [A\*](./astar.md) 
 
 ## IDA\*搜索
 
-主条目： [IDA\*](/search/idastar.md) 
+主条目： [IDA\*](./idastar.md) 
 
 ## 剪枝
 

diff --git a/docs/search/opt.md b/docs/search/opt.md
@@ -29,7 +29,7 @@ void dfs(传入数值) {
 
 ### 记忆化搜索
 
-因为在搜索中，相同的传入值往往会带来相同的解，那我们就可以用数组来记忆，详见 [记忆化搜索](/dp/memo.md) 。
+因为在搜索中，相同的传入值往往会带来相同的解，那我们就可以用数组来记忆，详见 [记忆化搜索](../dp/memo.md) 。
 
  **模板：**