Shortest Common Supersequence - Practice Coding Problems

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

Understanding the Visualization

Analyze Overlaps

Find books that appear in both lists (like finding LCS)

Smart Merging

When books overlap, include them once; otherwise include from both lists

Optimal Result

The final master list contains all books with minimal duplication

Key Takeaway

🎯 Key Insight: The shortest supersequence has length len(str1) + len(str2) - len(LCS), achieved by using dynamic programming to optimally merge the strings.

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(m*n)	O(m*n)	Use DP to find LCS, then reconstruct the shortest common supersequence
Brute Force (Generate All Supersequences)	O(2^(m+n))	O(m+n)	Generate all possible supersequences and find the shortest one

Dynamic Programming (Optimal) — Algorithm Steps

Create a 2D DP table to find the LCS of both strings
Fill the DP table using standard LCS algorithm
Backtrack from bottom-right corner of the DP table
While backtracking, build the supersequence by choosing characters optimally
When characters match, include once; otherwise include both

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Table

Create (m+1)×(n+1) table with base cases filled

Fill DP Table

Use LCS recurrence relation to fill each cell

Backtrack from End

Start from dp[m][n] and trace back the optimal path

Build Result String

Construct supersequence by choosing characters optimally

Code -

solution.c — C

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

int max(int a, int b) {
    return (a > b) ? a : b;
}

char* shortestCommonSupersequence(char* str1, char* str2) {
    int m = strlen(str1), n = strlen(str2);
    
    // Step 1: Build LCS DP table
    int** dp = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    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] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
    }
    
    // Step 2: Reconstruct the supersequence
    char* result = (char*)malloc((m + n + 1) * sizeof(char));
    int resultIdx = 0;
    int i = m, j = n;
    
    while (i > 0 && j > 0) {
        if (str1[i-1] == str2[j-1]) {
            result[resultIdx++] = str1[i-1];
            i--;
            j--;
        } else if (dp[i-1][j] > dp[i][j-1]) {
            result[resultIdx++] = str1[i-1];
            i--;
        } else {
            result[resultIdx++] = str2[j-1];
            j--;
        }
    }
    
    // Add remaining characters
    while (i > 0) {
        result[resultIdx++] = str1[i-1];
        i--;
    }
    
    while (j > 0) {
        result[resultIdx++] = str2[j-1];
        j--;
    }
    
    result[resultIdx] = '\0';
    
    // Reverse the result
    for (int k = 0; k < resultIdx / 2; k++) {
        char temp = result[k];
        result[k] = result[resultIdx - 1 - k];
        result[resultIdx - 1 - k] = temp;
    }
    
    // Free DP table
    for (int i = 0; i <= m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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(m*n)

We fill an m×n DP table once, then backtrack through it once

✓ Linear Growth

Space Complexity

O(m*n)

We need an m×n DP table to store LCS lengths for all subproblems

⚡ Linearithmic Space

67.3K 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler