Remove duplicate KnapsackMemoization (#3769)

src/main/java/com/thealgorithms/dynamicprogramming/KnapsackMemoization.java

@@ -1,51 +1,52 @@
 package com.thealgorithms.dynamicprogramming;
 
-import java.util.Arrays;
-
 /**
  * Recursive Solution for 0-1 knapsack with memoization
+ * This method is basically an extension to the recursive approach so that we
+ * can overcome the problem of calculating redundant cases and thus increased
+ * complexity. We can solve this problem by simply creating a 2-D array that can
+ * store a particular state (n, w) if we get it the first time.
  */
 public class KnapsackMemoization {
 
-    private static int[][] t;
+    int knapSack(int W, int wt[], int val[], int N) {
 
-    // Returns the maximum value that can
-    // be put in a knapsack of capacity W
-    public static int knapsack(int[] wt, int[] value, int W, int n) {
-        if (t[n][W] != -1) {
-            return t[n][W];
+        // Declare the table dynamically
+        int dp[][] = new int[N + 1][W + 1];
+
+        // Loop to initially filled the
+        // table with -1
+        for (int i = 0; i < N + 1; i++) {
+            for (int j = 0; j < W + 1; j++) {
+                dp[i][j] = -1;
+            }
         }
+
+        return knapSackRec(W, wt, val, N, dp);
+    }
+
+    // Returns the value of maximum profit using Recursive approach
+    int knapSackRec(int W, int wt[],
+            int val[], int n,
+            int[][] dp) {
+
+        // Base condition
         if (n == 0 || W == 0) {
             return 0;
         }
-        if (wt[n - 1] <= W) {
-            t[n - 1][W - wt[n - 1]] = knapsack(wt, value, W - wt[n - 1], n - 1);
-            // Include item in the bag. In that case add the value of the item and call for the remaining items
-            int tmp1 = value[n - 1] + t[n - 1][W - wt[n - 1]];
-            // Don't include the nth item in the bag anl call for remaining item without reducing the weight
-            int tmp2 = knapsack(wt, value, W, n - 1);
-            t[n - 1][W] = tmp2;
-            // include the larger one
-            int tmp = tmp1 > tmp2 ? tmp1 : tmp2;
-            t[n][W] = tmp;
-            return tmp;
-            // If Weight for the item is more than the desired weight then don't include it
-            // Call for rest of the n-1 items
-        } else if (wt[n - 1] > W) {
-            t[n][W] = knapsack(wt, value, W, n - 1);
-            return t[n][W];
-        }
-        return -1;
-    }
 
-    // Driver code
-    public static void main(String args[]) {
-        int[] wt = { 1, 3, 4, 5 };
-        int[] value = { 1, 4, 5, 7 };
-        int W = 10;
-        t = new int[wt.length + 1][W + 1];
-        Arrays.stream(t).forEach(a -> Arrays.fill(a, -1));
-        int res = knapsack(wt, value, W, wt.length);
-        System.out.println("Maximum knapsack value " + res);
+        if (dp[n][W] != -1) {
+            return dp[n][W];
+        }
+
+        if (wt[n - 1] > W) {
+            // Store the value of function call stack in table
+            dp[n][W] = knapSackRec(W, wt, val, n - 1, dp);
+            return dp[n][W];
+        } else {
+            // Return value of table after storing
+            return dp[n][W] = Math.max((val[n - 1] + knapSackRec(W - wt[n - 1], wt, val, n - 1, dp)),
+                    knapSackRec(W, wt, val, n - 1, dp));
+        }
     }
 }

src/main/java/com/thealgorithms/dynamicprogramming/MemoizationTechniqueKnapsack.java

@@ -1,68 +0,0 @@
-package com.thealgorithms.dynamicprogramming;
-
-// Here is the top-down approach of
-// dynamic programming
-
-public class MemoizationTechniqueKnapsack {
-
-    // A utility function that returns
-    // maximum of two integers
-    static int max(int a, int b) {
-        return (a > b) ? a : b;
-    }
-
-    // Returns the value of maximum profit
-    static int knapSackRec(int W, int wt[], int val[], int n, int[][] dp) {
-        // Base condition
-        if (n == 0 || W == 0) {
-            return 0;
-        }
-
-        if (dp[n][W] != -1) {
-            return dp[n][W];
-        }
-
-        if (
-            wt[n - 1] > W
-        ) { // stack in table before return // Store the value of function call
-            return dp[n][W] = knapSackRec(W, wt, val, n - 1, dp);
-        } else { // Return value of table after storing
-            return (
-                dp[n][W] =
-                    max(
-                        (
-                            val[n - 1] +
-                            knapSackRec(W - wt[n - 1], wt, val, n - 1, dp)
-                        ),
-                        knapSackRec(W, wt, val, n - 1, dp)
-                    )
-            );
-        }
-    }
-
-    static int knapSack(int W, int wt[], int val[], int N) {
-        // Declare the table dynamically
-        int dp[][] = new int[N + 1][W + 1];
-
-        // Loop to initially filled the
-        // table with -1
-        for (int i = 0; i < N + 1; i++) {
-            for (int j = 0; j < W + 1; j++) {
-                dp[i][j] = -1;
-            }
-        }
-
-        return knapSackRec(W, wt, val, N, dp);
-    }
-
-    // Driver Code
-    public static void main(String[] args) {
-        int val[] = { 60, 100, 120 };
-        int wt[] = { 10, 20, 30 };
-
-        int W = 50;
-        int N = val.length;
-
-        System.out.println(knapSack(W, wt, val, N));
-    }
-}