Retranslate the complete English edition from Simplified Chinese (#2010)

* Retranslate the complete English edition from Simplified Chinese

* Polish three English explanations after reader-focused review

en/codes/cpp/chapter_dynamic_programming/knapsack.cpp

@@ -4,58 +4,58 @@
 
 using namespace std;
 
-/* 0-1 knapsack: Brute-force search */
+/* 0-1 knapsack: brute-force search */
 int knapsackDFS(vector<int> &wgt, vector<int> &val, int i, int c) {
-    // If all items have been selected or knapsack has no remaining capacity, return value 0
+    // If all items have been considered or no capacity remains, return value 0
     if (i == 0 || c == 0) {
         return 0;
     }
-    // If exceeds knapsack capacity, can only choose not to put it in
+    // If the item exceeds the remaining capacity, it must be excluded
     if (wgt[i - 1] > c) {
         return knapsackDFS(wgt, val, i - 1, c);
     }
-    // Calculate the maximum value of not putting in and putting in item i
+    // Calculate the maximum values obtained by excluding and including item i
     int no = knapsackDFS(wgt, val, i - 1, c);
     int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
-    // Return the larger value of the two options
+    // Return the larger value from the two choices
     return max(no, yes);
 }
 
-/* 0-1 knapsack: Memoization search */
+/* 0-1 knapsack: memoized search */
 int knapsackDFSMem(vector<int> &wgt, vector<int> &val, vector<vector<int>> &mem, int i, int c) {
-    // If all items have been selected or knapsack has no remaining capacity, return value 0
+    // If all items have been considered or no capacity remains, return value 0
     if (i == 0 || c == 0) {
         return 0;
     }
-    // If there's a record, return it directly
+    // If a result has already been recorded, return it directly
     if (mem[i][c] != -1) {
         return mem[i][c];
     }
-    // If exceeds knapsack capacity, can only choose not to put it in
+    // If the item exceeds the remaining capacity, it must be excluded
     if (wgt[i - 1] > c) {
         return knapsackDFSMem(wgt, val, mem, i - 1, c);
     }
-    // Calculate the maximum value of not putting in and putting in item i
+    // Calculate the maximum values obtained by excluding and including item i
     int no = knapsackDFSMem(wgt, val, mem, i - 1, c);
     int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
-    // Record and return the larger value of the two options
+    // Record and return the larger value from the two choices
     mem[i][c] = max(no, yes);
     return mem[i][c];
 }
 
-/* 0-1 knapsack: Dynamic programming */
+/* 0-1 knapsack: dynamic programming */
 int knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
     int n = wgt.size();
-    // Initialize dp table
+    // Initialize the dp table
     vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));
-    // State transition
+    // State transitions
     for (int i = 1; i <= n; i++) {
         for (int c = 1; c <= cap; c++) {
             if (wgt[i - 1] > c) {
-                // If exceeds knapsack capacity, don't select item i
+                // If item i exceeds the remaining capacity, do not choose it
                 dp[i][c] = dp[i - 1][c];
             } else {
-                // The larger value between not selecting and selecting item i
+                // Take the larger value obtained by excluding and including item i
                 dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
             }
         }
@@ -63,17 +63,17 @@ int knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
     return dp[n][cap];
 }
 
-/* 0-1 knapsack: Space-optimized dynamic programming */
+/* 0-1 knapsack: space-optimized dynamic programming */
 int knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
     int n = wgt.size();
-    // Initialize dp table
+    // Initialize the dp table
     vector<int> dp(cap + 1, 0);
-    // State transition
+    // State transitions
     for (int i = 1; i <= n; i++) {
-        // Traverse in reverse order
+        // Traverse in decreasing order
         for (int c = cap; c >= 1; c--) {
             if (wgt[i - 1] <= c) {
-                // The larger value between not selecting and selecting item i
+                // Take the larger value obtained by excluding and including item i
                 dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
             }
         }
@@ -81,7 +81,7 @@ int knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
     return dp[cap];
 }
 
-/* Driver Code */
+/* Driver code */
 int main() {
     vector<int> wgt = {10, 20, 30, 40, 50};
     vector<int> val = {50, 120, 150, 210, 240};
@@ -90,20 +90,20 @@ int main() {
 
     // Brute-force search
     int res = knapsackDFS(wgt, val, n, cap);
-    cout << "Maximum item value not exceeding knapsack capacity is " << res << endl;
+    cout << "Maximum total item value within the knapsack capacity: " << res << endl;
 
-    // Memoization search
+    // Memoized search
     vector<vector<int>> mem(n + 1, vector<int>(cap + 1, -1));
     res = knapsackDFSMem(wgt, val, mem, n, cap);
-    cout << "Maximum item value not exceeding knapsack capacity is " << res << endl;
+    cout << "Maximum total item value within the knapsack capacity: " << res << endl;
 
     // Dynamic programming
     res = knapsackDP(wgt, val, cap);
-    cout << "Maximum item value not exceeding knapsack capacity is " << res << endl;
+    cout << "Maximum total item value within the knapsack capacity: " << res << endl;
 
     // Space-optimized dynamic programming
     res = knapsackDPComp(wgt, val, cap);
-    cout << "Maximum item value not exceeding knapsack capacity is " << res << endl;
+    cout << "Maximum total item value within the knapsack capacity: " << res << endl;
 
     return 0;
 }