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

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

✓ Brute Force - Try All Interleavings

⏱️ Time: O(2^(m+n)) Space: O(m+n)

For each position in the result string, try placing a character from str1 or str2. Recursively build all possible supersequences and return the shortest one that contains both strings as subsequences.

Dynamic Programming with LCS

⏱️ Time: O(m×n) Space: O(m×n)

First find the Longest Common Subsequence (LCS) using 2D DP, then construct the shortest supersequence by merging characters optimally. Include all characters from both strings while avoiding duplication of common subsequence characters.

Recursive with Memoization

⏱️ Time: O(m×n) Space: O(m×n)

Use recursion to explore all possibilities of building the supersequence, but cache results to avoid recomputing the same subproblems. For each position, decide whether to take from str1, str2, or both if characters match.

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>

static int dp[1001][1001];

char* solution(char* str1, char* str2) {
    int m = strlen(str1);
    int n = strlen(str2);
    
    // Initialize dp table
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
            dp[i][j] = 0;
        }
    }
    
    // Build LCS table
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (str1[i-1] == str2[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
            } else {
                dp[i][j] = (dp[i-1][j] > dp[i][j-1]) ? dp[i-1][j] : dp[i][j-1];
            }
        }
    }
    
    // Reconstruct the shortest common supersequence
    char* result = malloc(2001);
    int pos = 0;
    int i = m, j = n;
    
    while (i > 0 && j > 0) {
        if (str1[i-1] == str2[j-1]) {
            result[pos++] = str1[i-1];
            i--;
            j--;
        } else if (dp[i-1][j] > dp[i][j-1]) {
            result[pos++] = str1[i-1];
            i--;
        } else {
            result[pos++] = str2[j-1];
            j--;
        }
    }
    
    // Add remaining characters
    while (i > 0) {
        result[pos++] = str1[i-1];
        i--;
    }
    
    while (j > 0) {
        result[pos++] = str2[j-1];
        j--;
    }
    
    result[pos] = '\0';
    
    // Reverse the result
    for (int k = 0; k < pos / 2; k++) {
        char temp = result[k];
        result[k] = result[pos - 1 - k];
        result[pos - 1 - k] = temp;
    }
    
    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

Shortest Common Supersequence - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Interleavings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler