remote $

Author: youngyangyang04

problems/0005.最长回文子串.md

@@ -38,7 +38,7 @@
 
 两层for循环，遍历区间起始位置和终止位置，然后判断这个区间是不是回文。
 
-时间复杂度：$O(n^3)$
+时间复杂度：O(n^3)
 
 ## 动态规划
 
@@ -205,8 +205,8 @@ public:
 
 ```
 
-* 时间复杂度：$O(n^2)$
-* 空间复杂度：$O(n^2)$
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(n^2)
 
 ## 双指针
 
@@ -253,8 +253,8 @@ public:
 
 ```
 
-* 时间复杂度：$O(n^2)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(1)
 
 
 

problems/0027.移除元素.md

@@ -11,7 +11,7 @@
 
 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
 
-不要使用额外的数组空间，你必须仅使用 $O(1)$ 额外空间并**原地**修改输入数组。
+不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并**原地**修改输入数组。
 
 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
 
@@ -42,7 +42,7 @@
 
 ![27.移除元素-暴力解法](https://tva1.sinaimg.cn/large/008eGmZEly1gntrc7x9tjg30du09m1ky.gif)
 
-很明显暴力解法的时间复杂度是$O(n^2)$，这道题目暴力解法在leetcode上是可以过的。
+很明显暴力解法的时间复杂度是O(n^2)，这道题目暴力解法在leetcode上是可以过的。
 
 代码如下：
 
@@ -68,8 +68,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n^2)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(1)
 
 ### 双指针法
 
@@ -101,16 +101,16 @@ public:
 ```
 注意这些实现方法并没有改变元素的相对位置！
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 旧文链接：[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)
 
 ```CPP
 /**
 * 相向双指针方法，基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 */
 class Solution {
 public:

problems/0028.实现strStr.md

@@ -229,9 +229,9 @@ next数组就可以是前缀表，但是很多实现都是把前缀表统一减
 
 # 时间复杂度分析
 
-其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是$O(n)$，之前还要单独生成next数组，时间复杂度是$O(m)$。所以整个KMP算法的时间复杂度是$O(n+m)$的。
+其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
 
-暴力的解法显而易见是$O(n × m)$，所以**KMP在字符串匹配中极大的提高的搜索的效率。**
+暴力的解法显而易见是O(n × m)，所以**KMP在字符串匹配中极大的提高的搜索的效率。**
 
 为了和力扣题目28.实现strStr保持一致，方便大家理解，以下文章统称haystack为文本串, needle为模式串。
 

problems/0042.接雨水.md

@@ -129,8 +129,8 @@ public:
 };
 ```
 
-因为每次遍历列的时候，还要向两边寻找最高的列，所以时间复杂度为$O(n^2)$。
-空间复杂度为$O(1)$。
+因为每次遍历列的时候，还要向两边寻找最高的列，所以时间复杂度为O(n^2)。
+空间复杂度为O(1)。
 
 
 
@@ -779,8 +779,8 @@ int trap(int* height, int heightSize) {
 }
 ```
 
-* 时间复杂度 $O(n)$
-* 空间复杂度 $O(1)$
+* 时间复杂度 O(n)
+* 空间复杂度 O(1)
 
 
 -----------------------

problems/0053.最大子序和.md

@@ -21,8 +21,8 @@
 
 暴力解法的思路，第一层for 就是设置起始位置，第二层for循环遍历数组寻找最大值
 
-* 时间复杂度：$O(n^2)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(1)
 
 ```CPP
 class Solution {
@@ -98,8 +98,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 当然题目没有说如果数组为空，应该返回什么，所以数组为空的话返回啥都可以了。
 
@@ -128,8 +128,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 ## 总结
 

problems/0053.最大子序和（动态规划）.md

@@ -80,8 +80,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 
 ## 总结

problems/0062.不同路径.md

@@ -80,7 +80,7 @@ public:
 
 那二叉树的节点个数就是 2^(m + n - 1) - 1。可以理解深搜的算法就是遍历了整个满二叉树（其实没有遍历整个满二叉树，只是近似而已）
 
-所以上面深搜代码的时间复杂度为$O(2^{m + n - 1} - 1)$，可以看出，这是指数级别的时间复杂度，是非常大的。
+所以上面深搜代码的时间复杂度为O(2^(m + n - 1) - 1)，可以看出，这是指数级别的时间复杂度，是非常大的。
 
 ### 动态规划
 
@@ -143,8 +143,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(m × n)$
-* 空间复杂度：$O(m × n)$
+* 时间复杂度：O(m × n)
+* 空间复杂度：O(m × n)
 
 其实用一个一维数组（也可以理解是滚动数组）就可以了，但是不利于理解，可以优化点空间，建议先理解了二维，在理解一维，C++代码如下：
 
@@ -164,8 +164,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(m × n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(m × n)
+* 空间复杂度：O(n)
 
 ### 数论方法
 
@@ -224,8 +224,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(m)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(m)
+* 空间复杂度：O(1)
 
 **计算组合问题的代码还是有难度的，特别是处理溢出的情况！**
 

problems/0063.不同路径II.md

@@ -152,8 +152,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n × m)$，n、m 分别为obstacleGrid 长度和宽度
-* 空间复杂度：$O(n × m)$
+* 时间复杂度：O(n × m)，n、m 分别为obstacleGrid 长度和宽度
+* 空间复杂度：O(n × m)
 
 ## 总结
 

problems/0122.买卖股票的最佳时机II（动态规划）.md

@@ -88,8 +88,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 大家可以本题和[121. 买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)的代码几乎一样，唯一的区别在：
 
@@ -121,8 +121,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$ 
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 
 

problems/0139.单词拆分.md

@@ -66,8 +66,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(2^n)$，因为每一个单词都有两个状态，切割和不切割
-* 空间复杂度：$O(n)$，算法递归系统调用栈的空间
+* 时间复杂度：O(2^n)，因为每一个单词都有两个状态，切割和不切割
+* 空间复杂度：O(n)，算法递归系统调用栈的空间
 
 那么以上代码很明显要超时了，超时的数据如下：
 
@@ -114,7 +114,7 @@ public:
 };
 ```
 
-这个时间复杂度其实也是：$O(2^n)$。只不过对于上面那个超时测试用例优化效果特别明显。
+这个时间复杂度其实也是：O(2^n)。只不过对于上面那个超时测试用例优化效果特别明显。
 
 **这个代码就可以AC了，当然回溯算法不是本题的主菜，背包才是！**
 
@@ -207,8 +207,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n^3)$，因为substr返回子串的副本是$O(n)$的复杂度（这里的n是substring的长度）
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n^3)，因为substr返回子串的副本是$O(n)$的复杂度（这里的n是substring的长度）
+* 空间复杂度：O(n)
 
 
 ## 总结