diff --git a/Dynamic Programming/Coin_change/a.exe b/Dynamic Programming/Coin_change/a.exe
new file mode 100644
index 0000000..36a2d2e
Binary files /dev/null and b/Dynamic Programming/Coin_change/a.exe differ
diff --git a/Dynamic Programming/Coin_change/max_ways.cpp b/Dynamic Programming/Coin_change/max_ways.cpp
new file mode 100644
index 0000000..5b94346
--- /dev/null
+++ b/Dynamic Programming/Coin_change/max_ways.cpp	
@@ -0,0 +1,43 @@
+//Program to count how many ways exist that an amount can be broken into a number of denominations.
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int counting(int arr[], int sum,int n) //unbounded subset sum
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<sum+1;j++)
+        {
+            if(j==0)
+             t[i][j]=1;
+            
+            if(i==0)
+             t[i][j]=0;           
+            
+        }
+    }
+    t[0][0]=1;
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<sum+1;j++)
+        {
+            if(arr[i-1]<=j)
+                {
+                    t[i][j]= (t[i][j-arr[i-1]])+ t[i-1][j];
+                }
+            else if (arr[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][sum];
+}
+int main()
+{   int coin[] = {1,2,3}; //example cases
+    int amount= 10; 
+    int n = sizeof(coin) / sizeof(coin[0]); 
+    memset(t,0,sizeof(t));
+    int count= counting(coin,amount,n);
+    cout<<count<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Coin_change/minimum_coins.cpp b/Dynamic Programming/Coin_change/minimum_coins.cpp
new file mode 100644
index 0000000..89cf70b
--- /dev/null
+++ b/Dynamic Programming/Coin_change/minimum_coins.cpp	
@@ -0,0 +1,55 @@
+//Program to fin dthe minimum number of coins required to add up to a given denomination.
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int counting(int arr[], int sum,int n) //unbounded subset sum
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<sum+1;j++)
+        {
+            if(i==0)
+             t[i][j]=INT_MAX-1;   
+            if(j==0)
+             t[i][j]=0;
+                            
+        }
+    }
+    int j=1;
+ for(int i =1;j<sum+1;j++) //twist in the initialization
+ {
+     if(j%arr[0]==0)
+     {
+         t[i][j]=j/arr[0];
+     }
+     else
+     {
+         t[i][j]=INT_MAX-1;
+     }
+     
+ }
+
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<sum+1;j++)
+        {
+            if(arr[i-1]<=j)
+                {
+                    t[i][j]= min(1+t[i][j-arr[i-1]],t[i-1][j]);
+                }
+            else if (arr[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][sum];
+}
+int main()
+{   int coin[] = {9, 6, 5, 1}; //example cases
+    int amount= 11; 
+    int n = sizeof(coin) / sizeof(coin[0]); 
+    memset(t,0,sizeof(t));
+    int count= counting(coin,amount,n);
+    cout<<count<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Count_of_subset_sum/a.exe b/Dynamic Programming/Count_of_subset_sum/a.exe
new file mode 100644
index 0000000..cacbd47
Binary files /dev/null and b/Dynamic Programming/Count_of_subset_sum/a.exe differ
diff --git a/Dynamic Programming/Count_of_subset_sum/count.cpp b/Dynamic Programming/Count_of_subset_sum/count.cpp
new file mode 100644
index 0000000..f0cdb8f
--- /dev/null
+++ b/Dynamic Programming/Count_of_subset_sum/count.cpp	
@@ -0,0 +1,43 @@
+//Program to count how many subsets exist which adds up to the given sum.
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int counting(int arr[], int sum,int n)
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<sum+1;j++)
+        {
+            if(j==0)
+             t[i][j]=1;
+            
+            if(i==0)
+             t[i][j]=0;           
+            
+        }
+    }
+    t[0][0]=1;
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<sum+1;j++)
+        {
+            if(arr[i-1]<=j)
+                {
+                    t[i][j]= (t[i-1][j-arr[i-1]])+ t[i-1][j];
+                }
+            else if (arr[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][sum];
+}
+int main()
+{   int arr[] = { 2,3,4,7}; //example cases
+    int sum= 5; 
+    int n = sizeof(arr) / sizeof(arr[0]); 
+    memset(t,0,sizeof(t));
+    int count= counting(arr,sum,n);
+    cout<<count<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Equal_sum_partition/a.exe b/Dynamic Programming/Equal_sum_partition/a.exe
new file mode 100644
index 0000000..a917e64
Binary files /dev/null and b/Dynamic Programming/Equal_sum_partition/a.exe differ
diff --git a/Dynamic Programming/Equal_sum_partition/equal_sum.cpp b/Dynamic Programming/Equal_sum_partition/equal_sum.cpp
new file mode 100644
index 0000000..ba33c4f
--- /dev/null
+++ b/Dynamic Programming/Equal_sum_partition/equal_sum.cpp	
@@ -0,0 +1,57 @@
+//Program to check whether 2 partitions exist which have equal sum.
+#include<bits/stdc++.h>
+using namespace std;
+bool t[100][1000];        //t[n+1][sum+1]
+bool equalsum(int arr[], int n)
+{  int sum=0;
+    for(int i=0;i<n;i++)
+    {
+        sum+=arr[i];
+    }
+    if(sum%2!=0)
+        return false;
+
+  sum=sum/2;
+
+  //same code as subset sum
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<sum+1;j++)
+        {
+            if(j==0)
+             t[i][j]=true;
+            
+            if(i==0)
+             t[i][j]=false;           
+            
+        }
+    }
+    t[0][0]=true;
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<sum+1;j++)
+        {
+            if(arr[i-1]<=j)
+                {
+                    t[i][j]= (t[i-1][j-arr[i-1]])|| t[i-1][j];
+                }
+            else if (arr[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][sum];
+}
+int main()
+{   int arr[] = { 2,4 }; //example cases
+    int n = sizeof(arr) / sizeof(arr[0]); 
+    memset(t,-false,sizeof(t));
+    if(equalsum( arr,n))
+        printf("YES");
+    else
+    {
+        printf("NO");
+    }
+     
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Knapsack_zero_one/a.exe b/Dynamic Programming/Knapsack_zero_one/a.exe
new file mode 100644
index 0000000..9e5e378
Binary files /dev/null and b/Dynamic Programming/Knapsack_zero_one/a.exe differ
diff --git a/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_dp.cpp b/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_dp.cpp
new file mode 100644
index 0000000..fa0567b
--- /dev/null
+++ b/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_dp.cpp	
@@ -0,0 +1,39 @@
+//dp code maximum profit
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int max(int a, int b) { return (a > b) ? a : b; }
+int knapsack(int weight[],int val[], int c,int n)
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<c+1;j++)
+        {
+            if(i==0||j==0)
+            t[i][j]=0;
+        }
+    }
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<c+1;j++)
+        {
+            if(weight[i-1]<=j)
+                {
+                    t[i][j]= max((val[i-1]+ t[i-1][j-weight[i-1]]), t[i-1][j]);
+                }
+            else if (weight[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][c];
+}
+int main()
+{   int val[] = { 60, 100, 120 }; //example cases
+    int wt[] = { 10, 20, 30 }; 
+    int W = 50; 
+    int n = sizeof(val) / sizeof(val[0]); 
+    memset(t,-1,sizeof(t));
+    cout << knapsack( wt, val,W, n); 
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_mem.cpp b/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_mem.cpp
new file mode 100644
index 0000000..e1ece14
--- /dev/null
+++ b/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_mem.cpp	
@@ -0,0 +1,34 @@
+//memoization code
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int max(int a, int b) { return (a > b) ? a : b; }
+int knapsack(int weight[],int val[], int c,int n)
+{  
+    if(n==0||c==0)
+    {
+        return 0;
+    }
+    if(t[n][c]!=-1)
+    {
+        return t[n][c];
+    }
+
+
+    if(weight[n-1]<=c)
+    {
+       return t[n][c]= max((val[n-1]+ knapsack(weight,val,c-weight[n-1],n-1)), knapsack(weight,val,c, n-1));
+    }
+    else if (weight[n-1]>c)
+        return t[n][c]=knapsack(weight,val,c,n-1);
+   return 0;
+}
+int main()
+{   int val[] = { 60, 100, 120 }; //example cases
+    int wt[] = { 10, 20, 30 }; 
+    int W = 50; 
+    memset(t,-1,sizeof(t));
+    int n = sizeof(val) / sizeof(val[0]); 
+    cout << knapsack( wt, val,W, n); 
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_rec.cpp b/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_rec.cpp
new file mode 100644
index 0000000..f4d9a8b
--- /dev/null
+++ b/Dynamic Programming/Knapsack_zero_one/zero_one_knapsack_rec.cpp	
@@ -0,0 +1,26 @@
+//recursive code maximum profit
+#include<bits/stdc++.h>
+using namespace std;
+int max(int a, int b) { return (a > b) ? a : b; }
+int knapsack(int weight[],int val[], int c,int n)
+{  
+    if(n==0||c==0)
+    {
+        return 0;
+    }
+    if(weight[n-1]<=c)
+    {
+       return max((val[n-1]+ knapsack(weight,val,c-weight[n-1],n-1)), knapsack(weight,val,c, n-1));
+    }
+    else if (weight[n-1]>c)
+        return knapsack(weight,val,c,n-1);
+   return 0;
+}
+int main()
+{   int val[] = { 60, 100, 120 }; //example cases
+    int wt[] = { 10, 20, 30 }; 
+    int W = 50; 
+    int n = sizeof(val) / sizeof(val[0]); 
+    cout << knapsack( wt, val,W, n); 
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Largest_Palindromic_Subsequence/a.exe b/Dynamic Programming/Largest_Palindromic_Subsequence/a.exe
new file mode 100644
index 0000000..176b187
Binary files /dev/null and b/Dynamic Programming/Largest_Palindromic_Subsequence/a.exe differ
diff --git a/Dynamic Programming/Largest_Palindromic_Subsequence/pal.cpp b/Dynamic Programming/Largest_Palindromic_Subsequence/pal.cpp
new file mode 100644
index 0000000..10b680e
--- /dev/null
+++ b/Dynamic Programming/Largest_Palindromic_Subsequence/pal.cpp	
@@ -0,0 +1,49 @@
+/*Longest Palindromic Subsequence
+Given a sequence, find the length of the longest palindromic subsequence in it.
+Example :
+Input:"bbbab"
+Output:4*/
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1])
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="bbbab";
+    string Y=X;
+    reverse(Y.begin(), Y.end()); 
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    cout<<LCS(X,Y,m,n)<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Longest_common_subsequence/a.exe b/Dynamic Programming/Longest_common_subsequence/a.exe
new file mode 100644
index 0000000..05eb4b3
Binary files /dev/null and b/Dynamic Programming/Longest_common_subsequence/a.exe differ
diff --git a/Dynamic Programming/Longest_common_subsequence/a.out b/Dynamic Programming/Longest_common_subsequence/a.out
new file mode 100644
index 0000000..7bb3a65
Binary files /dev/null and b/Dynamic Programming/Longest_common_subsequence/a.out differ
diff --git a/Dynamic Programming/Longest_common_subsequence/dp.cpp b/Dynamic Programming/Longest_common_subsequence/dp.cpp
new file mode 100644
index 0000000..2404c7f
--- /dev/null
+++ b/Dynamic Programming/Longest_common_subsequence/dp.cpp	
@@ -0,0 +1,43 @@
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1])
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="sujoy";
+    string Y="sujoyy";
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    cout<<LCS(X,Y,m,n)<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Longest_common_subsequence/memoization.cpp b/Dynamic Programming/Longest_common_subsequence/memoization.cpp
new file mode 100644
index 0000000..f9ababb
--- /dev/null
+++ b/Dynamic Programming/Longest_common_subsequence/memoization.cpp	
@@ -0,0 +1,37 @@
+#include<bits/stdc++.h>
+#include<string.h>
+using namespace std;
+int t[100][1000];
+int LCS(string X,string Y, int m,int n)
+{
+    
+   if(m==0||n==0)
+    return 0;
+    
+             
+   if(t[m][n]!=-1)
+   {
+   	return t[m][n];
+    }
+
+   if(X[m-1]==Y[n-1])
+    {
+     return t[m][n]= 1+LCS(X,Y,m-1,n-1);
+    }
+   else
+   {
+     return t[m][n]= max(LCS(X,Y,m,n-1),LCS(X,Y, m-1, n-1));
+   }
+            
+
+}
+int main()
+{
+    string X="sujffy";
+    string Y="sujoyyyy";
+    int m= X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    cout<<LCS(X,Y,m,n)<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Longest_common_subsequence/recursive.cpp b/Dynamic Programming/Longest_common_subsequence/recursive.cpp
new file mode 100644
index 0000000..6fc0b4b
--- /dev/null
+++ b/Dynamic Programming/Longest_common_subsequence/recursive.cpp	
@@ -0,0 +1,29 @@
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int LCS(string X,string Y, int m,int n)
+{
+    if(m==0||n==0)
+        return 0;
+    
+
+if(X[m-1]==Y[n-1])
+{
+    return 1+LCS(X,Y,m-1,n-1);
+}
+else
+{
+    return max(LCS (X,Y,m,n-1),LCS(X,Y, m-1, n-1));
+}
+
+}
+int main()
+{
+    string X="sujoy";
+    string Y="sujoyy";
+    int m=X.length();
+    int n = Y.length();
+    cout<<LCS(X,Y,m,n)<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Longest_common_substring/a.exe b/Dynamic Programming/Longest_common_substring/a.exe
new file mode 100644
index 0000000..5fec5dc
Binary files /dev/null and b/Dynamic Programming/Longest_common_substring/a.exe differ
diff --git a/Dynamic Programming/Longest_common_substring/a.out b/Dynamic Programming/Longest_common_substring/a.out
new file mode 100644
index 0000000..e42222c
Binary files /dev/null and b/Dynamic Programming/Longest_common_substring/a.out differ
diff --git a/Dynamic Programming/Longest_common_substring/substring.cpp b/Dynamic Programming/Longest_common_substring/substring.cpp
new file mode 100644
index 0000000..8e1436a
--- /dev/null
+++ b/Dynamic Programming/Longest_common_substring/substring.cpp	
@@ -0,0 +1,62 @@
+/*Longest Common Substring(Dynamic Programming)
+Given two strings ‘X’ and ‘Y’, find the length of the longest common substring.
+Examples:
+
+Input : X = “GeeksforGeeks”, y = “GeeksQuiz”
+Output : 5
+The longest common substring is “Geeks” and is of length 5.*/
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1])
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=0;
+        }
+    }
+}
+auto max= t[0][0];
+
+for (int i = 0; i < m+1; ++i)
+{
+  for (int j = 0; j < n+1; ++j)
+  {
+    if(max<t[i][j])
+      max=t[i][j];
+  }
+}
+return max;
+
+
+}
+int main()
+{
+    string X="GeeksforGeeks";
+    string Y="GeeksQuiz";
+    int m = X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    cout<<LCS(X,Y,m,n)<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Matrix_Chain_Multiplication/a.exe b/Dynamic Programming/Matrix_Chain_Multiplication/a.exe
new file mode 100644
index 0000000..d47a759
Binary files /dev/null and b/Dynamic Programming/Matrix_Chain_Multiplication/a.exe differ
diff --git a/Dynamic Programming/Matrix_Chain_Multiplication/mem.cpp b/Dynamic Programming/Matrix_Chain_Multiplication/mem.cpp
new file mode 100644
index 0000000..b77d6d7
--- /dev/null
+++ b/Dynamic Programming/Matrix_Chain_Multiplication/mem.cpp	
@@ -0,0 +1,34 @@
+#include<bits/stdc++.h>
+using namespace std;
+int t[1001][1001];
+int solve(int arr[],int i,int j)
+{
+    if(i>=j)
+    {
+        return 0;
+    }
+    if(t[i][j]!=-1)
+    {
+        return t[i][j];
+    }
+    int min = INT_MAX;
+    for(int k=i;k<j;k++)
+    {
+        int temp = solve(arr,i,k)+solve(arr,k+1,j)+arr[i-1]*arr[k]*arr[j];
+        if(min>temp)
+        {
+            min=temp;
+        }
+
+    }
+    t[i][j]=min;
+    return t[i][j];
+
+}
+int main()
+{
+    memset(t,-1,sizeof(t));
+    int arr[]={40,30,20,30};
+    cout<<solve(arr,1,(sizeof(arr)/sizeof(arr[0])-1));
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Matrix_Chain_Multiplication/mem.exe b/Dynamic Programming/Matrix_Chain_Multiplication/mem.exe
new file mode 100644
index 0000000..44db2d4
Binary files /dev/null and b/Dynamic Programming/Matrix_Chain_Multiplication/mem.exe differ
diff --git a/Dynamic Programming/Matrix_Chain_Multiplication/recursive.cpp b/Dynamic Programming/Matrix_Chain_Multiplication/recursive.cpp
new file mode 100644
index 0000000..360acb2
--- /dev/null
+++ b/Dynamic Programming/Matrix_Chain_Multiplication/recursive.cpp	
@@ -0,0 +1,31 @@
+/*Matrix Chain Multiplication
+Given a sequence of matrices, find the most efficient way to multiply these matrices together. The problem is not actually to  perform the multiplications, but merely to decide in which order to perform the multiplications.
+*/
+#include<bits/stdc++.h>
+using namespace std;
+int solve(int arr[],int i,int j)
+{
+    if(i>=j)
+    {
+        return 0;
+    }
+    int min = INT_MAX;
+    for(int k=i;k<j;k++)
+    {
+        int temp = solve(arr,i,k)+solve(arr,k+1,j)+arr[i-1]*arr[k]*arr[j];
+        if(min>temp)
+        {
+            min=temp;
+        }
+
+    }
+    return min;
+
+}
+int main()
+{
+    int arr[]={40,30,20,30};
+    int i=1,j=3;
+    cout<<solve(arr,i,j);
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/MaxGridSum/try.java b/Dynamic Programming/MaxGridSum/try.java
new file mode 100644
index 0000000..3a846e4
--- /dev/null
+++ b/Dynamic Programming/MaxGridSum/try.java	
@@ -0,0 +1,48 @@
+// Traverse from top left to bottom right of 2d array m X n
+// from each cell u can go to the cell on right or down
+// return the maximum sum possible
+import java.util.*;
+public class problem
+{
+public static void main(String[] args)
+{
+    Scanner sc = new Scanner(System.in);
+    int X,Y; //X:number of rows, Y: number of columns(X=Y) because square
+    System.out.println("Enter size");
+    X=sc.nextInt();
+    Y=X;
+    int[][] Cost= new int[X][Y];
+    for(int i=0;i<X;i++)
+    {
+        for(int j=0;j<Y;j++)
+        {
+            //Take input the cost of visiting cell (i,j)
+            Cost[i][j]=sc.nextInt();
+        }
+    }
+
+    int[][] MaxCost= new int[X][Y];
+
+    MaxCost[0][0] = Cost[0][0];
+
+   
+   for(int j=1;j<Y;j++)
+        MaxCost[0][j] = MaxCost[0][j-1] + Cost[0][j];
+
+    
+   for(int i=1;i<X;i++)
+        MaxCost[i][0] = MaxCost[i-1][0] + Cost[i][0];
+
+   for(int i=1;i<X;i++)
+    {
+        for(int j=1;j<Y;j++)
+        {
+            
+            MaxCost[i][j] = Math.max(MaxCost[i-1][j],MaxCost[i][j-1]) + Cost[i][j];
+        }
+    }
+
+    System.out.println(MaxCost[X-1][Y-1]);
+    
+}
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Minimum number of deletion in a string to make it a palindrome/a.exe b/Dynamic Programming/Minimum number of deletion in a string to make it a palindrome/a.exe
new file mode 100644
index 0000000..27788a0
Binary files /dev/null and b/Dynamic Programming/Minimum number of deletion in a string to make it a palindrome/a.exe differ
diff --git a/Dynamic Programming/Minimum number of deletion in a string to make it a palindrome/min.cpp b/Dynamic Programming/Minimum number of deletion in a string to make it a palindrome/min.cpp
new file mode 100644
index 0000000..59cf96a
--- /dev/null
+++ b/Dynamic Programming/Minimum number of deletion in a string to make it a palindrome/min.cpp	
@@ -0,0 +1,53 @@
+/*Minimum number of deletions to make a string palindrome
+Given a string of size ‘n’. The task is to remove or delete minimum number of characters from the string so that the resultant string is palindrome.
+Example :
+Input : aebcbda
+Output : 2
+Remove characters 'e' and 'd'
+Resultant string will be 'abcba'
+which is a palindromic string*/
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1])
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="aebcbda";
+    string Y=X;
+    reverse(Y.begin(), Y.end()); 
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    int d= m-LCS(X,Y,m,n);
+    cout<<d<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Minimum number of insertion in a string to make it a palindrome/min.cpp b/Dynamic Programming/Minimum number of insertion in a string to make it a palindrome/min.cpp
new file mode 100644
index 0000000..21b5f0c
--- /dev/null
+++ b/Dynamic Programming/Minimum number of insertion in a string to make it a palindrome/min.cpp	
@@ -0,0 +1,51 @@
+/*Minimum number of insertions to make a string palindrome
+Given a string, find the minimum number of characters to be inserted to form Palindrome string out of given string
+
+Examples:
+ab: Number of insertions required is 1. bab
+aa: Number of insertions required is 0. aa*/
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1])
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="aebcbda";
+    string Y=X;
+    reverse(Y.begin(), Y.end()); 
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    int d= m-LCS(X,Y,m,n);
+    cout<<d<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Number_of_subsets_with_given_diff/a.exe b/Dynamic Programming/Number_of_subsets_with_given_diff/a.exe
new file mode 100644
index 0000000..a487b57
Binary files /dev/null and b/Dynamic Programming/Number_of_subsets_with_given_diff/a.exe differ
diff --git a/Dynamic Programming/Number_of_subsets_with_given_diff/num.cpp b/Dynamic Programming/Number_of_subsets_with_given_diff/num.cpp
new file mode 100644
index 0000000..cb9eb1b
--- /dev/null
+++ b/Dynamic Programming/Number_of_subsets_with_given_diff/num.cpp	
@@ -0,0 +1,52 @@
+//Counting the numbere of subsets of a given array with a given difference.
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int counting(int arr[], int sum,int n) //using count of subset sum
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<sum+1;j++)
+        {
+            if(j==0)
+             t[i][j]=1;
+            
+            if(i==0)
+             t[i][j]=0;           
+            
+        }
+    }
+    t[0][0]=1;
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<sum+1;j++)
+        {
+            if(arr[i-1]<=j)
+                {
+                    t[i][j]= (t[i-1][j-arr[i-1]])+ t[i-1][j];
+                }
+            else if (arr[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][sum];
+}
+int main()
+{   int arr[] = {1,1,2,3}; //example cases
+    int diff= 1;
+
+    int n = sizeof(arr) / sizeof(arr[0]); 
+    int range=0,sum;
+    for(int i=0;i<n;i++)
+    {
+        range+=arr[i];
+    }
+     /* S1+S2=range
+       S1-S2=diff*/
+    sum = (diff+range)/2; //formula derived using simultaneous equations. 
+    memset(t,0,sizeof(t));
+    int count= counting(arr,sum,n);
+    cout<<count<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Palindrome_partitioning_recursive/a.exe b/Dynamic Programming/Palindrome_partitioning_recursive/a.exe
new file mode 100644
index 0000000..f15539c
Binary files /dev/null and b/Dynamic Programming/Palindrome_partitioning_recursive/a.exe differ
diff --git a/Dynamic Programming/Palindrome_partitioning_recursive/mem.cpp b/Dynamic Programming/Palindrome_partitioning_recursive/mem.cpp
new file mode 100644
index 0000000..b16610a
--- /dev/null
+++ b/Dynamic Programming/Palindrome_partitioning_recursive/mem.cpp	
@@ -0,0 +1,76 @@
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[1001][1001];
+bool ispalindrome(string s, int i, int j) 
+{	
+		if(i == j) {
+			return true;
+		}
+		
+		if(i > j) {
+			return true;
+		}
+		
+		while( i < j) {
+			if(s[i] != s[j]) {
+				return false;
+			}
+			
+			i++;
+			j--;
+		}
+		return true;
+		
+	}
+int solve(string s,int i,int j)
+{
+    if(i>=j)
+    {
+        return 0;
+    }
+    if(ispalindrome(s,i,j))
+    {
+        return 0;
+    }
+    if(t[i][j]!=-1)
+    {
+        return t[i][j];
+    }
+    int min = INT_MAX; int left,right;
+    for(int k=i;k<j;k++)
+    {
+       if(t[i][k]!=-1)
+       {
+           left=t[i][k];
+       }
+       else
+       {
+           left=solve(s,i,k);
+       }
+        if(t[k+1][j]!=-1)
+       {
+           right=t[k+1][j];
+       }
+       else
+       {
+           right=solve(s,k+1,j);
+       }
+       int temp=1+left+right;
+        if(min>temp)
+        {
+            min=temp;
+        }
+
+    }
+    return t[i][j]=min;
+
+}
+int main()
+{   
+    string s= "abcde";
+    memset(t,-1,sizeof(t));
+    cout<<solve(s,0,s.length()-1)<<endl;;
+    return 0;   
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Palindrome_partitioning_recursive/mem.exe b/Dynamic Programming/Palindrome_partitioning_recursive/mem.exe
new file mode 100644
index 0000000..2b41b8f
Binary files /dev/null and b/Dynamic Programming/Palindrome_partitioning_recursive/mem.exe differ
diff --git a/Dynamic Programming/Palindrome_partitioning_recursive/recursive.cpp b/Dynamic Programming/Palindrome_partitioning_recursive/recursive.cpp
new file mode 100644
index 0000000..cd914f6
--- /dev/null
+++ b/Dynamic Programming/Palindrome_partitioning_recursive/recursive.cpp	
@@ -0,0 +1,56 @@
+/*Given a string, a partitioning of the string is a palindrome partitioning if every substring of the partition is a palindrome. 
+Example:
+“aba|b|bbabb|a|b|aba” is a palindrome partitioning of “ababbbabbababa”.*/
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+bool ispalindrome(string s, int i, int j) {	
+		if(i == j) {
+			return true;
+		}
+		
+		if(i > j) {
+			return true;
+		}
+		
+		while( i < j) {
+			if(s[i] != s[j]) {
+				return false;
+			}
+			
+			i++;
+			j--;
+		}
+		return true;
+		
+	}
+int solve(string s,int i,int j)
+{
+    if(i>=j)
+    {
+        return 0;
+    }
+    if(ispalindrome(s,i,j))
+    {
+        return 0;
+    }
+    int min = INT_MAX;
+    for(int k=i;k<j;k++)
+    {
+        int temp =1+ solve(s,i,k)+solve(s,k+1,j);
+        if(min>temp)
+        {
+            min=temp;
+        }
+
+    }
+    return min;
+
+}
+int main()
+{   
+    string s= "abcde";
+    cout<<solve(s,0,s.length()-1)<<endl;;
+    return 0;   
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Palindrome_partitioning_recursive/recursive.exe b/Dynamic Programming/Palindrome_partitioning_recursive/recursive.exe
new file mode 100644
index 0000000..ad690e3
Binary files /dev/null and b/Dynamic Programming/Palindrome_partitioning_recursive/recursive.exe differ
diff --git a/Dynamic Programming/Printing_Longest_common_subsequence/a.exe b/Dynamic Programming/Printing_Longest_common_subsequence/a.exe
new file mode 100644
index 0000000..5a13336
Binary files /dev/null and b/Dynamic Programming/Printing_Longest_common_subsequence/a.exe differ
diff --git a/Dynamic Programming/Printing_Longest_common_subsequence/print.cpp b/Dynamic Programming/Printing_Longest_common_subsequence/print.cpp
new file mode 100644
index 0000000..49b3edc
--- /dev/null
+++ b/Dynamic Programming/Printing_Longest_common_subsequence/print.cpp	
@@ -0,0 +1,73 @@
+/*Given two sequences, print the longest subsequence present in both of them.
+Examples:
+LCS for input Sequences “ABCDGH” and “AEDFHR” is “ADH” of length 3.
+LCS for input Sequences “AGGTAB” and “GXTXAYB” is “GTAB” of length 4.*/
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1])
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="AGGTAB";
+    string Y="GXTXAYB";
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    LCS(X,Y,m,n);
+    int i=m,j=n;
+    string s;
+    while (i>0 && j>0)
+    {
+        if(X[i-1]==Y[j-1])
+        {
+            s.push_back(X[i-1]);
+            i--;j--;
+        }
+        else
+        {
+            if(t[i][j-1]>t[i-1][j])
+            {
+                j--;
+            }
+            else
+            {
+                i--;
+            }
+            
+        }
+        
+    }
+    reverse(s.begin(),s.end());
+    cout<<s<<endl;
+    cout<<t[m][n]<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Rod_cutting_problem/rod.cpp b/Dynamic Programming/Rod_cutting_problem/rod.cpp
new file mode 100644
index 0000000..66e27f3
--- /dev/null
+++ b/Dynamic Programming/Rod_cutting_problem/rod.cpp	
@@ -0,0 +1,39 @@
+//dp code maximum profit using rod cuts.
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int max(int a, int b) { return (a > b) ? a : b; }
+int knapsack(int weight[],int val[], int c,int n) //unbounded
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<c+1;j++)
+        {
+            if(i==0||j==0)
+            t[i][j]=0;
+        }
+    }
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<c+1;j++)
+        {
+            if(weight[i-1]<=j)
+                {
+                    t[i][j]= max((val[i-1]+ t[i][j-weight[i-1]]), t[i-1][j]); 
+                }
+            else if (weight[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][c];
+}
+int main()
+{   int price[] = { 60, 100, 120 }; //example cases
+    int length[] = { 10, 20, 30 }; 
+    int L = 50; 
+    int n = sizeof(length) / sizeof(length[0]); 
+    memset(t,-1,sizeof(t));
+    cout << knapsack( length, price,L, n); 
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Shortest_Common_SuperSequence/a.exe b/Dynamic Programming/Shortest_Common_SuperSequence/a.exe
new file mode 100644
index 0000000..07edec1
Binary files /dev/null and b/Dynamic Programming/Shortest_Common_SuperSequence/a.exe differ
diff --git a/Dynamic Programming/Shortest_Common_SuperSequence/short.cpp b/Dynamic Programming/Shortest_Common_SuperSequence/short.cpp
new file mode 100644
index 0000000..a4a3fec
--- /dev/null
+++ b/Dynamic Programming/Shortest_Common_SuperSequence/short.cpp	
@@ -0,0 +1,51 @@
+/*Given two strings str1 and str2, find the shortest string that has both str1 and str2 as subsequences.
+Examples :
+
+Input:   str1 = "geek",  str2 = "eke"
+Output: 5
+
+Input:   str1 = "AGGTAB",  str2 = "GXTXAYB"
+Output:  9 */
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1])
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="geek";
+    string Y="eke";
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    cout<<(m+n-LCS(X,Y,m,n))<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Subset_sum/a.exe b/Dynamic Programming/Subset_sum/a.exe
new file mode 100644
index 0000000..9342d8a
Binary files /dev/null and b/Dynamic Programming/Subset_sum/a.exe differ
diff --git a/Dynamic Programming/Subset_sum/subset_sum.cpp b/Dynamic Programming/Subset_sum/subset_sum.cpp
new file mode 100644
index 0000000..cd9b50a
--- /dev/null
+++ b/Dynamic Programming/Subset_sum/subset_sum.cpp	
@@ -0,0 +1,48 @@
+//Program to check whether a subset exists which adds up to the given sum.
+#include<bits/stdc++.h>
+using namespace std;
+bool t[100][1000];
+bool subsetsum(int arr[], int sum,int n)
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<sum+1;j++)
+        {
+            if(j==0)
+             t[i][j]=true;
+            
+            if(i==0)
+             t[i][j]=false;           
+            
+        }
+    }
+    t[0][0]=true;
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<sum+1;j++)
+        {
+            if(arr[i-1]<=j)
+                {
+                    t[i][j]= (t[i-1][j-arr[i-1]])|| t[i-1][j];
+                }
+            else if (arr[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][sum];
+}
+int main()
+{   int arr[] = { 2,3,6,10 }; //example cases
+    int sum= 18436; 
+    int n = sizeof(arr) / sizeof(arr[0]); 
+    memset(t,false,sizeof(t));
+    if(subsetsum( arr,sum,n))
+        printf("YES");
+    else
+    {
+        printf("NO");
+    }
+     
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Target_sum/a.exe b/Dynamic Programming/Target_sum/a.exe
new file mode 100644
index 0000000..6a41fcc
Binary files /dev/null and b/Dynamic Programming/Target_sum/a.exe differ
diff --git a/Dynamic Programming/Target_sum/target.cpp b/Dynamic Programming/Target_sum/target.cpp
new file mode 100644
index 0000000..cc7fec3
--- /dev/null
+++ b/Dynamic Programming/Target_sum/target.cpp	
@@ -0,0 +1,52 @@
+//Counting the numbere of subsets of a given array with a given difference. //LEETCODE PROBLEM.
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int counting(int arr[], int sum,int n) //using count of subset sum
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<sum+1;j++)
+        {
+            if(j==0)
+             t[i][j]=1;
+            
+            if(i==0)
+             t[i][j]=0;           
+            
+        }
+    }
+    t[0][0]=1;
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<sum+1;j++)
+        {
+            if(arr[i-1]<=j)
+                {
+                    t[i][j]= (t[i-1][j-arr[i-1]])+ t[i-1][j];
+                }
+            else if (arr[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][sum];
+}
+int main()
+{   int arr[] = {1,1,2,3}; //example cases
+    int diff= 1;
+
+    int n = sizeof(arr) / sizeof(arr[0]); 
+    int range=0,sum;
+    for(int i=0;i<n;i++)
+    {
+        range+=arr[i];
+    }
+     /* S1+S2=range
+       S1-S2=diff*/
+    sum = (diff+range)/2; //formula derived using simultaneous equations. 
+    memset(t,0,sizeof(t));
+    int count= counting(arr,sum,n);
+    cout<<count<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/Unbounded_Knapsack/a.exe b/Dynamic Programming/Unbounded_Knapsack/a.exe
new file mode 100644
index 0000000..a6da0bf
Binary files /dev/null and b/Dynamic Programming/Unbounded_Knapsack/a.exe differ
diff --git a/Dynamic Programming/Unbounded_Knapsack/unbounded.cpp b/Dynamic Programming/Unbounded_Knapsack/unbounded.cpp
new file mode 100644
index 0000000..fa0567b
--- /dev/null
+++ b/Dynamic Programming/Unbounded_Knapsack/unbounded.cpp	
@@ -0,0 +1,39 @@
+//dp code maximum profit
+#include<bits/stdc++.h>
+using namespace std;
+int t[100][1000];
+int max(int a, int b) { return (a > b) ? a : b; }
+int knapsack(int weight[],int val[], int c,int n)
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<c+1;j++)
+        {
+            if(i==0||j==0)
+            t[i][j]=0;
+        }
+    }
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<c+1;j++)
+        {
+            if(weight[i-1]<=j)
+                {
+                    t[i][j]= max((val[i-1]+ t[i-1][j-weight[i-1]]), t[i-1][j]);
+                }
+            else if (weight[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][c];
+}
+int main()
+{   int val[] = { 60, 100, 120 }; //example cases
+    int wt[] = { 10, 20, 30 }; 
+    int W = 50; 
+    int n = sizeof(val) / sizeof(val[0]); 
+    memset(t,-1,sizeof(t));
+    cout << knapsack( wt, val,W, n); 
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/longest_repeating_subsequence/a.exe b/Dynamic Programming/longest_repeating_subsequence/a.exe
new file mode 100644
index 0000000..456912e
Binary files /dev/null and b/Dynamic Programming/longest_repeating_subsequence/a.exe differ
diff --git a/Dynamic Programming/longest_repeating_subsequence/long.cpp b/Dynamic Programming/longest_repeating_subsequence/long.cpp
new file mode 100644
index 0000000..e0137f5
--- /dev/null
+++ b/Dynamic Programming/longest_repeating_subsequence/long.cpp	
@@ -0,0 +1,51 @@
+/*Given a string, print the longest repeating subsequence such that the two subsequence don’t have same string character at same position, i.e., any i’th character in the two subsequences shouldn’t have the same index in the original string.
+Example:
+Input: str = "aab"
+Output: "a"
+The two subsequence are 'a'(first) and 'a' 
+(second). Note that 'b' cannot be considered 
+as part of subsequence as it would be at same
+index in both.*/
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1]&& i!=j)
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="aabbdefgcc";
+    string Y=X;
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    cout<<LCS(X,Y,m,n)<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/min_insert_delete/a.exe b/Dynamic Programming/min_insert_delete/a.exe
new file mode 100644
index 0000000..936af38
Binary files /dev/null and b/Dynamic Programming/min_insert_delete/a.exe differ
diff --git a/Dynamic Programming/min_insert_delete/min.cpp b/Dynamic Programming/min_insert_delete/min.cpp
new file mode 100644
index 0000000..ec265e5
--- /dev/null
+++ b/Dynamic Programming/min_insert_delete/min.cpp	
@@ -0,0 +1,53 @@
+/* Given two strings ‘str1’ and ‘str2’ of size m and n respectively. The task is to remove/delete and insert minimum number of characters from/in str1 so as to transform it into str2. It could be possible that the same character needs to be removed/deleted from one point of str1 and inserted to some another point.
+
+Examples:
+
+Input : str1 = "heap", str2 = "pea" 
+Output : Minimum Deletion = 2 and
+         Minimum Insertion = 1*/
+
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1])
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="heap";
+    string Y="pea";
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    int ins = n-LCS(X,Y,m,n);
+    int del = m-LCS(X,Y,m,n);
+    cout<<ins<<" "<<del<<endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/minimum_subset_sum_diff/a.exe b/Dynamic Programming/minimum_subset_sum_diff/a.exe
new file mode 100644
index 0000000..cacc804
Binary files /dev/null and b/Dynamic Programming/minimum_subset_sum_diff/a.exe differ
diff --git a/Dynamic Programming/minimum_subset_sum_diff/min.cpp b/Dynamic Programming/minimum_subset_sum_diff/min.cpp
new file mode 100644
index 0000000..99a8380
--- /dev/null
+++ b/Dynamic Programming/minimum_subset_sum_diff/min.cpp	
@@ -0,0 +1,60 @@
+//Find the minimum possible difference of the sum of two chose subsets of a given array.
+#include<bits/stdc++.h>
+using namespace std;
+bool t[100][1000];
+bool subsetsum(int arr[], int sum,int n) //use of the subset-sum problem function
+{  
+    for(int i=0;i<n+1;i++)
+    {
+        for(int j=0;j<sum+1;j++)
+        {
+            if(j==0)
+             t[i][j]=true;
+            
+            if(i==0)
+             t[i][j]=false;           
+            
+        }
+    }
+    t[0][0]=true;
+ for(int i=1;i<n+1;i++)
+    {
+        for(int j=1;j<sum+1;j++)
+        {
+            if(arr[i-1]<=j)
+                {
+                    t[i][j]= (t[i-1][j-arr[i-1]])|| t[i-1][j];
+                }
+            else if (arr[i-1]>j)
+                t[i][j]=t[i-1][j];
+
+        }
+    }    
+return t[n][sum];
+}
+int main()
+{   int arr[] = {1,2,7,8,9 }; //example cases
+    int range=0;
+    int n = sizeof(arr) / sizeof(arr[0]); 
+    memset(t,false,sizeof(t));
+    for(int i=0;i<n;i++)
+    {
+        range+=arr[i];
+    }
+   subsetsum(arr,range,n);
+   int mn =INT_MAX;
+   vector<int> v;
+   for(int i=0;i<=range/2;i++)
+   {
+       if(t[n][i])
+       {
+           v.push_back(i);
+       }
+   }
+   for(int i=0;i<v.size();i++)
+   {
+       mn = min(mn, range - 2* v[i]);
+   }
+  cout<<mn<<endl;// subsets are: {7.8} and {1,2,9} hence the difference will be 3.
+    return 0;
+}
\ No newline at end of file
diff --git a/Dynamic Programming/sequence_pattern_matching/a.exe b/Dynamic Programming/sequence_pattern_matching/a.exe
new file mode 100644
index 0000000..4d185f5
Binary files /dev/null and b/Dynamic Programming/sequence_pattern_matching/a.exe differ
diff --git a/Dynamic Programming/sequence_pattern_matching/seq.cpp b/Dynamic Programming/sequence_pattern_matching/seq.cpp
new file mode 100644
index 0000000..64bc847
--- /dev/null
+++ b/Dynamic Programming/sequence_pattern_matching/seq.cpp	
@@ -0,0 +1,53 @@
+#include<bits/stdc++.h>
+#include<string.h>
+#include<string>
+using namespace std;
+int t[100][1000];
+
+int LCS(string X,string Y, int m,int n)
+{
+    for (int i = 0; i < m+1; ++i)
+    {
+       for (int j = 0; j < n+1; ++j)
+       {
+          if(i==0||j==0)
+            t[i][j]=0;
+       }
+    }
+
+for (int i = 1; i < m+1; ++i)
+{
+    for(int j = 1; j < n+1; ++j)
+    {
+        if(X[i-1]==Y[j-1]&& i!=j)
+         { 
+            t[i][j]=1+t[i-1][j-1];
+         }
+        else
+        {
+            t[i][j]=max(t[i-1][j],t[i][j-1]);
+        }
+    }
+}
+return t[m][n];
+}
+int main()
+{
+    string X="AXY";
+    int p=X.length();
+    string Y="ADX";
+    X=Y+X;
+    Y=X;
+    int m=X.length();
+    int n = Y.length();
+    memset(t,-1,sizeof(t));
+    if(LCS(X,Y,m,n)>=p)
+    {
+        cout<<"True"<<endl;
+    }
+    else
+    {
+        cout<<"False"<<endl;
+    }
+    return 0;
+}
\ No newline at end of file