youngyangyang04 · jiubao76799 · Aug 20, 2026
diff --git a/problems/O(n)的算法居然超时了，此时的n究竟是多大？.md b/problems/O(n)的算法居然超时了，此时的n究竟是多大？.md
@@ -27,7 +27,7 @@
 
 计算机的运算速度主要看CPU的配置，以2015年MacPro为例，CPU配置：2.7 GHz Dual-Core Intel Core i5 。
 
-也就是 2.7 GHz 奔腾双核，i5处理器，GHz是指什么呢，1Hz = 1/s，1Hz 是CPU的一次脉冲（可以理解为一次改变状态，也叫时钟周期），称之为为赫兹，那么1GHz等于多少赫兹呢
+也就是 2.7 GHz 奔腾双核，i5处理器，GHz是指什么呢，1Hz = 1/s，1Hz 是CPU的一次脉冲（可以理解为一次改变状态，也叫时钟周期），称之为赫兹，那么1GHz等于多少赫兹呢
 
 * 1GHz（兆赫）= 1000MHz（兆赫）
 * 1MHz（兆赫）= 1百万赫兹
@@ -212,7 +212,7 @@ int main() {
 
 ## 总结
 
-本文详细分析了在leetcode上做题程序为什么会有超时，以及从硬件配置上大体知道CPU的执行速度，然后亲自做一个实验来看看O(n)的算法，跑一秒钟，这个n究竟是做大，最后给出不同时间复杂度，一秒内可以运算出来的n的大小。
+本文详细分析了在leetcode上做题程序为什么会有超时，以及从硬件配置上大体知道CPU的执行速度，然后亲自做一个实验来看看O(n)的算法，跑一秒钟，这个n究竟是多大，最后给出不同时间复杂度，一秒内可以运算出来的n的大小。
 
 建议录友们也都自己做一做实验，测一测，看看是不是和我的测出来的结果差不多。
 

diff --git a/problems/kamacoder/0094.城市间货物运输I-SPFA.md b/problems/kamacoder/0094.城市间货物运输I-SPFA.md
@@ -50,7 +50,7 @@
 
 本题我们来系统讲解 Bellman_ford 队列优化算法 ，也叫SPFA算法（Shortest Path Faster Algorithm）。 
 
->  SPFA的称呼来自 1994年西南交通大学段凡丁的论文，其实Bellman_ford 提出后不久 （20世纪50年代末期） 就有队列优化的版本，国际上不承认这个算法是是国内提出的。 所以国际上一般称呼 该算法为 Bellman_ford 队列优化算法（Queue improved Bellman-Ford） 
+>  SPFA的称呼来自 1994年西南交通大学段凡丁的论文，其实Bellman_ford 提出后不久 （20世纪50年代末期） 就有队列优化的版本，国际上不承认这个算法是国内提出的。 所以国际上一般称呼 该算法为 Bellman_ford 队列优化算法（Queue improved Bellman-Ford） 
 
 大家知道以上来历，知道 SPFA 和 Bellman_ford 队列优化算法 指的都是一个算法就好。 
 
@@ -79,7 +79,7 @@
 
 ## 模拟过程
 
-接下来来举例这个队列是如何工作的。 
+接下来举例这个队列是如何工作的。 
 
 以示例给出的所有边为例： 
 
@@ -213,7 +213,7 @@ int main() {
 
     vector<list<Edge>> grid(n + 1); 
 
-    vector<bool> isInQueue(n + 1); // 加入优化，已经在队里里的元素不用重复添加
+    vector<bool> isInQueue(n + 1); // 加入优化，已经在队列里的元素不用重复添加
 
     // 将所有边保存起来
     for(int i = 0; i < m; i++){
@@ -321,7 +321,7 @@ SPFA（队列优化版Bellman_ford） 在理论上 时间复杂度更胜一筹
 
 ## 拓展 
 
-这里可能有录友疑惑，`while (!que.empty())` 队里里 会不会造成死循环？  例如 图中有环，这样一直有元素加入到队列里？ 
+这里可能有录友疑惑，`while (!que.empty())` 队列里 会不会造成死循环？  例如 图中有环，这样一直有元素加入到队列里？ 
 
 其实有环的情况，要看它是 正权回路 还是 负权回路。 
 
@@ -335,7 +335,7 @@ SPFA（队列优化版Bellman_ford） 在理论上 时间复杂度更胜一筹
 
 在有环且只有正权回路的情况下，即使元素重复加入队列，最后，也会因为 所有边都松弛后，节点数值（minDist数组）不在发生变化了 而终止。
 
-（而且有重复元素加入队列是正常的，多条路径到达同一个节点，节点必要要选择一个最短的路径，而这个节点就会重复加入队列进行判断，选一个最短的）
+（而且有重复元素加入队列是正常的，多条路径到达同一个节点，节点必须要选择一个最短的路径，而这个节点就会重复加入队列进行判断，选一个最短的）
 
 在[0094.城市间货物运输I](./0094.城市间货物运输I.md) 中我们讲过对所有边 最多松弛 n -1 次，就一定可以求出所有起点到所有节点的最小距离即 minDist数组。 
 

diff --git a/problems/kamacoder/0095.城市间货物运输II.md b/problems/kamacoder/0095.城市间货物运输II.md
@@ -94,7 +94,7 @@ circle
 
 如果在负权回路多绕两圈，三圈，无穷圈，那么我们的总成本就会无限小， 如果要求最小成本的话，你会发现本题就无解了。 
 
-在 bellman_ford 算法中，松弛 n-1 次所有的边 就可以求得 起点到任何节点的最短路径，松弛 n 次以上，minDist数组（记录起到到其他节点的最短距离）中的结果也不会有改变 （如果对 bellman_ford 算法 不了解，也不知道 minDist 是什么，建议详看上篇讲解[kama94.城市间货物运输I](./0094.城市间货物运输I.md)）  
+在 bellman_ford 算法中，松弛 n-1 次所有的边 就可以求得 起点到任何节点的最短路径，松弛 n 次以上，minDist数组（记录起点到其他节点的最短距离）中的结果也不会有改变 （如果对 bellman_ford 算法 不了解，也不知道 minDist 是什么，建议详看上篇讲解[kama94.城市间货物运输I](./0094.城市间货物运输I.md)）  
 
 而本题有负权回路的情况下，一直都会有更短的最短路，所以 松弛 第n次，minDist数组 也会发生改变。  
 

diff --git a/problems/kamacoder/0108.冗余连接.md b/problems/kamacoder/0108.冗余连接.md
@@ -79,7 +79,7 @@
 
 ![](https://file1.kamacoder.com/i/algo/20230604104330.png)
 
-已经判断 节点A  和 节点B 在在同一个集合（同一个根），如果将 节点A 和 节点B 连在一起就一定会出现环。 
+已经判断 节点A  和 节点B 在同一个集合（同一个根），如果将 节点A 和 节点B 连在一起就一定会出现环。 
 
 这个思路清晰之后，代码就很好写了。
 

diff --git a/problems/kamacoder/0126.骑士的攻击astar.md b/problems/kamacoder/0126.骑士的攻击astar.md
@@ -191,7 +191,7 @@ x1, x2 为起点坐标，y1, y2 为终点坐标 ，abs 为求绝对值，sqrt
 
 所以 使用欧拉距离计算 和 广搜搜出来的最短路的节点数是一样的。 （路径可能不同，但路径上的节点数是相同的）
 
-我在制作动画演示的过程中，分别给出了曼哈顿、欧拉以及契比雪夫 三种计算方式下，A * 算法的寻路过程，大家可以自己看看看其区别。
+我在制作动画演示的过程中，分别给出了曼哈顿、欧拉以及契比雪夫 三种计算方式下，A * 算法的寻路过程，大家可以自己看看其区别。
 
 动画地址：https://kamacoder.com/tools/knight.html 
 

diff --git a/problems/kamacoder/图论并查集理论基础.md b/problems/kamacoder/图论并查集理论基础.md
@@ -31,7 +31,7 @@
 
 但如果我们要判断两个元素是否在同一个集合里的时候 我们又能怎么办？ 只能把而二维数组都遍历一遍。
 
-而且每当想添加一个元素到某集合的时候，依然需要把把二维数组都遍历一遍，才知道要放在哪个集合里。
+而且每当想添加一个元素到某集合的时候，依然需要把二维数组都遍历一遍，才知道要放在哪个集合里。
 
 这仅仅是一个粗略的思路，如果沿着这个思路去实现代码，非常复杂，因为管理集合还需要很多逻辑。
 
@@ -61,7 +61,7 @@ void join(int u, int v) {
 
 给出A元素，就可以通过 father[A] = B，father[B] = C，找到根为 C。
 
-给出B元素，就可以通过 father[B] = C，找到根也为为 C，说明 A 和 B 是在同一个集合里。
+给出B元素，就可以通过 father[B] = C，找到根也为 C，说明 A 和 B 是在同一个集合里。
 大家会想第一段代码里find函数是如何实现的呢？其实就是通过数组下标找到数组元素，一层一层寻根过程，代码如下：
 
 ```CPP

diff --git a/problems/周总结/20201030回溯周末总结.md b/problems/周总结/20201030回溯周末总结.md
@@ -74,7 +74,7 @@
 
 例如这里for循环，可不像是在 [回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)和[回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)中从startIndex开始遍历的。
 
-**因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而[回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)和[回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)都是是求同一个集合中的组合！**
+**因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而[回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)和[回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)都是求同一个集合中的组合！**
 
 如果大家在现场面试的时候，一定要注意各种输入异常的情况，例如本题输入1 * #按键。
 

diff --git a/problems/周总结/20201224贪心周末总结.md b/problems/周总结/20201224贪心周末总结.md
@@ -44,7 +44,7 @@ public:
 
         int result = 1;
         for (int i = 1; i < intervals.size(); i++) {
-            if (intervals[i][0] >= intervals[i - 1][1]) { // 需要要把> 改成 >= 就可以了
+            if (intervals[i][0] >= intervals[i - 1][1]) { // 需要把> 改成 >= 就可以了
                 result++; // 需要一支箭
             }
             else {

diff --git a/problems/周总结/20210225动规周末总结.md b/problems/周总结/20210225动规周末总结.md
@@ -125,7 +125,7 @@ public:
 vector<int> robTree(TreeNode* cur) {
 ```
 
-dp数组含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。
+dp数组含义：下标为0记录不偷该节点所得到的最大金钱，下标为1记录偷该节点所得到的最大金钱。
 
 **所以本题dp数组就是一个长度为2的数组！**
 

diff --git a/problems/回溯总结.md b/problems/回溯总结.md
@@ -157,7 +157,7 @@ for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target;
 
 例如这里for循环，可不像是在 [回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)和[回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)中从startIndex开始遍历的。
 
-**因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而[回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)和[回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)都是是求同一个集合中的组合！**
+**因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而[回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)和[回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)都是求同一个集合中的组合！**
 
 树形结构如下：