diff --git a/TangDou/AcWing_TiGao/T3/Floyd/343_1.cpp b/TangDou/AcWing_TiGao/T3/Floyd/343.cpp
similarity index 95%
rename from TangDou/AcWing_TiGao/T3/Floyd/343_1.cpp
rename to TangDou/AcWing_TiGao/T3/Floyd/343.cpp
index 2f30f0c..9c69f46 100644
--- a/TangDou/AcWing_TiGao/T3/Floyd/343_1.cpp
+++ b/TangDou/AcWing_TiGao/T3/Floyd/343.cpp
@@ -1,6 +1,7 @@
 #include <bits/stdc++.h>
-// Floyd解决传送闭包问题
 using namespace std;
+
+// Floyd解决传送闭包问题
 const int N = 27;
 int n;       // n个变量
 int m;       // m个不等式
@@ -41,7 +42,7 @@ string getorder() { // 升序输出所有变量
 int main() {
     // n个变量,m个不等式
     // 当输入一行 0 0 时，表示输入终止
-    while (scanf("%d %d", &n, &m), n && m) {
+    while (cin >> n >> m, n && m) {
         string S;
         int k = 3;              // 3:不能确定两两之间的关系
         memset(f, 0, sizeof f); // 初始化邻接矩阵
diff --git a/TangDou/AcWing_TiGao/T3/Floyd/343.md b/TangDou/AcWing_TiGao/T3/Floyd/343.md
index 7305f97..4c3c56e 100644
--- a/TangDou/AcWing_TiGao/T3/Floyd/343.md
+++ b/TangDou/AcWing_TiGao/T3/Floyd/343.md
@@ -96,7 +96,7 @@ Sorted sequence determined after 4 relations: ABCDE.
 **概念**
 给定若干对元素和若干对二元关系，并且关系具有传递性，通过传递性推导出尽量多的元素之间关系的问题被称为 **传递闭包**。
 
->**解释**:比如$a < b,b < c$,就可以推导出$a < c$，如果用图形表示出这种大小关系，就是$a$到$b$有一条有向边，$b$到$c$有一条有向边，可以推出$a$可以到达$c$，找出图中各点能够到达点的集合，就 **类似** 于$floyd$算法求图中任意两点间的最短距离。
+>**解释**:比如$a < b,b < c$,就可以推导出$a < c$，如果用图形表示出这种大小关系，就是$a$到$b$有一条有向边 <font color='red' size=4><b>【小的向大的连一条边】</b></font>，$b$到$c$有一条有向边，可以推出$a$可以到达$c$，找出图中各点能够到达点的集合，**类似** 于$floyd$算法求图中任意两点间的最短距离 <font color='red' size=4><b>【魔改版的$floyd$】</b></font>。
 
 **模板**
 ```cpp {.line-numbers}
@@ -147,10 +147,10 @@ int check() {
     return 1;
 }
 ```
+* ① 所有的关系都确定,而且没有发生矛盾
+* ② $f[i][i] = 1$ 发生矛盾
+* ③ $f[i][j] = f[j][i] = 0$ 表示$i$与$j$之间的大小关系还没有确定下来，需要继续读取下一对二元关系
 
-* ① $f[i][i] = 1$ 发生矛盾
-* ② $f[i][j] = f[j][i] = 0$ 表示$i$与$j$之间的大小关系还没有确定下来，需要继续读取下一对二元关系
-* ③ 所有的关系都确定,而且没有发生矛盾
 
 ```cpp {.line-numbers}
 string getorder(){
@@ -169,8 +169,9 @@ string getorder(){
 #### $Code$
 ```cpp {.line-numbers}
 #include <bits/stdc++.h>
-// Floyd解决传送闭包问题
 using namespace std;
+
+// Floyd解决传送闭包问题
 const int N = 27;
 int n;       // n个变量
 int m;       // m个不等式
@@ -211,7 +212,7 @@ string getorder() { // 升序输出所有变量
 int main() {
     // n个变量,m个不等式
     // 当输入一行 0 0 时，表示输入终止
-    while (scanf("%d %d", &n, &m), n && m) {
+    while (cin >> n >> m, n && m) {
         string S;
         int k = 3;              // 3:不能确定两两之间的关系
         memset(f, 0, sizeof f); // 初始化邻接矩阵
@@ -242,129 +243,4 @@ int main() {
     }
     return 0;
 }
-```
-
-### 三、拓扑序解法
-开始想到拓扑排序，但是感觉从前往后枚举一遍会超时，然后看了蓝书$floyd$的做法实现了一遍，感觉还不如直接拓扑。
-
-大致是:
-
-$m$次循环，每次加入一条边到图中，再跑一遍拓扑排序
-
-- 排序后，排序数组不为$n$个，则表示有环，矛盾，跳出循环
-- 排序后，排序数组为$n$个，但是在过程中，有$2$个或以上的点在队列中，表示拓扑序并不唯一，那么此时并不能确定所有点的顺序，因此进行下一次循环
-- 排序后，排序数组为$n$个，且在过程中，队列中一直只有一个，拓扑序唯一，输出结果，跳出循环
-
-```cpp {.line-numbers}
-#include <bits/stdc++.h>
-using namespace std;
-
-const int N = 30, M = N * N;
-
-int n, m;
-int a[1050], b[1050]; // a[i]<b[i]
-char s[N];            // 输入的偏序关系
-
-int in[N], ind[N];
-int d[N], dl;
-
-// 链式前向星
-int e[M], h[N], idx, w[M], ne[M];
-void add(int a, int b, int c = 0) {
-    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
-}
-
-/*
-拓扑序
-(1) 出队列节点数量小于n,表示有环，矛盾
-(2) 出队列节点数量等于n,在过程中，有2个或以上的点在队列中，表示拓扑序并不唯一，那么此时并不能确定所有点的顺序
-(3) 出队列节点数量等于n,在过程中，队列中一直只有一个，拓扑序唯一
-*/
-int topsort() {
-    queue<int> q;
-    bool flag = 0;
-
-    for (int i = 0; i < n; i++) // 枚举每个节点，入度为零的入队列
-        if (in[i] == 0) q.push(i);
-
-    while (q.size()) {
-        /*
-         注意：此处需要优先检查是不是有环，即使检查到某个点有多个前序节点，也并不表示它应该返回2，因为此时也可能是一个环！
-         因为一旦检查是环，就不必再录入新的大小关系的，是一个截止的标识！
-         总结：判断是不是拓扑序不唯一的标准是：
-         ① 队列节点数量等于n
-         ② 在过程中，有2个或以上的点在队列中
-
-         如果只发现了②就着急返回拓扑序不唯一，就可能会掉入到是环的坑中！
-        */
-        if (q.size() > 1) flag = 1;
-
-        int u = q.front();
-        q.pop();
-        d[++dl] = u; // 按出队列的顺序来记录由小到大的关系
-        for (int i = h[u]; ~i; i = ne[i]) {
-            int j = e[i];
-            if (--in[j] == 0) q.push(j);
-        }
-    }
-    // 有环
-    if (dl < n) return 1;
-    // 不确定
-    if (dl == n && flag) return 2;
-    // 已确定
-    return 3;
-}
-
-int main() {
-    // n个变量，m个不等式，也就是n 个节点，m条边
-    while (~scanf("%d%d", &n, &m) && n | m) {
-        // 多组测试数据，需要初始化
-
-        //  链式前向星
-        memset(h, -1, sizeof h);
-        idx = 0;
-        // 入度数组初始化
-        memset(ind, 0, sizeof ind);
-
-        // 输入大小关系,'A'->0,...,'Z'->25
-        for (int i = 1; i <= m; i++) {
-            scanf("%s", s);                       // 通用格式 类似于： B<C
-            a[i] = s[0] - 'A', b[i] = s[2] - 'A'; // 用两个数组a[],b[]记录关系,表示a[i]<b[i]
-        }
-
-        bool flag = 1; // 是不是已经找出了全部的大于关系序列
-
-        // 逐个讨论每个大小关系
-        for (int i = 1; i <= m; i++) {
-            dl = 0;          // 拓扑序输出数组清零
-            add(a[i], b[i]); // 建图
-            ind[b[i]]++;     // 记录b[i]入度
-
-            // 因为topsort会在过程中执行--ind[j]，而此图和入度的值后面还要继续用，不能让topsort改坏了
-            // 复制出来一个临时的入度数组in[]
-            memcpy(in, ind, sizeof ind);
-
-            // 每输入一个关系表达式，就topsort一次
-            int res = topsort();
-
-            // 拓扑序唯一
-            if (res == 3) {
-                printf("Sorted sequence determined after %d relations: ", i);
-                for (int j = 1; j <= dl; j++) printf("%c", d[j] + 'A');
-                puts(".");
-                flag = 0;
-                break;
-            } else if (res == 1) { // 有环
-                printf("Inconsistency found after %d relations.\n", i);
-                flag = 0;
-                break;
-            }
-        }
-        // 最终还是没有发现矛盾，也没有输出唯一序，说明条件还是不够啊，顺序无法确定
-        if (flag) puts("Sorted sequence cannot be determined.");
-    }
-    return 0;
-}
-```
-
-> **注**:此题没有给出$M$的数据范围，导致我调试了半个多小时，差评$yxc$
\ No newline at end of file
+```
\ No newline at end of file
diff --git a/TangDou/AcWing_TiGao/T3/Floyd/343_2.cpp b/TangDou/AcWing_TiGao/T3/Floyd/343_2.cpp
deleted file mode 100644
index 0d92f25..0000000
--- a/TangDou/AcWing_TiGao/T3/Floyd/343_2.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include <bits/stdc++.h>
-using namespace std;
-
-const int N = 30, M = N * N;
-
-int n, m;
-int a[1050], b[1050]; // a[i]<b[i]
-char s[N];            // 输入的偏序关系
-
-int in[N], ind[N];
-int d[N], dl;
-
-// 链式前向星
-int e[M], h[N], idx, w[M], ne[M];
-void add(int a, int b, int c = 0) {
-    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
-}
-
-/*
-拓扑序
-(1) 出队列节点数量小于n,表示有环，矛盾
-(2) 出队列节点数量等于n,在过程中，有2个或以上的点在队列中，表示拓扑序并不唯一，那么此时并不能确定所有点的顺序
-(3) 出队列节点数量等于n,在过程中，队列中一直只有一个，拓扑序唯一
-*/
-int topsort() {
-    queue<int> q;
-    bool flag = 0;
-
-    for (int i = 0; i < n; i++) // 枚举每个节点，入度为零的入队列
-        if (in[i] == 0) q.push(i);
-
-    while (q.size()) {
-        /*
-         注意：此处需要优先检查是不是有环，即使检查到某个点有多个前序节点，也并不表示它应该返回2，因为此时也可能是一个环！
-         因为一旦检查是环，就不必再录入新的大小关系的，是一个截止的标识！
-         总结：判断是不是拓扑序不唯一的标准是：
-         ① 队列节点数量等于n
-         ② 在过程中，有2个或以上的点在队列中
-
-         如果只发现了②就着急返回拓扑序不唯一，就可能会掉入到是环的坑中！
-        */
-        if (q.size() > 1) flag = 1;
-
-        int u = q.front();
-        q.pop();
-        d[++dl] = u; // 按出队列的顺序来记录由小到大的关系
-        for (int i = h[u]; ~i; i = ne[i]) {
-            int j = e[i];
-            if (--in[j] == 0) q.push(j);
-        }
-    }
-    // 有环
-    if (dl < n) return 1;
-    // 不确定
-    if (dl == n && flag) return 2;
-    // 已确定
-    return 3;
-}
-
-int main() {
-    // n个变量，m个不等式，也就是n 个节点，m条边
-    while (~scanf("%d%d", &n, &m) && n | m) {
-        // 多组测试数据，需要初始化
-
-        //  链式前向星
-        memset(h, -1, sizeof h);
-        idx = 0;
-        // 入度数组初始化
-        memset(ind, 0, sizeof ind);
-
-        // 输入大小关系,'A'->0,...,'Z'->25
-        for (int i = 1; i <= m; i++) {
-            scanf("%s", s);                       // 通用格式 类似于： B<C
-            a[i] = s[0] - 'A', b[i] = s[2] - 'A'; // 用两个数组a[],b[]记录关系,表示a[i]<b[i]
-        }
-
-        bool flag = 1; // 是不是已经找出了全部的大于关系序列
-
-        // 逐个讨论每个大小关系
-        for (int i = 1; i <= m; i++) {
-            dl = 0;          // 拓扑序输出数组清零
-            add(a[i], b[i]); // 建图
-            ind[b[i]]++;     // 记录b[i]入度
-
-            // 因为topsort会在过程中执行--ind[j]，而此图和入度的值后面还要继续用，不能让topsort改坏了
-            // 复制出来一个临时的入度数组in[]
-            memcpy(in, ind, sizeof ind);
-
-            // 每输入一个关系表达式，就topsort一次
-            int res = topsort();
-
-            // 拓扑序唯一
-            if (res == 3) {
-                printf("Sorted sequence determined after %d relations: ", i);
-                for (int j = 1; j <= dl; j++) printf("%c", d[j] + 'A');
-                puts(".");
-                flag = 0;
-                break;
-            } else if (res == 1) { // 有环
-                printf("Inconsistency found after %d relations.\n", i);
-                flag = 0;
-                break;
-            }
-        }
-        // 最终还是没有发现矛盾，也没有输出唯一序，说明条件还是不够啊，顺序无法确定
-        if (flag) puts("Sorted sequence cannot be determined.");
-    }
-    return 0;
-}
\ No newline at end of file