Find the Shortest Superstring II - Practice Coding Problems

Find the Shortest Superstring II - Problem

String Easy

Find the Shortest Superstring

You are given two strings s1 and s2. Your task is to find the shortest possible string that contains both input strings as substrings.

🎯 Goal: Create a superstring by finding the optimal way to combine two strings, potentially overlapping them to minimize the total length.

Example: If s1 = "abc" and s2 = "bcd", the shortest superstring is "abcd" (length 4) rather than "abcbcd" (length 6), because we can overlap the common part "bc".

Input: Two strings s1 and s2
Output: The shortest string containing both as substrings
Note: If multiple valid answers exist, return any one of them.

Input & Output

example_1.py — Basic Overlap

$ Input: s1 = "abc", s2 = "bcd"

› Output: "abcd"

💡 Note: The strings overlap at 'bc'. We can merge them as 'a[bc]d' where [bc] is the shared part, resulting in 'abcd' with length 4 instead of 'abcbcd' with length 6.

example_2.py — One Contains Other

$ Input: s1 = "abc", s2 = "ab"

› Output: "abc"

💡 Note: Since 'ab' is already contained within 'abc' as a substring, the shortest superstring is just 'abc'.

example_3.py — No Overlap

$ Input: s1 = "hello", s2 = "world"

› Output: "helloworld"

💡 Note: There's no overlap between 'hello' and 'world', so we simply concatenate them. Both 'helloworld' and 'worldhello' have the same length, so either is valid.

Visualization

Tap to expand

Understanding the Visualization

Identify Overlap

Find where the end of one string matches the beginning of another

Calculate Savings

Determine how many characters we can save by merging

Choose Best Merge

Select the combination that gives the shortest result

Construct Result

Build the final superstring using the optimal overlap

Key Takeaway

🎯 Key Insight: By finding overlaps between string endings and beginnings, we can merge strings efficiently to create the shortest possible superstring that contains both inputs.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where n and m are lengths of the strings. We need to check all possible overlaps between suffixes and prefixes

✓ Linear Growth

Space Complexity

O(n + m)

Space for storing the result string

⚡ Linearithmic Space

Constraints

1 ≤ s1.length, s2.length ≤ 1000
s1 and s2 consist of lowercase English letters
Both strings are non-empty

Asked in

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

The optimal solution uses overlap detection to find the maximum overlap between string suffixes and prefixes. Instead of naive concatenation, we identify shared character sequences and merge strings intelligently, achieving the shortest possible superstring in O(n×m) time.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Overlap Detection	O(n × m)	O(n + m)	Find maximum overlap between strings and merge optimally
Brute Force (Try All Combinations)	O(n + m)	O(n + m)	Try all possible ways to combine the strings and pick the shortest

Optimal Overlap Detection — Algorithm Steps

Check if one string contains the other completely
Find maximum overlap: suffix of s1 with prefix of s2
Find maximum overlap: suffix of s2 with prefix of s1
Choose the combination that produces the shortest result
Construct the final superstring using the best overlap

Visualization

Tap to expand

Step-by-Step Walkthrough

Find s1→s2 Overlap

Check suffix of s1 against prefix of s2

Find s2→s1 Overlap

Check suffix of s2 against prefix of s1

Build Both Options

Create superstrings using each overlap

Choose Optimal

Return the shorter superstring

Code -

solution.c — C

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

int findOverlap(const char* a, const char* b) {
    int lenA = strlen(a), lenB = strlen(b);
    int maxOverlap = 0;
    int minLen = lenA < lenB ? lenA : lenB;
    
    for (int i = 1; i <= minLen; i++) {
        if (strncmp(a + lenA - i, b, i) == 0) {
            maxOverlap = i;
        }
    }
    return maxOverlap;
}

char* shortestSuperstring(const char* s1, const char* s2) {
    int len1 = strlen(s1), len2 = strlen(s2);
    
    // Check if one string contains the other
    if (strstr(s2, s1)) {
        char* result = malloc(len2 + 1);
        strcpy(result, s2);
        return result;
    }
    if (strstr(s1, s2)) {
        char* result = malloc(len1 + 1);
        strcpy(result, s1);
        return result;
    }
    
    // Find overlaps
    int overlap1 = findOverlap(s1, s2);
    int overlap2 = findOverlap(s2, s1);
    
    // Build results
    char* result1 = malloc(len1 + len2 - overlap1 + 1);
    char* result2 = malloc(len1 + len2 - overlap2 + 1);
    
    strcpy(result1, s1);
    strcat(result1, s2 + overlap1);
    
    strcpy(result2, s2);
    strcat(result2, s1 + overlap2);
    
    // Return shorter result
    if (strlen(result1) <= strlen(result2)) {
        free(result2);
        return result1;
    } else {
        free(result1);
        return result2;
    }
}

int main() {
    char s1[1001], s2[1001];
    fgets(s1, sizeof(s1), stdin);
    fgets(s2, sizeof(s2), stdin);
    
    // Remove newlines
    s1[strcspn(s1, "\n")] = 0;
    s2[strcspn(s2, "\n")] = 0;
    
    char* result = shortestSuperstring(s1, s2);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where n and m are lengths of the strings. We need to check all possible overlaps between suffixes and prefixes

✓ Linear Growth

Space Complexity

O(n + m)

Space for storing the result string

⚡ Linearithmic Space

Constraints

1 ≤ s1.length, s2.length ≤ 1000
s1 and s2 consist of lowercase English letters
Both strings are non-empty

31.0K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal Overlap Detection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler