Merge branch 'master' into feature/climbing-stairs

Author: mrid88

DP/#1092 - Shortest Common Supersequence - Hard/Shortest Common Supersequence - Explanation.md

@@ -0,0 +1,38 @@
+Shortest Common Supersequence Solution
+Overview
+The goal of this solution is to find the shortest common supersequence (SCS) of two given strings, str1 and str2. The shortest common supersequence is the shortest string that has both str1 and str2 as subsequences.
+
+Steps
+Create DP Table:
+
+We first create a dynamic programming (DP) table dp of size (m + 1) x (n + 1), where m is the length of str1 and n is the length of str2.
+
+Fill the DP Table:
+
+We fill the DP table based on the following conditions:
+
+If characters of str1 and str2 match, we take the diagonal value and add 1: dp[i][j] = dp[i - 1][j - 1] + 1.
+
+If characters do not match, we take the maximum value from the left or the top cell: dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]).
+
+Build the Shortest Common Supersequence:
+
+We use a StringBuilder to construct the SCS.
+
+Starting from the bottom-right corner of the DP table, we move based on the values in the DP table:
+
+If characters match, we add that character to the result and move diagonally up-left.
+
+If characters do not match, we move in the direction of the larger DP value (either up or left).
+
+Finally, we add any remaining characters from str1 or str2.
+
+Reverse the Result:
+
+The result is constructed in reverse order, so we reverse it before returning.
+
+Time Complexity
+The time complexity is O(m * n) because we traverse the DP table of size (m + 1) x (n + 1).
+
+Space Complexity
+The space complexity is O(m * n) because we use a DP table of size (m + 1) x (n + 1).

DP/#1092 - Shortest Common Supersequence - Hard/Shortest Common Supersequence.java

@@ -0,0 +1,56 @@
+class Solution {
+    public String shortestCommonSupersequence(String str1, String str2) {
+        int m = str1.length();
+        int n = str2.length();
+
+        // Create DP table
+        int[][] dp = new int[m + 1][n + 1];
+
+        // Fill the DP table
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1; // If characters match
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); // Take max from either previous row or column
+                }
+            }
+        }
+
+        // Build the shortest common supersequence
+        StringBuilder result = new StringBuilder();
+        int i = m, j = n;
+        while (i > 0 && j > 0) {
+            // If characters are the same, add to the result
+            if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
+                result.append(str1.charAt(i - 1));
+                i--;
+                j--;
+            } else if (dp[i - 1][j] > dp[i][j - 1]) { // Move in the direction of the larger dp value
+                result.append(str1.charAt(i - 1));
+                i--;
+            } else {
+                result.append(str2.charAt(j - 1));
+                j--;
+            }
+        }
+
+        // If there are any remaining characters in str1
+        while (i > 0) {
+            result.append(str1.charAt(i - 1));
+            i--;
+        }
+
+        // If there are any remaining characters in str2
+        while (j > 0) {
+            result.append(str2.charAt(j - 1));
+            j--;
+        }
+
+        // Reverse the result before returning
+        return result.reverse().toString();
+    }
+}
+
+//Time Complexity : O(m*n)
+//Space Complexity : O(m*n)