Find the Shortest Superstring - Practice Coding Problems

Find the Shortest Superstring - Problem

Find the Shortest Superstring is a fascinating string optimization problem that challenges you to find the most efficient way to combine multiple strings into one compact superstring.

Given an array of strings words, your task is to construct the shortest possible string that contains each string in words as a substring. Think of it as creating a master string that encompasses all input strings with maximum overlap.

Key Points:
• If multiple valid strings exist with the same minimum length, return any of them
• No string in the input is a substring of another string
• The goal is to maximize overlaps between strings to minimize total length

Example: For ["catg", "ctaagt", "gcta"], one possible superstring is "gctaagttcatg" which contains all three strings with optimal overlapping.

Input & Output

example_1.py — Basic Case

$ Input: ["catg", "ctaagt", "gcta"]

› Output: "gctaagttcatg"

💡 Note: The strings can be arranged as gcta → catg → ctaagt with overlaps: gcta+catg overlap by 'cat' (3 chars), catg+ctaagt overlap by 'ct' (2 chars). Result: gcta + g + aagt = gctaagttcatg

example_2.py — Simple Chain

$ Input: ["ab", "bc", "cd"]

› Output: "abcd"

💡 Note: Perfect chain with single character overlaps: ab → bc → cd becomes ab + c + d = abcd

example_3.py — No Overlaps

$ Input: ["abc", "def", "ghi"]

› Output: "abcdefghi"

💡 Note: When no overlaps exist between any strings, we simply concatenate them in any order. Total length equals sum of all string lengths.

Visualization

Tap to expand

Understanding the Visualization

Identify Fragments

You receive DNA fragments: 'CATG', 'CTAAGT', 'GCTA' that came from a larger sequence

Find Overlaps

Look for overlapping regions: 'GCTA' overlaps with 'CATG' by 'CAT', 'CATG' overlaps with 'CTAAGT' by 'CT'

Optimal Assembly

Arrange fragments to maximize overlaps: GCTA + G + AAGT = GCTAAGTTCATG

Verify Completeness

Confirm all original fragments exist as substrings in the final genome sequence

Key Takeaway

🎯 Key Insight: This is essentially the Traveling Salesman Problem where we want to visit all string 'cities' exactly once, minimizing the total 'travel cost' (superstring length). The DP with bitmask approach efficiently explores all possible orderings while avoiding redundant calculations.

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

2ⁿ possible bitmask states, each with n possible endings, and n transitions

⚠ Quadratic Growth

Space Complexity

O(n × 2ⁿ)

DP table storing minimum length for each (mask, ending) state

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 12
1 ≤ words[i].length ≤ 20
words[i] consists of lowercase English letters
No string is a substring of another string
The answer is guaranteed to be unique

Asked in

G Google 38 a Amazon 24 f Meta 19 ⊞ Microsoft 15

The optimal solution uses Dynamic Programming with Bitmasks to model this as a Traveling Salesman Problem variant. We precompute all pairwise overlaps, then use DP states dp[mask][i] to track the minimum superstring length using strings in 'mask' and ending at string 'i'. Time complexity: O(n² × 2ⁿ), which is efficient for the constraint n ≤ 12.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask	O(n² × 2ⁿ)	O(n × 2ⁿ)	Use dynamic programming with bitmasks to efficiently find the shortest superstring
Brute Force (Try All Permutations)	O(n! × n²)	O(n)	Generate all permutations of strings and find the shortest superstring among them

Dynamic Programming with Bitmask — Algorithm Steps

Precompute all pairwise overlaps between strings
Use bitmask DP where dp[mask][i] = minimum length to visit all strings in mask ending at string i
Initialize dp[1<<i][i] = len(words[i]) for all i
For each mask and ending position, try extending with unused strings
Find the minimum among all dp[full_mask][i] values
Reconstruct the actual superstring by backtracking

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute Overlaps

Calculate all pairwise overlaps between strings

Initialize DP States

Set base cases for single-string masks

Fill DP Table

Extend each state by adding unused strings

Reconstruct Solution

Backtrack to build the actual superstring

Code -

solution.c — C

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

