Update 0-1KnapsackProblem.java

Author: 17tanya

DynamicProgramming/0-1KnapsackProblem.java

@@ -4,7 +4,8 @@
 */
 
 /*
-In the 0/1 Knapsack Problem we must include an item entirely or exclude the item with an objective of maximizing profit/value constrainted by the size of the knapsack.
+In the 0/1 Knapsack Problem we must include an item entirely or exclude the item with an objective
+of maximizing profit/value constrainted by the size of the knapsack.
 
 If the problem is not 0/1 knapsack and we are allowed to split items, we can take a greedy approach
 we can chose items by sorting items according to profit per unit weight.
@@ -39,12 +40,52 @@ For each item we are exploring the two choices(We include and exclude each item)
 DYNAMIC PROGRAMMING - BOTTOM UP APPROACH
 */
 
-public int knapsack(int W, int item, int wt[], int val[]){
-    int k[][] = new int[item+1][W+1];
+public int knapsack(int W, int items, int wt[], int val[]){
+    int k[][] = new int[items+1][W+1];
 
-    for(int i=0;i<=item;i++){
-        for(int j=0)
+    for(int item=0 ; item <= items ; item++){
+        for(int w=0 ;w <= W ; w++){
+            //Base Case: when items = 0 or capacity of knapsack = 0
+            if(item==0 || w==0) k[item][w] = 0;
+            
+            //if weight of current item exceeds the knapsack capacity we EXCLUDE current item
+            //Simply put the value which was calculated with respect to previous item and same knapsack capacity
+            else if(wt[item-1] > w) k[item][w] = k[item-1][w];
+            
+            //If the weight of item does not exceed knapsack's capacity - we explore 2 choices
+            //1. INCLUDE current item - we find the cell that represents a state which has been calculated with respect to the 
+            //previous item and knapsack's capacity reduced by current item's weight ie, k[item-1][w-wt[item-1]]
+            //2. EXCLUDE current item - value same as the one which was calculated
+            //with respect to previous item and same knapsack capacity
+            else k[item][w] = Math.max( k[item-1][w], val[item-1] + k[item-1][w-wt[item-1]]);
+        }
     }
+    
+    return k[items][W];
 }
 
+/*
+Time and Space Complexity - O(items * knapsackCapacity)
+*/
+
+//RECURSION USING MEMOIZATION
+
+public int knapsack(int W, int item, int wt[], int val[], HashMap<String,Integer> map){
+    if(W==0 || item==0) return 0;
+    
+    String key = item + "|" + W;
+    int include = 0;
+    int exclude = 0;
+    if(!map.containsKey(key)){
+        if(wt[item] < W) include = v[n] + knapsack(W-w[n],item-1,wt,val,map);
+        exclude = knapsack(W,item-1,wt,val,map);
+        
+        map.put(key, Math.max(include,exclude));
+    }
+    return map.get(key);
+}
+
+//Time Complexity - O(n*W)
+//where n - number of items and W - capacity of knapsack
+