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/java/chapter_dynamic_programming/knapsack.java

@@ -10,58 +10,58 @@ import java.util.Arrays;
 
 public class knapsack {
 
-    /* 0-1 knapsack: Brute-force search */
+    /* 0-1 knapsack: brute-force search */
     static int knapsackDFS(int[] wgt, 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 Math.max(no, yes);
     }
 
-    /* 0-1 knapsack: Memoization search */
+    /* 0-1 knapsack: memoized search */
     static int knapsackDFSMem(int[] wgt, int[] val, 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] = Math.max(no, yes);
         return mem[i][c];
     }
 
-    /* 0-1 knapsack: Dynamic programming */
+    /* 0-1 knapsack: dynamic programming */
     static int knapsackDP(int[] wgt, int[] val, int cap) {
         int n = wgt.length;
-        // Initialize dp table
+        // Initialize the dp table
         int[][] dp = new int[n + 1][cap + 1];
-        // 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] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
                 }
             }
@@ -69,17 +69,17 @@ public class knapsack {
         return dp[n][cap];
     }
 
-    /* 0-1 knapsack: Space-optimized dynamic programming */
+    /* 0-1 knapsack: space-optimized dynamic programming */
     static int knapsackDPComp(int[] wgt, int[] val, int cap) {
         int n = wgt.length;
-        // Initialize dp table
+        // Initialize the dp table
         int[] dp = new int[cap + 1];
-        // 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] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
                 }
             }
@@ -95,22 +95,22 @@ public class knapsack {
 
         // Brute-force search
         int res = knapsackDFS(wgt, val, n, cap);
-        System.out.println("Maximum item value not exceeding knapsack capacity is " + res);
+        System.out.println("Maximum total item value within the knapsack capacity: " + res);
 
-        // Memoization search
+        // Memoized search
         int[][] mem = new int[n + 1][cap + 1];
         for (int[] row : mem) {
             Arrays.fill(row, -1);
         }
         res = knapsackDFSMem(wgt, val, mem, n, cap);
-        System.out.println("Maximum item value not exceeding knapsack capacity is " + res);
+        System.out.println("Maximum total item value within the knapsack capacity: " + res);
 
         // Dynamic programming
         res = knapsackDP(wgt, val, cap);
-        System.out.println("Maximum item value not exceeding knapsack capacity is " + res);
+        System.out.println("Maximum total item value within the knapsack capacity: " + res);
 
         // Space-optimized dynamic programming
         res = knapsackDPComp(wgt, val, cap);
-        System.out.println("Maximum item value not exceeding knapsack capacity is " + res);
+        System.out.println("Maximum total item value within the knapsack capacity: " + res);
     }
 }