Shortest Common Supersequence

Shortest Common Supersequence - Problem

You're given two strings str1 and str2, and your task is to find the shortest possible string that contains both strings as subsequences.

A subsequence is formed by deleting some (possibly zero) characters from a string while maintaining the relative order of the remaining characters. For example, "ace" is a subsequence of "abcde".

The shortest common supersequence is the smallest string that has both input strings as subsequences. Think of it as merging two strings optimally while preserving their character order.

Example: For strings "abac" and "cab", one possible shortest common supersequence is "cabac" (length 5), which contains both "abac" and "cab" as subsequences.

Goal: Return any valid shortest common supersequence. If multiple solutions exist with the same minimum length, any of them is acceptable.

Input & Output

example_1.py — Basic Example

$ Input: {"str1": "abac", "str2": "cab"}

› Output: "cabac"

💡 Note: Both 'abac' and 'cab' are subsequences of 'cabac'. The LCS is 'ca' with length 2, so minimum supersequence length is 4+3-2=5.

example_2.py — No Common Characters

$ Input: {"str1": "abc", "str2": "def"}

› Output: "abcdef"

💡 Note: Since strings share no common characters, we simply concatenate them. LCS length is 0, so result length is 3+3-0=6.

example_3.py — One String is Subsequence

$ Input: {"str1": "abc", "str2": "aec"}

› Output: "aebac"

💡 Note: The strings share common subsequence 'ac'. We merge optimally to get minimum length supersequence of length 3+3-2=4.

Constraints

1 ≤ str1.length, str2.length ≤ 1000
str1 and str2 consist of lowercase English letters only
Important: Multiple valid answers may exist - return any shortest one

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses Dynamic Programming to solve this in two phases: first build an LCS (Longest Common Subsequence) table, then backtrack to reconstruct the shortest supersequence. The key insight is that the minimum length equals len(str1) + len(str2) - len(LCS).

Common Approaches

✓ Brute Force (Generate All Supersequences)

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

This approach generates all possible ways to interleave characters from both strings while maintaining their relative order, then selects the shortest valid supersequence. We use recursion to explore all possibilities at each step.

Dynamic Programming (Optimal)

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

This optimal approach uses dynamic programming in two phases: first find the Longest Common Subsequence (LCS) using a 2D DP table, then reconstruct the shortest common supersequence by backtracking through the DP table and intelligently merging characters from both strings.

Brute Force (Generate All Supersequences) — Algorithm Steps

Use recursion with two pointers, one for each string
At each step, choose to include next character from str1, str2, or both (if same)
Generate all possible supersequences recursively
Track the minimum length supersequence found
Return the shortest valid result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with both pointers at beginning

Begin recursion with i=0, j=0, empty result string

At each step, make choices

Choose to take character from str1, str2, or both (if matching)

Explore all branches

Recursively explore every possible combination

Track minimum result

Keep track of the shortest supersequence found so far

Code -

solution.c — C

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

char* minResult;
int minLength;

void backtrack(char* str1, char* str2, int i, int j, char* current, int currentLen) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    
    if (i == len1 && j == len2) {
        if (currentLen < minLength) {
            minLength = currentLen;
            strcpy(minResult, current);
        }
        return;
    }
    
    if (currentLen >= minLength) {
        return;
    }
    
    if (i == len1) {
        strcat(current, str2 + j);
        int newLen = currentLen + (len2 - j);
        if (newLen < minLength) {
            minLength = newLen;
            strcpy(minResult, current);
        }
        current[currentLen] = '\0'; // backtrack
        return;
    }
    
    if (j == len2) {
        strcat(current, str1 + i);
        int newLen = currentLen + (len1 - i);
        if (newLen < minLength) {
            minLength = newLen;
            strcpy(minResult, current);
        }
        current[currentLen] = '\0'; // backtrack
        return;
    }
    
    if (str1[i] == str2[j]) {
        current[currentLen] = str1[i];
        current[currentLen + 1] = '\0';
        backtrack(str1, str2, i + 1, j + 1, current, currentLen + 1);
        current[currentLen] = '\0'; // backtrack
    } else {
        current[currentLen] = str1[i];
        current[currentLen + 1] = '\0';
        backtrack(str1, str2, i + 1, j, current, currentLen + 1);
        current[currentLen] = '\0'; // backtrack
        
        current[currentLen] = str2[j];
        current[currentLen + 1] = '\0';
        backtrack(str1, str2, i, j + 1, current, currentLen + 1);
        current[currentLen] = '\0'; // backtrack
    }
}

char* shortestCommonSupersequence(char* str1, char* str2) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    
    minResult = (char*)malloc(2000 * sizeof(char));
    char* current = (char*)malloc(2000 * sizeof(char));
    
    strcpy(minResult, str1);
    strcat(minResult, str2);
    minLength = len1 + len2;
    
    current[0] = '\0';
    backtrack(str1, str2, 0, 0, current, 0);
    
    free(current);
    return minResult;
}

int main() {
    char str1[1000], str2[1000];
    scanf("%s %s", str1, str2);
    
    char* result = shortestCommonSupersequence(str1, str2);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

At each position, we have multiple choices leading to exponential possibilities

✓ Linear Growth

Space Complexity

O(m+n)

Recursion stack depth is at most m+n where m,n are string lengths

⚡ Linearithmic Space

67.4K 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 (Generate All Supersequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler