diff --git a/TangDou/AcWing_TiGao/T3/Floyd/344.md b/TangDou/AcWing_TiGao/T3/Floyd/344.md
index 2138e43..2b8e45b 100644
--- a/TangDou/AcWing_TiGao/T3/Floyd/344.md
+++ b/TangDou/AcWing_TiGao/T3/Floyd/344.md
@@ -44,8 +44,6 @@ $floyd$是 **插点** 算法，在点$k$被 **插入前** 可计算$i \rightarro
 
 枚举所有以$k$为环中 **最大节点** 的环即可。
 
-> **解释**：$k$是从$1\sim n$的，说它是最大节点，是指每次插入的节点号最大，并不表示在环中它一定比$i,j$还大。
-
 
 ### 三、$floyd+dp$
 ```cpp {.line-numbers}
@@ -54,8 +52,8 @@ $floyd$是 **插点** 算法，在点$k$被 **插入前** 可计算$i \rightarro
 using namespace std;
 const int N = 110, INF = 0x3f3f3f3f;
 int n, m;
-int g[N][N], dist[N][N];
-int path[N], idx;
+int g[N][N], dis[N][N];
+vector<int> path;
 int mid[N][N];
 int ans = INF;
 
@@ -64,13 +62,13 @@ void get_path(int i, int j) {
     int k = mid[i][j]; // 获取中间转移点
     if (!k) return;    // 如果i,j之间没有中间点，停止
     get_path(i, k);    // 递归前半段
-    path[idx++] = k;   // 记录k节点
+    path.push_back(k); // 记录k节点
     get_path(k, j);    // 递归后半段
 }
 
 int main() {
     // n个顶点，m条边
-    scanf("%d %d", &n, &m);
+    cin >> n >> m;
 
     // 初始化邻接矩阵
     memset(g, 0x3f, sizeof g);
@@ -78,12 +76,12 @@ int main() {
 
     while (m--) {
         int a, b, c;
-        scanf("%d %d %d", &a, &b, &c);
+        cin >> a >> b >> c;
         g[a][b] = g[b][a] = min(g[a][b], c); // 求最短路之类，(a,b)之间多条边输入只保留最短边
     }
 
-    // 把原始地图复制出来到生成最短距离dist
-    memcpy(dist, g, sizeof dist);
+    // 把原始地图复制出来到生成最短距离dis
+    memcpy(dis, g, sizeof dis);
 
     for (int k = 1; k <= n; k++) { // 枚举每一个引入点k来连接缩短i,j的距离
         /*
@@ -92,31 +90,31 @@ int main() {
         其实循环到n也是可以的，不过当i, j, k中有两个相同时就要continue一下
 
         Q2:为什么非得把DP的这段代码嵌入到Floyd的整体代码中，不能先Floyd后再进行DP吗？
-        A:是不可以的。因为在进行插入节点号为k时，其实dist[i][j]中记录的是1~k-1插点后的最小距离，
+        A:是不可以的。因为在进行插入节点号为k时，其实dis[i][j]中记录的是1~k-1插点后的最小距离，
         而不是全部插入点后的最短距离。
         */
         for (int i = 1; i < k; i++)
             for (int j = i + 1; j < k; j++)
-                if (g[i][k] + g[k][j] < ans - dist[i][j]) { // 减法防止爆INT
-                    ans = dist[i][j] + g[i][k] + g[k][j];
+                if (g[i][k] + g[k][j] < ans - dis[i][j]) { // 减法防止爆INT
+                    ans = dis[i][j] + g[i][k] + g[k][j];
                     // 找到更小的环，需要记录路径,并且要求: 最小环的所有节点（按顺序输出）
                     //  顺序
                     //  1. 上面的i,j枚举逻辑是j>i,所以i是第一个
                     //  2. i->j 中间的路线不明，需要用get_path进行查询出i->j的最短路径怎么走,当然，也是在<k的范围内的
                     //  3. 记录j
                     //  4. 记录k
-                    idx = 0;
-                    path[idx++] = i;
-                    get_path(i, j); // i是怎么到达j的？就是问dist[i][j]是怎么获取到的，这是在求最短路径过程中的一个路径记录问题
-                    path[idx++] = j;
-                    path[idx++] = k;
+                    path.clear();
+                    path.push_back(i);
+                    get_path(i, j); // i是怎么到达j的？就是问dis[i][j]是怎么获取到的，这是在求最短路径过程中的一个路径记录问题
+                    path.push_back(j);
+                    path.push_back(k);
                 }
 
         // 正常floyd
         for (int i = 1; i <= n; i++)
             for (int j = 1; j <= n; j++)
-                if (dist[i][j] > dist[i][k] + dist[k][j]) {
-                    dist[i][j] = dist[i][k] + dist[k][j];
+                if (dis[i][j] > dis[i][k] + dis[k][j]) {
+                    dis[i][j] = dis[i][k] + dis[k][j];
                     mid[i][j] = k; // 记录路径i->j 是通过k进行转移的
                 }
     }
@@ -124,7 +122,7 @@ int main() {
     if (ans == INF)
         puts("No solution.");
     else
-        for (int i = 0; i < idx; i++) cout << path[i] << ' ';
+        for (int i = 0; i < path.size(); i++) cout << path[i] << ' ';
 
     return 0;
 }