0072, 0392, 0583 Reworded.

gazeldx · gazeldx · commit 04e7ef8623b3 · 2024-11-26T19:22:16.000+08:00
diff --git a/0072-edit-distance.md b/0072-edit-distance.md
@@ -43,7 +43,7 @@ These five steps are a pattern for solving dynamic programming problems.
 2. Determine the `dp` array's initial value
     * Use an example:
    ```
-   After initialized, the 'dp' array would be:  
+   After initialization, the 'dp' array would be:  
    #     r o s
    #   0 1 2 3 # dp[0]
    # h 1 0 0 0
@@ -67,7 +67,7 @@ These five steps are a pattern for solving dynamic programming problems.
    # e 5 4 4 3
    ```
     * When analyzing the sample `dp` grid, remember there are three important points which you should pay special attention to: `dp[i - 1][j - 1]`, `dp[i - 1][j]` and `dp[i][j - 1]`. The current `dp[i][j]` often depends on them.
-    * If we need to use `dp[i - 1][j]` or `dp[i][j - 1]`, and the question is also true in reverse, then we probably need to use both of them.
+    * If the question is also true in reverse (swap `word1` and `word2`), and we need to use `dp[i - 1][j]` or `dp[i][j - 1]`, then we probably need to use both of them.
     * We can derive the `Recurrence Formula`:
    ```python
    if word1[i - 1] == word2[j - 1]
diff --git a/0392-is-subsequence.md b/0392-is-subsequence.md
@@ -2,7 +2,7 @@
 LeetCode problem: [392. Is Subsequence](https://leetcode.com/problems/is-subsequence/)
 
 ## LeetCode problem description
-> Given two strings `s` and `t`, return `true` if s is a **subsequence** of `t`, or `false` otherwise.
+> Given two strings `s` and `t`, return `true` if `s` is a **subsequence** of `t`, or `false` otherwise.
 
 A **subsequence** of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., `"ace"` is a subsequence of `"abcde"` while `"aec"` is not).
 
@@ -31,7 +31,7 @@ These five steps are a pattern for solving dynamic programming problems.
 2. Determine the `dp` array's initial value
     * Use an example:
    ```
-   After initialized, the 'dp' array would be:
+   After initialization, the 'dp' array would be:
    s = "abc", t = "ahbgdc"
    #     a h b g d c
    #   T T T T T T T # dp[0]
@@ -52,7 +52,7 @@ These five steps are a pattern for solving dynamic programming problems.
    # c F F F F F F T
    ```
     * When analyzing the sample `dp` grid, remember there are three important points which you should pay special attention to: `dp[i - 1][j - 1]`, `dp[i - 1][j]` and `dp[i][j - 1]`. The current `dp[i][j]` often depends on them.
-    * If we need to use `dp[i - 1][j]` or `dp[i][j - 1]`, and the question is also true in reverse, then we probably need to use both of them.
+    * If the question is also true in reverse (swap `s` and `t`), and we need to use `dp[i - 1][j]` or `dp[i][j - 1]`, then we probably need to use both of them.
     * We can derive the `Recurrence Formula`:
    ```
    if s[i - 1] == t[j - 1]
diff --git a/0583-delete-operation-for-two-strings.md b/0583-delete-operation-for-two-strings.md
@@ -31,7 +31,7 @@ These five steps are a pattern for solving dynamic programming problems.
 2. Determine the `dp` array's initial value
     * Use an example:
    ```
-   After initialized, the 'dp' array would be:  
+   After initialization, the 'dp' array would be:  
    #     e a t
    #   0 1 2 3 # dp[0]
    # s 1 0 0 0
@@ -50,7 +50,7 @@ These five steps are a pattern for solving dynamic programming problems.
    # a 3 2 1 2
    ```
     * When analyzing the sample `dp` grid, remember there are three important points which you should pay special attention to: `dp[i - 1][j - 1]`, `dp[i - 1][j]` and `dp[i][j - 1]`. The current `dp[i][j]` often depends on them.
-    * If we need to use `dp[i - 1][j]` or `dp[i][j - 1]`, and the question is also true in reverse, then we probably need to use both of them.  
+    * If the question is also true in reverse (swap `word1` and `word2`), and we need to use `dp[i - 1][j]` or `dp[i][j - 1]`, then we probably need to use both of them.  
     * We can derive the `Recurrence Formula`:
    ```python
    if word1[i - 1] == word2[j - 1]
