Find the Shortest Superstring II

Find the Shortest Superstring II - Problem

String Easy

You are given two strings, s1 and s2. Return the shortest possible string that contains both s1 and s2 as substrings.

If there are multiple valid answers, return any one of them. A substring is a contiguous sequence of characters within a string.

Input & Output

Example 1 — Overlap Case

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

› Output: "abcd"

💡 Note: The suffix "bc" of s1 overlaps with the prefix "bc" of s2, so we merge them as "abc" + "d" = "abcd"

Example 2 — Containment Case

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

› Output: "hello"

💡 Note: s2 "ell" is already contained in s1 "hello", so the shortest superstring is just "hello"

Example 3 — No Overlap

$ Input: s1 = "cat", s2 = "dog"

› Output: "catdog"

💡 Note: No overlap exists between the strings, so we concatenate them as "cat" + "dog" = "catdog"

Constraints

1 ≤ s1.length, s2.length ≤ 1000
s1 and s2 consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is to find the maximum overlap between the suffix of one string and the prefix of another. The optimal approach checks for containment first, then finds overlaps in both directions to minimize the total length. Time: O(n × m), Space: O(n + m)

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

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

Generate all possible superstrings by trying s1+s2, s2+s1, and checking if one string is already contained in the other. Return the shortest valid combination.

Optimized - Find Maximum Overlap

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

Check for overlaps at the ends of the strings. Try overlapping s1's suffix with s2's prefix and vice versa. Choose the combination with maximum overlap to get the shortest superstring.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_LEN 10000

int min(int a, int b) {
    return a < b ? a : b;
}

char* solution(char* s1, char* s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    
    // Check if one string contains the other
    if (strstr(s1, s2) != NULL) {
        char* result = (char*)malloc((len2 + 1) * sizeof(char));
        strcpy(result, s2);
        return result;
    }
    if (strstr(s2, s1) != NULL) {
        char* result = (char*)malloc((len1 + 1) * sizeof(char));
        strcpy(result, s1);
        return result;
    }
    
    // Find maximum overlap of s1's suffix with s2's prefix
    int maxOverlap1 = 0;
    for (int i = 1; i <= min(len1, len2); i++) {
        if (strncmp(s1 + len1 - i, s2, i) == 0) {
            maxOverlap1 = i;
        }
    }
    
    // Find maximum overlap of s2's suffix with s1's prefix
    int maxOverlap2 = 0;
    for (int i = 1; i <= min(len1, len2); i++) {
        if (strncmp(s2 + len2 - i, s1, i) == 0) {
            maxOverlap2 = i;
        }
    }
    
    // Choose the option with maximum overlap
    char* result = (char*)malloc((len1 + len2 + 1) * sizeof(char));
    if (maxOverlap1 >= maxOverlap2) {
        strcpy(result, s1);
        strcat(result, s2 + maxOverlap1);
    } else {
        strcpy(result, s2);
        strcat(result, s1 + maxOverlap2);
    }
    
    return result;
}

int main() {
    char s1[MAX_LEN], s2[MAX_LEN];
    fgets(s1, sizeof(s1), stdin);
    fgets(s2, sizeof(s2), stdin);
    
    // Remove newlines
    int len1 = strlen(s1);
    if (len1 > 0 && s1[len1-1] == '\n') s1[len1-1] = '\0';
    int len2 = strlen(s2);
    if (len2 > 0 && s2[len2-1] == '\n') s2[len2-1] = '\0';
    
    char* result = solution(s1, s2);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

21.3K Views

Medium Frequency

~15 min Avg. Time

850 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