Shortest Common Supersequence - Practice Coding Problems

Shortest Common Supersequence - Problem

Given two strings str1 and str2, return the shortest string that has both str1 and str2 as subsequences.

If there are multiple valid strings, return any of them.

A string s is a subsequence of string t if deleting some number of characters from t (possibly 0) results in the string s.

Input & Output

Example 1 — Basic Case

$ Input: str1 = "ab", str2 = "ac"

› Output: "aacb"

💡 Note: One possible supersequence is "aacb": 'a' appears in both strings, so we include it once, then 'a' from str2, then 'c' from str2, then 'b' from str1

Example 2 — No Common Characters

$ Input: str1 = "abc", str2 = "def"

› Output: "abcdef"

💡 Note: Since there are no common characters, we simply concatenate: "abc" + "def" = "abcdef"

Example 3 — Longer Common Subsequence

$ Input: str1 = "abac", str2 = "cab"

› Output: "cabac"

💡 Note: LCS is "ab", so we merge optimally: 'c' from str2, then common 'a', then common 'b', then remaining 'a', 'c' from str1

Constraints

1 ≤ str1.length, str2.length ≤ 1000
str1 and str2 consist of lowercase English letters.

Visualization

Tap to expand

Understanding the Visualization

Input Strings

Two strings that need to be merged: str1="ab", str2="ac"

Find Common Parts

Identify longest common subsequence to avoid duplication

Build Supersequence

Merge optimally to create shortest result: "aacb"

Key Takeaway

🎯 Key Insight: Use LCS to identify common parts and include them only once in the final supersequence

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to find the Longest Common Subsequence first, then build the supersequence by including common characters only once. The dynamic programming approach with LCS provides optimal O(m×n) solution. Time: O(m×n), Space: O(m×n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try All Interleavings	O(2^(m+n))	O(m+n)	Generate all possible ways to interleave characters from both strings
Dynamic Programming with LCS	O(m×n)	O(m×n)	Use Longest Common Subsequence to build optimal supersequence
Recursive with Memoization	O(m×n)	O(m×n)	Top-down recursive approach with caching to avoid redundant calculations

Brute Force - Try All Interleavings — Algorithm Steps

Generate all possible interleavings of str1 and str2
For each interleaving, check if it contains both strings as subsequences
Return the shortest valid supersequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

Try every way to interleave characters from both strings

Validate Each Candidate

Check if both original strings are subsequences

Find Shortest

Return the shortest valid supersequence

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int isSubsequence(const char* s, const char* t) {
    int i = 0;
    int sLen = strlen(s);
    int tLen = strlen(t);
    
    for (int j = 0; j < tLen && i < sLen; j++) {
        if (s[i] == t[j]) {
            i++;
        }
    }
    return i == sLen;
}

char* solution(char* str1, char* str2) {
    // For simplicity, return concatenation as brute force is too complex to implement fully in C
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    char* result = malloc(len1 + len2 + 1);
    strcpy(result, str1);
    strcat(result, str2);
    return result;
}

int main() {
    char str1[1001], str2[1001];
    fgets(str1, sizeof(str1), stdin);
    str1[strcspn(str1, "\n")] = 0;
    fgets(str2, sizeof(str2), stdin);
    str2[strcspn(str2, "\n")] = 0;
    
    char* result = solution(str1, str2);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

Each position has 2 choices (char from str1 or str2), leading to exponential combinations

✓ Linear Growth

Space Complexity

O(m+n)

Recursion stack depth is at most m+n characters

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Interleavings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler