diff --git a/TangDou/AcWing/MinimalSpanningTree/1140_Kruskal.cpp b/TangDou/AcWing/MinimalSpanningTree/1140_Kruskal.cpp
deleted file mode 100644
index 6d2dc0e..0000000
--- a/TangDou/AcWing/MinimalSpanningTree/1140_Kruskal.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <bits/stdc++.h>
-using namespace std;
-
-const int N = 110;
-const int M = 10010;
-
-struct Node { //用结构体存储每条边
-    int f, t, w;
-    bool operator<(const Node &e) const {
-        return w < e.w;
-    }
-} edges[M];
-
-int p[N];
-
-int find(int x) { //并查集找根节点
-    if (p[x] != x) p[x] = find(p[x]);
-    return p[x];
-}
-
-int n, idx, ans;
-int main() {
-    scanf("%d", &n);
-
-    //邻接矩阵
-    for (int i = 1; i <= n; i++)
-        for (int j = 1; j <= n; j++) {
-            int w;
-            scanf("%d", &w);
-            edges[idx++] = {i, j, w}; //加入当前的边
-        }
-    sort(edges, edges + idx); //对边权进行排序,注意这里不是优先队列，是谁小谁在前
-
-    for (int i = 1; i <= n; i++) p[i] = i; //并查集初始化
-    for (int i = 1; i <= idx; i++) {       //枚举每条边
-        int f = find(edges[i].f), t = find(edges[i].t);
-        if (f != t) {          //当前两点不连通
-            ans += edges[i].w; //更新答案
-            p[f] = t;          //让两点变连通
-        }
-    }
-    printf("%d", ans);
-
-    return 0;
-}
\ No newline at end of file
diff --git a/TangDou/AcWing/MinimalSpanningTree/858.cpp b/TangDou/AcWing/MinimalSpanningTree/858.cpp
index 330bd09..f834f03 100644
--- a/TangDou/AcWing/MinimalSpanningTree/858.cpp
+++ b/TangDou/AcWing/MinimalSpanningTree/858.cpp
@@ -6,49 +6,63 @@ const int INF = 0x3f3f3f3f;
 
 int n, m;
 int g[N][N]; // 稠密图，邻接矩阵
-int dist[N]; // 这个点到集合的距离
+int dis[N];  // 这个点到集合的距离
 bool st[N];  // 是不是已经使用过
 int res;     // 最小生成树里面边的长度之和
 
