diff --git a/problems/0072.编辑距离.md b/problems/0072.编辑距离.md
index 2044ac25..26f080fe 100644
--- a/problems/0072.编辑距离.md
+++ b/problems/0072.编辑距离.md
@@ -8,7 +8,7 @@
 
 ## 72. 编辑距离
 
-https://leetcode-cn.com/problems/edit-distance/ 
+https://leetcode-cn.com/problems/edit-distance/
 
 给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
 
@@ -18,23 +18,23 @@ https://leetcode-cn.com/problems/edit-distance/
 * 删除一个字符
 * 替换一个字符
 
-示例 1：      
-输入：word1 = "horse", word2 = "ros"     
-输出：3      
-解释：     
-horse -> rorse (将 'h' 替换为 'r')     
-rorse -> rose (删除 'r')     
-rose -> ros (删除 'e')        
+示例 1：
+输入：word1 = "horse", word2 = "ros"
+输出：3
+解释：
+horse -> rorse (将 'h' 替换为 'r')
+rorse -> rose (删除 'r')
+rose -> ros (删除 'e')
 
-示例 2：     
-输入：word1 = "intention", word2 = "execution"     
-输出：5     
-解释：       
-intention -> inention (删除 't')      
-inention -> enention (将 'i' 替换为 'e')      
-enention -> exention (将 'n' 替换为 'x')       
-exention -> exection (将 'n' 替换为 'c')     
-exection -> execution (插入 'u')      
+示例 2：
+输入：word1 = "intention", word2 = "execution"
+输出：5
+解释：
+intention -> inention (删除 't')
+inention -> enention (将 'i' 替换为 'e')
+enention -> exention (将 'n' 替换为 'x')
+exention -> exection (将 'n' 替换为 'c')
+exection -> execution (插入 'u')
  
 
 提示：
@@ -51,7 +51,9 @@ exection -> execution (插入 'u')
 
 接下来我依然使用动规五部曲，对本题做一个详细的分析：
 
-1. 确定dp数组（dp table）以及下标的含义
+-----------------------
+
+### 1. 确定dp数组（dp table）以及下标的含义
 
 **dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]**。
 
@@ -59,49 +61,65 @@ exection -> execution (插入 'u')
 
 用i来表示也可以！ 但我统一以下标i-1为结尾的字符串，在下面的递归公式中会容易理解一点。
 
-2. 确定递推公式
+-----------------------
+
+### 2. 确定递推公式
 
 在确定递推公式的时候，首先要考虑清楚编辑的几种操作，整理如下：
 
-* if (word1[i - 1] == word2[j - 1])
-    * 不操作
-* if (word1[i - 1] != word2[j - 1])
-    * 增
-    * 删
-    * 换
+```
+if (word1[i - 1] == word2[j - 1])
+    不操作
+if (word1[i - 1] != word2[j - 1])
+    增
+    删
+    换
+```
 
-也就是如上四种情况。
+也就是如上4种情况。
 
-if (word1[i - 1] == word2[j - 1]) 那么说明不用任何编辑，dp[i][j] 就应该是 dp[i - 1][j - 1]，即dp[i][j] = dp[i - 1][j - 1];
+`if (word1[i - 1] == word2[j - 1])` 那么说明不用任何编辑，`dp[i][j]` 就应该是 `dp[i - 1][j - 1]`，即`dp[i][j] = dp[i - 1][j - 1];`
 
-此时可能有同学有点不明白，为啥要即dp[i][j] = dp[i - 1][j - 1]呢？
+此时可能有同学有点不明白，为啥要即`dp[i][j] = dp[i - 1][j - 1]`呢？
 
-那么就在回顾上面讲过的dp[i][j]的定义，word1[i - 1] 与 word2[j - 1]相等了，那么就不用编辑了，以下标i-2为结尾的字符串word1和以下标j-2为结尾的字符串word2的最近编辑距离dp[i - 1][j - 1] 就是 dp[i][j]了。
+那么就在回顾上面讲过的`dp[i][j]`的定义，`word1[i - 1]` 与 `word2[j - 1]`相等了，那么就不用编辑了，以下标i-2为结尾的字符串word1和以下标j-2为结尾的字符串`word2`的最近编辑距离`dp[i - 1][j - 1]`就是 `dp[i][j]`了。
 
-在下面的讲解中，如果哪里看不懂，就回想一下dp[i][j]的定义，就明白了。
+在下面的讲解中，如果哪里看不懂，就回想一下`dp[i][j]`的定义，就明白了。
 
-**在整个动规的过程中，最为关键就是正确理解dp[i][j]的定义！**
+**在整个动规的过程中，最为关键就是正确理解`dp[i][j]`的定义！**
 
-if (word1[i - 1] != word2[j - 1])，此时就需要编辑了，如何编辑呢？
 
-操作一：word1增加一个元素，使其word1[i - 1]与word2[j - 1]相同，那么就是以下标i-2为结尾的word1 与 i-1为结尾的word2的最近编辑距离 加上一个增加元素的操作。
+`if (word1[i - 1] != word2[j - 1])`，此时就需要编辑了，如何编辑呢？
 
-即 dp[i][j] = dp[i - 1][j] + 1;
+操作一：word1增加一个元素，使其word1[i - 1]与word2[j - 1]相同，那么就是以下标i-2为结尾的word1 与 j-1为结尾的word2的最近编辑距离 加上一个增加元素的操作。
+
+即 `dp[i][j] = dp[i - 1][j] + 1;`
 
 
 操作二：word2添加一个元素，使其word1[i - 1]与word2[j - 1]相同，那么就是以下标i-1为结尾的word1 与 j-2为结尾的word2的最近编辑距离 加上一个增加元素的操作。
 
-即 dp[i][j] = dp[i][j - 1] + 1;
+即 `dp[i][j] = dp[i][j - 1] + 1;`
 
 这里有同学发现了，怎么都是添加元素，删除元素去哪了。
 
-**word2添加一个元素，相当于word1删除一个元素**，例如 word1 = "ad" ，word2 = "a"，word2添加一个元素d，也就是相当于word1删除一个元素d，操作数是一样！
+**word2添加一个元素，相当于word1删除一个元素**，例如 `word1 = "ad" ，word2 = "a"`，`word1`删除元素`'d'`，`word2`添加一个元素`'d'`，变成`word1="a", word2="ad"`， 最终的操作数是一样！ dp数组如下图所示意的：
 
-操作三：替换元素，word1替换word1[i - 1]，使其与word2[j - 1]相同，此时不用增加元素，那么以下标i-2为结尾的word1 与 j-2为结尾的word2的最近编辑距离 加上一个替换元素的操作。
+```
+            a                         a     d
+   +-----+-----+             +-----+-----+-----+
+   |  0  |  1  |             |  0  |  1  |  2  |
+   +-----+-----+   ===>      +-----+-----+-----+
+ a |  1  |  0  |           a |  1  |  0  |  1  |
+   +-----+-----+             +-----+-----+-----+
+ d |  2  |  1  |
+   +-----+-----+
+```
 
-即 dp[i][j] = dp[i - 1][j - 1] + 1;
+操作三：替换元素，`word1`替换`word1[i - 1]`，使其与`word2[j - 1]`相同，此时不用增加元素，那么以下标`i-2`为结尾的`word1` 与 `j-2`为结尾的`word2`的最近编辑距离 加上一个替换元素的操作。
 
-综上，当 if (word1[i - 1] != word2[j - 1]) 时取最小的，即：dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
+即 `dp[i][j] = dp[i - 1][j - 1] + 1;`
+
+综上，当 `if (word1[i - 1] != word2[j - 1])` 时取最小的，即：`dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;`
 
 递归公式代码如下：
 
@@ -114,9 +132,12 @@ else {
 }
 ```
 
-3. dp数组如何初始化
+---
 
-在回顾一下dp[i][j]的定义。
+### 3. dp数组如何初始化
+
+
+再回顾一下dp[i][j]的定义：
 
 **dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]**。
 
@@ -135,14 +156,16 @@ for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
 for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
 ```
 
-4. 确定遍历顺序
+-----------------------
+
+### 4. 确定遍历顺序
 
 从如下四个递推公式：
 
-* dp[i][j] = dp[i - 1][j - 1]
-* dp[i][j] = dp[i - 1][j - 1] + 1
-* dp[i][j] = dp[i][j - 1] + 1
-* dp[i][j] = dp[i - 1][j] + 1
+* `dp[i][j] = dp[i - 1][j - 1]`
+* `dp[i][j] = dp[i - 1][j - 1] + 1`
+* `dp[i][j] = dp[i][j - 1] + 1`
+* `dp[i][j] = dp[i - 1][j] + 1`
 
 可以看出dp[i][j]是依赖左方，上方和左上方元素的，如图：
 
@@ -164,10 +187,12 @@ for (int i = 1; i <= word1.size(); i++) {
     }
 }
 ```
+-----------------------
 
-5. 举例推导dp数组
+### 5. 举例推导dp数组
 
-以示例1，输入：word1 = "horse", word2 = "ros"为例，dp矩阵状态图如下：
+
+以示例1为例，输入：`word1 = "horse", word2 = "ros"`为例，dp矩阵状态图如下：
 
 ![72.编辑距离1](https://img-blog.csdnimg.cn/20210114162132300.jpg)
 
@@ -195,7 +220,7 @@ public:
 };
 ```
 
-
+-----------------------
 ## 其他语言版本