Update

Author: youngyangyang04

problems/0377.组合总和Ⅳ.md

@@ -117,7 +117,7 @@ public:
         dp[0] = 1;
         for (int i = 0; i <= target; i++) { // 遍历背包
             for (int j = 0; j < nums.size(); j++) { // 遍历物品
-                if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
+                if (i - nums[j] >= 0 && dp[i] <= INT_MAX - dp[i - nums[j]]) {
                     dp[i] += dp[i - nums[j]];
                 }
             }

problems/kamacoder/0047.参会dijkstra堆.md

@@ -614,12 +614,12 @@ int main() {
 
 ```
 
-* 时间复杂度：O(E * (N + logE))   E为边的数量，N为节点数量
+* 时间复杂度：O(E * N * logE)   E为边的数量，N为节点数量
 * 空间复杂度：O(log(N^2))
 
-`while (!pq.empty())` 时间复杂度为 E ，while 里面 每次取元素 时间复杂度 为 logE，和 一个for循环 时间复杂度 为 N 。
+`while (!pq.empty())` 时间复杂度为 E ，优先级队列每次插入元素 时间复杂度 为 logE，和 一个for循环 时间复杂度 为 N 。
 
-所以整体是 E * (N + logE) 
+所以整体是 E * N * logE
 
 
 ## 总结 

problems/kamacoder/0053.寻宝-Kruskal.md

@@ -46,6 +46,8 @@
 
 ## 解题思路
 
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[图论：最小生成树之kruskal算法](https://www.bilibili.com/video/BV1GD3uz8EY4),相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
 在上一篇 我们讲解了 prim算法求解 最小生成树，本篇我们来讲解另一个算法：Kruskal，同样可以求最小生成树。 
 
 **prim 算法是维护节点的集合，而 Kruskal 是维护边的集合**。

problems/kamacoder/0053.寻宝-prim.md

@@ -47,6 +47,8 @@
 
 ## 解题思路
 
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[图论：最小生成树之prim算法](https://www.bilibili.com/video/BV1gFKVzpExq),相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
 本题是最小生成树的模板题，那么我们来讲一讲最小生成树。
 
 最小生成树可以使用prim算法也可以使用kruskal算法计算出来。

problems/kamacoder/0097.小明逛公园.md

@@ -31,18 +31,22 @@
 
 【输入示例】
 
+```
 7 3
 1 2 4
 2 5 6
 3 6 8
 2
 1 2
 2 3
+```
 
 【输出示例】
 
+```
 4
 -1
+```
 
 【提示信息】
 

problems/kamacoder/0105.有向图的完全可达性.md

@@ -66,15 +66,15 @@
 
 1. 确认递归函数，参数 
 
-需要传入地图，需要知道当前我们拿到的key，以至于去下一个房间。 
+需要传入地图，需要知道当前我们拿到的key，以至于去下一个节点。 
 
-同时还需要一个数组，用来记录我们都走过了哪些房间，这样好知道最后有没有把所有房间都遍历的，可以定义一个一维数组。
+同时还需要一个数组，用来记录我们都走过了哪些节点，这样好知道最后有没有把所有节点都遍历的，可以定义一个一维数组。
 
 所以 递归函数参数如下： 
 
 ```C++ 
 // key 当前得到的可以 
-// visited 记录访问过的房间 
+// visited 记录访问过的节点
 void dfs(const vector<list<int>>& graph, int key, vector<bool>& visited) {
 ```
 
@@ -259,9 +259,9 @@ int main() {
 
     }
     vector<bool> visited(n + 1, false);
-    visited[1] = true; //  1 号房间开始
+    visited[1] = true; //  节点1开始
     queue<int> que;
-    que.push(1); //  1 号房间开始
+    que.push(1); //  节点1开始
 
     // 广度优先搜索的过程
     while (!que.empty()) {

problems/kamacoder/0107.寻找存在的路径.md

@@ -48,6 +48,8 @@
 
 ## 思路
 
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[图论：没想到并查集这么简单 ！](https://www.bilibili.com/video/BV1k3T7zWEVj),相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
 本题是并查集基础题目。 如果还不了解并查集，可以看这里：[并查集理论基础](https://programmercarl.com/kamacoder/图论并查集理论基础.html)
 
 并查集可以解决什么问题呢？

problems/kamacoder/0108.冗余连接.md

@@ -52,6 +52,8 @@
 
 ## 思路
 
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[图论：并查集有点不简单了。。](https://www.bilibili.com/video/BV1gRM3z9EwZ),相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
 这道题目也是并查集基础题目。
 
 这里我依然降调一下，并查集可以解决什么问题：两个节点是否在一个集合，也可以将两个节点添加到一个集合中。

problems/kamacoder/0109.冗余连接II.md

@@ -52,6 +52,8 @@
 
 ## 思路
 
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[图论：并查集这次要上难度了](https://www.bilibili.com/video/BV1t2NEzaEMR),相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
 本题与 [108.冗余连接](./0108.冗余连接.md) 类似，但本题是一个有向图，有向图相对要复杂一些。
 
 本题的本质是 ：有一个有向图，是由一颗有向树 + 一条有向边组成的 （所以此时这个图就不能称之为有向树），现在让我们找到那条边 把这条边删了，让这个图恢复为有向树。

problems/kamacoder/0126.骑士的攻击astar.md

@@ -279,17 +279,15 @@ int main()
 
 ## 复杂度分析   
 
-A * 算法的时间复杂度 其实是不好去量化的，因为他取决于 启发式函数怎么写。 
+A*算法的时间复杂度其实是不容易量化的，这取决于怎么写启发式函数。
 
-最坏情况下，A * 退化成广搜，算法的时间复杂度 是 O(n * 2)，n 为节点数量。
+最坏情况下，A*算法退化成BFS，时间复杂度是O(n^2)，n为节点的数量。
 
-最佳情况，是从起点直接到终点，时间复杂度为 O(dlogd)，d 为起点到终点的深度。 
+一般情况下，搜索路径是从起点直接到终点，while(!que.empty()) 需要执行d次，d为起点到终点的深度，而优先级队列每次添加元素都要进行堆排序，时间复杂度是O(logk)，k为队列中元素的数量。所以时间复杂度为O(dlogk)。
 
-因为在搜索的过程中也需要堆排序，所以是 O(dlogd)。
+也可以非常粗略地认为A*算法的时间复杂度是O(nlogn)，n为节点的数量。
 
-实际上 A * 的时间复杂度是介于 最优 和最坏 情况之间， 可以 非常粗略的认为 A * 算法的时间复杂度是 O(nlogn) ，n 为节点数量。
-
-A * 算法的空间复杂度 O(b ^ d) ,d 为起点到终点的深度，b 是 图中节点间的连接数量，本题因为是无权网格图，所以 节点间连接数量为 4。 
+本题中A*算法的空间复杂度是O(k)，k为队列中元素的数量，空间消耗主要是队列里需要存放遍历的节点。
 
 
 ## 拓展