-/**
- * 功能：普利姆算法求最小生成树
- * @return
- */
+// 普利姆算法求最小生成树
 int prim() {
-    // 迭代n次
-    for (int i = 0; i < n; i++) {
-        // 找出距离集合最小的点
+    for (int i = 0; i < n; i++) { // 迭代n次
+        /*
+        1、找到集合外，距离集合最近的点，记为t,此时有两种情况进行猴子选大王：
+        （1）首次查找,此时还没有大王，那么，默认第一个找到的就是大王
+        （2）非首次查找,那么PK距离最小的成为大王
+        */
         int t = -1;
         for (int j = 1; j <= n; j++)
-            if (!st[j] && (t == -1 || dist[t] > dist[j])) t = j;
-        // 如果找不到距离最小的点
-        if (i && dist[t] == INF) return INF;
-        // 累加最小生成树的长度
-        if (i) res += dist[t];
-        // 利用找到的t更新其它的点
+            if (!st[j] && (t == -1 || dis[t] > dis[j])) t = j;
+
+        /*2、如果不是第一个点，并且剩余的点距离集合的最小距离是INF，说明现在没有点可以连通到生成树，
+         这时不是连通图，没有最小生成树，返回INF
+
+        如果是第一个点，因为把它加到集合中去的代码是在下面进行的，此时它也没有被加入到集合中去，所以dist[t]=INF,这时不能说无解
+        因为才刚刚开始，需要特判一下
+        */
+        if (i && dis[t] == INF) return INF;
+
+        // 3、同上，这里也需要特判一下是不是第1个节点，第一个节点不用加边权值，其它的需要加
+        if (i) res += dis[t];
+
+        // 4、因为本轮选择的是结点t,那么用t更新其它未加入到集合中点到集合的距离
         for (int j = 1; j <= n; j++)
-            if (!st[j] && g[t][j] < dist[j])
-                dist[j] = g[t][j];
-        // 标识t点已在集合内
-        st[t] = 1;
+            if (!st[j] && dis[j] > g[t][j])
+                dis[j] = g[t][j];
+
+        // 5、把t放到集合中
+        st[t] = true;
     }
     return res;
 }
 
 int main() {
     cin >> n >> m;
+    // 所有点之间的距离初始化为正无穷，然后再读入所有边
     memset(g, 0x3f, sizeof g);
-    memset(dist, 0x3f, sizeof dist);
+    // 距离初始化无穷大,表示所有结点都在生成树之外
+    memset(dis, 0x3f, sizeof dis);
     // 读入数据
     while (m--) {
         int a, b, c;
         cin >> a >> b >> c;
         g[a][b] = g[b][a] = min(g[a][b], c);
+        // 允许重复，构建双向有向成为无向图,同时保留最小的
     }
-    int t = prim();
-    if (t == INF)
-        puts("impossible");
+    int t = prim(); // 普利姆算法
+    // 输出结果
+    if (t == INF) puts("impossible");
+    // 不存在生成树，比如所有点不连通的情况下
     else
-        printf("%d\n", t);
+        cout << t << endl; // 否则输出t
+
     return 0;
 }
diff --git a/TangDou/AcWing/MinimalSpanningTree/858.md b/TangDou/AcWing/MinimalSpanningTree/858.md
index 608720b..35c0735 100644
--- a/TangDou/AcWing/MinimalSpanningTree/858.md
+++ b/TangDou/AcWing/MinimalSpanningTree/858.md
@@ -132,31 +132,38 @@ const int N = 510;
 const int INF = 0x3f3f3f3f;
 
 int n, m;
-int g[N][N];    //稠密图，邻接矩阵
-int dist[N];    //这个点到集合的距离
-bool st[N];     //是不是已经使用过
-int res;        //最小生成树里面边的长度之和
+int g[N][N]; // 稠密图，邻接矩阵
+int dis[N];  // 这个点到集合的距离
+bool st[N];  // 是不是已经使用过
+int res;     // 最小生成树里面边的长度之和
 
-/**
- * 功能：普利姆算法求最小生成树
- * @return
- */
+// 普利姆算法求最小生成树
 int prim() {
-    //迭代n次
-    for (int i = 0; i < n; i++) {
-        //1、找到集合外，距离集合最近的点
+    for (int i = 0; i < n; i++) { // 迭代n次
+        /*
+        1、找到集合外，距离集合最近的点，记为t,此时有两种情况进行猴子选大王：
+        （1）首次查找,此时还没有大王，那么，默认第一个找到的就是大王
+        （2）非首次查找,那么PK距离最小的成为大王
+        */
         int t = -1;
         for (int j = 1; j <= n; j++)
-            if (!st[j] && (t == -1 || dist[t] > dist[j])) t = j;
-        /*如果不是第一个点，并且距离是INF，说明现在没有点可以连通到生成树，
-         这时不是连通图，没有最小生成树，返回INF*/
-        if (i && dist[t] == INF) return INF;
-        /*是第一个结点，dist[1]应该是0,现在初始化的是INF,所有这里特判一下。
-        不是第一个点,结果加上这条边的权值。*/
-        if (i)res += dist[t];
-        //2、因为本轮选择的是结点t,那么用t更新其它未加入到集合中点到集合的距离
-        for (int j = 1; j <= n; j++) dist[j] = min(dist[j], g[t][j]);
-        //3、把t放到集合中
+            if (!st[j] && (t == -1 || dis[t] > dis[j])) t = j;
+
+        /*2、如果不是第一个点，并且剩余的点距离集合的最小距离是INF，说明现在没有点可以连通到生成树，
+         这时不是连通图，没有最小生成树，返回INF
+
+        如果是第一个点，因为把它加到集合中去的代码是在下面进行的，此时它也没有被加入到集合中去，所以dist[t]=INF,这时不能说无解
+        因为才刚刚开始，需要特判一下
+        */
+        if (i && dis[t] == INF) return INF;
+
+        // 3、同上，这里也需要特判一下是不是第1个节点，第一个节点不用加边权值，其它的需要加
+        if (i) res += dis[t];
+
+        // 4、因为本轮选择的是结点t,那么用t更新其它未加入到集合中点到集合的距离
+        for (int j = 1; j <= n; j++) dis[j] = min(dis[j], g[t][j]);
+
+        // 5、把t放到集合中
         st[t] = true;
     }
     return res;
@@ -164,25 +171,27 @@ int prim() {
 
 int main() {
     cin >> n >> m;
-    //所有点之间的距离初始化为正无穷，然后再读入所有边
+    // 所有点之间的距离初始化为正无穷，然后再读入所有边
     memset(g, 0x3f, sizeof g);
-    //距离初始化无穷大,表示所有结点都在生成树之外
-    memset(dist, 0x3f, sizeof dist);
-    //读入数据
+    // 距离初始化无穷大,表示所有结点都在生成树之外
+    memset(dis, 0x3f, sizeof dis);
+    // 读入数据
     while (m--) {
         int a, b, c;
         cin >> a >> b >> c;
         g[a][b] = g[b][a] = min(g[a][b], c);
-        //允许重复，构建双向有向成为无向图,同时保留最小的
+        // 允许重复，构建双向有向成为无向图,同时保留最小的
     }
-    int t = prim();//普利姆算法
-    //输出结果
+    int t = prim(); // 普利姆算法
+    // 输出结果
     if (t == INF) puts("impossible");
-    //不存在生成树，比如所有点不连通的情况下
-    else printf("%d\n", t); //否则输出t
+    // 不存在生成树，比如所有点不连通的情况下
+    else
+        cout << t << endl; // 否则输出t
 
     return 0;
 }
+
 ```
 
 ### 五、带路径输出的$Prim$算法
@@ -195,7 +204,7 @@ const int INF = 0x3f3f3f3f;
 
 int n, m;
 int g[N][N];    //稠密图，邻接矩阵
-int dist[N];    //这个点到集合的距离
+int dis[N];    //这个点到集合的距离
 bool st[N];     //是不是已经使用过
 int res;        //最小生成树里面边的长度之和
 int pre[N];     //前驱结点
@@ -209,13 +218,13 @@ int prim() {
     for (int i = 0; i < n; i++) {
         int t = -1;
         for (int j = 1; j <= n; j++)
-            if (!st[j] && (t == -1 || dist[t] > dist[j])) t = j;
-        if (i && dist[t] == INF) return INF;
-        if (i)res += dist[t];
+            if (!st[j] && (t == -1 || dis[t] > dis[j])) t = j;
+        if (i && dis[t] == INF) return INF;
+        if (i)res += dis[t];
         for (int j = 1; j <= n; j++)
             if (!st[j]) {
-                if (g[t][j] < dist[j]) {
-                    dist[j] = g[t][j];
+                if (g[t][j] < dis[j]) {
+                    dis[j] = g[t][j];
                     pre[j] = t;//记录是由谁转移而来
                 }
             }
diff --git a/TangDou/AcWing/MinimalSpanningTree/858_WithPath.cpp b/TangDou/AcWing/MinimalSpanningTree/858_WithPath.cpp
new file mode 100644
index 0000000..1b7203e
--- /dev/null
+++ b/TangDou/AcWing/MinimalSpanningTree/858_WithPath.cpp
@@ -0,0 +1,53 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+const int N = 510;
+const int INF = 0x3f3f3f3f;
+
+int n, m;
+int g[N][N]; // 稠密图，邻接矩阵
+int dis[N];  // 这个点到集合的距离
+bool st[N];  // 是不是已经使用过
+int res;     // 最小生成树里面边的长度之和
+int pre[N];  // 前驱结点
+
+// 普利姆算法求最小生成树
+int prim() {
+    for (int i = 0; i < n; i++) { // 迭代n次
+        int t = -1;
+        for (int j = 1; j <= n; j++)
+            if (!st[j] && (t == -1 || dis[t] > dis[j])) t = j;
+        if (i && dis[t] == INF) return INF; // 非连通图，没有最小生成树
+        if (i) res += dis[t];
+        for (int j = 1; j <= n; j++)
+            if (!st[j] && g[t][j] < dis[j]) {
+                dis[j] = g[t][j];
+                pre[j] = t; // 记录是由谁转移而来
+            }
+        st[t] = true;
+    }
+    return res;
+}
+
+int main() {
+    cin >> n >> m;
+    memset(g, 0x3f, sizeof g);
+    memset(dis, 0x3f, sizeof dis);
+    memset(pre, -1, sizeof pre); // 记录前驱路径
+
+    // 读入数据
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        g[a][b] = g[b][a] = min(g[a][b], c);
+    }
+    int t = prim();
+    if (t == INF)
+        puts("impossible");
+    else
+        cout << t << endl;
+
+    // 输出前驱结点
+    for (int i = 1; i <= n; i++) printf("%d ", pre[i]);
+    return 0;
+}
\ No newline at end of file
diff --git a/TangDou/AcWing/MinimalSpanningTree/1140.md b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140.md
similarity index 63%
rename from TangDou/AcWing/MinimalSpanningTree/1140.md
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140.md
index 91124d1..731a891 100644
--- a/TangDou/AcWing/MinimalSpanningTree/1140.md
+++ b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140.md
@@ -39,23 +39,6 @@ $3≤n≤100$
 ```c++
 28
 ```
-### 二、解题思路
-$Prim$算法和$Kruskal$算法都是用于 **求解最小生成树的算法**，但它们的使用场景和应用领域存在一些差异。
-
-#### $Prim$算法
-① $Prim$算法是一种贪心算法，基于顶点的方式构建最小生成树。
-② $Prim$算法 **适用于稠密图**，即边的数量接近于完全图$(n*(n-1)/2)$的图。
-③ $Prim$算法从一个起始顶点开始逐步扩展，直到生成一个包含所有顶点的最小生成树。
-④ $Prim$算法的时间复杂度为$O(ElogV)$，对于稠密图有较好的性能。
-
-#### $Kruskal$算法
-① $Kruskal$算法是一种基于边的方式构建最小生成树的算法。
-② $Kruskal$算法 **适用于稀疏图**，即边的数量远小于完全图$(n*(n-1)/2)$的图。
-③ $Kruskal$算法按权值递增的顺序选择边，并通过判断是否构成环来决定是否将边加入最小生成树。
-④ $Kruskal$算法的时间复杂度为$O(ElogE)$，对于稀疏图有较好的性能。
-
-#### 总结
-总体而言，$Prim$算法适用于稠密图，具有更好的时间复杂度，而$Kruskal$算法适用于稀疏图，具有相对较好的性能。在选择使用哪种算法时，可以根据图的特性和规模来进行选择。
 
 
 ### 三、$Prim$ 算法
@@ -66,42 +49,43 @@ using namespace std;
 const int N = 110;
 
 int n;
-int w[N][N]; // 邻接矩阵，记录每两个点之间的距离
-int dist[N]; // 每个点距离集合的最小长度
+int g[N][N]; // 邻接矩阵，记录每两个点之间的距离
+int dis[N];  // 每个点距离集合的最小长度
 bool st[N];  // 是不是已经加入到集合中
 
 int prim() {
     // 初始化所有节点到集合的距离为正无穷
-    memset(dist, 0x3f, sizeof dist);
-    dist[1] = 0; // 1号节点到集合的距离为0
+    memset(dis, 0x3f, sizeof dis);
+    dis[1] = 0; // 1号节点到集合的距离为0
+
     int res = 0;
     for (int i = 1; i <= n; i++) { // 迭代n次
         int t = -1;
         //(1)是不是第一次
         //(2)如果不是第1次那么找出距离最近的那个点j
         for (int j = 1; j <= n; j++)
-            if (!st[j] && (t == -1 || dist[t] > dist[j]))
+            if (!st[j] && (t == -1 || dis[t] > dis[j])) // 第一次就是猴子选大王，赶鸭子上架
                 t = j;
-        // 最小生成树的距离和增加dist[t]
-        res += dist[t];
+        // 最小生成树的距离和增加dis[t]
+        res += dis[t];
         // t节点入集合
         st[t] = true;
         // 利用t，拉近其它节点长度
-        for (int j = 1; j <= n; j++) dist[j] = min(dist[j], w[t][j]);
+        for (int j = 1; j <= n; j++) dis[j] = min(dis[j], g[t][j]);
     }
 
     return res;
 }
 
 int main() {
-    scanf("%d", &n);
+    cin >> n;
     // 完全图，每两个点之间都有距离，不用考虑无解情况
     for (int i = 1; i <= n; i++)
         for (int j = 1; j <= n; j++)
-            scanf("%d", &w[i][j]);
+            cin >> g[i][j];
 
     // 利用prim算法计算最小生成树
-    printf("%d\n", prim());
+    cout << prim() << endl;
     return 0;
 }
 ```
diff --git a/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140_Kruskal.cpp b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140_Kruskal.cpp
new file mode 100644
index 0000000..f316ab4
--- /dev/null
+++ b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140_Kruskal.cpp
@@ -0,0 +1,44 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+const int N = 110;
+const int M = 10010;
+
+struct Node { // 用结构体存储每条边
+    int f, t, w;
+    bool operator<(const Node &e) const {
+        return w < e.w;
+    }
+} edges[M];
+
+int p[N];
+
+int find(int x) { // 并查集找根节点
+    if (p[x] != x) p[x] = find(p[x]);
+    return p[x];
+}
+
+int n, idx, ans;
+int main() {
+    cin >> n;
+    for (int i = 1; i <= n; i++) p[i] = i; // 并查集初始化
+    
+    // 邻接矩阵
+    for (int i = 1; i <= n; i++)
+        for (int j = 1; j <= n; j++) {
+            int w;
+            cin >> w;
+            edges[idx++] = {i, j, w}; // 加入当前的边
+        }
+    sort(edges, edges + idx); // 对边权进行排序,谁小谁在前
+
+    for (int i = 1; i <= idx; i++) { // 枚举每条边
+        int f = find(edges[i].f), t = find(edges[i].t);
+        if (f != t) {          // 当前两点不连通
+            ans += edges[i].w; // 更新答案
+            p[f] = t;          // 让两点变连通
+        }
+    }
+    cout << ans << endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/TangDou/AcWing/MinimalSpanningTree/1140_Prim.cpp b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140_Prim.cpp
similarity index 58%
rename from TangDou/AcWing/MinimalSpanningTree/1140_Prim.cpp
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140_Prim.cpp
index 8847617..be97b2e 100644
--- a/TangDou/AcWing/MinimalSpanningTree/1140_Prim.cpp
+++ b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1140_Prim.cpp
@@ -4,41 +4,42 @@ using namespace std;
 const int N = 110;
 
 int n;
-int w[N][N]; // 邻接矩阵，记录每两个点之间的距离
-int dist[N]; // 每个点距离集合的最小长度
+int g[N][N]; // 邻接矩阵，记录每两个点之间的距离
+int dis[N];  // 每个点距离集合的最小长度
 bool st[N];  // 是不是已经加入到集合中
 
 int prim() {
     // 初始化所有节点到集合的距离为正无穷
-    memset(dist, 0x3f, sizeof dist);
-    dist[1] = 0; // 1号节点到集合的距离为0
+    memset(dis, 0x3f, sizeof dis);
+    dis[1] = 0; // 1号节点到集合的距离为0
+
     int res = 0;
     for (int i = 1; i <= n; i++) { // 迭代n次
         int t = -1;
         //(1)是不是第一次
         //(2)如果不是第1次那么找出距离最近的那个点j
         for (int j = 1; j <= n; j++)
-            if (!st[j] && (t == -1 || dist[t] > dist[j]))
+            if (!st[j] && (t == -1 || dis[t] > dis[j])) // 第一次就是猴子选大王，赶鸭子上架
                 t = j;
-        // 最小生成树的距离和增加dist[t]
-        res += dist[t];
+        // 最小生成树的距离和增加dis[t]
+        res += dis[t];
         // t节点入集合
         st[t] = true;
         // 利用t，拉近其它节点长度
-        for (int j = 1; j <= n; j++) dist[j] = min(dist[j], w[t][j]);
+        for (int j = 1; j <= n; j++) dis[j] = min(dis[j], g[t][j]);
     }
 
     return res;
 }
 
 int main() {
-    scanf("%d", &n);
+    cin >> n;
     // 完全图，每两个点之间都有距离，不用考虑无解情况
     for (int i = 1; i <= n; i++)
         for (int j = 1; j <= n; j++)
-            scanf("%d", &w[i][j]);
+            cin >> g[i][j];
 
     // 利用prim算法计算最小生成树
-    printf("%d\n", prim());
+    cout << prim() << endl;
     return 0;
 }
\ No newline at end of file
diff --git a/TangDou/AcWing/MinimalSpanningTree/1141.md b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1141.md
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1141.md
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1141.md
diff --git a/TangDou/AcWing/MinimalSpanningTree/1141_Kruskal.cpp b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1141_Kruskal.cpp
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1141_Kruskal.cpp
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1141_Kruskal.cpp
diff --git a/TangDou/AcWing/MinimalSpanningTree/1141_Prim.cpp b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1141_Prim.cpp
similarity index 60%
rename from TangDou/AcWing/MinimalSpanningTree/1141_Prim.cpp
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1141_Prim.cpp
index c6067cb..611fc48 100644
--- a/TangDou/AcWing/MinimalSpanningTree/1141_Prim.cpp
+++ b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1141_Prim.cpp
@@ -3,39 +3,39 @@ using namespace std;
 const int INF = 0x3f3f3f3f;
 
 const int N = 110;
-int w[N][N];
-int dist[N];
+int g[N][N];
+int dis[N];
 bool st[N];
 int n, m, sum;
 int b[N];
 
-int prim(int source) {
-    memset(dist, 0x3f, sizeof dist);
-    dist[source] = 0;
-    b[source] = 1;
+int prim(int s) {
+    memset(dis, 0x3f, sizeof dis);
+    dis[s] = 0;
+    b[s] = 1;
 
     int res = 0;
     for (int i = 1; i <= n; i++) {
         int t = -1;
         for (int j = 1; j <= n; j++)
-            if (!st[j] && (t == -1 || dist[t] > dist[j]))
+            if (!st[j] && (t == -1 || dis[t] > dis[j]))
                 t = j;
         st[t] = true;
 
-        if (dist[t] != INF) res += dist[t], b[t] = 1;
+        if (dis[t] != INF) res += dis[t], b[t] = 1;
         for (int j = 1; j <= n; j++)
-            dist[j] = min(dist[j], w[t][j]);
+            dis[j] = min(dis[j], g[t][j]);
     }
     return res;
 }
 
 int main() {
     cin >> n >> m;
-    memset(w, 0x3f, sizeof w);
+    memset(g, 0x3f, sizeof g);
     while (m--) {
         int a, b, c;
         cin >> a >> b >> c;
-        w[a][b] = w[b][a] = c;
+        g[a][b] = g[b][a] = c;
         sum += c; // 总边长
     }
 
diff --git a/TangDou/AcWing/MinimalSpanningTree/1142.md b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1142.md
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1142.md
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1142.md
diff --git a/TangDou/AcWing/MinimalSpanningTree/1142_Kruskal.cpp b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1142_Kruskal.cpp
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1142_Kruskal.cpp
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1142_Kruskal.cpp
diff --git a/TangDou/AcWing/MinimalSpanningTree/1142_Prim.cpp b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1142_Prim.cpp
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1142_Prim.cpp
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1142_Prim.cpp
diff --git a/TangDou/AcWing/MinimalSpanningTree/1143.cpp b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1143.cpp
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1143.cpp
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1143.cpp
diff --git a/TangDou/AcWing/MinimalSpanningTree/1143.md b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1143.md
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1143.md
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1143.md
diff --git a/TangDou/AcWing/MinimalSpanningTree/1144.cpp b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1144.cpp
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1144.cpp
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1144.cpp
diff --git a/TangDou/AcWing/MinimalSpanningTree/1144.md b/TangDou/AcWing_TiGao/T3/MinialSpanningTree/1144.md
similarity index 100%
rename from TangDou/AcWing/MinimalSpanningTree/1144.md
rename to TangDou/AcWing_TiGao/T3/MinialSpanningTree/1144.md
diff --git a/TangDou/Topic/【最小生成树】专题.md b/TangDou/Topic/【最小生成树】专题.md
new file mode 100644
index 0000000..4375281
--- /dev/null
+++ b/TangDou/Topic/【最小生成树】专题.md
@@ -0,0 +1,18 @@
+## 最小生成树
+
+$Prim$算法和$Kruskal$算法都是用于 **求解最小生成树的算法**，但它们的使用场景和应用领域存在一些差异。
+
+#### $Prim$算法
+① $Prim$算法是一种贪心算法，基于顶点的方式构建最小生成树。
+② $Prim$算法 **适用于稠密图**，即边的数量接近于完全图$(n*(n-1)/2)$的图。
+③ $Prim$算法从一个起始顶点开始逐步扩展，直到生成一个包含所有顶点的最小生成树。
+④ $Prim$算法的时间复杂度为$O(ElogV)$，对于稠密图有较好的性能。
+
+#### $Kruskal$算法
+① $Kruskal$算法是一种基于边的方式构建最小生成树的算法。
+② $Kruskal$算法 **适用于稀疏图**，即边的数量远小于完全图$(n*(n-1)/2)$的图。
+③ $Kruskal$算法按权值递增的顺序选择边，并通过判断是否构成环来决定是否将边加入最小生成树。
+④ $Kruskal$算法的时间复杂度为$O(ElogE)$，对于稀疏图有较好的性能。
+
+#### 总结
+总体而言，$Prim$算法适用于稠密图，具有更好的时间复杂度，而$Kruskal$算法适用于稀疏图，具有相对较好的性能。在选择使用哪种算法时，可以根据图的特性和规模来进行选择。