Add files via upload

Author: yashk9293

01_Recursive_Knapsack.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+using namespace std;
+
+int Knapsack(int wt[], int val[], int W, int n) {
+	// every recursive solution will have a base condition 
+    // for base condition we need to think of the smallest valid input that we can pass 
+    // array size can be atleast 0 || min weight can be 0 but not negetive; 
+	if (n == 0 || W == 0)
+		return 0;
+
+	// these are the choices we are having 
+	if (wt[n - 1] <= W) {
+		return max(val[n - 1] + Knapsack(wt, val, W - wt[n - 1], n - 1), Knapsack(wt, val, W, n - 1));
+	}
+	else if (wt[n - 1] > W) // if the weight is greater then the required weight there is no sence for taking that value. 
+		return Knapsack(wt, val, W, n - 1); // return as it is by redusing the size of array 
+	else
+		return -1; 
+}
+
+int main() {
+	int n,W; 
+    cin >> n; // number of items
+	int val[n], wt[n]; // values and weights of array
+	for (int i = 0; i < n; i++)
+		cin >> wt[i];
+	for (int i = 0; i < n; i++)
+		cin >> val[i];
+	
+    cin >> W; // Knapsack capacity
+
+	cout << Knapsack(wt, val, W, n) << endl;
+	return 0;
+}
+// T(N) = 2T(N-1) + O(1), which is simplified to O(2^N).

02_Knapsack_memoization.cpp

@@ -0,0 +1,45 @@
+#include <iostream>
+using namespace std;
+
+const int D = 1000; // DP - matrix dimension
+
+int t[D][D]; // DP matrix
+
+int Knapsack(int wt[], int val[], int W, int n) {
+	// base case
+	if (n == 0 || W == 0)
+		return 0;
+
+	// if already calculated
+	if (t[n][W] != -1)
+		return t[n][W];
+  
+	// else calculate
+	else {
+		if (wt[n - 1] <= W)
+			t[n][W] = max(val[n - 1] + Knapsack(wt, val, W - wt[n - 1], n - 1),Knapsack(wt, val, W, n - 1));
+		else if (wt[n - 1] > W)
+			t[n][W] = Knapsack(wt, val, W, n - 1);
+
+		return t[n][W];
+	}
+}
+
+signed main() {
+	int n; cin >> n;   // number of items
+	int val[n], wt[n]; // values and wts array
+	for (int i = 0; i < n; i++)
+		cin >> wt[i];
+	for (int i = 0; i < n; i++)
+		cin >> val[i];
+	int W; 
+    cin >> W;   // capacity
+
+	// matrix initialization
+	for (int i = 0; i <= n; i++)
+		for (int j = 0; j <= W; j++)
+			t[i][j] = -1; // initialize matrix with -1
+
+	cout << Knapsack(wt, val, W, n) << endl;
+	return 0;
+}

03_Knapsack_BottomUp.cpp

@@ -0,0 +1,34 @@
+// Question Link :- https://www.geeksforgeeks.org/problems/0-1-knapsack-problem0945/1
+// 0 - 1 Knapsack Problem
+
+// Notes - https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/
+
+// T.C = O(N*W), where ‘N’ is the number of weight element and ‘W’ is capacity. As for every weight 
+// element we traverse through all weight capacities 1<=w<=W.
+// S.C = O(N*W) (2-D array of size ‘N*W’)
+
+
+class Solution {
+    public:
+    int knapSack(int W, int wt[], int val[], int n) {
+        int t[n + 1][W + 1];
+        for (int i = 0; i<n+1; i++) {
+    		for (int j = 0; j<W+1; j++) {
+    			if (i == 0 || j == 0) {// initialization
+    				t[i][j] = 0;
+				}
+    		}
+    	}
+    	for (int i = 1; i<n+1; i++) {
+    		for (int j = 1; j<W+1; j++) {
+    			if (wt[i - 1] <= j) {  // current wt can fit in bag
+    				t[i][j] = max(val[i - 1] + t[i - 1][j - wt[i - 1]], t[i - 1][j]);
+    			}
+    			else if (wt[i - 1] > j) {  // current wt doesn't fit in bag
+    				t[i][j] = t[i - 1][j]; // move to next
+    			}
+			}
+    	}
+    	return t[n][W];
+    }
+};

04_SubsetSum.cpp

