feat: latex $ -> $$

shen-lan · Nov 27, 2020 · b971fca · b971fca
1 parent c80758e
commit b971fca
Show file tree

Hide file tree

Showing 183 changed files with 630 additions and 629 deletions.
diff --git a/91/binary-search.md b/91/binary-search.md
@@ -54,12 +54,12 @@
 
 **复杂度分析**
 
-- 平均时间复杂度： $O(logN)$
-- 最坏时间复杂度： $O(logN)$
-- 最优时间复杂度： $O(1)$
+- 平均时间复杂度： $$O(logN)$$
+- 最坏时间复杂度： $$O(logN)$$
+- 最优时间复杂度： $$O(1)$$
 - 空间复杂度
-  - 迭代: $O(1)$
-  - 递归： $O(logN)$（无尾调用消除）
+  - 迭代: $$O(1)$$
+  - 递归： $$O(logN)$$（无尾调用消除）
 
 > 后面的复杂度也是类似的，不再赘述。
 
@@ -467,8 +467,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(log N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(log N)$$
+- 空间复杂度：$$O(1)$$
 
 ### 二维数组
 
@@ -553,8 +553,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：最坏的情况是只有一行或者只有一列，此时时间复杂度为 $O(M * N)$。更多的情况下时间复杂度为 $O(M + N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：最坏的情况是只有一行或者只有一列，此时时间复杂度为 $$O(M * N)$$。更多的情况下时间复杂度为 $$O(M + N)$$
+- 空间复杂度：$$O(1)$$
 
 力扣 [240. 搜索二维矩阵 II](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/) 发生了一点变化，不再是`每行的第一个整数大于前一行的最后一个整数`，而是 `每列的元素从上到下升序排列`。我们仍然可以选择左下进行二分。
 
@@ -633,8 +633,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(log N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(log N)$$
+- 空间复杂度：$$O(1)$$
 
 ##### 另一种二分法
 
@@ -712,8 +712,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(log N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(log N)$$
+- 空间复杂度：$$O(1)$$
 
 ### 二叉树
 

diff --git a/daily/2019-08-09.md b/daily/2019-08-09.md
@@ -24,7 +24,7 @@
 我们新建一个额外的dp数组，与原矩阵大小相同。在这个矩阵中,dp(i,j)表示从原点到坐标(i,j)的最小路径和。我们初始化dp值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑从上方移动过来还是从左方移动过来，因此获得最小路径和我们有如下递推公式：`dp(i,j)=grid(i,j)+min(dp(i-1,j),dp(i,j-1))`
 
 
-我们可以使用原地算法，这样就不需要开辟dp数组，空间复杂度可以降低到$O(1)$。
+我们可以使用原地算法，这样就不需要开辟dp数组，空间复杂度可以降低到$$O(1)$$。
 
 ```c++
 class Solution {
@@ -62,8 +62,8 @@ public:
 
 
 **复杂度分析**
-- 时间复杂度：$O(M * N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(M * N)$$
+- 空间复杂度：$$O(1)$$
 ## 其他优秀解答
 
 > 暂缺
diff --git a/problems/1.two-sum.md b/problems/1.two-sum.md
@@ -92,8 +92,8 @@ func twoSum(nums []int, target int) []int {
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：$O(N)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：$$O(N)$$
 
 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode  。 目前已经37K star啦。
 

diff --git a/problems/100.same-tree.md b/problems/100.same-tree.md
@@ -114,8 +114,8 @@ class Solution
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$，其中 N 为树的节点数。
-- 空间复杂度：$O(h)$，其中 h 为树的高度。
+- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。
+- 空间复杂度：$$O(h)$$，其中 h 为树的高度。
 
 ## 层序遍历
 
@@ -174,8 +174,8 @@ function isSameNode(nodeA, nodeB) {
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$，其中 N 为树的节点数。
-- 空间复杂度：$O(Q)$，其中 Q 为队列的长度最大值，在这里不会超过相邻两层的节点数的最大值。
+- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。
+- 空间复杂度：$$O(Q)$$，其中 Q 为队列的长度最大值，在这里不会超过相邻两层的节点数的最大值。
 
 ## 前中序确定一棵树
 
@@ -226,5 +226,5 @@ function inorder(root, arr) {
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$，其中 N 为树的节点数。
-- 空间复杂度：使用了中序遍历的结果数组，因此空间复杂度为 $O(N)$，其中 N 为树的节点数。
+- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。
+- 空间复杂度：使用了中序遍历的结果数组，因此空间复杂度为 $$O(N)$$，其中 N 为树的节点数。
diff --git a/problems/101.symmetric-tree.md b/problems/101.symmetric-tree.md
@@ -191,8 +191,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$，其中 N 为节点数。
-- 空间复杂度：递归的深度最高为节点数，因此空间复杂度是 $O(N)$，其中 N 为节点数。
+- 时间复杂度：$$O(N)$$，其中 N 为节点数。
+- 空间复杂度：递归的深度最高为节点数，因此空间复杂度是 $$O(N)$$，其中 N 为节点数。
 
 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

diff --git a/problems/1011.capacity-to-ship-packages-within-d-days.md b/problems/1011.capacity-to-ship-packages-within-d-days.md
@@ -176,5 +176,5 @@ var shipWithinDays = function(weights, D) {
 
 **复杂度分析**
 
-- 时间复杂度：$O(logN)$
-- 空间复杂度：$O(N)$
+- 时间复杂度：$$O(logN)$$
+- 空间复杂度：$$O(N)$$
diff --git a/problems/1014.best-sightseeing-pair.md b/problems/1014.best-sightseeing-pair.md
@@ -106,8 +106,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：$O(N)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：$$O(N)$$
 
 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

diff --git a/problems/1019.next-greater-node-in-linked-list.md b/problems/1019.next-greater-node-in-linked-list.md
@@ -49,7 +49,7 @@ https://leetcode-cn.com/problems/next-greater-node-in-linked-list/
 
 看完题目就应该想到单调栈才行，LeetCode 上关于单调栈的题目还不少，难度都不小。但是一旦你掌握了这个算法，那么这些题目对你来说都不是问题了。
 
-如果你不用单调栈，那么可以暴力$O(N^2)$的时间复杂度解决，只需要双层循环即可。但是这种做法应该是过不了关的。使用单调栈可以将时间复杂度降低到线性，当然需要额外的$O(N)$的空间复杂度。
+如果你不用单调栈，那么可以暴力$$O(N^2)$$的时间复杂度解决，只需要双层循环即可。但是这种做法应该是过不了关的。使用单调栈可以将时间复杂度降低到线性，当然需要额外的$$O(N)$$的空间复杂度。
 
 顾名思义，单调栈即满足单调性的栈结构。与单调队列相比，其只在一端进行进出。为了描述方便，以下举例及代码以维护一个整数的单调递减栈为例。将一个元素插入单调栈时，为了维护栈的单调性，需要在保证将该元素插入到栈顶后整个栈满足单调性的前提下弹出最少的元素。
 
@@ -107,8 +107,8 @@ class Solution:
 
 其中 N 为链表的长度。
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：$O(N)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：$$O(N)$$
 
 ## 扩展
 

diff --git a/problems/102.binary-tree-level-order-traversal.md b/problems/102.binary-tree-level-order-traversal.md
@@ -195,8 +195,8 @@ class Solution:
 ```
 
 ***复杂度分析***
-- 时间复杂度：$O(N)$，其中N为树中节点总数。
-- 空间复杂度：$O(N)$，其中N为树中节点总数。
+- 时间复杂度：$$O(N)$$，其中N为树中节点总数。
+- 空间复杂度：$$O(N)$$，其中N为树中节点总数。
 
 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode  。 目前已经30K star啦。
 

diff --git a/problems/1020.number-of-enclaves.md b/problems/1020.number-of-enclaves.md
@@ -103,8 +103,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(M * N)$
-- 空间复杂度：$O(M * N)$
+- 时间复杂度：$$O(M * N)$$
+- 空间复杂度：$$O(M * N)$$
 
 ## 解法二 (原地标记法)
 
@@ -114,7 +114,7 @@ class Solution:
 
 ### 思路
 
-上面的解法空间复杂度很差，我们考虑进行优化， 这里我们使用消除法。即使用题目范围外的数据原地标记是否访问， 这样时间复杂度可以优化到 $O(1)$，这是一种非常常见的优化技巧，请务必掌握，另外文章末尾的题目也是类似的技巧，大家可以结合起来练习。
+上面的解法空间复杂度很差，我们考虑进行优化， 这里我们使用消除法。即使用题目范围外的数据原地标记是否访问， 这样时间复杂度可以优化到 $$O(1)$$，这是一种非常常见的优化技巧，请务必掌握，另外文章末尾的题目也是类似的技巧，大家可以结合起来练习。
 
 - 从矩阵边界开始 dfs
 - 如果碰到 1 就将其变成 0
@@ -173,8 +173,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(M * N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(M * N)$$
+- 空间复杂度：$$O(1)$$
 
 ## 参考
 

diff --git a/problems/1023.camelcase-matching.md b/problems/1023.camelcase-matching.md
@@ -139,8 +139,8 @@ class Solution:
 
 其中 N 为 queries 的长度， M 为 queries 的平均长度， P 为 pattern 的长度。
 
-- 时间复杂度：$O(N * M * P)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(N * M * P)$$
+- 空间复杂度：$$O(1)$$
 
 ## 扩展
 

diff --git a/problems/1032.stream-of-characters.md b/problems/1032.stream-of-characters.md
@@ -60,7 +60,7 @@ streamChecker.query("c"); // stream：cba
 
 这里有两个小的点需要注意：
 
-1. 如果用数组来存储， 由于每次都往数组头部插入一个元素，因此每次 query 操作的时间复杂度为 $O(N)$，其中 $N$ 为截止当前执行 query 的次数，我们可以使用双端队列进行优化。
+1. 如果用数组来存储， 由于每次都往数组头部插入一个元素，因此每次 query 操作的时间复杂度为 $$O(N)$$，其中 $N$ 为截止当前执行 query 的次数，我们可以使用双端队列进行优化。
 2. 由于不必 query 形成的查询全部命中。比如 stream 为 cba 的时候，找到单词 c， bc， abc 都是可以的。如果是找到 c，cb，cba 比较好吧，现在是反的。其实我们可以反序插入是，类似的技巧在[211.add-and-search-word-data-structure-design](https://github.com/azl397985856/leetcode/blob/b8e8fa5f0554926efa9039495b25ed7fc158372a/problems/211.add-and-search-word-data-structure-design.md) 也有用到。
 
 之后我们用拼接的单词在 words 中查询即可， 最简单的方式当然是每次 query 都去扫描一次，这种方式毫无疑问会超时。

diff --git a/problems/104.maximum-depth-of-binary-tree.md b/problems/104.maximum-depth-of-binary-tree.md
@@ -295,8 +295,8 @@ class Solution
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：$O(N)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：$$O(N)$$
 
 ## 相关题目
 

diff --git a/problems/108.convert-sorted-array-to-binary-search-tree.md b/problems/108.convert-sorted-array-to-binary-search-tree.md
@@ -88,8 +88,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：每次递归都 copy 了 N 的 空间，因此空间复杂度为 $O(N ^ 2)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：每次递归都 copy 了 N 的 空间，因此空间复杂度为 $$O(N ^ 2)$$
 
 然而，实际上没必要开辟新的空间：
 
@@ -171,8 +171,8 @@ class Solution(object):
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：由于是平衡二叉树，因此隐式调用栈的开销为 $O(logN)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：由于是平衡二叉树，因此隐式调用栈的开销为 $$O(logN)$$
 
 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
 

diff --git a/problems/109.Convert-Sorted-List-to-Binary-Search-Tree.md b/problems/109.Convert-Sorted-List-to-Binary-Search-Tree.md
@@ -88,8 +88,8 @@ class Solution {
 ```
 
 **复杂度分析**
-- 时间复杂度：节点最多只遍历N*logN遍，时间复杂度为$O(NlogN)$
-- 空间复杂度：空间复杂度为$O(1)$
+- 时间复杂度：节点最多只遍历N*logN遍，时间复杂度为$$O(NlogN)$$
+- 空间复杂度：空间复杂度为$$O(1)$$
 
 ### 缓存法
 因为链表访问中点的时间复杂度为O(n),所以可以使用数组将链表的值存储,以空间换时间
@@ -217,6 +217,6 @@ class Solution
 ```
 
 **复杂度分析**
-- 时间复杂度：节点最多只遍历两遍，时间复杂度为$O(N)$
-- 空间复杂度：若使用数组对链表的值进行缓存，空间复杂度为$O(N)$
+- 时间复杂度：节点最多只遍历两遍，时间复杂度为$$O(N)$$
+- 空间复杂度：若使用数组对链表的值进行缓存，空间复杂度为$$O(N)$$
 
diff --git a/problems/11.container-with-most-water.md b/problems/11.container-with-most-water.md
@@ -34,7 +34,7 @@ https://leetcode-cn.com/problems/container-with-most-water/description/
 
 ## 思路
 
-题目中说`找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。` ，因此符合直觉的解法就是固定两个端点，计算可以承载的水量， 然后不断更新最大值，最后返回最大值即可。这种算法，需要两层循环，时间复杂度是 $O(n^2)$。
+题目中说`找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。` ，因此符合直觉的解法就是固定两个端点，计算可以承载的水量， 然后不断更新最大值，最后返回最大值即可。这种算法，需要两层循环，时间复杂度是 $$O(n^2)$$。
 
 代码（JS）:
 
@@ -60,7 +60,7 @@ return max;
 - ...
 - 计算长度为 1 的面积。
 
-很显然这种解法也是完备的，但是似乎时间复杂度还是 $O(n ^ 2)$, 不要着急，我们继续优化。
+很显然这种解法也是完备的，但是似乎时间复杂度还是 $$O(n ^ 2)$$, 不要着急，我们继续优化。
 
 考虑一下，如果我们计算 n-1 长度的面积的时候，是可以直接排除一半的结果的。
 
@@ -149,8 +149,8 @@ class Solution:
 
 **_复杂度分析_**
 
-- 时间复杂度：由于左右指针移动的次数加起来正好是 n， 因此时间复杂度为 $O(N)$。
-- 空间复杂度：$O(1)$。
+- 时间复杂度：由于左右指针移动的次数加起来正好是 n， 因此时间复杂度为 $$O(N)$$。
+- 空间复杂度：$$O(1)$$。
 
 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
 

diff --git a/problems/1104.path-in-zigzag-labelled-binary-tree.md b/problems/1104.path-in-zigzag-labelled-binary-tree.md
@@ -91,8 +91,8 @@ class Solution:
 ```
 
 **复杂度分析**
-- 时间复杂度：由于每次都在头部插入 res，因此时间复杂度为 $O(log_Label)$， 一共插入了 $O(log_Label)$ 次， 因此总的时间复杂度为 $O(logLabel * logLabel)$。
-- 空间复杂度：$O(1)$
+- 时间复杂度：由于每次都在头部插入 res，因此时间复杂度为 $$O(log_Label)$$， 一共插入了 $$O(log_Label)$$ 次， 因此总的时间复杂度为 $$O(logLabel * logLabel)$$。
+- 空间复杂度：$$O(1)$$
 
 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

diff --git a/problems/1131.maximum-of-absolute-value-expression.md b/problems/1131.maximum-of-absolute-value-expression.md
@@ -190,8 +190,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(N^3)$
-- 空间复杂度：$O(N)$
+- 时间复杂度：$$O(N^3)$$
+- 空间复杂度：$$O(N)$$
 
 ## 总结
 

diff --git a/problems/1186.maximum-subarray-sum-with-one-deletion.md b/problems/1186.maximum-subarray-sum-with-one-deletion.md
@@ -150,8 +150,8 @@ class Solution:
 ```
 
 **复杂度分析**
-- 时间复杂度：$O(N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：$$O(1)$$
 
 ## 关键点解析
 

diff --git a/problems/121.best-time-to-buy-and-sell-stock.md b/problems/121.best-time-to-buy-and-sell-stock.md
@@ -143,8 +143,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：$$O(1)$$
 
 ## 相关题目
 

diff --git a/problems/1218.longest-arithmetic-subsequence-of-given-difference.md b/problems/1218.longest-arithmetic-subsequence-of-given-difference.md
@@ -67,8 +67,8 @@ https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-differe
 
 **复杂度分析**
 
-- 时间复杂度：$O(N^2)$
-- 空间复杂度：$O(N)$
+- 时间复杂度：$$O(N^2)$$
+- 空间复杂度：$$O(N)$$
 
 ### 动态规划
 
@@ -113,8 +113,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：$O(N)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：$$O(N)$$
 
 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

diff --git a/problems/122.best-time-to-buy-and-sell-stock-ii.md b/problems/122.best-time-to-buy-and-sell-stock-ii.md
@@ -131,8 +131,8 @@ class Solution {
 
 **复杂度分析**
 
-- 时间复杂度：$O(N)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$$O(N)$$
+- 空间复杂度：$$O(1)$$
 
 ## 相关题目