feat: Add 0/1 Knapsack and its tabulation implementation with their corresponding tests

Author: o000SAI000o

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

@@ -0,0 +1,50 @@
+package com.thealgorithms.dynamicprogramming;
+
+/**
+ * Class to solve the 0/1 Knapsack Problem using recursion.
+ *
+ * The 0/1 Knapsack problem is a classic dynamic programming problem
+ * where we are given weights and values of `n` items. We need to put
+ * these items in a knapsack of capacity `W` to get the maximum total value
+ * in the knapsack. We can either include an item or exclude it — but cannot
+ * include it more than once.
+ *
+ * Time Complexity: O(2^n) in worst case for the pure recursive approach (due to overlapping subproblems).
+ * Using memoization or bottom-up dynamic programming reduces the time complexity to O(nW).
+ *
+ * Example:
+ * val[] = {15, 14, 10, 45, 30}
+ * wt[]  = {2, 5, 1, 3, 4}
+ * W = 7
+ * Output: 75
+ */
+public class ZeroOneKnapsack {
+
+    /**
+     * Solves the 0/1 Knapsack problem using recursion.
+     *
+     * @param val Array of item values (must have length at least n)
+     * @param wt  Array of item weights (must have length at least n)
+     * @param W   Total capacity of the knapsack
+     * @param n   Number of items to consider
+     * @return The maximum value that can be obtained
+     */
+    public static int knapsack(int[] val, int[] wt, int W, int n) {
+        if (val == null || wt == null || val.length != wt.length) {
+            throw new IllegalArgumentException("Value and weight arrays must be non-null and of equal length.");
+        }
+        if (W == 0 || n == 0) {
+            return 0;
+        }
+        if (wt[n - 1] <= W) {
+            // Include the current item
+            int include = val[n - 1] + knapsack(val, wt, W - wt[n - 1], n - 1);
+            // Exclude the current item
+            int exclude = knapsack(val, wt, W, n - 1);
+            return Math.max(include, exclude);
+        } else {
+            // Cannot include the item, move to next
+            return knapsack(val, wt, W, n - 1);
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+package com.thealgorithms.dynamicprogramming;
+
+/**
+ * Dynamic Programming approach for solving 0-1 Knapsack problem using tabulation.
+ * 
+ * Problem Statement:
+ * Given weights and values of n items, put these items in a knapsack of capacity W 
+ * to get the maximum total value in the knapsack. You cannot break an item.
+ *
+ * Time Complexity: O(n * W)
+ * Space Complexity: O(n * W)
+ */
+public class ZeroOneKnapsackTab {
+
+    /**
+     * Solves the 0-1 Knapsack problem using a tabulation approach (bottom-up DP).
+     *
+     * @param val The values of the items
+     * @param wt The weights of the items
+     * @param W The total capacity of the knapsack
+     * @param n The number of items
+     * @return The maximum value that can be put in a knapsack of capacity W
+     */
+    public static int knapsackTab(int[] val, int[] wt, int W, int n) {
+        int[][] dp = new int[n + 1][W + 1];
+
+        for (int i = 1; i <= n; i++) {
+            int v = val[i - 1]; // value of current item
+            int w = wt[i - 1];  // weight of current item
+            for (int j = 1; j <= W; j++) {
+                if (w <= j) {
+                    int include = v + dp[i - 1][j - w];
+                    int exclude = dp[i - 1][j];
+                    dp[i][j] = Math.max(include, exclude);
+                } else {
+                    dp[i][j] = dp[i - 1][j];
+                }
+            }
+        }
+        return dp[n][W];
+    }
+}

src/test/java/com/thealgorithms/dynamicprogramming/ZeroOneKnapsackTabTest.java

@@ -0,0 +1,49 @@
+package com.thealgorithms.dynamicprogramming;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Unit tests for the ZeroOneKnapsackTab class.
+ */
+public class ZeroOneKnapsackTabTest {
+
+    /**
+     * Test knapsackTab with a typical set of values and weights.
+     * Checks if the maximum value for the given capacity is correct.
+     */
+    @Test
+    public void testKnapsackTab() {
+        int[] val = {15, 14, 10, 45, 30};
+        int[] wt = {2, 5, 1, 3, 4};
+        int W = 7;
+        int expected = 75;
+        assertEquals(expected, ZeroOneKnapsackTab.knapsackTab(val, wt, W, val.length));
+    }
+
+    /**
+     * Test knapsackTab with empty arrays.
+     * Should return 0 as there are no items to include.
+     */
+    @Test
+    public void testKnapsackTabEmpty() {
+        int[] val = {};
+        int[] wt = {};
+        int W = 10;
+        int expected = 0;
+        assertEquals(expected, ZeroOneKnapsackTab.knapsackTab(val, wt, W, 0));
+    }
+
+    /**
+     * Test knapsackTab with zero capacity.
+     * Should return 0 as no items can be included.
+     */
+    @Test
+    public void testKnapsackTabZeroCapacity() {
+        int[] val = {10, 20, 30};
+        int[] wt = {1, 1, 1};
+        int W = 0;
+        int expected = 0;
+        assertEquals(expected, ZeroOneKnapsackTab.knapsackTab(val, wt, W, val.length));
+    }
+}

src/test/java/com/thealgorithms/dynamicprogramming/ZeroOneKnapsackTest.java

@@ -0,0 +1,60 @@
+package com.thealgorithms.dynamicprogramming;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the ZeroOneKnapsack algorithm.
+ */
+public class ZeroOneKnapsackTest {
+
+    /**
+     * Test the knapsack algorithm with a basic example.
+     */
+    @Test
+    void testKnapsackBasic() {
+        int[] val = {15, 14, 10, 45, 30};
+        int[] wt = {2, 5, 1, 3, 4};
+        int W = 7;
+        int expected = 75;
+        assertEquals(expected, ZeroOneKnapsack.knapsack(val, wt, W, val.length));
+    }
+
+    /**
+     * Test the knapsack algorithm when the knapsack capacity is zero.
+     * Expected result is zero since nothing can be added.
+     */
+    @Test
+    void testZeroCapacity() {
+        int[] val = {10, 20, 30};
+        int[] wt = {1, 1, 1};
+        int W = 0;
+        int expected = 0;
+        assertEquals(expected, ZeroOneKnapsack.knapsack(val, wt, W, val.length));
+    }
+
+    /**
+     * Test the knapsack algorithm when there are no items.
+     * Expected result is zero since there is nothing to add.
+     */
+    @Test
+    void testNoItems() {
+        int[] val = {};
+        int[] wt = {};
+        int W = 10;
+        int expected = 0;
+        assertEquals(expected, ZeroOneKnapsack.knapsack(val, wt, W, 0));
+    }
+
+    /**
+     * Test the knapsack algorithm with items that exactly fit the knapsack.
+     */
+    @Test
+    void testExactFit() {
+        int[] val = {60, 100, 120};
+        int[] wt = {10, 20, 30};
+        int W = 50;
+        int expected = 220;
+        assertEquals(expected, ZeroOneKnapsack.knapsack(val, wt, W, val.length));
+    }
+}