@@ -0,0 +1,34 @@
+// Question Link :- https://www.geeksforgeeks.org/problems/subset-sum-problem-1611555638/1
+// Subset Sum Problem
+
+// T.C = O(sum*n)
+// S.C = O(sum*n)
+class Solution {
+public:
+    bool isSubsetSum(vector<int>arr, int sum) {
+        int n = arr.size();
+        bool t[n + 1][sum + 1];
+    	// initialization
+    	for (int i=0; i<n+1; i++) {          // i -> size of the array
+    		for (int j=0; j<sum+1; j++) {    // j -> target sum (subset sum)
+    			if (i == 0) {
+    				t[i][j] = false;
+    			}
+    			if (j == 0) {
+    				t[i][j] = true;
+    			}
+    		}
+    	}
+    	for (int i = 1; i<n+1; i++) {
+    		for (int j = 1; j<sum+1; j++) {
+    			if (arr[i - 1] <= j) {   // if element of arr is smaller than the target sum
+    				t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; // either take or(||) do not take 
+    			} 
+				else {  // if element of arr is greater than the target sum
+    				t[i][j] = t[i - 1][j];
+    			}
+    		}
+    	}
+    	return t[n][sum]; // at last return T/F
+    }
+};

05_EqualSumPartition.cpp

@@ -0,0 +1,47 @@
+// Question Link :- https://leetcode.com/problems/partition-equal-subset-sum/
+// Partition Equal Subset Sum
+
+// T.C = O(sum*n)
+// S.C = O(sum)
+class Solution {
+public:
+    bool isSubsetPossible(vector<int>& arr, int n, int sum) {
+    	bool t[n + 1][sum + 1]; // DP - matrix
+    	// initialization
+    	for (int i = 0; i<n+1; i++) {   // i -> size of array
+    		for (int j = 0; j<sum+1; j++) {  // j -> target sum (subset sum)
+    			// when array(i) is empty than there is no meaning of sum of elements so return false
+    			if (i == 0) {
+    				t[i][j] = false;
+    			}
+    			// when sum(j) is zero and there is always a chance of empty subset so return it as true;
+    			if (j == 0) { 
+    				t[i][j] = true;
+    			}
+    		}
+    	}
+    	for (int i = 1; i <n+1; i++) {
+    		for (int j = 1; j <sum+1; j++) {
+    			if (arr[i - 1] <= j) {
+                    // after taking and element substract from the (sum) i.e -> in {3,8} 3 is taken then we want 11-3=8in the array 
+    				t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; // either take or(||) do not take 
+    			} else {// if sum is less than array size just leave and increment 
+    				t[i][j] = t[i - 1][j];
+				}
+    		}
+    	}
+    	return t[n][sum]; // at last return T/F
+    }
+
+    bool canPartition(vector<int>& arr) {
+        int n = arr.size();
+        int sum = 0;
+    	for (int i = 0; i < n; i++) {
+    		sum += arr[i];
+    	}
+    	if (sum % 2 != 0) { // if sum is odd --> not possible to make equal partitions
+    		return false;
+    	}
+    	return isSubsetPossible(arr, n, sum / 2);
+    }
+};

06_CountOfSubset_with_given_sum.cpp

@@ -0,0 +1,41 @@
+// Question Link :- https://www.geeksforgeeks.org/problems/perfect-sum-problem5633/1
+// Perfect Sum Problem
+
+
+// Brute Force
+// generating all the possible subsets and then checking whether the subset has the required sum.
+
+
+// Tabulation (Bottom-Up)
+// T.C = O(sum*n)
+// S.C = O(sum*n)
+class Solution {
+public:
+    int mod = 1e9 + 7;
+	int perfectSum(int arr[], int n, int sum) {
+        // vector<vector<int>> t(n + 1, vector<int>(sum + 1, 0));
+        int t[n + 1][sum + 1];
+    	for (int i = 0; i<n+1; i++) {   // i -> size of array
+    		for (int j = 0; j<sum+1; j++) {  // j -> target sum (subset sum)
+    			if (i == 0) {
+    				t[i][j] = 0;
+    			}
+    			if (j == 0) { 
+    				t[i][j] = 1;
+    			}
+    		}
+    	}
+
+		for (int i = 1; i <n+1; i++) {
+			for (int j = 0; j < sum+1; j++) {   // NOTE :- here j started from 0
+				if (arr[i - 1] <= j) {   // when element in the list is less then target sum 
+					t[i][j] = (t[i - 1][j - arr[i - 1]] + t[i - 1][j]) % mod;  // either exclude or inxlude and add both of them to get final count 
+				} 
+				else {
+					t[i][j] = (t[i - 1][j]) % mod;  // exclude when element in the list is greater then the sum 
+				}
+			}
+		}
+		return t[n][sum];
+	}
+};

07_Minimum_subset_sum_difference.cpp

