├── Binary Search ├── 0 find peak element.cpp ├── 01 Binary search.cpp ├── 02 Binary search on reverse sorted array.cpp ├── 03 Order not known or Agonostic BS.cpp ├── 04 First and last occurrence of an element.cpp ├── 05 Count of an element in a sorted array.cpp ├── 06 Find Minimum in Rotated Sorted Array.cpp ├── 07 Search in Rotated Sorted Array.cpp ├── 08 Searching in Nearly sorted array.cpp ├── 09 Find floor of an element in a sorted array.cpp ├── 10 Find ceil of an element in a sorted array.cpp ├── 11 Next Alphabetical Element.cpp ├── 12 Find the pos of an element in infinite sorted array.cpp └── 13 Find the index of 1st '1' in a Binary sorted array.cpp ├── Dynamic Programming ├── 01 Recursive Knapsack.cpp ├── 02 Knapsack Memoization(DP).cpp ├── 03 Knapsack Bottom up.cpp ├── 04 Subset sum(Knapsack variation).cpp ├── 05 Equal sum partition.cpp ├── 06 Count of Subsets with given Sum.cpp ├── 07 Minimum subset sum difference.cpp ├── 08 Count the number of subset with given difference.cpp ├── 09 Target sum.cpp ├── 10 Unbounded Knapsack.cpp ├── 11 Rod cutting problem.cpp ├── 12 Coin change problem _ maximum no of ways.cpp ├── 13 Coin change problem_ Minimum number of coin.cpp ├── 14 Longest Common Subsequence recursive.cpp ├── 15 Longest Common Subsequence Top down(Memoization).cpp ├── 16 Longest Common Subsequence Bottom Up(DP).cpp ├── 17 LCS Substring.cpp ├── 18 Print LCS.cpp ├── 19 Shortest Common Supersequence.cpp ├── 20 Minimum insertion deletion to convert a to b.cpp ├── 21 Longest Palindromic Subsequence.cpp ├── 22 Minimum number of deletions to make a string palindrome.cpp ├── 23 Print Shortest Common Supersequence.cpp ├── 24 Longest repeating subsequence.cpp ├── 25 Sequence pattern matching.cpp ├── 26 Minimum Number of insertion to make a string palindrome.cpp ├── 27 Matrix chain multiplication.cpp ├── 28 MCM Memoization.cpp ├── 29 Palindrome Partitioning Recursive.cpp ├── 30 Palindrome Partitioning Memoization.cpp ├── 31 Palindrome Partitioning Memoized optimization.cpp ├── 32 Evaluate Expression to true Recursive.cpp ├── 33 Evaluate expression to true memoization using map.cpp ├── 34 Evaluate expression to true memoization using 3d array.cpp ├── 35 Scramble string recursive.cpp ├── 36 Scramble string top down.cpp ├── 37 Egg dropping problem recursive.cpp ├── 38 Egg dropping problem top down.cpp ├── 39 Egg dropping problem memoization optimization.cpp ├── 40 Diameter of binary tree.cpp ├── 41 Max path sum from any node to any.cpp └── 42 Max_path_sum_from_leaf_to_leaf.cpp ├── Heap ├── 01 Kth smallest element.cpp ├── 02 Kth largest element in an array.cpp └── 03 Nearly Sorted Algorithm or sort k sorted array.cpp ├── README.md ├── Sliding Window ├── 01 Maximum Sum Subarray of size K.cpp ├── 02 First negative integer in every window of size k.cpp ├── 03 Count the number of anagram.cpp ├── 04 maximum of all subarray of size k.cpp └── 05 Longest Substring Without Repeating Characters.cpp └── Stack ├── 01 Nearest greater to right.cpp ├── 02 Nearest greater to left(NGL).cpp ├── 03 Nearest smaller to left.cpp ├── 04 Nearest smaller to right.cpp ├── 05 Stock span problem.cpp ├── 06 Maximum Rectangular Area in a Histogram.cpp └── 07 Max area rectangle in Binary matrix.cpp /Binary Search/0 find peak element.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findPeakElement(vector& nums) { 4 | int n=nums.size(); 5 | int start=0; 6 | int end= n-1; 7 | while (start<=end) 8 | { 9 | int mid=start+(end-start)/2; 10 | if (mid>0 and midnums[mid-1] && nums[mid]>nums[mid+1]) 13 | return mid; 14 | else if (nums[mid-1]>nums[mid] && nums[mid+1]) 15 | end=mid-1; 16 | else 17 | start=mid+1; 18 | } 19 | else if (mid==0) 20 | { 21 | if (nums[0]>nums[1]) 22 | return 0; 23 | else 24 | return 1; 25 | } 26 | else if(mid==n-1) 27 | { 28 | if (nums[n-1]>nums[n-2]) 29 | return n-1; 30 | else 31 | return n-2; 32 | } 33 | } 34 | return 0; 35 | 36 | } 37 | }; 38 | -------------------------------------------------------------------------------- /Binary Search/01 Binary search.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int search(vector& nums, int target) { 4 | int start= 0; 5 | int end= nums.size()-1; 6 | while (start <= end) 7 | { 8 | int mid = start + (end-start)/2; 9 | if (target==nums[mid]) 10 | return mid; 11 | else if (target& nums, int target) { 4 | int start= 0; 5 | int end= nums.size()-1; 6 | while (start <= end) 7 | { 8 | int mid = start + (end-start)/2; 9 | if (target==nums[mid]) 10 | return mid; 11 | else if (target& nums, int target) { 4 | int start= 0; 5 | int end= nums.size()-1; 6 | if (nums[0]>nums[1]){ // desending 7 | while (start <= end) 8 | { 9 | int mid = start + (end-start)/2; 10 | if (target==nums[mid]) 11 | return mid; 12 | else if (target searchRange(vector& nums, int target) { 4 | vector res; 5 | int start=0; 6 | int first=-1, last=-1; 7 | int end= nums.size()-1; 8 | while(start <=end) 9 | { 10 | int mid = start + (end-start)/2; 11 | if (target==nums[mid]) 12 | { 13 | first=mid; 14 | end=mid-1; 15 | 16 | } 17 | else if (target < nums[mid]) 18 | end= mid-1; 19 | else 20 | start = mid+1; 21 | } 22 | start=0,end= nums.size()-1; 23 | while (start <= end) 24 | { 25 | int mid = start+(end-start)/2; 26 | if (target== nums[mid]) 27 | { 28 | last=mid; 29 | start=mid+1; 30 | } 31 | else if (target< nums[mid]) 32 | end= mid-1; 33 | else 34 | start = mid+1; 35 | } 36 | res.push_back(first); 37 | res.push_back(last); 38 | return res; 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /Binary Search/05 Count of an element in a sorted array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int count(int nums[], int target) { 4 | int n= nums.size()-1; 5 | int start=0; 6 | int end= n-1; 7 | int first=-1, last=-1; 8 | while(start <=end) 9 | { 10 | int mid = start + (end-start)/2; 11 | if (target==nums[mid]) 12 | { 13 | first=mid; // we will get 1st occurrence of duplicate element 14 | end=mid-1; 15 | } 16 | else if (target < nums[mid]) 17 | end= mid-1; 18 | else 19 | start = mid+1; 20 | } 21 | start=0,end= nums.size()-1; 22 | while (start <= end) 23 | { 24 | int mid = start+(end-start)/2; 25 | if (target== nums[mid]) 26 | { 27 | last=mid; // we will get last occurrence of duplicate element 28 | start=mid+1; 29 | } 30 | else if (target< nums[mid]) 31 | end= mid-1; 32 | else 33 | start = mid+1; 34 | } 35 | if (last==-1 && first==-1) 36 | { 37 | return 0; 38 | } 39 | int res=0; 40 | res= last-first+1; // to get count 41 | return res; 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /Binary Search/06 Find Minimum in Rotated Sorted Array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findMin(vector& nums) { 4 | int n= nums.size(); 5 | int start=0; 6 | int end = nums.size()-1; 7 | if (n==1) 8 | return nums[0]; 9 | while (start<=end){ 10 | int mid= start+ (end-start)/2; 11 | int prev=(mid+n-1)%n; 12 | int next= (mid+1)%n; 13 | if (nums[mid]& nums, int target) { 4 | int s = nums.size(); 5 | 6 | if(s==1) { // corner case 7 | if(nums[0]==target) 8 | return 0; 9 | return -1; 10 | } 11 | 12 | if(nums[0]=nums[0] && nums[m]>=nums[s-1]) 26 | l = (m+1)%s; 27 | 28 | else 29 | h = (m-1+s)%s; 30 | 31 | } 32 | if(target >= nums[pivot] && target <= nums[s-1]) 33 | return bs(nums,pivot,s-1,target); 34 | 35 | return bs(nums,0,pivot-1,target); 36 | 37 | } 38 | int bs(vector& nums,int l,int h,int target) { //Binary Search Function 39 | while(l<=h) { 40 | int m = l+(h-l)/2; 41 | if(nums[m]==target) 42 | return m; 43 | else if(target > nums[m]) 44 | l = m+1; 45 | else 46 | h = m-1; 47 | } 48 | return -1; 49 | } 50 | }; 51 | -------------------------------------------------------------------------------- /Binary Search/08 Searching in Nearly sorted array.cpp: -------------------------------------------------------------------------------- 1 | // https://www.geeksforgeeks.org/search-almost-sorted-array/ 2 | int binarySearch(int arr[], int l, int r, int x) 3 | { 4 | if (r >= l) 5 | { 6 | int mid = l + (r - l) / 2; 7 | 8 | // If the element is present at 9 | // one of the middle 3 positions 10 | if (arr[mid] == x) 11 | return mid; 12 | if (mid > l && arr[mid - 1] == x) 13 | return (mid - 1); 14 | if (mid < r && arr[mid + 1] == x) 15 | return (mid + 1); 16 | 17 | // If element is smaller than mid, then 18 | // it can only be present in left subarray 19 | if (arr[mid] > x) 20 | return binarySearch(arr, l, mid - 2, x); // this time check on mid-2 cz mid-1 is already checked 21 | 22 | // Else the element can only be present 23 | // in right subarray 24 | return binarySearch(arr, mid + 2, r, x); // this time check on mid+2 cz mid+1 is already checked 25 | } 26 | -------------------------------------------------------------------------------- /Binary Search/09 Find floor of an element in a sorted array.cpp: -------------------------------------------------------------------------------- 1 | // https://practice.geeksforgeeks.org/problems/floor-in-a-sorted-array-1587115620/1# 2 | 3 | class Solution{ 4 | public: 5 | int findFloor(vector v, long long n, long long x){ 6 | int start=0; 7 | int end=n-1; 8 | int res=-1; 9 | while (start<=end){ 10 | int mid= start+(end-start)/2; 11 | if (x==v[mid]) 12 | return mid; 13 | else if(x>v[mid]) 14 | end= mid-1; // continue biniry search on left size of the array 15 | else 16 | { 17 | res=mid; // store candidate in res and continue BS in right side 18 | start=mid+1; 19 | } 20 | } 21 | return res; // at last return greatest element smaller then x 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /Binary Search/10 Find ceil of an element in a sorted array.cpp: -------------------------------------------------------------------------------- 1 | class Solution{ 2 | public: 3 | int findFloor(vector v, long long n, long long x){ 4 | int start=0; 5 | int end=n-1; 6 | int res=-1; 7 | while (start<=end){ 8 | int mid= start+(end-start)/2; 9 | if (x==v[mid]) 10 | return v[mid]; 11 | else if(x& letters, char target) { 7 | int start=0; 8 | int end= letters.size()-1; 9 | char res=letters[start]; 10 | while (start<=end){ 11 | int mid = start+ (end-start)/2; 12 | if (target == letters[mid]) 13 | start=mid+1; // here we dont want to return the matched we want the greater then target 14 | else if (target=l) 5 | { 6 | int mid = l + (r - l)/2; 7 | if (arr[mid] == x) 8 | return mid; 9 | if (arr[mid] > x) 10 | return binarySearch(arr, l, mid-1, x); 11 | return binarySearch(arr, mid+1, r, x); 12 | } 13 | return -1; 14 | } 15 | 16 | // function takes an infinite size array and a key to be 17 | // searched and returns its position if found else -1. 18 | // We don't know size of arr[] and we can assume size to be 19 | // infinite in this function. 20 | // NOTE THAT THIS FUNCTION ASSUMES arr[] TO BE OF INFINITE SIZE 21 | // THEREFORE, THERE IS NO INDEX OUT OF BOUND CHECKING 22 | int findPos(int arr[], int key) 23 | { 24 | int l = 0, h = 1; 25 | int val = arr[0]; 26 | 27 | // Find h to do binary search 28 | while (val < key) 29 | { 30 | l = h; // store previous high // set low equals to hign 31 | h = 2*h; // double high index 32 | val = arr[h]; // update new val 33 | } 34 | 35 | // at this point we have updated low and 36 | // high indices, Thus use binary search 37 | // between them 38 | return binarySearch(arr, l, h, key); 39 | } 40 | -------------------------------------------------------------------------------- /Binary Search/13 Find the index of 1st '1' in a Binary sorted array.cpp: -------------------------------------------------------------------------------- 1 | class Solution{ 2 | public: 3 | int firstIndex(int a[], int n) 4 | { 5 | int start =0; 6 | int end= n-1; 7 | while (start<=end){ 8 | int mid = start+(end-start)/2; 9 | if (a[mid]==1) 10 | { 11 | if (a[mid-1]==1) // when the previous is also 1 then check in the right side 12 | { 13 | end=mid-1; 14 | } 15 | else 16 | return mid; 17 | } 18 | else 19 | if (a[mid]==0) 20 | { 21 | start=mid+1; 22 | } 23 | } // close of while loop 24 | return -1; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /Dynamic Programming/01 Recursive Knapsack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Knapsack(int wt[], int val[], int W, int n) { 5 | // every recursive solution will have a base condition 6 | // for base condition we need to think of the smallest valid input that we can pass 7 | // array size can be atleast 0 || min weight can be 0 but not negetive; 8 | if (n == 0 || W == 0) 9 | return 0; 10 | 11 | // these are the choices we are having 12 | if (wt[n - 1] <= W) { 13 | return max(val[n - 1] + Knapsack(wt, val, W - wt[n - 1], n - 1), 14 | Knapsack(wt, val, W, n - 1)); 15 | } 16 | else if (wt[n - 1] > W) // if the weight is greater then the required weight there is no sence for taking that value. 17 | return Knapsack(wt, val, W, n - 1); // return as it is by redusing the size of array 18 | else 19 | return -1; 20 | } 21 | 22 | int main() { 23 | int n,W; 24 | cin >> n; // number of items 25 | int val[n], wt[n]; // values and weights of array 26 | for (int i = 0; i < n; i++) 27 | cin >> wt[i]; 28 | for (int i = 0; i < n; i++) 29 | cin >> val[i]; 30 | 31 | cin >> W; // Knapsack capacity 32 | 33 | cout << Knapsack(wt, val, W, n) << endl; 34 | return 0; 35 | } 36 | // T(N) = 2T(N-1) + O(1), which is simplified to O(2^N). 37 | -------------------------------------------------------------------------------- /Dynamic Programming/02 Knapsack Memoization(DP).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1000; // DP - matrix dimension 5 | 6 | int t[D][D]; // DP matrix 7 | 8 | int Knapsack(int wt[], int val[], int W, int n) { 9 | // base case 10 | if (n == 0 || W == 0) 11 | return 0; 12 | 13 | // if already calculated 14 | 15 | 16 | if (t[n][W] != -1) 17 | return t[n][W]; 18 | 19 | // else calculate 20 | else { 21 | if (wt[n - 1] <= W) 22 | t[n][W] = max(val[n - 1] + Knapsack(wt, val, W - wt[n - 1], n - 1),Knapsack(wt, val, W, n - 1)); 23 | else if (wt[n - 1] > W) 24 | t[n][W] = Knapsack(wt, val, W, n - 1); 25 | 26 | return t[n][W]; 27 | } 28 | } 29 | 30 | signed main() { 31 | int n; cin >> n; // number of items 32 | int val[n], wt[n]; // values and wts array 33 | for (int i = 0; i < n; i++) 34 | cin >> wt[i]; 35 | for (int i = 0; i < n; i++) 36 | cin >> val[i]; 37 | int W; cin >> W; // capacity 38 | 39 | // matrix initialization 40 | for (int i = 0; i <= n; i++) 41 | for (int j = 0; j <= W; j++) 42 | t[i][j] = -1; // initialize matrix with -1 43 | 44 | cout << Knapsack(wt, val, W, n) << endl; 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /Dynamic Programming/03 Knapsack Bottom up.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Knapsack(int wt[], int val[], int W, int n) { 5 | int t[n + 1][W + 1]; // DP matrix 6 | 7 | for (int i = 0; i <= n; i++) { 8 | for (int j = 0; j <= W; j++) { 9 | if (i == 0 || j == 0) // base case // filling 1st row and 1st column of the matrix with zero as per the base condition of the recursive solution 10 | t[i][j] = 0; 11 | else if (wt[i - 1] <= j) { // current wt can fit in bag // this is for the choice diagram of the recursive solution 12 | int val1 = val[i - 1] + t[i - 1][j - wt[i - 1]]; // take current wt // and after taking weight substract the inserted weight from the final weight 13 | int val2 = t[i - 1][j]; // skip current wt 14 | t[i][j] = max(val1, val2); 15 | } 16 | else if (wt[i - 1] > j) // current wt doesn't fit in bag 17 | t[i][j] = t[i - 1][j]; // move to next 18 | } 19 | } 20 | 21 | return t[n][W]; 22 | } 23 | 24 | int main() { 25 | int n; cin >> n; // number of items 26 | int val[n], wt[n]; // values and wts array 27 | for (int i = 0; i < n; i++) 28 | cin >> wt[i]; 29 | for (int i = 0; i < n; i++) 30 | cin >> val[i]; 31 | int W; cin >> W; // capacity 32 | 33 | cout << Knapsack(wt, val, W, n) << endl; 34 | return 0; 35 | } 36 | 37 | /* Complexity Analysis: 38 | 39 | Time Complexity: O(N*W). 40 | 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. 41 | Auxiliary Space: O(N*W). 42 | The use of 2-D array of size ‘N*W’. 43 | */ 44 | // https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/ 45 | -------------------------------------------------------------------------------- /Dynamic Programming/04 Subset sum(Knapsack variation).cpp: -------------------------------------------------------------------------------- 1 | // https://www.geeksforgeeks.org/subset-sum-problem-dp-25/ 2 | #include 3 | using namespace std; 4 | 5 | bool isSubsetPossible(int arr[], int n, int sum) { 6 | bool t[n + 1][sum + 1]; // DP - matrix 7 | // initialization 8 | // here we are setting 1st row and 1st column 9 | // i denotes the size of the array 10 | // j denotes the target sum (subset sum) 11 | for (int i = 0; i <= n; i++) { // itereate as long it is less then length of the array 12 | for (int j = 0; j <= sum; j++) { 13 | if (i == 0)// when array(i) is empty than there is no meaning of sum of elements so return false 14 | t[i][j] = false; 15 | if (j == 0) // when sum(j) is zero and there is always a chance of empty subset so return it as true; 16 | t[i][j] = true; 17 | } 18 | } 19 | // start from 1 since 1st row and column is already considerd 20 | for (int i = 1; i <= n; i++) { 21 | for (int j = 1; j <= sum; j++) { 22 | if (arr[i - 1] <= j) 23 | // after taking and element substract from the (sum) i.e -> in {3,8} 3 is taken then we want 11-3=8in the array 24 | t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; // either take or(||) do not take 25 | else // if sum is less than array size just leave and increment 26 | t[i][j] = t[i - 1][j]; 27 | } 28 | } 29 | 30 | return t[n][sum]; // at last return T/F 31 | } 32 | 33 | int main() { 34 | int n; cin >> n; 35 | int arr[n]; 36 | for (int i = 0; i < n; i++) 37 | cin >> arr[i]; 38 | int sum; cin >> sum; 39 | 40 | isSubsetPossible(arr, n, sum) ? cout << "Yes\n" : cout << "No\n"; 41 | return 0; 42 | } 43 | /* 44 | Complexity Analysis: 45 | 46 | Time Complexity: O(sum*n), where sum is the ‘target sum’ and ‘n’ is the size of array. 47 | Auxiliary Space: O(sum*n), as the size of 2-D array is sum*n. 48 | */ 49 | -------------------------------------------------------------------------------- /Dynamic Programming/05 Equal sum partition.cpp: -------------------------------------------------------------------------------- 1 | // https://www.geeksforgeeks.org/partition-problem-dp-18/ 2 | #include 3 | using namespace std; 4 | 5 | bool isSubsetPossible(int arr[], int n, int sum) { 6 | bool t[n + 1][sum + 1]; // DP - matrix 7 | // initialization 8 | // here we are setting 1st row and 1st column 9 | // i denotes the size of the array 10 | // j denotes the target sum (subset sum) 11 | for (int i = 0; i <= n; i++) { // itereate as long it is less then length of the array 12 | for (int j = 0; j <= sum; j++) { 13 | if (i == 0)// when array(i) is empty than there is no meaning of sum of elements so return false 14 | t[i][j] = false; 15 | if (j == 0) // when sum(j) is zero and there is always a chance of empty subset so return it as true; 16 | t[i][j] = true; 17 | } 18 | } 19 | // start from 1 since 1st row and column is already considerd 20 | for (int i = 1; i <= n; i++) { 21 | for (int j = 1; j <= sum; j++) { 22 | if (arr[i - 1] <= j) 23 | // after taking and element substract from the (sum) i.e -> in {3,8} 3 is taken then we want 11-3=8in the array 24 | t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; // either take or(||) do not take 25 | else // if sum is less than array size just leave and increment 26 | t[i][j] = t[i - 1][j]; 27 | } 28 | } 29 | 30 | return t[n][sum]; // at last return T/F 31 | } 32 | 33 | bool EqualSumPartitionPossible(int arr[], int n) { 34 | int sum = 0; // sum of all elements of arr 35 | for (int i = 0; i < n; i++) // take the sum of array 36 | sum += arr[i]; 37 | 38 | if (sum % 2 != 0) // if sum is odd --> not possible to make equal partitions 39 | return false; 40 | 41 | return isSubsetPossible(arr, n, sum / 2); // when even divide sum of array into two part and apply subset sum 42 | } 43 | 44 | int main() { 45 | int n; cin >> n; 46 | int arr[n]; 47 | for (int i = 0; i < n; i++) 48 | cin >> arr[i]; 49 | 50 | EqualSumPartitionPossible(arr, n) ? cout << "YES\n" : cout << "NO\n"; 51 | return 0; 52 | } 53 | 54 | /* 55 | Time Complexity: O(sum * n) 56 | Auxiliary Space: O(sum) 57 | */ 58 | -------------------------------------------------------------------------------- /Dynamic Programming/06 Count of Subsets with given Sum.cpp: -------------------------------------------------------------------------------- 1 | // https://www.geeksforgeeks.org/count-of-subsets-with-sum-equal-to-x/ 2 | #include 3 | using namespace std; 4 | 5 | int CountSubsets(int arr[], int n, int sum) { 6 | int t[n + 1][sum + 1]; // DP - matrix 7 | // initialization 8 | // here we are setting 1st row and 1st column 9 | // i denotes the size of the array 10 | // j denotes the target sum (subset sum) 11 | for (int i = 0; i <= n; i++) { 12 | for (int j = 0; j <= sum; j++) { 13 | if (i == 0) // when array(i) is empty than there is no meaning of sum of elements so return count of subset as 0; 14 | t[i][j] = 0; 15 | if (j == 0) // when sum(j) is zero and there is always a chance of empty subset so return count as 1; 16 | t[i][j] = 1; 17 | } 18 | } 19 | 20 | for (int i = 1; i <= n; i++) { 21 | for (int j = 1; j <= sum; j++) { 22 | if (arr[i - 1] <= j) // when element in the list is less then target sum 23 | t[i][j] = t[i - 1][j - arr[i - 1]] + t[i - 1][j]; // either exclude or inxlude and add both of them to get final count 24 | else 25 | t[i][j] = t[i - 1][j]; // exclude when element in the list is greater then the sum 26 | } 27 | } 28 | 29 | return t[n][sum]; // finally return the last row and last column element 30 | } 31 | 32 | signed main() { 33 | int n; cin >> n; 34 | int arr[n]; 35 | for (int i = 0; i < n; i++) 36 | cin >> arr[i]; 37 | int sum; cin >> sum; 38 | 39 | cout << CountSubsets(arr, n, sum) << endl; 40 | return 0; 41 | } 42 | 43 | /* 44 | Time Complexity: O(sum*n), where the sum is the ‘target sum’ and ‘n’ is the size of the array. 45 | 46 | Auxiliary Space: O(sum*n), as the size of the 2-D array, is sum*n. 47 | */ 48 | -------------------------------------------------------------------------------- /Dynamic Programming/07 Minimum subset sum difference.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | vector isSubsetPoss(int arr[], int n, int sum) { 5 | bool t[n + 1][sum + 1]; // DP - matrix 6 | // initialization 7 | for (int i = 0; i <= n; i++) { 8 | for (int j = 0; j <= sum; j++) { 9 | if (i == 0) 10 | t[i][j] = false; 11 | if (j == 0) 12 | t[i][j] = true; 13 | } 14 | } 15 | // taking from the 2nd row and 2nd column 16 | for (int i = 1; i <= n; i++) { 17 | for (int j = 1; j <= sum; j++) { 18 | if (arr[i - 1] <= j) 19 | t[i][j] = t[i - 1][j - arr[i - 1]] || t[i - 1][j]; // include or exclude 20 | else 21 | t[i][j] = t[i - 1][j]; // exclude 22 | } 23 | } 24 | 25 | vector v; // contains all subset sums possible with n elements // creating a vector varible to store all the element of the last row 26 | for (int j = 0; j <= sum; j++) // from the range we need to exclude the element which is not there in the existing problem 27 | if (t[n][j] == true) // keep true to only those place whose subset sum exist 28 | v.push_back(j); // store in the vector 29 | 30 | return v; 31 | } 32 | 33 | int MinSubsetSumDiff(int arr[], int n) { 34 | int range = 0; 35 | for (int i = 0; i < n; i++) 36 | range += arr[i]; // taking sum of the array for range 37 | 38 | vector v = isSubsetPoss(arr, n, range); 39 | int mn = INT_MAX; 40 | for (int i = 0; i < v.size(); i++) // iterating through the last row of the matrix 41 | mn = min(mn, abs(range - 2 * v[i])); // taking minimum from the last row 42 | 43 | return mn; 44 | } 45 | 46 | signed main() { 47 | int n; cin >> n; 48 | int arr[n]; 49 | for (int i = 0; i < n; i++) 50 | cin >> arr[i]; 51 | 52 | cout << MinSubsetSumDiff(arr, n) << endl; 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /Dynamic Programming/08 Count the number of subset with given difference.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int CountSubsetsWithSum(int arr[], int n, int sum) { 5 | int t[n + 1][sum + 1]; // DP - matrix 6 | // initialization 7 | // here we are setting 1st row and 1st column 8 | // i denotes the size of the array 9 | // j denotes the target sum (subset sum) 10 | for (int i = 0; i <= n; i++) { 11 | for (int j = 0; j <= sum; j++) { 12 | if (i == 0) // when array(i) is empty than there is no meaning of sum of elements so return count of subset as 0; 13 | t[i][j] = 0; 14 | if (j == 0) // when sum(j) is zero and there is always a chance of empty subset so return count as 1; 15 | t[i][j] = 1; 16 | } 17 | } 18 | 19 | for (int i = 1; i <= n; i++) { 20 | for (int j = 1; j <= sum; j++) { 21 | if (arr[i - 1] <= j) // when element in the list is less then target sum 22 | t[i][j] = t[i - 1][j - arr[i - 1]] + t[i - 1][j]; // either exclude or inxlude and add both of them to get final count 23 | else 24 | t[i][j] = t[i - 1][j]; // exclude when element in the list is greater then the sum 25 | } 26 | } 27 | 28 | return t[n][sum]; // finally return the last row and last column element 29 | } 30 | 31 | int CountSubsetsWithDiff(int arr[], int n, int diff) { 32 | int sumOfArray = 0; 33 | for (int i = 0; i < n; i++) 34 | sumOfArray += arr[i]; // taking sum of the array 35 | 36 | if ((sumOfArray + diff) % 2 != 0) 37 | return 0; 38 | else 39 | return CountSubsetsWithSum(arr, n, (sumOfArray + diff) / 2);// we will get the number of array(subset) with particular sum 40 | } 41 | 42 | signed main() { 43 | int n; cin >> n; 44 | int arr[n]; 45 | for (int i = 0; i < n; i++) 46 | cin >> arr[i]; 47 | int diff; cin >> diff; 48 | 49 | cout << CountSubsetsWithDiff(arr, n, diff) << endl; 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /Dynamic Programming/09 Target sum.cpp: -------------------------------------------------------------------------------- 1 | 2 | class Solution { 3 | public: 4 | int CountSubsetsWithSum(vector& nums,int sum) { 5 | int n= nums.size(); 6 | int t[n + 1][sum + 1]; // DP - matrix 7 | // initialization 8 | t[0][0] = 1; 9 | int k = 1; 10 | for (int i = 0; i <= n; i++) { 11 | for (int j = 0; j <= sum; j++) { 12 | if (i == 0 && j > 0) 13 | t[i][j] = 0; 14 | if (j == 0 && i > 0) { 15 | if (nums[i - 1] == 0) { 16 | t[i][j] = pow(2, k); 17 | k++; 18 | } 19 | else 20 | t[i][j] = t[i - 1][j]; 21 | } 22 | } 23 | } 24 | 25 | for (int i = 1; i <= n; i++) { 26 | for (int j = 1; j <= sum; j++) { 27 | if (nums[i - 1] <= j) 28 | t[i][j] = t[i - 1][j - nums[i - 1]] + t[i - 1][j]; 29 | else 30 | t[i][j] = t[i - 1][j]; 31 | } 32 | } 33 | 34 | return t[n][sum]; 35 | } 36 | int findTargetSumWays(vector& nums, int diff) { 37 | int n= nums.size(); 38 | int sumOfArray = 0; 39 | for (int i = 0; i < n; i++) 40 | sumOfArray += nums[i]; 41 | 42 | if ((sumOfArray + diff) % 2 != 0) 43 | return 0; 44 | else 45 | return CountSubsetsWithSum(nums, (sumOfArray + diff) / 2); 46 | 47 | 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /Dynamic Programming/10 Unbounded Knapsack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Un_knapsack(int wt[], int val[], int W, int n) { 5 | int t[n + 1][W + 1]; // DP matrix 6 | 7 | for (int i = 0; i <= n; i++) { 8 | for (int j = 0; j <= W; j++) { 9 | if (i == 0 || j == 0) // base case 10 | t[i][j] = 0; 11 | else if (wt[i - 1] <= j) { // current wt can fit in bag 12 | int val1 = val[i - 1] + t[i][j - wt[i - 1]]; // take current wt 13 | int val2 = t[i - 1][j]; // skip current wt 14 | t[i][j] = max(val1, val2); 15 | } 16 | else if (wt[i - 1] > j) // current wt doesn't fit in bag 17 | t[i][j] = t[i - 1][j]; 18 | } 19 | } 20 | 21 | return t[n][W]; 22 | } 23 | 24 | signed main() { 25 | int n; cin >> n; // number of items 26 | int val[n], wt[n]; // values and wts array 27 | for (int i = 0; i < n; i++) 28 | cin >> wt[i]; 29 | for (int i = 0; i < n; i++) 30 | cin >> val[i]; 31 | int W; cin >> W; // capacity 32 | 33 | cout << Un_knapsack(wt, val, W, n) << endl; 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /Dynamic Programming/11 Rod cutting problem.cpp: -------------------------------------------------------------------------------- 1 | //https://www.geeksforgeeks.org/cutting-a-rod-dp-13/ 2 | #include 3 | using namespace std; 4 | 5 | int getMaxProfit(int length[], int price[], int n, int L) { 6 | int dp[n + 1][L + 1]; 7 | for (int i = 0; i <= n; i++) 8 | for (int j = 0; j <= L; j++) 9 | if (j == 0 || i == 0) 10 | dp[i][j] = 0; 11 | 12 | for (int i = 1; i <= n; i++) { 13 | for (int j = 1; j <= L; j++) { 14 | if (length[i - 1] <= j) { 15 | dp[i][j] = max(dp[i - 1][j], 16 | price[i - 1] + dp[i][j - length[i - 1]]); 17 | } 18 | else 19 | dp[i][j] = dp[i - 1][j]; 20 | } 21 | } 22 | 23 | return dp[n][L]; 24 | } 25 | 26 | signed main() { 27 | int n; cin >> n; 28 | int length[n], price[n]; 29 | for (int i = 0; i < n; i++) 30 | cin >> length[i]; 31 | for (int i = 0; i < n; i++) 32 | cin >> price[i]; 33 | int L; cin >> L; 34 | 35 | cout << getMaxProfit(length, price, n, L) << endl; 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /Dynamic Programming/12 Coin change problem _ maximum no of ways.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int getMaxNumberOfWays(int coins[], int n, int sum) { 5 | int t[n + 1][sum + 1]; 6 | // initialization 7 | for (int i = 0; i <= n; i++) { 8 | for (int j = 0; j <= sum; j++) { 9 | if (i == 0) 10 | t[i][j] = 0; 11 | if (j == 0) 12 | t[i][j] = 1; 13 | } 14 | } 15 | 16 | for (int i = 1; i <= n; i++) 17 | for (int j = 1; j <= sum; j++) 18 | if (coins[i - 1] <= j) 19 | t[i][j] = t[i - 1][j] + t[i][j - coins[i - 1]]; 20 | else 21 | t[i][j] = t[i - 1][j]; 22 | 23 | return t[n][sum]; 24 | } 25 | 26 | signed main() { 27 | int n; cin >> n; 28 | int coins[n]; 29 | for (int i = 0; i < n; i++) 30 | cin >> coins[i]; 31 | int sum; cin >> sum; 32 | 33 | cout << getMaxNumberOfWays(coins, n, sum) << endl; 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /Dynamic Programming/13 Coin change problem_ Minimum number of coin.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define INF INT_MAX-1 4 | 5 | int getMinNumberOfCoins(int coins[], int n, int sum) { 6 | int t[n + 1][sum + 1]; 7 | // initialization 8 | for (int i = 0; i <= n; i++) { 9 | for (int j = 0; j <= sum; j++) { 10 | if (j == 0) 11 | t[i][j] = 0; 12 | if (i == 0) 13 | t[i][j] = INF; 14 | if (i == 1) { 15 | if (j % coins[i - 1] == 0) 16 | t[i][j] = j / coins[i - 1]; 17 | else 18 | t[i][j] = INF; 19 | } 20 | } 21 | } 22 | 23 | t[0][0] = 0; 24 | 25 | for (int i = 1; i <= n; i++) 26 | for (int j = 1; j <= sum; j++) 27 | if (coins[i - 1] <= j) 28 | t[i][j] = min(t[i - 1][j], 1 + t[i][j - coins[i - 1]]); 29 | else 30 | t[i][j] = t[i - 1][j]; 31 | 32 | return t[n][sum]; 33 | } 34 | 35 | signed main() { 36 | int n; cin >> n; 37 | int coins[n]; 38 | for (int i = 0; i < n; i++) 39 | cin >> coins[i]; 40 | int sum; cin >> sum; 41 | 42 | cout << getMinNumberOfCoins(coins, n, sum) << endl; 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /Dynamic Programming/14 Longest Common Subsequence recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | // base case 6 | if (n == 0 || m == 0) 7 | return 0; 8 | 9 | // choice diagram 10 | // when both string X and Y is having same last char 11 | if (X[n - 1] == Y[m - 1]) 12 | return 1 + LCS(X, Y, n - 1, m - 1); // count the number and decreament the both's string length 13 | // when both string's last character is not same 14 | else 15 | return max(LCS(X, Y, n - 1, m), LCS(X, Y, n, m - 1)); // one take full and another by leaving last and vice versa 16 | } 17 | 18 | int main() { 19 | string X, Y; cin >> X >> Y; 20 | int n = X.length(), m = Y.length(); 21 | 22 | cout << LCS(X, Y, n, m) << endl; 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /Dynamic Programming/15 Longest Common Subsequence Top down(Memoization).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | int dp[1001][1001]; 6 | 7 | int LCS(string X, string Y, int n, int m) { 8 | // base case 9 | if (n == 0 || m == 0) 10 | dp[n][m] = 0; 11 | 12 | if (dp[n][m] != -1) // when table is not having -1 then return the value which is preseent in that block 13 | return dp[n][m]; 14 | 15 | // choice diagram 16 | // when last character is same 17 | if (X[n - 1] == Y[m - 1]) 18 | dp[n][m] = 1 + LCS(X, Y, n - 1, m - 1);// count the number and decreament the both's string length // store the value in particular block 19 | // when last character is not same -> pick max 20 | else 21 | dp[n][m] = max(LCS(X, Y, n - 1, m), LCS(X, Y, n, m - 1)); // one take full and another by leaving last char and vice versa // store the value in particular block 22 | 23 | return dp[n][m]; 24 | } 25 | 26 | int main() { 27 | string X, Y; cin >> X >> Y; 28 | int n = X.length(), m = Y.length(); 29 | 30 | memset(dp, -1, sizeof(dp)); // intialize the whole dp matrix with -1; // from memset we can initialise either -1 and zero; 31 | 32 | cout << LCS(X, Y, n, m) << endl; 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /Dynamic Programming/16 Longest Common Subsequence Bottom Up(DP).cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | using namespace std; 4 | 5 | int LCS(string X, string Y, int n, int m) { 6 | int dp[n + 1][m + 1]; // DP - matrix 7 | 8 | // initialize 1st row and of dp matrix with 0 according to the base condition of recursion // base case of recursion --> for initialization of dp - matrix 9 | for (int i = 0; i <= n; i++) 10 | for (int j = 0; j <= m; j++) 11 | if (i == 0 || j == 0) 12 | dp[i][j] = 0; 13 | // choise diagram is used to fill rest of the matrix 14 | for (int i = 1; i <= n; i++) 15 | for (int j = 1; j <= m; j++) 16 | if (X[i - 1] == Y[j - 1]) // when last character is same 17 | dp[i][j] = 1 + dp[i - 1][j - 1]; 18 | else // when last character is not same -> pick max 19 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 20 | 21 | return dp[n][m]; // last row and last column element will give the length of the LCS; 22 | } 23 | 24 | int main() { 25 | string X, Y; cin >> X >> Y; 26 | int n = X.length(), m = Y.length(); 27 | 28 | cout << LCS(X, Y, n, m) << endl; 29 | return 0; 30 | } 31 | 32 | // https://www.geeksforgeeks.org/longest-common-subsequence-dp-4/#:~:text=Time%20complexity%20of%20the%20above,length%20of%20LCS%20is%200.&text=In%20the%20above%20partial%20recursion,%E2%80%9D)%20is%20being%20solved%20twice. 33 | -------------------------------------------------------------------------------- /Dynamic Programming/17 LCS Substring.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCSubstr(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base condition 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; // 12 | 13 | // choice diagram 14 | for (int i = 1; i <= n; i++) 15 | for (int j = 1; j <= m; j++) 16 | if (X[i - 1] == Y[j - 1]) // when both string's last char is same 17 | dp[i][j] = 1 + dp[i - 1][j - 1]; // count the number and decrement the table 18 | else 19 | dp[i][j] = 0; // variation from LCS(DP) 20 | 21 | int mx = INT_MIN; 22 | for (int i = 0; i <= n; i++) 23 | for (int j = 0; j <= m; j++) 24 | mx = max(mx, dp[i][j]); 25 | 26 | return mx; 27 | } 28 | 29 | int main() { 30 | string X, Y; cin >> X >> Y; 31 | int n = X.length(), m = Y.length(); 32 | 33 | cout << LCSubstr(X, Y, n, m) << endl; 34 | return 0; 35 | } 36 | 37 | // https://www.geeksforgeeks.org/longest-common-substring-dp-29/ 38 | -------------------------------------------------------------------------------- /Dynamic Programming/18 Print LCS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | int i = n, j = m; 21 | string lcs = ""; // store charecter when it is equal in the table 22 | while (i > 0 && j > 0) { 23 | if (X[i - 1] == Y[j - 1]) { 24 | lcs += X[i - 1]; // insert in string 25 | i--, j--; 26 | } 27 | else { 28 | if (dp[i][j - 1] > dp[i - 1][j]) 29 | j--; // move to the larger side 30 | else 31 | i--; 32 | } 33 | } 34 | reverse(lcs.begin(), lcs.end()); // at last reverse the string to get LCS 35 | 36 | return lcs; 37 | } 38 | 39 | signed main() { 40 | string X, Y; cin >> X >> Y; 41 | int n = X.length(), m = Y.length(); 42 | 43 | cout << LCS(X, Y, n, m) << endl; 44 | return 0; 45 | } 46 | // https://www.geeksforgeeks.org/printing-longest-common-subsequence/ 47 | -------------------------------------------------------------------------------- /Dynamic Programming/19 Shortest Common Supersequence.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | using namespace std; 4 | 5 | int LCS(string X, string Y, int n, int m) { 6 | int dp[n + 1][m + 1]; // DP - matrix 7 | 8 | // base case of recursion --> for initialization of dp - matrix 9 | for (int i = 0; i <= n; i++) 10 | for (int j = 0; j <= m; j++) 11 | if (i == 0 || j == 0) 12 | dp[i][j] = 0; 13 | 14 | for (int i = 1; i <= n; i++) 15 | for (int j = 1; j <= m; j++) 16 | if (X[i - 1] == Y[j - 1]) // when last character is same 17 | dp[i][j] = 1 + dp[i - 1][j - 1]; 18 | else // when last character is not same -> pick max 19 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 20 | 21 | return dp[n][m]; 22 | } 23 | 24 | int SCS(string X, string Y, int n, int m) { 25 | return m + n - LCS(X, Y, n, m); // formula // n-> length of string x ; m-> length of string y 26 | } 27 | 28 | signed main() { 29 | string X, Y; cin >> X >> Y; 30 | int n = X.length(), m = Y.length(); 31 | 32 | cout << SCS(X, Y, n, m) << endl; 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /Dynamic Programming/20 Minimum insertion deletion to convert a to b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | void MinInsertDel(string X, string Y, int n, int m) { 24 | int lcs_len = LCS(X, Y, n, m); 25 | cout << "Minimum number of deletions = " << (n - lcs_len)< 0 && j > 0) { 23 | if (X[i - 1] == Y[j - 1]) { // when char are eqaul from table obs 24 | scs += X[i - 1]; // take only once 25 | i--, j--; // and decrement both 26 | } 27 | else if (dp[i][j - 1] > dp[i - 1][j]) { 28 | scs += Y[j - 1]; // in this we will take the charecter to string 29 | j--; 30 | } 31 | else { 32 | scs += X[i - 1]; // taking the charecter to string 33 | i--; 34 | } 35 | } 36 | 37 | while (i > 0) { 38 | scs += X[i - 1]; // take left chareter from str1 39 | i--; 40 | } 41 | 42 | while (j > 0) { 43 | scs += Y[j - 1]; // take left chareter from str1 44 | j--; 45 | } 46 | 47 | reverse(scs.begin(), scs.end()); 48 | 49 | return scs; 50 | } 51 | 52 | int main() { 53 | string X, Y; cin >> X >> Y; 54 | int n = X.length(), m = Y.length(); 55 | 56 | cout << SCS(X, Y, n, m) << endl; 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /Dynamic Programming/24 Longest repeating subsequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | for (int i = 0; i <= n; i++) 8 | for (int j = 0; j <= m; j++) 9 | if (i == 0 || j == 0) 10 | dp[i][j] = 0; 11 | 12 | for (int i = 1; i <= n; i++) 13 | for (int j = 1; j <= m; j++) 14 | if (X[i - 1] == Y[j - 1] && i != j) // jsut add an condition that element at ith index should not be equal to jth index 15 | dp[i][j] = 1 + dp[i - 1][j - 1]; 16 | else 17 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 18 | 19 | return dp[n][m]; 20 | } 21 | 22 | signed main() { 23 | string X; cin >> X; 24 | int n = X.length(); 25 | 26 | cout << LCS(X, X, n, n) << endl; 27 | return 0; 28 | } 29 | // https://www.geeksforgeeks.org/longest-repeating-subsequence/ 30 | -------------------------------------------------------------------------------- /Dynamic Programming/25 Sequence pattern matching.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | bool SeqPatternMatching(string X, string Y, int n, int m) { 24 | return LCS(X, Y, n, m) == min(n, m); // condition to get sequence // if string x is there in y print boolean value according to LCS 25 | } 26 | 27 | signed main() { 28 | string X, Y; cin >> X >> Y; 29 | int n = X.length(), m = Y.length(); 30 | 31 | SeqPatternMatching(X, Y, n, m) ? "YES\n" : "NO\n"; 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /Dynamic Programming/26 Minimum Number of insertion to make a string palindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int LCS(string X, string Y, int n, int m) { 5 | int dp[n + 1][m + 1]; // DP - matrix 6 | 7 | // base case of recursion --> for initialization of dp - matrix 8 | for (int i = 0; i <= n; i++) 9 | for (int j = 0; j <= m; j++) 10 | if (i == 0 || j == 0) 11 | dp[i][j] = 0; 12 | 13 | for (int i = 1; i <= n; i++) 14 | for (int j = 1; j <= m; j++) 15 | if (X[i - 1] == Y[j - 1]) // when last character is same 16 | dp[i][j] = 1 + dp[i - 1][j - 1]; 17 | else // when last character is not same -> pick max 18 | dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]); 19 | 20 | return dp[n][m]; 21 | } 22 | 23 | int LPS(string X, int n) { 24 | string rev_X = X; 25 | reverse(rev_X.begin(), rev_X.end()); 26 | return LCS(X, rev_X, n, n); 27 | } 28 | 29 | int MinInsertForPallindrome(string X, int n) { 30 | return n - LPS(X, n); // substract LPS from the length of string to get Minimum number of insertion to make a string palindrome 31 | } 32 | 33 | int main() { 34 | string X, Y; cin >> X; 35 | int n = X.length(); 36 | 37 | cout << MinInsertForPallindrome(X, n) << endl; 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /Dynamic Programming/27 Matrix chain multiplication.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Solve(int arr[], int i, int j) { 5 | if (i >= j) 6 | return 0; 7 | 8 | int ans = INT_MAX; 9 | for (int k = i; k <= j - 1; k++) { 10 | int temp_ans = Solve(arr, i, k) + Solve(arr, k + 1, j) + arr[i - 1] * arr[k] * arr[j]; 11 | ans = min(ans, temp_ans); // take temp minimum value from the temp answers 12 | } 13 | 14 | return ans; 15 | } 16 | 17 | signed main() { 18 | int n; cin >> n; 19 | int arr[n]; 20 | for (int i = 0; i < n; i++) 21 | cin >> arr[i]; 22 | 23 | cout << Solve(arr, 1, n - 1) << endl; 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /Dynamic Programming/28 MCM Memoization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1000; 5 | int t[D][D]; 6 | 7 | int Solve(int arr[], int i, int j) { 8 | if (i >= j) { 9 | t[i][j] = 0; 10 | return 0; 11 | } 12 | 13 | if (t[i][j] != -1)// when it is not zero means return the value from the table other than -1 14 | return t[i][j]; 15 | 16 | int ans = INT_MAX; 17 | for (int k = i; k <= j - 1; k++) { 18 | int temp_ans = Solve(arr, i, k) + Solve(arr, k + 1, j) + arr[i - 1] * arr[k] * arr[j]; 19 | ans = min(ans, temp_ans); 20 | } 21 | 22 | return t[i][j] = ans; // store it in table 23 | } 24 | 25 | signed main() { 26 | int n; cin >> n; 27 | int arr[n]; 28 | for (int i = 0; i < n; i++) 29 | cin >> arr[i]; 30 | 31 | memset(t, -1, sizeof(t)); 32 | 33 | cout << Solve(arr, 1, n - 1) << endl; 34 | return 0; 35 | } 36 | //https://www.techiedelight.com/matrix-chain-multiplication/ 37 | -------------------------------------------------------------------------------- /Dynamic Programming/29 Palindrome Partitioning Recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool isPallindrome(string X, int i, int j) { // function to check either a string is palindrome or not 5 | while (i <= j) { 6 | if (X[i] != X[j]) 7 | return false; 8 | i++, j--; 9 | } 10 | 11 | return true; 12 | } 13 | 14 | int Solve(string X, int i, int j) { 15 | if (i >= j || isPallindrome(X, i, j)) 16 | return 0; 17 | 18 | int ans = INT_MAX; 19 | for (int k = i; k < j; k++) { 20 | int temp_ans = Solve(X, i, k) + Solve(X, k + 1, j) + 1; 21 | ans = min(ans, temp_ans); 22 | } 23 | 24 | return ans; 25 | } 26 | 27 | int main() { 28 | string X; cin >> X; 29 | 30 | cout << Solve(X, 0, X.length() - 1) << endl; 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /Dynamic Programming/30 Palindrome Partitioning Memoization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1001; 5 | int t[D][D]; 6 | 7 | bool isPallindrome(string X, int i, int j) { 8 | while (i <= j) { 9 | if (X[i] != X[j]) 10 | return false; 11 | i++, j--; 12 | } 13 | 14 | return true; 15 | } 16 | 17 | int Solve(string X, int i, int j) { 18 | if (i >= j || isPallindrome(X, i, j)) { 19 | t[i][j] = 0; 20 | return 0; 21 | } 22 | 23 | if (t[i][j] != -1) 24 | return t[i][j]; 25 | 26 | int ans = INT_MAX; 27 | for (int k = i; k < j; k++) { 28 | int temp_ans = Solve(X, i, k) + Solve(X, k + 1, j) + 1; 29 | ans = min(ans, temp_ans); 30 | } 31 | 32 | return t[i][j] = ans; 33 | } 34 | 35 | int main() { 36 | string X; cin >> X; 37 | 38 | memset(t, -1, sizeof(t)); 39 | 40 | cout << Solve(X, 0, X.length() - 1) << endl; 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /Dynamic Programming/31 Palindrome Partitioning Memoized optimization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1001; 5 | int t[D][D]; 6 | 7 | bool isPallindrome(string X, int i, int j) { 8 | while (i <= j) { 9 | if (X[i] != X[j]) 10 | return false; 11 | i++, j--; 12 | } 13 | 14 | return true; 15 | } 16 | 17 | int Solve(string X, int i, int j) { 18 | if (t[i][j] != -1) 19 | return t[i][j]; 20 | 21 | if (i >= j || isPallindrome(X, i, j)) { 22 | t[i][j] = 0; 23 | return 0; 24 | } 25 | 26 | int ans = INT_MAX; 27 | for (int k = i; k < j; k++) { 28 | int left, right; 29 | if (t[i][k] == -1) 30 | left = Solve(X, i, k); 31 | else 32 | left = t[i][k]; 33 | 34 | if (t[k + 1][j] == -1) 35 | right = Solve(X, k + 1, j); 36 | else 37 | right = t[k + 1][j]; 38 | 39 | int temp_ans = left + right + 1; 40 | ans = min(ans, temp_ans); 41 | } 42 | 43 | return t[i][j] = ans; 44 | } 45 | 46 | int main() { 47 | string X; cin >> X; 48 | 49 | memset(t, -1, sizeof(t)); 50 | 51 | cout << Solve(X, 0, X.length() - 1) << endl; 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /Dynamic Programming/32 Evaluate Expression to true Recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Solve(string X, int i, int j, bool isTrue) { 5 | if (i >= j) { 6 | if (isTrue) 7 | return X[i] == 'T'; 8 | else 9 | return X[i] == 'F'; 10 | } 11 | 12 | int ans = 0; 13 | for (int k = i + 1; k < j; k += 2) { 14 | int l_T = Solve(X, i, k - 1, true); 15 | int l_F = Solve(X, i, k - 1, false); 16 | int r_T = Solve(X, k + 1, j, true); 17 | int r_F = Solve(X, k + 1, j, false); 18 | 19 | if (X[k] == '|') { 20 | if (isTrue == true) 21 | ans += l_T * r_T + l_T * r_F + l_F * r_T; 22 | else 23 | ans += l_F * r_F; 24 | } 25 | else if (X[k] == '&') { 26 | if (isTrue == true) 27 | ans += l_T * r_T; 28 | else 29 | ans += l_T * r_F + l_F * r_T + l_F * r_F; 30 | } 31 | else if (X[k] == '^') { 32 | if (isTrue == true) 33 | ans += l_T * r_F + l_F * r_T; 34 | else 35 | ans += l_T * r_T + l_F * r_F; 36 | } 37 | 38 | } 39 | 40 | return ans; 41 | } 42 | 43 | int main() { 44 | string X; cin >> X; 45 | cout << Solve(X, 0, X.length() - 1, true) << endl; 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /Dynamic Programming/33 Evaluate expression to true memoization using map.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | unordered_map ump; 5 | 6 | int Solve(string X, int i, int j, bool isTrue) { 7 | string key = to_string(i) + " " + to_string(j) + " " + (isTrue ? "T" : "F"); 8 | 9 | if (ump.find(key) != ump.end()) 10 | return ump[key]; 11 | 12 | if (i >= j) { 13 | if (isTrue) 14 | ump[key] = X[i] == 'T'; 15 | else 16 | ump[key] = X[i] == 'F'; 17 | return ump[key]; 18 | } 19 | 20 | int ans = 0; 21 | for (int k = i + 1; k < j; k += 2) { 22 | int l_T = Solve(X, i, k - 1, true); 23 | int l_F = Solve(X, i, k - 1, false); 24 | int r_T = Solve(X, k + 1, j, true); 25 | int r_F = Solve(X, k + 1, j, false); 26 | 27 | if (X[k] == '|') { 28 | if (isTrue == true) 29 | ans += l_T * r_T + l_T * r_F + l_F * r_T; 30 | else 31 | ans += l_F * r_F; 32 | } 33 | else if (X[k] == '&') { 34 | if (isTrue == true) 35 | ans += l_T * r_T; 36 | else 37 | ans += l_T * r_F + l_F * r_T + l_F * r_F; 38 | } 39 | else if (X[k] == '^') { 40 | if (isTrue == true) 41 | ans += l_T * r_F + l_F * r_T; 42 | else 43 | ans += l_T * r_T + l_F * r_F; 44 | } 45 | 46 | } 47 | 48 | return ump[key] = ans; 49 | } 50 | 51 | signed main() { 52 | string X; cin >> X; 53 | ump.clear(); 54 | cout << Solve(X, 0, X.length() - 1, true) << endl; 55 | return 0; 56 | } 57 | -------------------------------------------------------------------------------- /Dynamic Programming/34 Evaluate expression to true memoization using 3d array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 1001; 5 | int dp[2][D][D]; // i,j and istrue and false is changing 6 | 7 | int Solve(string X, int i, int j, bool isTrue) { 8 | if (i >= j) { 9 | if (isTrue) 10 | dp[1][i][j] = X[i] == 'T'; 11 | else 12 | dp[0][i][j] = X[i] == 'F'; 13 | return dp[isTrue][i][j]; 14 | } 15 | 16 | if (dp[isTrue][i][j] != -1) 17 | return dp[isTrue][i][j]; 18 | 19 | int ans = 0; 20 | for (int k = i + 1; k < j; k += 2) { 21 | int l_T = Solve(X, i, k - 1, true); 22 | int l_F = Solve(X, i, k - 1, false); 23 | int r_T = Solve(X, k + 1, j, true); 24 | int r_F = Solve(X, k + 1, j, false); 25 | 26 | if (X[k] == '|') { 27 | if (isTrue == true) 28 | ans += l_T * r_T + l_T * r_F + l_F * r_T; 29 | else 30 | ans += l_F * r_F; 31 | } 32 | else if (X[k] == '&') { 33 | if (isTrue == true) 34 | ans += l_T * r_T; 35 | else 36 | ans += l_T * r_F + l_F * r_T + l_F * r_F; 37 | } 38 | else if (X[k] == '^') { 39 | if (isTrue == true) 40 | ans += l_T * r_F + l_F * r_T; 41 | else 42 | ans += l_T * r_T + l_F * r_F; 43 | } 44 | 45 | } 46 | 47 | dp[isTrue][i][j] = ans; 48 | 49 | return ans; 50 | } 51 | 52 | int main() { 53 | string X; cin >> X; 54 | 55 | memset(dp[0], -1, sizeof(dp[0])); 56 | memset(dp[1], -1, sizeof(dp[1])); 57 | 58 | cout << Solve(X, 0, X.length() - 1, true) << endl; 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /Dynamic Programming/35 Scramble string recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool Solve(string X, string Y) { 5 | if (X.compare(Y) == 0) 6 | return true; 7 | if (X.length() <= 1) 8 | return false; 9 | 10 | int n = X.length(); 11 | int flag = false; 12 | for (int i = 1; i <= n - 1; i++) { 13 | if ((Solve(X.substr(0, i), Y.substr(n - i, i)) && Solve(X.substr(i), Y.substr(0, n - i))) || // these are two condition for swapping and not swapping the string 14 | (Solve(X.substr(0, i), Y.substr(0, i)) && Solve(X.substr(i), Y.substr(i)))) { 15 | flag = true; // change the flag to true and break 16 | break; 17 | } 18 | } 19 | 20 | return flag; 21 | } 22 | 23 | int main() { 24 | string X, Y; cin >> X >> Y; 25 | 26 | if (X.length() != Y.length()) 27 | cout << "No\n"; 28 | else 29 | Solve(X, Y) ? cout << "Yes\n" : cout << "No\n"; 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /Dynamic Programming/36 Scramble string top down.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | unordered_map ump; 5 | 6 | bool Solve(string X, string Y) { 7 | string key = X + " " + Y; 8 | if (ump.find(key) != ump.end()) // if we did not found the and travesed upto end of the map 9 | return ump[key]; 10 | 11 | if (X.compare(Y) == 0) { 12 | ump[key] = true; 13 | return true; 14 | } 15 | if (X.length() <= 1) { 16 | ump[key] = false; 17 | return false; 18 | } 19 | 20 | int n = X.length(); 21 | int flag = false; 22 | for (int i = 1; i <= n - 1; i++) { 23 | if ((Solve(X.substr(0, i), Y.substr(n - i, i)) && Solve(X.substr(i), Y.substr(0, n - i))) || 24 | (Solve(X.substr(0, i), Y.substr(0, i)) && Solve(X.substr(i), Y.substr(i)))) { 25 | flag = true; 26 | break; 27 | } 28 | } 29 | 30 | return ump[key] = flag; // store in table for further reference 31 | } 32 | 33 | int main() { 34 | string X, Y; cin >> X >> Y; 35 | 36 | ump.clear(); 37 | 38 | if (X.length() != Y.length()) 39 | cout << "No\n"; 40 | else 41 | Solve(X, Y) ? cout << "Yes\n" : cout << "No\n"; 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /Dynamic Programming/37 Egg dropping problem recursive.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int Solve(int eggs, int floors) { 5 | if (eggs == 1) 6 | return floors; 7 | if (floors == 0 || floors == 1) 8 | return floors; 9 | 10 | int mn = INT_MAX; 11 | for (int k = 1; k <= floors; k++) { 12 | int temp_ans = 1 + max(Solve(eggs - 1, k - 1), Solve(eggs, floors - k)); // once egg break means decrement both floor and egg another agg did not break means check egg dropping from above 13 | mn = min(mn, temp_ans); 14 | } 15 | 16 | return mn; 17 | } 18 | 19 | int main() { 20 | int eggs, floors; 21 | cin >> eggs >> floors; 22 | 23 | cout << Solve(eggs, floors) << endl; 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /Dynamic Programming/38 Egg dropping problem top down.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 101; 5 | int t[D][D]; 6 | 7 | int Solve(int eggs, int floors) { 8 | if (t[eggs][floors] != -1) 9 | return t[eggs][floors]; 10 | 11 | if (eggs == 1 || floors == 0 || floors == 1) { 12 | t[eggs][floors] = floors; 13 | return floors; 14 | } 15 | 16 | int mn = INT_MAX; 17 | for (int k = 1; k <= floors; k++) { 18 | int temp_ans = 1 + max(Solve(eggs - 1, k - 1), Solve(eggs, floors - k)); 19 | mn = min(mn, temp_ans); 20 | } 21 | 22 | return t[eggs][floors] = mn; // store in table for further reference 23 | } 24 | 25 | signed main() { 26 | int eggs, floors; 27 | cin >> eggs >> floors; 28 | 29 | memset(t, -1, sizeof(t)); 30 | 31 | cout << Solve(eggs, floors) << endl; 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /Dynamic Programming/39 Egg dropping problem memoization optimization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int D = 101; 5 | int dp[D][D]; 6 | 7 | int Solve(int eggs, int floors) { 8 | if (dp[eggs][floors] != -1) // if value is already there in the table then return the value 9 | return dp[eggs][floors]; 10 | 11 | if (eggs == 1 || floors == 0 || floors == 1) { // base condition 12 | dp[eggs][floors] = floors; 13 | return floors; 14 | } 15 | 16 | int mn = INT_MAX; 17 | for (int k = 1; k <= floors; k++) { 18 | int top, bottom; 19 | if (dp[eggs - 1][k - 1] != -1) // break the temp in sub problemes 20 | top = dp[eggs - 1][k - 1]; 21 | else { 22 | top = Solve(eggs - 1, k - 1); 23 | dp[eggs - 1][k - 1] = top; 24 | } 25 | 26 | if (dp[eggs][floors - k] != -1) 27 | bottom = dp[eggs][floors - k]; 28 | else { 29 | bottom = Solve(eggs, floors - k); 30 | dp[eggs][floors - k] = bottom; 31 | } 32 | int temp_ans = 1 + max(top, bottom); 33 | mn = min(mn, temp_ans); 34 | } 35 | 36 | return dp[eggs][floors] = mn; 37 | } 38 | 39 | int main() { 40 | int eggs, floors; 41 | cin >> eggs >> floors; 42 | 43 | memset(dp, -1, sizeof(dp)); 44 | 45 | cout << Solve(eggs, floors) << endl; 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /Dynamic Programming/40 Diameter of binary tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | private: 14 | int res; 15 | public: 16 | int Solve(TreeNode* root) { 17 | if (root == NULL) 18 | return 0; 19 | 20 | int l = Solve(root->left); 21 | int r = Solve(root->right); 22 | 23 | int temp = 1 + max(l, r); 24 | int ans = max(temp, l + r + 1); 25 | res = max(res, ans); 26 | return temp; 27 | } 28 | int diameterOfBinaryTree(TreeNode* root) { 29 | if (root == NULL) 30 | return 0; 31 | 32 | res = INT_MIN + 1; 33 | Solve(root); 34 | return res - 1; 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /Dynamic Programming/41 Max path sum from any node to any.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | private: 14 | int res; 15 | public: 16 | int Solve(TreeNode* root) { 17 | if (root == NULL) 18 | return 0; 19 | 20 | int l = Solve(root->left); 21 | int r = Solve(root->right); 22 | 23 | int temp = max(root->val + max(l, r), root->val); 24 | int ans = max(temp, l + r + root->val); 25 | res = max(res, ans); 26 | 27 | return temp; 28 | } 29 | int maxPathSum(TreeNode* root) { 30 | res = INT_MIN; 31 | Solve(root); 32 | return res; 33 | } 34 | }; 35 | -------------------------------------------------------------------------------- /Dynamic Programming/42 Max_path_sum_from_leaf_to_leaf.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | private: 3 | int res; 4 | 5 | int Solve(Node* root) { 6 | if (root == NULL) 7 | return 0; 8 | 9 | int l = Solve(root->left); 10 | int r = Solve(root->right); 11 | 12 | int temp; 13 | if (root->left && root->right) { 14 | res = max(res, l + r + root->data); 15 | temp = root->data + max(l, r); 16 | } 17 | else if (root->left) 18 | temp = root->data + l; 19 | else if (root->right) 20 | temp = root->data + r; 21 | else 22 | temp = root->data; 23 | } 24 | 25 | return temp; 26 | } 27 | 28 | int maxPathSum(Node* root) 29 | { 30 | // code here 31 | res = INT_MIN; 32 | Solve(root); 33 | return res; 34 | } 35 | -------------------------------------------------------------------------------- /Heap/01 Kth smallest element.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findKthLargest(vector& nums, int k) { 4 | int val; 5 | priority_queue int; 6 | int n= nums.size(); 7 | for (int i=0;ik) 12 | minh.pop(); 13 | } 14 | } 15 | return minh.top(); 16 | 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /Heap/02 Kth largest element in an array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findKthLargest(vector& nums, int k) { 4 | int val; 5 | priority_queue,greater> minh; 6 | int n= nums.size(); 7 | for (int i=0;ik) 12 | minh.pop(); 13 | } 14 | } 15 | return minh.top(); 16 | 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /Heap/03 Nearly Sorted Algorithm or sort k sorted array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int t; 6 | int n,k; 7 | cin>>t; 8 | while (t--) 9 | { 10 | cin>>n>>k; 11 | int a; 12 | vector v; 13 | priority_queue,greater> minh; 14 | for (int i=0;i>a; 17 | minh.push(a); 18 | if (minh.size()>k) 19 | { 20 | int val= minh.top(); 21 | minh.pop(); 22 | v.push_back(val); 23 | } 24 | } 25 | while (!minh.empty()) 26 | { 27 | int val = minh.top(); 28 | minh.pop(); 29 | v.push_back(val); 30 | } 31 | for (int i=0;iShow some  ❤️  by starring this repository! It will push me to give more percentage of efforts 14 | 15 | ## Dynamic Programming 16 | | S.No | Problem | Handwritten Notes | Time | Space | 17 | |-----|---------------- | --------------- | --------------- | --------------- | 18 | 1 | [Knapsack Recursion](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/01%20Recursive%20Knapsack.cpp) | [:blue_book:](https://drive.google.com/file/d/1DhuwI5-RWRfu1FO9_RAOnn46c5Lf687O/view?usp=sharing) | _O(2^n)_ | _O(1)_ | 19 | 2 | [Knapsack Memoization-Top-Down](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/02%20Knapsack%20Memoization(DP).cpp) | [:blue_book:](https://drive.google.com/file/d/1nwv4ZAAAbZrUVi8Po49grzYiJo39ibSw/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 20 | 3 | [Knapsack Bottom-Up(DP)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/03%20Knapsack%20Bottom%20up.cpp)| [:blue_book:](https://drive.google.com/file/d/1X8Vr_PYOwHiaBBkDtifnjcdmJ1dYPphf/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 21 | 4 | [Subset sum(Knapsack Variation)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/04%20Subset%20sum(Knapsack%20variation).cpp)| [:blue_book:](https://drive.google.com/file/d/18w_Sca0Jn18X4m8sjzFXpo-1Hxsu7uSt/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 22 | 5 | [Equal sum partition(subset sum & Knapsack Variation)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/05%20Equal%20sum%20partition.cpp)| [:blue_book:](https://drive.google.com/file/d/1w3a8Xg8UzkeY6mStgnMkK9wnYRNVSBSB/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 23 | 6 | [Count of Subsets with given Sum(subset sum & Knapsack Variation)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/06%20Count%20of%20Subsets%20with%20given%20Sum.cpp)| [:blue_book:](https://drive.google.com/file/d/181rnNr7JfxWQgfxImbCnSuUEatCl1yZn/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 24 | 7 | [Minimum subset sum difference](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/07%20Minimum%20subset%20sum%20difference.cpp)| [:blue_book:](https://drive.google.com/file/d/1akz5zmPu6YnV93TkEXIpeVpoowIj06Pp/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 25 | 8 | [Count the number of subset with given difference](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/08%20Count%20the%20number%20of%20subset%20with%20given%20difference.cpp)| [:blue_book:](https://drive.google.com/file/d/1I5r71mRFOc3uC8nL5ybxj_U7TrxISkvB/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 26 | 9 | [Target sum(Leetcode)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/09%20Target%20sum.cpp)| [:blue_book:](https://drive.google.com/file/d/1I5r71mRFOc3uC8nL5ybxj_U7TrxISkvB/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 27 | 10 | [Unbounded Knapsack](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/10%20Unbounded%20Knapsack.cpp)| [:blue_book:](https://drive.google.com/file/d/1nSqa9Fx0Nxws93Y27m3P9JFuY2hX43dO/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 28 | 11 | [Rod cutting problem(Unbounded Knapsack)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/11%20Rod%20cutting%20problem.cpp)| [:blue_book:](https://drive.google.com/file/d/1QrSiIw_Nk0EKKbNTn0GiXDvfWowIEPzR/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 29 | 12 | [Coin change problem : maximum no of ways](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/12%20Coin%20change%20problem%20:%20maximum%20no%20of%20ways.cpp)| [:blue_book:](https://drive.google.com/file/d/1_77U9fv8hg0zX-KwKa9oEz_JzNNofmyW/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 30 | 13 |[Coin change problem: Minimum number of coin](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/13%20Coin%20change%20problem:%20Minimum%20number%20of%20coin.cpp)| [:blue_book:](https://drive.google.com/file/d/1QrSiIw_Nk0EKKbNTn0GiXDvfWowIEPzR/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 31 | 14 | [Longest Common Subsequence Recursive](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/14%20Longest%20Common%20Subsequence%20recursive.cpp)| [:blue_book:](https://drive.google.com/file/d/1rHnxMNLtBJMy0ZvjNJ2sIB4HOyvxO0d1/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 32 | 15 |[Longest Common Subsequence Top down (Memoization)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/15%20Longest%20Common%20Subsequence%20Top%20down(Memoization).cpp) | [:blue_book:](https://drive.google.com/file/d/1EeDnia9Z5jX3rdyGndZu3Qxbwug_RNw7/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 33 | 16 |[Longest Common Subsequence Bottom Up(DP)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/16%20Longest%20Common%20Subsequence%20Bottom%20Up(DP).cpp) |[:blue_book:](https://drive.google.com/file/d/1ys7JAYt54UrAQi01p6WU0rSAu9Pq9fBR/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 34 | 17 | [Longest Common Substring](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/17%20LCS%20Substring.cpp)| [:blue_book:](https://drive.google.com/file/d/1q-xNcvSPggnZo4K7AUAjGG6dXq5_Sw90/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 35 | 18 |[Print Longest Common Subsequence](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/18%20Print%20LCS.cpp) | [:blue_book:](https://drive.google.com/file/d/17v5LhQk6J7g7HtazUc8Jac8phS9yHCdI/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 36 | 19 |[Shortest Common Supersequence](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/19%20Shortest%20Common%20Supersequence.cpp) | [:blue_book:](https://drive.google.com/file/d/1slMl5RuAsNcBHLgbb07PvNcdRijHYSZh/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 37 | 20 |[Minimum insertion & deletion to convert a to b](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/20%20Minimum%20insertion%20deletion%20to%20convert%20a%20to%20b.cpp)| [:blue_book:](https://drive.google.com/file/d/1v1VGAk9fc6r_1VLXHeiJco9C7hVa13Dv/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 38 | 21 |[Longest Palindromic Subsequence](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/21%20Longest%20Palindromic%20Subsequence.cpp) | [:blue_book:](https://drive.google.com/file/d/1LNrqRZv5WkAp3GppwU5g46l47luBYKpx/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 39 | 22 |[Minimum number of deletions to make a string palindrome](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/22%20Minimum%20number%20of%20deletions%20to%20make%20a%20string%20palindrome.cpp) | [:blue_book:](https://drive.google.com/file/d/1vAxYmhl2K9Ttgpbjw_x4r8kQ5vWxUCrx/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 40 | 23 | [Print Shortest Common Supersequence](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/23%20Print%20Shortest%20Common%20Supersequence.cpp) |[:blue_book:](https://drive.google.com/file/d/1iV_vEGe9puZjEg_0ONGuNVNJ9XzCejEc/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 41 | 24 |[Longest repeating subsequence](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/24%20Longest%20repeating%20subsequence.cpp) | [:blue_book:](https://drive.google.com/file/d/19A7ZshA8UZyYP2mgqMWopxu-BWfPDo6n/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 42 | 25 |[Sequence pattern matching](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/25%20Sequence%20pattern%20matching.cpp) | [:blue_book:](https://drive.google.com/file/d/1qeLP_OgOOuowO3YtxOkq6x3v__w16X9x/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 43 | 26 |[Minimum Number of insertion to make a string palindrome](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/26%20Minimum%20Number%20of%20insertion%20to%20make%20a%20string%20palindrome.cpp) | [:blue_book:](https://drive.google.com/file/d/1NBiKWYRRkbv0E62zKXJxEkeVPy-1hUyO/view?usp=sharing)| _O(N*W)_ | _O(N*W)_ | 44 | 27 |[Matrix Chain Multiplication Recursive](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/27%20Matrix%20chain%20multiplication.cpp) | [:blue_book:](https://drive.google.com/file/d/1wAe0Lmmn_EldPpMgoNcQ6oXTyz6miNwZ/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 45 | 28 |[Matrix Chain Multiplication Top Down (Memoization)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/28%20MCM%20Memoization.cpp) | [:blue_book:](https://drive.google.com/file/d/1gaMhq4VyMepVAdyAibrlQQ4HyA0-S-A4/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 46 | 29 |[Palindrome Partitioning Recursive](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/29%20Palindrome%20Partitioning%20Recursive.cpp)| [:blue_book:](https://drive.google.com/file/d/149gE-tx63xpXEmVetDm1P8Yg3jDY76zy/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 47 | 30 |[Palindrome Partitioning Memoization](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/30%20Palindrome%20Partitioning%20Memoization.cpp)| [:blue_book:](https://drive.google.com/file/d/1uB_cwe4Oq9MlRD6DYepMh3Ah5O4No74m/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 48 | 31 |[Palindrome Partitioning Memoized optimization](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/31%20Palindrome%20Partitioning%20Memoized%20optimization.cpp) | [:blue_book:](https://drive.google.com/file/d/1Wkvhccw5qXCxAJODvtZXBXoBdwsX4DLo/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 49 | 32 |[Evaluate Expression to true Recursive](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/32%20Evaluate%20Expression%20to%20true%20Recursive.cpp) | [:blue_book:](https://drive.google.com/file/d/113CvcjEPSHETAEgb9s3f_qC1sqKgIJIR/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 50 | 33 |[Evaluate expression to true memoization using map](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/33%20Evaluate%20expression%20to%20true%20memoization%20using%20map.cpp) |[:blue_book:](https://drive.google.com/file/d/1BFpuxP1Dx7i2AhSrPNWcLyhENSkZqgtA/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 51 | 34 |[Evaluate expression to true memoization using 3d array](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/34%20Evaluate%20expression%20to%20true%20memoization%20using%203d%20array.cpp) | [:blue_book:](https://drive.google.com/file/d/1BFpuxP1Dx7i2AhSrPNWcLyhENSkZqgtA/view?usp=sharing)| _O(N*W)_ | _O(N*W)_ | 52 | 35 | [Scramble string recursive](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/35%20Scramble%20string%20recursive.cpp)| [:blue_book:](https://drive.google.com/file/d/1Bx27UUnbvk_pLCCxebGcuhMuiorR6UIb/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 53 | 36 |[Scramble string Top Down](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/36%20Scramble%20string%20top%20down.cpp) | [:blue_book:](https://drive.google.com/file/d/14NF0jeCY83yRvsdt8UV1aYQ8ShOoK9d5/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 54 | 37 |[Egg dropping problem recursive](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/37%20Egg%20dropping%20problem%20recursive.cpp) | [:blue_book:](https://drive.google.com/file/d/1stnWelQ4p0ILxNvCj6pFwBawUS-pSxJr/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 55 | 38 |[Egg dropping problem Top Down(memoization)](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/38%20Egg%20dropping%20problem%20top%20down.cpp) | [:blue_book:](https://drive.google.com/file/d/16cecIM51gT8ktLyGfAiSWGLtvcSuyQ6i/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 56 | 39 |[Egg dropping problem memoization optimization](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/39%20Egg%20dropping%20problem%20memoization%20optimization.cpp) | [:blue_book:](https://drive.google.com/file/d/14OhSFRAEV82dijgEJisKekM0Gw7ZB9zs/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 57 | 40 |[Dynamic programming on trees Syntax](#) |[:blue_book:](https://drive.google.com/file/d/19KENQURNp2WXtJlCiuvNpMhqGfhPTh37/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 58 | 41 |[Diameter of binary tree](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/40%20Diameter%20of%20binary%20tree.cpp) | [:blue_book:](https://drive.google.com/file/d/1bUfIJNZHR7dN6ApoWPcQGRnv-1iGleht/view?usp=sharing)| _O(N*W)_ | _O(N*W)_ | 59 | 42 |[Max path sum from any node to any](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/41%20Max%20path%20sum%20from%20any%20node%20to%20any.cpp)| [:blue_book:](https://drive.google.com/file/d/1DMU1wcmfWCr-0Bi8JP0oTzb3CN_LOvLm/view?usp=sharing) | _O(N*W)_ | _O(N*W)_ | 60 | 43 | [ Max path sum from leaf to leaf](https://github.com/skjha1/Data-Structure-Algorithm-Programs/blob/master/src/Algorithms/Dynamic%20Programming/42%20Max_path_sum_from_leaf_to_leaf.cpp)| [:blue_book:](https://drive.google.com/file/d/1jXho_vvWeDHgMtDRkqt_AzE8J8UCSJSg/view?usp=sharing)| _O(N*W)_ | _O(N*W)_ | 61 | 62 | 63 | ## Stack 64 | 65 | 66 | 67 | | S.No | Problem | Handwritten Notes | Time | Space | 68 | |-----|---------------- | --------------- | --------------- | --------------- | 69 | 1 | [Nearest greater to right](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Stack/01%20Nearest%20greater%20to%20right.cpp) | [:blue_book:](https://drive.google.com/file/d/1K0GOA7KaNPVq6mW09MUwzdD9RnrT4iNd/view?usp=sharing) | _O(n)_ | _O(n)_ | 70 | 2 | [Nearest greater to left](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Stack/02%20Nearest%20greater%20to%20left(NGL).cpp) | [:blue_book:](https://drive.google.com/file/d/16ikIhdad0ojGZzYnrVAyR_dnqQsbeBIR/view?usp=sharing) | _O(n)_ | _O(n)_ | 71 | 3 | [Nearest smaller to left](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Stack/03%20Nearest%20smaller%20to%20left.cpp) | [:blue_book:](https://drive.google.com/file/d/16DO1rXKTu4U-beTh7nbsGd6XmUWqIFmb/view?usp=sharing) | _O(n)_ | _O(n)_ | 72 | 4 | [Nearest Smaller to right](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Stack/04%20Nearest%20smaller%20to%20right.cpp) | [:blue_book:](https://drive.google.com/file/d/1tzyQW8hk3KriYFQZQfuM7dw1uibvoJYN/view?usp=sharing) | _O(n)_ | _O(n)_ | 73 | 5 | [Stock span problem](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Stack/05%20Stock%20span%20problem.cpp) | [:blue_book:](https://drive.google.com/file/d/1-NqGSrilyDOBBXfqSrCgUFXFi6Qmjn9p/view?usp=sharing) | _O(n)_ | _O(n)_ | 74 | 5 | [Maximum Rectangular Area in a Histogram](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Stack/06%20Maximum%20Rectangular%20Area%20in%20a%20Histogram.cpp) | [:blue_book:](https://drive.google.com/file/d/19q3tYzuIKTNLd9yq0mPbSAyOQvx3tvcV/view?usp=sharing) | _O(n)_ | _O(n)_ | 75 | 6 | [Max area rectangle in Binary matrix](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Stack/07%20Max%20area%20rectangle%20in%20Binary%20matrix.cpp) | [:blue_book:](https://drive.google.com/file/d/1ckMtxRT61WyfWW_flioPFCFn47mcY-o2/view?usp=sharing) | _O(n)_ | _O(n)_ | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | ## Binary Search 86 | 87 | | S.No | Problem | Handwritten Notes | Time | Space | 88 | |-----|---------------- | --------------- | --------------- | --------------- | 89 | 1 | [Binary Search](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Binary%20Search/01%20Binary%20search.cpp) | [:blue_book:](https://drive.google.com/file/d/1Pv4r3xKmwmHhtbvc8VmKkK2VdNblnsRn/view?usp=sharing) | _O(logn)_ | _O(logn)_ | 90 | 2 | [Binary search on reverse sorted array](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Binary%20Search/02%20Binary%20search%20on%20reverse%20sorted%20array.cpp) | [:blue_book:](https://drive.google.com/file/d/1Pv4r3xKmwmHhtbvc8VmKkK2VdNblnsRn/view?usp=sharing) | _O(logn)_ | _O(logn)_ | 91 | 3 | [Order not known or Agonostic BS](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Binary%20Search/03%20Order%20not%20known%20or%20Agonostic%20BS.cpp) | [:blue_book:](https://drive.google.com/file/d/1Pv4r3xKmwmHhtbvc8VmKkK2VdNblnsRn/view?usp=sharing) | _O(logn)_ | _O(logn)_ | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | ## Heap 101 | 102 | | S.No | Problem | Handwritten Notes | Time | Space | 103 | |-----|---------------- | --------------- | --------------- | --------------- | 104 | 1 | [Kth smallest element](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Heap/01%20Kth%20smallest%20element.cpp) | [:blue_book:](https://drive.google.com/file/d/1Pv4r3xKmwmHhtbvc8VmKkK2VdNblnsRn/view?usp=sharing) | _O(n log k)_ | _O(n log k)_ | 105 | 2 | [Kth largest element in an array](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Heap/02%20Kth%20largest%20element%20in%20an%20array.cpp) | [:blue_book:](https://drive.google.com/file/d/1Pv4r3xKmwmHhtbvc8VmKkK2VdNblnsRn/view?usp=sharing) | _O(n log k)_ | _O(n log k)_ | 106 | 3 | [Nearly Sorted Algorithm or sort k sorted array](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Heap/03%20Nearly%20Sorted%20Algorithm%20or%20sort%20k%20sorted%20array.cpp) | [:blue_book:](https://drive.google.com/file/d/1Pv4r3xKmwmHhtbvc8VmKkK2VdNblnsRn/view?usp=sharing) | _O(n log k)_ | _O(n log k)_ | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | ## Sliding Window 115 | 116 | | S.No | Problem | Handwritten Notes | Time | Space | 117 | |-----|---------------- | --------------- | --------------- | --------------- | 118 | 1 | [Maximum Sum Subarray of size K](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Sliding%20Window/01%20Maximum%20Sum%20Subarray%20of%20size%20K.cpp) | [:blue_book:](https://drive.google.com/file/d/1ppRCKREsg4nysKrKncm2xre7D_IDUGaT/view?usp=sharing) | _O(n)_ | _O(1)_ | 119 | 2 | [First negative integer in every window of size k](https://github.com/skjha1/Aditya-verma-youtube-playlist-code/blob/main/Sliding%20Window/02%20First%20negative%20integer%20in%20every%20window%20of%20size%20k.cpp) | [:blue_book:](https://drive.google.com/file/d/17CwCrHr3DqJQ57hozH1peyDSfwUBvFT4/view?usp=sharing) | _O(n)_ | _O(K)_ | 120 | 121 | 122 | 123 | -------------------------------------------------------------------------------- /Sliding Window/01 Maximum Sum Subarray of size K.cpp: -------------------------------------------------------------------------------- 1 | // https://www.geeksforgeeks.org/find-maximum-minimum-sum-subarray-size-k/ 2 | //Time Complexity : O(n) 3 | //Auxiliary Space : O(1) 4 | class Solution{ 5 | public: 6 | int maximumSumSubarray(int K, vector &Arr , int N){ 7 | int i=0; 8 | int j=0; 9 | int sum=0; 10 | int mx=INT_MIN; 11 | while (j printFirstNegativeInteger(long long int A[],long long int N, long long int K) { 6 | long long i; 7 | long long j; 8 | vector ans; 9 | list l; 10 | while (j m; 6 | for(auto i: pat) 7 | m[i]++; 8 | 9 | int k = pat.size(); 10 | int count = m.size(); 11 | int ans = 0; 12 | int i = 0, j = 0; 13 | 14 | while(j < txt.size()) { 15 | 16 | if(m.find(txt[j]) != m.end()) { 17 | m[txt[j]]--; 18 | 19 | if(m[txt[j]] == 0) 20 | count--; 21 | } 22 | 23 | if(j - i + 1 < k) j++; 24 | 25 | else if(j - i + 1 == k) { 26 | if(count == 0) 27 | ans++; 28 | 29 | if(m.find(txt[i]) != m.end()) { 30 | m[txt[i]]++; 31 | 32 | if(m[txt[i]] == 1) 33 | count++; 34 | } 35 | 36 | i++; j++; 37 | } 38 | } 39 | 40 | return ans; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /Sliding Window/04 maximum of all subarray of size k.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector maxSlidingWindow(vector& nums, int k) { 4 | vector ans; 5 | list l; 6 | int i=0; 7 | int j=0; 8 | 9 | if (k>nums.size()) // edge case 10 | { 11 | ans.push_back(*max_element(l.begin(),l.end())); 12 | return ans; 13 | } 14 | 15 | while (j0 && l.back() mp; 5 | int i=0; 6 | int j=0; 7 | int mx=INT_MIN; 8 | if (s.size()==0) return 0; 9 | while(j nextLargerElement(vector arr, int n){ 5 | vector v; // creating a vector for storing result 6 | stack s; // creating a stack for temp. hold the values from array 7 | for (int i=n-1;i>=0;i--){ 8 | if(s.size() ==0) // when stack size is empty there is no element in stack return output as -1; 9 | v.push_back(-1); 10 | else if (s.size()>0 && s.top()>arr[i]) // when there is element in stack and stack top is greater then array element 11 | { 12 | v.push_back(s.top()); // take stack top in the result vector 13 | } 14 | else if (s.size()>0 && s.top()<=arr[i]) // when there is element in stack and that element is less then array element 15 | { 16 | while(s.size()>0 && s.top()<=arr[i]) // upto when there is element and stack top is less then array's element delete the element from stack 17 | { 18 | s.pop(); // delete the element from stack 19 | } 20 | if (s.size()==0) // when stack became empty return -1 21 | { 22 | v.push_back(-1); 23 | } 24 | else 25 | { 26 | v.push_back(s.top()); // else push stack top in the vector 27 | } 28 | } 29 | s.push(arr[i]); // push array in stack 30 | } 31 | reverse(v.begin(),v.end()); // while returning reverse the vector and return it. 32 | return v; 33 | } 34 | }; 35 | 36 | 37 | // Time Complexity: O(N) 38 | // Auxiliary Space: O(N) 39 | -------------------------------------------------------------------------------- /Stack/02 Nearest greater to left(NGL).cpp: -------------------------------------------------------------------------------- 1 | class 2 | { 3 | public: 4 | vector nextLargerElement(vector arr, int n){ 5 | vector v; // creating a vector for storing result 6 | stack s; // creating a stack for temp. hold the values from array 7 | for (int i=0;i0 && s.top()>arr[i]) // when there is element in stack and stack top is greater then array element 11 | { 12 | v.push_back(s.top()); // take stack top in the result vector 13 | } 14 | else if (s.size()>0 && s.top()<=arr[i]) // when there is element in stack and that element is less then array element 15 | { 16 | while(s.size()>0 && s.top()<=arr[i]) // upto when there is element and stack top is less then array's element delete the element from stack 17 | { 18 | s.pop(); // delete the element from stack 19 | } 20 | if (s.size()==0) // when stack became empty return -1 21 | { 22 | v.push_back(-1); 23 | } 24 | else 25 | { 26 | v.push_back(s.top()); // else push stack top in the vector 27 | } 28 | } 29 | s.push(arr[i]); // push array in stack 30 | } 31 | return v; 32 | } 33 | }; 34 | 35 | 36 | // Time Complexity: O(N) 37 | // Auxiliary Space: O(N) 38 | -------------------------------------------------------------------------------- /Stack/03 Nearest smaller to left.cpp: -------------------------------------------------------------------------------- 1 | class 2 | { 3 | public: 4 | vector nextLargerElement(vector arr, int n){ 5 | vector v; // creating a vector for storing result 6 | stack s; // creating a stack for temp. hold the values from array 7 | for (int i=0;i0 && s.top()0 && s.top()>=arr[i]) // when there is element in stack and that element is greater then equal to array element 15 | { 16 | while(s.size()>0 && s.top()>=arr[i]) // upto when there is element and stack top is greater then equal to array's element delete the element from stack 17 | { 18 | s.pop(); // delete the element from stack 19 | } 20 | if (s.size()==0) // when stack became empty return -1 21 | { 22 | v.push_back(-1); 23 | } 24 | else 25 | { 26 | v.push_back(s.top()); // else push stack top in the vector 27 | } 28 | } 29 | s.push(arr[i]); // push array in stack 30 | } 31 | return v; 32 | } 33 | }; 34 | 35 | 36 | // Time Complexity: O(N) 37 | // Auxiliary Space: O(N) 38 | -------------------------------------------------------------------------------- /Stack/04 Nearest smaller to right.cpp: -------------------------------------------------------------------------------- 1 | class 2 | { 3 | public: 4 | vector nextLargerElement(vector arr, int n){ 5 | vector v; // creating a vector for storing result 6 | stack s; // creating a stack for temp. hold the values from array 7 | for (int i=n-1;i>=0;i--){ 8 | if(s.size() ==0) // when stack size is empty there is no element in stack return output as -1; 9 | v.push_back(-1); 10 | else if (s.size()>0 && s.top()0 && s.top()>=arr[i]) // when there is element in stack and that element is greater then or equal to array element 15 | { 16 | while(s.size()>0 && s.top()>=arr[i]) // upto when there is element and stack top is greater then or equal to array's element delete the element from stack 17 | { 18 | s.pop(); // delete the element from stack 19 | } 20 | if (s.size()==0) // when stack became empty return -1 21 | { 22 | v.push_back(-1); 23 | } 24 | else 25 | { 26 | v.push_back(s.top()); // else push stack top in the vector 27 | } 28 | } 29 | s.push(arr[i]); // push array in stack 30 | } 31 | reverse(v.begin(),v.end()); // while returning reverse the vector and return it. 32 | return v; 33 | } 34 | }; 35 | 36 | 37 | // Time Complexity: O(N) 38 | // Auxiliary Space: O(N) 39 | -------------------------------------------------------------------------------- /Stack/05 Stock span problem.cpp: -------------------------------------------------------------------------------- 1 | // https://practice.geeksforgeeks.org/problems/stock-span-problem-1587115621/1 2 | 3 | class Solution 4 | { 5 | public: 6 | vector calculateSpan(int price[], int n) 7 | { 8 | vector v; // creating vector to store result 9 | stack> s; // creating the pair stack 10 | for (int i=0;i0 && s.top().first>price[i]) // when there is element in stack and stack top is greater then array element 17 | { 18 | v.push_back(s.top().second); // take stack top in the result vector 19 | } 20 | else if (s.size()>0 && s.top().first<=price[i] ){ // when there is element in stack and that element is less then array element 21 | while (s.size()>0 && s.top().first<=price[i] )// upto when there is element and stack top is less then array's element delete the element from stack 22 | { 23 | s.pop(); // delete the element from stack 24 | } 25 | if(s.size()==0) // when stack became empty return -1 26 | { 27 | v.push_back(-1); 28 | } 29 | else 30 | { 31 | v.push_back(s.top().second); // else push stack top in the vector 32 | } 33 | } 34 | s.push({price[i],i}); // take price array and index i inside pair stack 35 | } 36 | for (int i=0;i left,right; 8 | stack> s1,s2; 9 | int pseudo_index =-1; 10 | int pseudo_index1 =n; 11 | for (int i=0;i0 && s1.top().first0 && s1.top().first>=arr[i]) 22 | { 23 | while(s1.size()>0 && s1.top().first>=arr[i]) 24 | { 25 | s1.pop(); 26 | } 27 | if (s1.size()==0) 28 | { 29 | left.push_back(pseudo_index); 30 | } 31 | else 32 | { 33 | left.push_back(s1.top().second); 34 | } 35 | } 36 | s1.push({arr[i],i}); 37 | } 38 | for (int i=n-1;i>=0;i--) 39 | { 40 | if (s2.size()==0) 41 | { 42 | right.push_back(pseudo_index1); 43 | } 44 | else if (s2.size()>0 && s2.top().first0 && s2.top().first >= arr[i]) 49 | { 50 | while(s2.size()>0 && s2.top().first >= arr[i]) 51 | { 52 | s2.pop(); 53 | } 54 | if (s2.size()==0) 55 | { 56 | right.push_back(pseudo_index1); 57 | } 58 | else 59 | { 60 | right.push_back(s2.top().second); 61 | } 62 | } 63 | s2.push({arr[i],i}); 64 | } 65 | reverse(right.begin(),right.end()); 66 | long long m=INT_MIN; 67 | for (long long i=0;i& heights) { 5 | int n= heights.size(); 6 | vector left,right; 7 | stack> s1,s2; 8 | int pseudo_index =-1; 9 | int pseudo_index1 =n; 10 | for (int i=0;i0 && s1.top().first0 && s1.top().first>=heights[i]) 21 | { 22 | while(s1.size()>0 && s1.top().first>=heights[i]) 23 | { 24 | s1.pop(); 25 | } 26 | if (s1.size()==0) 27 | { 28 | left.push_back(pseudo_index); 29 | } 30 | else 31 | { 32 | left.push_back(s1.top().second); 33 | } 34 | } 35 | s1.push({heights[i],i}); 36 | } 37 | for (int i=n-1;i>=0;i--) 38 | { 39 | if (s2.size()==0) 40 | { 41 | right.push_back(pseudo_index1); 42 | } 43 | else if (s2.size()>0 && s2.top().first0 && s2.top().first >= heights[i]) 48 | { 49 | while(s2.size()>0 && s2.top().first >= heights[i]) 50 | { 51 | s2.pop(); 52 | } 53 | if (s2.size()==0) 54 | { 55 | right.push_back(pseudo_index1); 56 | } 57 | else 58 | { 59 | right.push_back(s2.top().second); 60 | } 61 | } 62 | s2.push({heights[i],i}); 63 | } 64 | reverse(right.begin(),right.end()); 65 | int m=INT_MIN; 66 | for (long long i=0;i>& matrix) { 74 | int m=matrix.size(); 75 | if(m==0) return 0; 76 | int n=matrix[0].size(), result=0; 77 | vector histogram(n, 0); 78 | 79 | for(int i=0; i