Update 01 - Recursive Approach (caused TLE).cpp

Author: JawadSher

24 - Dynamic Programming Problems/11 - 0-1 Knapsack Problem/01 - Recursive Approach (caused TLE).cpp

@@ -1,38 +1,39 @@
-// Solution class for 0/1 Knapsack problem
 class Solution {
   public:
-    // Recursive function to solve the 0/1 Knapsack problem
+    // Recursive function to solve the knapsack problem
     int solve(int capacity, vector<int> &value, vector<int> &weight, int index){
-        // Base case: if we've considered all items, return the value of the last item
-        // if it fits in the knapsack, otherwise return 0
+        
+        // Base case: If we are at the first item (index 0)
         if(index == 0){
+            // If the weight of the first item is less than or equal to the remaining capacity, return its value
             if(weight[0] <= capacity) return value[0];
+            // Otherwise, return 0 because we cannot include this item in the knapsack
             else return 0;
         }
 
-        // Initialize variables to store the maximum value with and without the current item
+        // Variable to store the value if we include the current item
         int include = 0;
-        
-        // If the current item fits in the knapsack, consider including it
+        // Check if the current item's weight is less than or equal to the remaining capacity
         if(weight[index] <= capacity) {
-            // Recursively call the function with the remaining capacity and items
+            // If we include the current item, reduce the capacity by the item's weight, and add its value
+            // Recursively solve the remaining problem (remaining capacity and items)
             include = solve(capacity - weight[index], value, weight, index-1) + value[index];
         }
 
-        // Consider excluding the current item
-        int exclude = solve(capacity, value, weight, index-1) + 0;
+        // Variable to store the value if we exclude the current item
+        int exclude = 0;
+        // If we exclude the current item, just solve the problem with the remaining items and the same capacity
+        exclude = solve(capacity, value, weight, index-1);
 
-        // Return the maximum value between including and excluding the current item
+        // Return the maximum of the two values: including the item or excluding the item
         return max(include, exclude);
     }
 
-    // Function to initialize and call the recursive solve function
+    // Function to initialize and call the recursive function to solve the knapsack problem
     int knapSack(int capacity, vector<int> &val, vector<int> &wt) {
 
-        // Get the number of items
-        int n = wt.size();
-        
-        // Call the recursive solve function with the initial capacity and all items
+        int n = wt.size();  // Get the number of items
+        // Start the recursive function with the full capacity and all items (index n-1)
         return solve(capacity, val, wt, n-1);
     }
 };