youngyangyang04 · jiubao76799 · Aug 20, 2026
diff --git a/problems/0005.最长回文子串.md b/problems/0005.最长回文子串.md
@@ -100,7 +100,7 @@ dp[i][j]可以初始化为true么？ 当然不行，怎能刚开始就全都匹
 
 4. 确定遍历顺序
 
-遍历顺序可有有点讲究了。
+遍历顺序可有点讲究了。
 
 首先从递推公式中可以看出，情况三是根据dp[i + 1][j - 1]是否为true，在对dp[i][j]进行赋值true的。
 

diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
@@ -400,7 +400,7 @@ class Solution:
         queue = collections.deque()
         queue.append(root.left) #将左子树头结点加入队列
         queue.append(root.right) #将右子树头结点加入队列
-        while queue: #接下来就要判断这这两个树是否相互翻转
+        while queue: #接下来就要判断这两个树是否相互翻转
             leftNode = queue.popleft()
             rightNode = queue.popleft()
             if not leftNode and not rightNode: #左节点为空、右节点为空，此时说明是对称的

diff --git a/problems/0115.不同的子序列.md b/problems/0115.不同的子序列.md
@@ -210,7 +210,7 @@ class SolutionDP2:
     既然dp[i]只用到dp[i - 1]的状态，
     我们可以通过缓存dp[i - 1]的状态来对dp进行压缩，
     减少空间复杂度。
-    （原理等同同于滚动数组）
+    （原理等同于滚动数组）
     """
 
     def numDistinct(self, s: str, t: str) -> int:

diff --git a/problems/0122.买卖股票的最佳时机II.md b/problems/0122.买卖股票的最佳时机II.md
@@ -276,7 +276,7 @@ const maxProfit = (prices) => {
     // 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
     dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
 
-    // 在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
+    // 再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
     // 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
     // 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0]
     dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);

diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md
@@ -286,7 +286,7 @@ const maxProfit = (prices) => {
         // 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
         dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] - prices[i]);
 
-        // 在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
+        // 再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
         // 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
         // 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0]
         dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] + prices[i]);

diff --git a/problems/0404.左叶子之和.md b/problems/0404.左叶子之和.md
@@ -532,7 +532,7 @@ int sumOfLeftLeaves(struct TreeNode* root){
     if(!root)
         return 0;
 
-    // 递归取左子树的左结点和和右子树的左结点和
+    // 递归取左子树的左结点和右子树的左结点和
     int leftValue = sumOfLeftLeaves(root->left);
     int rightValue = sumOfLeftLeaves(root->right);
 

diff --git a/problems/0509.斐波那契数.md b/problems/0509.斐波那契数.md
@@ -351,7 +351,7 @@ int fib(int n){
         return n;
     //动态开辟一个int数组，大小为n+1
     int *dp = (int *)malloc(sizeof(int) * (n + 1));
-    //设置0号位为0，1号为为1
+    //设置0号位为0，1号为1
     dp[0] = 0;
     dp[1] = 1;
 

diff --git a/problems/0685.冗余连接II.md b/problems/0685.冗余连接II.md
@@ -31,7 +31,7 @@
 
 先重点读懂题目中的这句**该图由一个有着N个节点 (节点值不重复1, 2, ..., N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。**
 
-**这说明题目中的图原本是是一棵树，只不过在不增加节点的情况下多加了一条边！**
+**这说明题目中的图原本是一棵树，只不过在不增加节点的情况下多加了一条边！**
 
 还有**若有多个答案，返回最后出现在给定二维数组的答案。**这说明在两条边都可以删除的情况下，要删顺序靠后的！
 
@@ -102,7 +102,7 @@ if (vec.size() > 0) {
 }
 ```
 
-在来看情况三，明确没有入度为2的情况，那么一定有向环，找到构成环的边就是要删除的边。
+再来看情况三，明确没有入度为2的情况，那么一定有向环，找到构成环的边就是要删除的边。
 
 可以定义一个函数，代码如下：
 

diff --git a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
@@ -64,7 +64,7 @@ dp[i][1] 表示第i天不持有股票所得最多现金
 所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
 
 
-在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
+再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
 * 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
 * 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，**注意这里需要有手续费了**即：dp[i - 1][0] + prices[i] - fee
 

diff --git a/problems/0739.每日温度.md b/problems/0739.每日温度.md
@@ -24,7 +24,7 @@
 
 首先想到的当然是暴力解法，两层for循环，把至少需要等待的天数就搜出来了。时间复杂度是O(n^2)
 
-那么接下来在来看看使用单调栈的解法。
+那么接下来再来看看使用单调栈的解法。
 
 那有同学就问了，我怎么能想到用单调栈呢？ 什么时候用单调栈呢？
 

diff --git a/problems/动态规划-股票问题总结篇.md b/problems/动态规划-股票问题总结篇.md
@@ -430,7 +430,7 @@ dp[i][1] 表示第i天不持有股票所得最多现金
 所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
 
 
-在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
+再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
 * 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
 * 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，**注意这里需要有手续费了**即：dp[i - 1][0] + prices[i] - fee
 

diff --git a/problems/双指针总结.md b/problems/双指针总结.md
@@ -69,7 +69,7 @@ for (int i = 0; i < array.size(); i++) {
 
 使用了哈希法解决了两数之和，但是哈希法并不适用于三数之和！
 
-使用哈希法的过程中要把符合条件的三元组放进vector中，然后在去去重，这样是非常费时的，很容易超时，也是三数之和通过率如此之低的根源所在。
+使用哈希法的过程中要把符合条件的三元组放进vector中，然后再去重，这样是非常费时的，很容易超时，也是三数之和通过率如此之低的根源所在。
 
 去重的过程不好处理，有很多小细节，如果在面试中很难想到位。