Added C++ Solution

Author: FarheenB

C++/soln-backtracking-problems/combination-sum-ii.cpp

@@ -0,0 +1,37 @@
+/**
+ @author Farheen Bano
+  
+ Date 13-08-2021
+ 
+ Reference-
+ https://leetcode.com/problems/combination-sum-ii/
+*/
+
+class Solution {
+public:
+    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
+        vector<vector<int>> result;
+        vector<int> cur;
+        sort(candidates.begin(),candidates.end());
+        generateSubsets(0,candidates,cur,result,target);
+        return result;
+    }
+    
+    void generateSubsets(int index, vector<int>& candidates, vector<int>& cur, vector<vector<int>>& result, int target){ 
+        if(target==0){
+            result.push_back(cur);
+            return;
+        }
+
+        if(target<0)
+            return;
+        
+        for(int i=index;i<candidates.size();i++){
+            if(i>index && candidates[i]==candidates[i-1])
+                continue;
+            cur.push_back(candidates[i]);
+            generateSubsets(i+1,candidates,cur,result,target-candidates[i]);
+            cur.pop_back();
+        }
+    }
+};

C++/soln-dynamic-programming-problems/0-1-knapsack.cpp

@@ -0,0 +1,72 @@
+/**
+ @author Farheen Bano
+ 
+ 0/1 Knapsack Problem - Given items of certain weights/values and maximum allowed weight
+ how to pick items to pick items from this set to maximize sum of value of items such that
+ sum of weights is less than or equal to maximum allowed weight.
+ 
+ Time complexity - O(W*total items)
+ 
+ Reference-
+ https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/
+*/
+
+//------------------------------------------------------------------------------
+//Memoization Approach 
+
+class Solution
+{
+    public:
+    int dp[1001][1001];
+    //Function to return max value that can be put in knapsack of capacity W.
+    int knapSack(int W, int wt[], int val[], int N) { 
+        memset(dp,-1,sizeof(dp));
+        KS(W,wt,val,N);
+    }
+    
+    //Recursive Function
+    int KS(int W, int wt[], int val[], int N){
+        if(N==0 || W==0)
+            return 0;
+            
+        if(dp[N][W]!=-1){
+            return dp[N][W];
+        }    
+        
+        if(wt[N-1]<=W){
+            dp[N][W]=max(
+                            (val[N-1]+KS(W-wt[N-1],wt,val,N-1)),
+                            KS(W,wt,val,N-1)
+                        );
+            return dp[N][W];
+        }
+        dp[N][W]=KS(W,wt,val,N-1);
+        return dp[N][W];
+    }
+};
+
+//------------------------------------------------------------------------------
+//Tabulation Approach
+
+class Solution
+{
+    public:
+    //Function to return max value that can be put in knapsack of capacity W.
+    int knapSack(int W, int wt[], int val[], int N){ 
+        int dp[N+1][W+1];
+        
+        for(int i=0;i<N+1;i++){
+            for(int j=0;j<W+1;j++){
+                if(i==0||j==0){
+                    dp[i][j]=0;
+                }
+                else if(wt[i-1]<=j){
+                    dp[i][j]=max(val[i-1]+dp[i-1][j-wt[i-1]],dp[i-1][j]);
+                }
+                else
+                    dp[i][j]=dp[i-1][j];
+            }
+        }
+        return dp[N][W];
+    }
+};

C++/soln-dynamic-programming-problems/climbing-stairs.cpp

@@ -0,0 +1,66 @@
+/**
+ @author Farheen Bano
+  
+ Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+ 
+ Date 14-08-2021
+ 
+ References-
+ https://leetcode.com/problems/climbing-stairs/
+ https://www.geeksforgeeks.org/count-ways-reach-nth-stair/
+
+ NOTE: Variation of Fibinacci Series
+*/
+
+//Recursive Solution 
+//Result in TLE error
+
+class Solution {
+    public int climbStairs(int n) {
+        return countWays(n+1);
+    }
+    
+    int countWays(int n){
+        if (n <= 1)
+            return n;
+        return countWays(n - 1) + countWays(n - 2);
+    }
+}
+
+
+//Dynamic Programming Solution
+
+class Solution {
+public:
+    int climbStairs(int n) {
+        if (n == 1) {
+            return 1;
+        }
+        int* dp = new int[n + 1];
+        dp[1] = 1;
+        dp[2] = 2;
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+        return dp[n];
+    }
+};
+
+
+//Constant Space Solution
+
+class Solution {
+public:
+    int climbStairs(int n) {
+        if(n==1)
+            return 1;
+        int a=1;
+        int b=2;
+        for(int i=3;i<=n;i++){
+            int c=a+b;
+            a=b;
+            b=c;
+        }
+        return b;
+    }
+};

C++/soln-dynamic-programming-problems/longest-common-subsequence.cpp

@@ -0,0 +1,67 @@
+/**
+ @author Farheen Bano
+  
+ Date 14-08-2021
+
+ References-
+ https://www.geeksforgeeks.org/longest-common-subsequence-dp-4/
+ https://leetcode.com/problems/longest-common-subsequence/
+*/
+
+//------------------------------------------------------------------------------
+//Memoization Approach
+//TLE Problem  
+
+class Solution
+{
+    public:
+    int dp[1001][1001];
+    //Function to find the length of longest common subsequence in two strings.
+    int lcs(int x, int y, string s1, string s2) {
+        memset(dp,-1,sizeof(dp));
+        return subsequence(x, y, s1, s2);
+    }
+    
+    //Recursive Function
+    int subsequence(int x, int y, string s1, string s2) {
+        if(x==0 || y==0)
+            return 0;
+            
+        if(dp[x][y]!=-1)
+            return dp[x][y];
+            
+        if(s1[x-1]==s2[y-1]){
+            dp[x][y]= 1+subsequence(x-1,y-1,s1,s2);
+            return dp[x][y];
+        }
+    
+        dp[x][y]=max(subsequence(x-1,y,s1,s2),subsequence(x,y-1,s1,s2));
+        return dp[x][y];
+    }
+};
+
+//------------------------------------------------------------------------------
+//Tabulation Approach
+
+class Solution
+{
+    public:
+    //Function to find the length of longest common subsequence in two strings.
+    int lcs(int x, int y, string s1, string s2)
+    {
+       int dp[x+1][y+1];
+
+        for(int i=0;i<=x;i++){
+            for(int j=0;j<=y;j++){
+                if(i==0 || j==0)
+                    dp[i][j]=0;
+                else if(s1[i-1]==s2[j-1]){
+                    dp[i][j]=1+dp[i-1][j-1];
+                }
+                else 
+                    dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
+            }
+        }        
+        return dp[x][y];
+    }
+};

C++/soln-dynamic-programming-problems/longest-common-substring.cpp

@@ -0,0 +1,37 @@
+/**
+ @author Farheen Bano
+  
+ Date 14-08-2021
+  
+ Reference-
+ https://practice.geeksforgeeks.org/problems/longest-common-substring1452/1
+
+ NOTE: Variation of Longest Common Subsequence
+*/ 
+
+//------------------------------------------------------------------------------
+//Tabulation Approach
+
+class Solution{
+    public:
+    
+    int longestCommonSubstr (string S1, string S2, int n, int m)
+    {
+        int dp[n+1][m+1];
+        int max_len=0;
+        
+        for(int i=0;i<=n;i++){
+            for(int j=0;j<=m;j++){
+                if(i==0 || j==0)
+                    dp[i][j]=0;
+                else if(S1[i-1]==S2[j-1]){
+                    dp[i][j]=1+dp[i-1][j-1];
+                    max_len=max(max_len,dp[i][j]);
+                }
+                else
+                    dp[i][j]=0;
+            }
+        }
+        return max_len;
+    }
+};

C++/soln-dynamic-programming-problems/longest-palindromic-subsequence.cpp

@@ -0,0 +1,41 @@
+/**
+ @author Farheen Bano
+  
+ Date 14-08-2021
+  
+ References-
+ https://www.geeksforgeeks.org/longest-palindromic-subsequence-dp-12/
+ https://leetcode.com/problems/longest-palindromic-subsequence/
+
+ NOTE: Variation of Longest Common Subsequence
+*/ 
+
+//------------------------------------------------------------------------------
+//Tabulation Approach
+
+class Solution {
+public:
+    int longestPalindromeSubseq(string s) {
+        string reverse_s=s;
+        int m=s.size();
+        reverse(reverse_s.begin(),reverse_s.end());
+        return lcs(m,m,s,reverse_s);
+    }
+    
+    int lcs(int x, int y, string s1, string s2) {
+        int dp[x+1][y+1];
+
+        for(int i=0;i<=x;i++){
+            for(int j=0;j<=y;j++){
+                if(i==0 || j==0)
+                    dp[i][j]=0;
+                else if(s1[i-1]==s2[j-1]){
+                    dp[i][j]=1+dp[i-1][j-1];
+                }
+                else 
+                    dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
+            }
+        }        
+        return dp[x][y];
+    }
+};

C++/soln-dynamic-programming-problems/shortest-common-supersequence.cpp

@@ -0,0 +1,41 @@
+/**
+ @author Farheen Bano
+  
+ Date 14-08-2021
+
+ Reference-
+ https://www.geeksforgeeks.org/shortest-common-supersequence/
+ 
+ NOTE: Variation of Longest Common Subsequence
+*/ 
+
+
+//------------------------------------------------------------------------------
+//Tabulation Approach
+
+class Solution
+{
+    public:
+    //Function to find length of shortest common supersequence of two strings.
+    int shortestCommonSupersequence(string X, string Y, int m, int n){
+        return n+m-lcs(m,n,X,Y);
+    }
+    
+    int lcs(int x, int y, string s1, string s2)
+    {
+       int dp[x+1][y+1];
+
+        for(int i=0;i<=x;i++){
+            for(int j=0;j<=y;j++){
+                if(i==0 || j==0)
+                    dp[i][j]=0;
+                else if(s1[i-1]==s2[j-1]){
+                    dp[i][j]=1+dp[i-1][j-1];
+                }
+                else 
+                    dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
+            }
+        }        
+        return dp[x][y];
+    }
+};