fix: $$ -> $

shen-lan · Feb 8, 2021 · 6044e75 · 6044e75
1 parent 6797afd
commit 6044e75
Show file tree

Hide file tree

Showing 191 changed files with 1,446 additions and 1,472 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)$（无尾调用消除）
 
 > 后面的复杂度也是类似的，不再赘述。
 
@@ -621,8 +621,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$$O(log N)$$
-- 空间复杂度：$$O(1)$$
+- 时间复杂度：$O(log N)$
+- 空间复杂度：$O(1)$
 
 ##### 扩展
 
@@ -745,8 +745,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/) 发生了一点变化，不再是`每行的第一个整数大于前一行的最后一个整数`，而是 `每列的元素从上到下升序排列`。我们仍然可以选择左下进行二分。
 
@@ -825,8 +825,8 @@ class Solution:
 
 **复杂度分析**
 
-- 时间复杂度：$$O(log N)$$
-- 空间复杂度：$$O(1)$$
+- 时间复杂度：$O(log N)$
+- 空间复杂度：$O(1)$
 
 ##### 另一种二分法
 
@@ -904,8 +904,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
@@ -1,14 +1,18 @@
-# 毎日一题 -  64.最小路径和
+# 毎日一题 - 64.最小路径和
 
 ## 信息卡片
 
-* 时间：2019-08-09
-* 题目链接：https://leetcode-cn.com/problems/minimum-path-sum/
-- tag：`动态规划` `Array`
+- 时间：2019-08-09
+- 题目链接：https://leetcode-cn.com/problems/minimum-path-sum/
+
+* tag：`动态规划` `Array`
+
 ## 题目描述
-给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
+
+给定一个包含非负整数的  m x n  网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
 **说明**：每次只能向下或者向右移动一步。
 **示例:**
+
 ```
 输入:
 [
@@ -19,12 +23,12 @@
 输出: 7
 解释: 因为路径 1→3→1→1→1 的总和最小。
 ```
-## 参考答案
 
-我们新建一个额外的dp数组，与原矩阵大小相同。在这个矩阵中,dp(i,j)表示从原点到坐标(i,j)的最小路径和。我们初始化dp值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑从上方移动过来还是从左方移动过来，因此获得最小路径和我们有如下递推公式：`dp(i,j)=grid(i,j)+min(dp(i-1,j),dp(i,j-1))`
+## 参考答案
 
+我们新建一个额外的 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 {
@@ -46,7 +50,7 @@ public:
         {
             grid[i][0] += grid[i-1][0];
         }
-        
+
         for(int i=1;i<n;i++)
         {
             for(int j=1;j<m;j++)
@@ -60,10 +64,11 @@ 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
@@ -109,8 +109,8 @@ public:
 
 **复杂度分析**
 
-- 时间复杂度：$$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
@@ -136,8 +136,8 @@ public:
 
 **复杂度分析**
 
-- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。
-- 空间复杂度：$$O(h)$$，其中 h 为树的高度。
+- 时间复杂度：$O(N)$，其中 N 为树的节点数。
+- 空间复杂度：$O(h)$，其中 h 为树的高度。
 
 ## 层序遍历
 
@@ -196,8 +196,8 @@ function isSameNode(nodeA, nodeB) {
 
 **复杂度分析**
 
-- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。
-- 空间复杂度：$$O(Q)$$，其中 Q 为队列的长度最大值，在这里不会超过相邻两层的节点数的最大值。
+- 时间复杂度：$O(N)$，其中 N 为树的节点数。
+- 空间复杂度：$O(Q)$，其中 Q 为队列的长度最大值，在这里不会超过相邻两层的节点数的最大值。
 
 ## 前中序确定一棵树
 
@@ -248,5 +248,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
@@ -98,9 +98,11 @@ return True
 > 其实更像本题一点的话应该是从中间分别向两边扩展 😂
 
 ## 代码
+
 代码支持：C++, Java, Python3
 
 C++ Code:
+
 ```c++
 /**
  * Definition for a binary tree node.
@@ -123,7 +125,7 @@ public:
         {
             return true;
         }
-        // 只存在一个子节点 或者左右不相等 
+        // 只存在一个子节点 或者左右不相等
         if(l==NULL || r==NULL || l->val != r->val)
         {
             return false;
@@ -134,8 +136,8 @@ public:
 };
 ```
 
-
 Java Code:
+
 ```java
 /**
  * Definition for a binary tree node.
@@ -164,7 +166,7 @@ class Solution {
         {
             return true;
         }
-        // 只存在一个子节点 或者左右不相等 
+        // 只存在一个子节点 或者左右不相等
         if(l==null || r==null || l.val != r.val)
         {
             return false;
@@ -176,6 +178,7 @@ class Solution {
 ```
 
 Python3 Code:
+
 ```py
 
 class Solution:
@@ -191,8 +194,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
@@ -138,43 +138,43 @@ js Code:
  * @param {number} D
  * @return {number}
  */
-var shipWithinDays = function(weights, D) {
-  let high = weights.reduce((acc, cur) => acc + cur)
-  let low = 0
+var shipWithinDays = function (weights, D) {
+  let high = weights.reduce((acc, cur) => acc + cur);
+  let low = 0;
 
-  while(low < high) {
-    let mid = Math.floor((high + low) / 2)
+  while (low < high) {
+    let mid = Math.floor((high + low) / 2);
     if (canShip(mid)) {
-      high = mid
+      high = mid;
     } else {
-      low = mid + 1
+      low = mid + 1;
     }
   }
 
-  return low
+  return low;
 
   function canShip(opacity) {
-    let remain = opacity
-    let count = 1
+    let remain = opacity;
+    let count = 1;
     for (let weight of weights) {
       if (weight > opacity) {
-        return false
+        return false;
       }
-      remain -= weight
+      remain -= weight;
       if (remain < 0) {
-        count++
-        remain = opacity - weight
+        count++;
+        remain = opacity - weight;
       }
       if (count > D) {
-        return false
+        return false;
       }
     }
-    return count <= D
+    return count <= 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,12 +107,12 @@ class Solution:
 
 其中 N 为链表的长度。
 
-- 时间复杂度：$$O(N)$$
-- 空间复杂度：$$O(N)$$
+- 时间复杂度：$O(N)$
+- 空间复杂度：$O(N)$
 
 ## 扩展
 
-甚至可以做到 O(1)的空间复杂度，请参考[C# O(n) time O(1) space](https://leetcode.com/problems/next-greater-node-in-linked-list/discuss/267090/C-O(n)-time-O(1)-space)
+甚至可以做到 O(1)的空间复杂度，请参考[C# O(n) time O(1) space](<https://leetcode.com/problems/next-greater-node-in-linked-list/discuss/267090/C-O(n)-time-O(1)-space>)
 
 ## 相关题目