Aligned the * and inside code.

gazeldx · gazeldx · commit 3c2b7a99d8d6 · 2024-11-26T14:12:10.000+08:00
diff --git a/0053-maximum-subarray.md b/0053-maximum-subarray.md
@@ -32,12 +32,12 @@ These five steps are a pattern for solving dynamic programming problems.
     * `dp[i] = nums[i]` would be good.
 3. Determine the `dp` array's recurrence formula
     * Use an example:
-```
-nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
-dp   = [-2, 1, -2, 4,  3, 5, 6,  1, 5]
-```
-   * After analyzing the sample `dp` data, we can derive the `recurrence formula`:
-   * `dp[i] = max(nums[i], dp[i - 1] + nums[i])`.
+   ```
+   nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+   dp   = [-2, 1, -2, 4,  3, 5, 6,  1, 5]
+   ```
+    * After analyzing the sample `dp` data, we can derive the `recurrence formula`:
+   ```dp[i] = max(nums[i], dp[i - 1] + nums[i])```
 4. Determine the `dp` array's traversal order
     * `dp[i]` depends on `dp[i - 1]`, so we should traverse the `dp` array from left to right.
 5. Check the `dp` array's value
diff --git a/0392-is-subsequence.md b/0392-is-subsequence.md
@@ -29,35 +29,35 @@ These five steps are a pattern for solving dynamic programming problems.
     * `dp[i][j]` represents whether the first `i` letters of `s` are a subsequence of `t`'s first `j` letters.
     * The value of `dp[i][j]` is `true` or `false`.
 2. Determine the `dp` array's initial value
-   * Use an example:
-```
-After initialized, the 'dp' array would be:
-s = "abc", t = "ahbgdc"
-#     a h b g d c
-#   T T T T T T T # dp[0]
-# a F F F F F F F
-# b F F F F F F F
-# c F F F F F F F
-```
-   * `dp[0][j] = true` because `dp[0]` represents the empty string, and empty string is a subsequence of any string.
-   * `dp[i][j] = false (i != 0)`.
+    * Use an example:
+   ```
+   After initialized, the 'dp' array would be:
+   s = "abc", t = "ahbgdc"
+   #     a h b g d c
+   #   T T T T T T T # dp[0]
+   # a F F F F F F F
+   # b F F F F F F F
+   # c F F F F F F F
+   ```
+    * `dp[0][j] = true` because `dp[0]` represents the empty string, and empty string is a subsequence of any string.
+    * `dp[i][j] = false (i != 0)`.
 3. Determine the `dp` array's recurrence formula
-```
-The final 'dp' array would be:
-s = "abc", t = "ahbgdc"
-#     a h b g d c
-#   T T T T T T T
-# a F T T T T T T
-# b F F F T T T T
-# c F F F F F F T
-```
-   * After analyzing the sample `dp` data, we can derive the `recurrence formula`:
-```
-if s[i - 1] == t[j - 1]
-  dp[i][j] = dp[i - 1][j - 1]
-else
-  dp[i][j] = dp[i][j - 1]
-```
+   ```
+   The final 'dp' array would be:
+   s = "abc", t = "ahbgdc"
+   #     a h b g d c
+   #   T T T T T T T
+   # a F T T T T T T
+   # b F F F T T T T
+   # c F F F F F F T
+   ```
+    * After analyzing the sample `dp` data, we can derive the `recurrence formula`:
+   ```
+   if s[i - 1] == t[j - 1]
+     dp[i][j] = dp[i - 1][j - 1]
+   else
+     dp[i][j] = dp[i][j - 1]
+   ```
 4. Determine the `dp` array's traversal order
     * `dp[i][j]` depends on `dp[i - 1][j - 1]` and `dp[i][j - 1]`, so we should traverse the `dp` array from top to bottom, then from left to right.
 5. Check the `dp` array's value
diff --git a/0583-delete-operation-for-two-strings.md b/0583-delete-operation-for-two-strings.md
@@ -30,32 +30,32 @@ These five steps are a pattern for solving dynamic programming problems.
     * The value of `dp[i][j]` is an integer.
 2. Determine the `dp` array's initial value
     * Use an example:
-```
-After initialized, the 'dp' array would be:  
-#     e a t
-#   0 1 2 3 # dp[0]
-# s 1 0 0 0
-# e 2 0 0 0
-# a 3 0 0 0
-```
-   * `dp[0][j] = j`, because `dp[0]` represents the empty string, and the number of steps is just the number of chars to be deleted.
-   * `dp[i][0] = i`, the reason is the same as previous line, yet in vertical direction.
+   ```
+   After initialized, the 'dp' array would be:  
+   #     e a t
+   #   0 1 2 3 # dp[0]
+   # s 1 0 0 0
+   # e 2 0 0 0
+   # a 3 0 0 0
+   ```
+    * `dp[0][j] = j`, because `dp[0]` represents the empty string, and the number of steps is just the number of chars to be deleted.
+    * `dp[i][0] = i`, the reason is the same as previous line, yet in vertical direction.
 3. Determine the `dp` array's recurrence formula
-```
-The final 'dp' array would be:
-#     e a t
-#   0 1 2 3
-# s 1 2 3 4
-# e 2 1 2 3
-# a 3 2 1 2
-```
-   * After analyzing the sample `dp` data, we can derive the `recurrence formula`:
-```python
-if word1[i - 1] == word2[j - 1]
-    dp[i][j] = dp[i - 1][j - 1]
-else
-    dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1
-```
+   ```
+   The final 'dp' array would be:
+   #     e a t
+   #   0 1 2 3
+   # s 1 2 3 4
+   # e 2 1 2 3
+   # a 3 2 1 2
+   ```
+    * After analyzing the sample `dp` data, we can derive the `recurrence formula`:
+   ```python
+   if word1[i - 1] == word2[j - 1]
+       dp[i][j] = dp[i - 1][j - 1]
+   else
+       dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1
+   ```
 4. Determine the `dp` array's traversal order
     * `dp[i][j]` depends on `dp[i - 1][j - 1]`, `dp[i - 1][j]` and `dp[i][j - 1]`, so we should traverse the `dp` array from top to bottom, then from left to right.
 5. Check the `dp` array's value
