dp init #8

Author: akashchouhan16

DynamicProgramming/longestPalindromicSubsequence.cpp

@@ -0,0 +1,59 @@
+/* Problem Statement :
+Given a sequence, find the length of the longest palindromic subsequence in it.
+Approach: The idea is very straightforward. We are familiar with the approach of finding the longest possible common subsequence of two given strings. Here, we and utilize that concept on the given string and its reverse to obtain the longest possible palindromic subsequence.
+Therefore, the Longest Palindromic subsequence (LPS) is nothing but the Longest Common Subsequence problem on the input string s and reverse(s).
+[Note] LPS(a,n) = LCS(a,reverse(a),n); 
+
+Sample Test Case :
+3
+bbbab       
+helloracecar
+agbcba      
+case #1 : 4
+case #2 : 7
+case #3 : 5
+*/
+#include "headers.hpp"
+
+int LCS(string, string, int);
+int LPS(string s, int n)
+{
+    string rev = s;
+    reverse(rev.begin(), rev.end());
+
+    return LCS(s, rev, n);
+}
+
+int LCS(string a, string b, int n)
+{
+    int dp[n + 1][n + 1];
+
+    for (int i = 0; i <= n; i++)
+        dp[0][i] = 0;
+    for (int i = 0; i <= n; i++)
+        dp[i][0] = 0;
+
+    for (int i = 1; i <= n; i++)
+    {
+        for (int j = 1; j <= n; j++)
+        {
+            if (a[i - 1] == b[j - 1])
+                dp[i][j] = 1 + dp[i - 1][j - 1];
+            else
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+    return dp[n][n];
+}
+int main()
+{
+    vi output;
+    tests(t)
+    {
+        string s;
+        cin >> s;
+        int n = s.size();
+        output.pb(LPS(s, n));
+    }
+    loop(i, output.size()) cout << "case #" << i + 1 << " : " << output[i] << endl;
+}

DynamicProgramming/minimumDeletionsToMakeStringPalindrome.cpp

@@ -0,0 +1,58 @@
+/*  Problem Statement: Minimum number of deletions to make a string palindrome
+Given a string of size ‘n’. The task is to remove or delete a minimum number of characters from the string so that the resultant string is a palindrome.
+
+Sample Test Case :
+3
+aebcbda
+geeksforgeeks
+racecar
+case #1 : 2
+case #2 : 8
+case #3 : 0 
+*/
+
+#include "headers.hpp"
+int LCS(string, string, int);
+int minDeletionsToMakeStringPalindrome(string str, int n)
+{
+    string revStr = str;
+    reverse(revStr.begin(), revStr.end());
+    return n - LCS(str, revStr, n);
+}
+
+int LCS(string a, string b, int n)
+{
+    int dp[n + 1][n + 1];
+    for (int i = 0; i <= n; i++)
+        dp[i][0] = 0;
+    for (int i = 0; i <= n; i++)
+        dp[0][i] = 0;
+
+    for (int i = 1; i <= n; i++)
+    {
+        for (int j = 1; j <= n; j++)
+        {
+            if (a[i - 1] == b[j - 1])
+                dp[i][j] = (1 + dp[i - 1][j - 1]);
+            else
+            {
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp[n][n];
+}
+int main()
+{
+    vi output;
+    tests(t)
+    {
+        string str;
+        cin >> str;
+        int n = str.size();
+        output.pb(minDeletionsToMakeStringPalindrome(str, n));
+    }
+
+    loop(i, output.size()) cout << "case #" << i + 1 << " : " << output[i] << endl;
+    return 0;
+}

DynamicProgramming/printShortestCommonSupersequence.cpp

@@ -0,0 +1,93 @@
+#include "headers.hpp"
+/* Problem Statement : A follow up problem of the Shortest Common Supersequence Problem.
+We can output any p&c of the resultant string. For example, a = "geek", b = "eke" -> the shortest possible supersequence will be of length = 5. Any valid string with both a & b strings as subsequences and of SCS length is allowed. (eg: "geeke", "gekek", etc.)
+
+Sample Test Case :
+3
+geek eke
+racecar aceit
+students tents
+case #1 : gekek    
+case #2 : raceitcar
+case #3 : students
+*/
+int **LCS(string s1, string s2, int n, int m)
+{
+    int **dp = new int *[n + 1];
+    loop(i, n + 1)
+        dp[i] = new int[m + 1];
+
+    for (int i = 0; i <= m; i++)
+        dp[0][i] = 0;
+    for (int i = 0; i <= n; i++)
+        dp[i][0] = 0;
+
+    for (int i = 1; i <= n; i++)
+    {
+        for (int j = 1; j <= m; j++)
+        {
+            if (s1[i - 1] == s2[j - 1])
+                dp[i][j] = (1 + dp[i - 1][j - 1]);
+            else
+            {
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp;
+}
+string printShortestCommonSuperSequence(string s1, string s2, int n, int m)
+{
+    int **dp = LCS(s1, s2, n, m);
+    string output = "";
+    int i = n, j = m;
+
+    while (i > 0 and j > 0)
+    {
+        if (s1[i - 1] == s2[j - 1])
+        {
+            output += (s1[i - 1]);
+            i--;
+            j--;
+        }
+        else
+        {
+            if (dp[i][j - 1] > dp[i - 1][j])
+            {
+                output += (s2[j - 1]);
+                j--;
+            }
+            else
+            {
+                output += (s1[i - 1]);
+                i--;
+            }
+        }
+    }
+    while (i > 0)
+    {
+        output += s1[i - 1];
+        i--;
+    }
+    while (j > 0)
+    {
+        output += s2[j - 1];
+        j--;
+    }
+    reverse(output.begin(), output.end()); //not needed here, as the length and the count of the resultant characters are preserved.
+    return output;
+}
+
+int main()
+{
+    v(string) output;
+    tests(t)
+    {
+        string s1, s2;
+        cin >> s1 >> s2;
+        int n = s1.size(), m = s2.size();
+        output.pb(printShortestCommonSuperSequence(s1, s2, n, m));
+    }
+    loop(i, output.size()) cout << "case #" << i + 1 << " : " << output[i] << endl;
+    return 0;
+}

DynamicProgramming/sequencePatternMatch.cpp

@@ -0,0 +1,63 @@
+/* Problem Statement: We are given two strings, a and b. We need to write a function to check if string a exists as a subsequence of string b.
+
+[Note] A subsequence of a string is a string where the order of the characters is preserved, but it can be at discontinuous positions. For example, If HelloWorld is our main string. A valid subsequence is Horld -> the order of characters is preserved, but the characters are allowed to be discontinuous.
+
+Input a larger String (b), and then a smaller string (a). Check if the second string(a) exists as a subsequence of the first string (b)
+The approach in short: The idea here is very simple. We can check for the longest possible common subsequence between a and b. Since we know the first string is the larger one, the LCS length must correspond to the length of the smaller string (a) for it to be a valid subsequence present in string b.
+Thus, we obtain the length of the LCS(a,b), and then in the driver function, we return true if the length of LCS and string a is the same, else return false.
+
+Sample Test Case :
+3
+DynamicProgramming  DP
+HelloWorld  Horld
+ABBEGYDH    ABDY
+case #1 : 1
+case #2 : 1
+case #3 : 0
+*/
+
+#include "headers.hpp"
+
+int LCS(string &, string &, int, int);
+bool sequencePatternMatch(string &a, string &b)
+{
+    int n = a.size(), m = b.size();
+    int lcs = LCS(a, b, n, m);
+    return (n == lcs);
+}
+int LCS(string &a, string &b, int n, int m)
+{
+    int dp[n + 1][m + 1];
+
+    for (int i = 0; i <= m; i++)
+        dp[0][i] = 0;
+    for (int i = 0; i <= n; i++)
+        dp[i][0] = 0;
+
+    for (int i = 1; i <= n; i++)
+    {
+        for (int j = 1; j <= m; j++)
+        {
+            if (a[i - 1] == b[j - 1])
+                dp[i][j] = (1 + dp[i - 1][j - 1]);
+            else
+            {
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp[n][m];
+}
+int main()
+{
+    v(bool) output;
+    tests(t)
+    {
+        string a, b;
+        cin >> b >> a;
+        output.pb(sequencePatternMatch(a, b));
+    }
+
+    loop(i, output.size()) cout << "case #" << i + 1 << " : " << output[i] << endl;
+    return 0;
+}