@@ -0,0 +1,54 @@
+// Question Link :- https://www.geeksforgeeks.org/problems/minimum-sum-partition3317/1
+// Minimum sum partition
+
+// Note :- 0 < arr[i] <= 10^5
+
+// T.C = O(n*sum)
+// S.C = O(n*sum)
+class Solution {
+public:
+    vector<int> isSubsetPoss(int arr[], int n, int sum) {
+    	bool t[n + 1][sum + 1];
+    	// initialization
+    	for (int i = 0; i <= n; i++) {
+    		for (int j = 0; j <= sum; j++) {
+    			if (i == 0) {
+    				t[i][j] = false;
+    			}
+    			if (j == 0) {
+    				t[i][j] = true;
+    			}
+    		}
+    	}
+    	for (int i = 1; i <= n; i++) {
+    		for (int j = 1; j <= sum; j++) {
+    			if (arr[i - 1] <= j) {
+    				t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; // include or exclude
+    			} else {
+    				t[i][j] = t[i - 1][j];  // exclude
+    			}
+    		}
+    	}
+    	vector<int> v;   // contains all subset sums possible with n elements 
+    	for (int j = 0; j <= sum; j++) {
+    		if (t[n][j] == true) {
+    			v.push_back(j); {
+    			}
+    		}
+    	}
+    	return v;
+    }
+    
+	int minDifference(int arr[], int n)  { 
+	    int range = 0;
+        for(int i=0; i<n; i++) {
+            range += arr[i];
+        }
+        vector<int> v = isSubsetPoss(arr, n, range);
+        int mn = INT_MAX;
+        for(int i=0; i< v.size(); i++) {
+            mn = min(mn, abs(range - 2*v[i]));
+        }
+        return mn;
+	} 
+};

08_CountOfSubset_with_given_difference.cpp

@@ -0,0 +1,46 @@
+// Question Link :- https://www.geeksforgeeks.org/problems/partitions-with-given-difference/1
+// Partitions with Given Difference
+
+// T.C = O(n*sum(arr))
+// S.C = O(sum(arr))
+class Solution {
+public:
+    int mod = 1e9+7;
+    int CountSubsetsWithSum(vector<int>& arr, int n, int sum) {
+    // 	int t[n + 1][sum + 1];
+    vector<vector<int>> t(n + 1, vector<int>(sum + 1, 0));
+    	// initialization 
+    	for (int i = 0; i <= n; i++) {     // i -> size of the array
+    		for (int j = 0; j <= sum; j++) {     // j -> target sum (subset sum)
+    			if (i == 0) {
+    				t[i][j] = 0;
+    			}
+    			if (j == 0) {
+    				t[i][j] = 1;
+    			}
+    		}
+    	}
+    
+    	for (int i = 1; i <= n; i++) {
+    		for (int j = 0; j <= sum; j++) {
+    			if (arr[i - 1] <= j) {   // when element in the list is less then target sum 
+    				t[i][j] = (t[i - 1][j - arr[i - 1]] + t[i - 1][j]) % mod; // either exclude or inxlude and add both of them to get final count 
+    			} else {
+    				t[i][j] = (t[i - 1][j]); // exclude when element in the list is greater then the sum 
+    			}
+    		}
+    	}
+    	return t[n][sum]; // finally return the last row and last column element 
+    }
+
+    int countPartitions(int n, int diff, vector<int>& arr) {
+        int sumOfArray = 0;
+    	for (int i = 0; i < n; i++) {
+    		sumOfArray += arr[i]; 
+    	}
+    	if ((sumOfArray + diff) % 2 != 0) {
+    		return 0;
+    	}
+    	return CountSubsetsWithSum(arr, n, (sumOfArray + diff) / 2);
+    }
+};

09_TargetSum.cpp

@@ -0,0 +1,44 @@
+// Question Link :- https://leetcode.com/problems/target-sum/
+// Target Sum
+
+// T.C = O(n*sum(arr))
+// S.C = O(sum(arr))
+class Solution {
+public:
+    int CountSubsetsWithSum(vector<int>& arr, int n, int sum) {
+	    int t[n + 1][sum + 1];
+	    for (int i = 0; i <= n; i++) {
+		    for (int j = 0; j <= sum; j++) {
+			    if (i == 0) {
+				    t[i][j] = 0;
+                }
+			    if (j == 0) {
+				    t[i][j] = 1;
+                }
+		    }
+	    }
+	    for (int i = 1; i <= n; i++) {
+		    for (int j = 0; j <= sum; j++) {
+			    if (arr[i - 1] <= j) {
+				    t[i][j] = t[i - 1][j - arr[i - 1]] + t[i - 1][j]; 
+                } else {
+				    t[i][j] = t[i - 1][j];
+                }
+		    }
+	    }
+	    return t[n][sum]; 
+    }
+
+    int findTargetSumWays(vector<int>& nums, int target) {
+        target = abs(target);
+        int n = nums.size();
+        int sum = 0;
+        for(int i=0; i<n; i++) {
+            sum += nums[i];
+        }
+        if(sum<target || (sum + target)%2 != 0) {
+            return 0;
+        }
+        return CountSubsetsWithSum(nums, n, (sum + target)/2);
+    }
+};