int getOverlap(const char* s1, const char* s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int minLen = len1 < len2 ? len1 : len2;
    
    for (int k = minLen; k > 0; k--) {
        if (strncmp(s1 + len1 - k, s2, k) == 0) {
            return k;
        }
    }
    return 0;
}

char* findShortestSuperstring(char** words, int n) {
    // Precompute overlaps
    int** overlaps = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        overlaps[i] = malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            if (i != j) {
                overlaps[i][j] = getOverlap(words[i], words[j]);
            } else {
                overlaps[i][j] = 0;
            }
        }
    }
    
    // DP with bitmask
    int maskSize = 1 << n;
    int** dp = malloc(maskSize * sizeof(int*));
    int** parent = malloc(maskSize * sizeof(int*));
    
    for (int i = 0; i < maskSize; i++) {
        dp[i] = malloc(n * sizeof(int));
        parent[i] = malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            dp[i][j] = INT_MAX;
            parent[i][j] = -1;
        }
    }
    
    // Initialize
    for (int i = 0; i < n; i++) {
        dp[1 << i][i] = strlen(words[i]);
    }
    
    // Fill DP table
    for (int mask = 0; mask < maskSize; mask++) {
        for (int i = 0; i < n; i++) {
            if (!(mask & (1 << i)) || dp[mask][i] == INT_MAX) {
                continue;
            }
            
            for (int j = 0; j < n; j++) {
                if (mask & (1 << j)) continue;
                
                int newMask = mask | (1 << j);
                int newLength = dp[mask][i] + strlen(words[j]) - overlaps[i][j];
                
                if (newLength < dp[newMask][j]) {
                    dp[newMask][j] = newLength;
                    parent[newMask][j] = i;
                }
            }
        }
    }
    
    // Find minimum result
    int fullMask = maskSize - 1;
    int minLength = INT_MAX;
    int lastWord = -1;
    
    for (int i = 0; i < n; i++) {
        if (dp[fullMask][i] < minLength) {
            minLength = dp[fullMask][i];
            lastWord = i;
        }
    }
    
    // Reconstruct path
    int* path = malloc(n * sizeof(int));
    int pathLen = 0;
    int mask = fullMask;
    int current = lastWord;
    
    while (current != -1) {
        path[pathLen++] = current;
        int prev = parent[mask][current];
        mask ^= (1 << current);
        current = prev;
    }
    
    // Reverse path
    for (int i = 0; i < pathLen / 2; i++) {
        int temp = path[i];
        path[i] = path[pathLen - 1 - i];
        path[pathLen - 1 - i] = temp;
    }
    
    // Build superstring
    char* result = malloc(10000);
    if (pathLen == 0) {
        strcpy(result, "");
    } else {
        strcpy(result, words[path[0]]);
        for (int i = 1; i < pathLen; i++) {
            int prevWord = path[i-1];
            int currWord = path[i];
            int overlap = overlaps[prevWord][currWord];
            strcat(result, words[currWord] + overlap);
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(overlaps[i]);
    }
    free(overlaps);
    for (int i = 0; i < maskSize; i++) {
        free(dp[i]);
        free(parent[i]);
    }
    free(dp);
    free(parent);
    free(path);
    
    return result;
}

int main() {
    char* words[20];
    int n = 0;
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],\"\n ");
    while (token && n < 20) {
        words[n] = malloc(strlen(token) + 1);
        strcpy(words[n], token);
        n++;
        token = strtok(NULL, "[],\"\n ");
    }
    
    char* result = findShortestSuperstring(words, n);
    printf("%s\n", result);
    
    for (int i = 0; i < n; i++) {
        free(words[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

2ⁿ possible bitmask states, each with n possible endings, and n transitions

⚠ Quadratic Growth

Space Complexity

O(n × 2ⁿ)

DP table storing minimum length for each (mask, ending) state

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 12
1 ≤ words[i].length ≤ 20
words[i] consists of lowercase English letters
No string is a substring of another string
The answer is guaranteed to be unique

34.7K Views

Medium Frequency

~35 min Avg. Time

892 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

Dynamic Programming with Bitmask — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler