Add "reference" for EN version. Bug fixes. (#1326)

en/docs/chapter_dynamic_programming/dp_problem_features.md

@@ -1,4 +1,4 @@
-# Dynamic programming problem characteristics
+# Characteristics of dynamic programming problems
 
 In the previous section, we learned how dynamic programming solves the original problem by decomposing it into subproblems. In fact, subproblem decomposition is a general algorithmic approach, with different emphases in divide and conquer, dynamic programming, and backtracking.
 

en/docs/chapter_dynamic_programming/edit_distance_problem.md

@@ -33,7 +33,7 @@ We aim to gradually reduce the problem size during the edit process, which enabl
 
 Thus, each round of decision (edit operation) in string $s$ changes the remaining characters in $s$ and $t$ to be matched. Therefore, the state is the $i$-th and $j$-th characters currently considered in $s$ and $t$, denoted as $[i, j]$.
 
-State $[i, j]$ corresponds to the subproblem: **The minimum number of edits required to change the first $i$ characters of $s$ into the first $j$ characters of $t**.
+State $[i, j]$ corresponds to the subproblem: **The minimum number of edits required to change the first $i$ characters of $s$ into the first $j$ characters of $t$**.
 
 From this, we obtain a two-dimensional $dp$ table of size $(i+1) \times (j+1)$.
 
@@ -122,7 +122,7 @@ As shown below, the process of state transition in the edit distance problem is
 
 Since $dp[i, j]$ is derived from the solutions above $dp[i-1, j]$, to the left $dp[i, j-1]$, and to the upper left $dp[i-1, j-1]$, and direct traversal will lose the upper left solution $dp[i-1, j-1]$, and reverse traversal cannot build $dp[i, j-1]$ in advance, therefore, both traversal orders are not feasible.
 
-For this reason, we can use a variable `leftup` to temporarily store the solution from the upper left $dp[i-1, j-1]`, thus only needing to consider the solutions to the left and above. This situation is similar to the complete knapsack problem, allowing for direct traversal. The code is as follows:
+For this reason, we can use a variable `leftup` to temporarily store the solution from the upper left $dp[i-1, j-1]$, thus only needing to consider the solutions to the left and above. This situation is similar to the unbounded knapsack problem, allowing for direct traversal. The code is as follows:
 
 ```src
 [file]{edit_distance}-[class]{}-[func]{edit_distance_dp_comp}

en/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -1,4 +1,4 @@
-# Initial exploration of dynamic programming
+# Introduction to dynamic programming
 
 <u>Dynamic programming</u> is an important algorithmic paradigm that decomposes a problem into a series of smaller subproblems, and stores the solutions of these subproblems to avoid redundant computations, thereby significantly improving time efficiency.
 

en/docs/chapter_dynamic_programming/knapsack_problem.md

@@ -1,6 +1,6 @@
 # 0-1 Knapsack problem
 
-The knapsack problem is an excellent introductory problem for dynamic programming and is the most common type of problem in dynamic programming. It has many variants, such as the 0-1 knapsack problem, the complete knapsack problem, and the multiple knapsack problem, etc.
+The knapsack problem is an excellent introductory problem for dynamic programming and is the most common type of problem in dynamic programming. It has many variants, such as the 0-1 knapsack problem, the unbounded knapsack problem, and the multiple knapsack problem, etc.
 
 In this section, we will first solve the most common 0-1 knapsack problem.
 

en/docs/chapter_dynamic_programming/summary.md

@@ -10,14 +10,14 @@
 
 **Knapsack problem**
 
-- The knapsack problem is one of the most typical dynamic programming problems, with variants including the 0-1 knapsack, complete knapsack, and multiple knapsacks.
+- The knapsack problem is one of the most typical dynamic programming problems, with variants including the 0-1 knapsack, unbounded knapsack, and multiple knapsacks.
 - The state definition of the 0-1 knapsack is the maximum value in a knapsack of capacity $c$ with the first $i$ items. Based on decisions not to include or to include an item in the knapsack, optimal substructures can be identified and state transition equations constructed. In space optimization, since each state depends on the state directly above and to the upper left, the list should be traversed in reverse order to avoid overwriting the upper left state.
-- In the complete knapsack problem, there is no limit on the number of each kind of item that can be chosen, thus the state transition for including items differs from the 0-1 knapsack. Since the state depends on the state directly above and to the left, space optimization should involve forward traversal.
-- The coin change problem is a variant of the complete knapsack problem, shifting from seeking the “maximum” value to seeking the “minimum” number of coins, thus the state transition equation should change $\max()$ to $\min()$. From pursuing “not exceeding” the capacity of the knapsack to seeking exactly the target amount, thus use $amt + 1$ to represent the invalid solution of “unable to make up the target amount.”
+- In the unbounded knapsack problem, there is no limit on the number of each kind of item that can be chosen, thus the state transition for including items differs from the 0-1 knapsack. Since the state depends on the state directly above and to the left, space optimization should involve forward traversal.
+- The coin change problem is a variant of the unbounded knapsack problem, shifting from seeking the “maximum” value to seeking the “minimum” number of coins, thus the state transition equation should change $\max()$ to $\min()$. From pursuing “not exceeding” the capacity of the knapsack to seeking exactly the target amount, thus use $amt + 1$ to represent the invalid solution of “unable to make up the target amount.”
 - Coin Change Problem II shifts from seeking the “minimum number of coins” to seeking the “number of coin combinations,” changing the state transition equation accordingly from $\min()$ to summation operator.
 
 **Edit distance problem**
 
 - Edit distance (Levenshtein distance) measures the similarity between two strings, defined as the minimum number of editing steps needed to change one string into another, with editing operations including adding, deleting, or replacing.
 - The state definition for the edit distance problem is the minimum number of editing steps needed to change the first $i$ characters of $s$ into the first $j$ characters of $t$. When $s[i] \ne t[j]$, there are three decisions: add, delete, replace, each with their corresponding residual subproblems. From this, optimal substructures can be identified, and state transition equations built. When $s[i] = t[j]$, no editing of the current character is necessary.
-- In edit distance, the state depends on the state directly above, to the left, and to the upper left. Therefore, after space optimization, neither forward nor reverse traversal can correctly perform state transitions. To address this, we use a variable to temporarily store the upper left state, making it equivalent to the situation in the complete knapsack problem, allowing for forward traversal after space optimization.
+- In edit distance, the state depends on the state directly above, to the left, and to the upper left. Therefore, after space optimization, neither forward nor reverse traversal can correctly perform state transitions. To address this, we use a variable to temporarily store the upper left state, making it equivalent to the situation in the unbounded knapsack problem, allowing for forward traversal after space optimization.

en/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md

@@ -1,23 +1,23 @@
-# Complete knapsack problem
+# Unbounded knapsack problem
 
-In this section, we first solve another common knapsack problem: the complete knapsack, and then explore a special case of it: the coin change problem.
+In this section, we first solve another common knapsack problem: the unbounded knapsack, and then explore a special case of it: the coin change problem.
 
-## Complete knapsack problem
+## Unbounded knapsack problem
 
 !!! question
 
     Given $n$ items, where the weight of the $i^{th}$ item is $wgt[i-1]$ and its value is $val[i-1]$, and a backpack with a capacity of $cap$. **Each item can be selected multiple times**. What is the maximum value of the items that can be put into the backpack without exceeding its capacity? See the example below.
 
-![Example data for the complete knapsack problem](unbounded_knapsack_problem.assets/unbounded_knapsack_example.png)
+![Example data for the unbounded knapsack problem](unbounded_knapsack_problem.assets/unbounded_knapsack_example.png)
 
 ### Dynamic programming approach
 
-The complete knapsack problem is very similar to the 0-1 knapsack problem, **the only difference being that there is no limit on the number of times an item can be chosen**.
+The unbounded knapsack problem is very similar to the 0-1 knapsack problem, **the only difference being that there is no limit on the number of times an item can be chosen**.
 
 - In the 0-1 knapsack problem, there is only one of each item, so after placing item $i$ into the backpack, you can only choose from the previous $i-1$ items.
-- In the complete knapsack problem, the quantity of each item is unlimited, so after placing item $i$ in the backpack, **you can still choose from the previous $i$ items**.
+- In the unbounded knapsack problem, the quantity of each item is unlimited, so after placing item $i$ in the backpack, **you can still choose from the previous $i$ items**.
 
-Under the rules of the complete knapsack problem, the state $[i, c]$ can change in two ways.
+Under the rules of the unbounded knapsack problem, the state $[i, c]$ can change in two ways.
 
 - **Not putting item $i$ in**: As with the 0-1 knapsack problem, transition to $[i-1, c]$.
 - **Putting item $i$ in**: Unlike the 0-1 knapsack problem, transition to $[i, c-wgt[i-1]]$.
@@ -43,7 +43,7 @@ Since the current state comes from the state to the left and above, **the space-
 This traversal order is the opposite of that for the 0-1 knapsack. Please refer to the following figures to understand the difference.
 
 === "<1>"
-    ![Dynamic programming process for the complete knapsack problem after space optimization](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step1.png)
+    ![Dynamic programming process for the unbounded knapsack problem after space optimization](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step1.png)
 
 === "<2>"
     ![unbounded_knapsack_dp_comp_step2](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step2.png)
@@ -78,11 +78,11 @@ The knapsack problem is a representative of a large class of dynamic programming
 
 ### Dynamic programming approach
 
-**The coin change can be seen as a special case of the complete knapsack problem**, sharing the following similarities and differences.
+**The coin change can be seen as a special case of the unbounded knapsack problem**, sharing the following similarities and differences.
 
 - The two problems can be converted into each other: "item" corresponds to "coin", "item weight" corresponds to "coin denomination", and "backpack capacity" corresponds to "target amount".
-- The optimization goals are opposite: the complete knapsack problem aims to maximize the value of items, while the coin change problem aims to minimize the number of coins.
-- The complete knapsack problem seeks solutions "not exceeding" the backpack capacity, while the coin change seeks solutions that "exactly" make up the target amount.
+- The optimization goals are opposite: the unbounded knapsack problem aims to maximize the value of items, while the coin change problem aims to minimize the number of coins.
+- The unbounded knapsack problem seeks solutions "not exceeding" the backpack capacity, while the coin change seeks solutions that "exactly" make up the target amount.
 
 **First step: Think through each round's decision-making, define the state, and thus derive the $dp$ table**
 
@@ -92,7 +92,7 @@ The two-dimensional $dp$ table is of size $(n+1) \times (amt+1)$.
 
 **Second step: Identify the optimal substructure and derive the state transition equation**
 
-This problem differs from the complete knapsack problem in two aspects of the state transition equation.
+This problem differs from the unbounded knapsack problem in two aspects of the state transition equation.
 
 - This problem seeks the minimum, so the operator $\max()$ needs to be changed to $\min()$.
 - The optimization is focused on the number of coins, so simply add $+1$ when a coin is chosen.
@@ -117,7 +117,7 @@ For this reason, we use the number $amt + 1$ to represent an invalid solution, b
 [file]{coin_change}-[class]{}-[func]{coin_change_dp}
 ```
 
-The following images show the dynamic programming process for the coin change problem, which is very similar to the complete knapsack problem.
+The following images show the dynamic programming process for the coin change problem, which is very similar to the unbounded knapsack problem.
 
 === "<1>"
     ![Dynamic programming process for the coin change problem](unbounded_knapsack_problem.assets/coin_change_dp_step1.png)
@@ -166,7 +166,7 @@ The following images show the dynamic programming process for the coin change pr
 
 ### Space optimization
 
-The space optimization for the coin change problem is handled in the same way as for the complete knapsack problem:
+The space optimization for the coin change problem is handled in the same way as for the unbounded knapsack problem:
 
 ```src
 [file]{coin_change}-[class]{}-[func]{coin_change_dp_comp}