Shortest String That Contains Three Strings

Shortest String That Contains Three Strings - Problem

Imagine you're tasked with creating the shortest possible string that contains three given strings as substrings. This is a classic string manipulation problem that tests your understanding of string overlap and optimization.

Given three strings a, b, and c, you need to find a string with minimum length that contains all three strings as substrings. The key insight is that strings can overlap - for example, if you have "abc" and "bcd", you can combine them as "abcd" instead of "abcbcd".

If multiple strings have the same minimum length, return the lexicographically smallest one (the one that would appear first in dictionary order).

Example: If a = "abc", b = "bcd", and c = "def", one possible answer is "abcdef", but we need to check all possible arrangements to find the shortest.

Input & Output

example_1.py — Basic Overlap

$ Input: a = "abc" b = "bcd" c = "def"

› Output: "abcdef"

💡 Note: We can merge "abc" and "bcd" as "abcd" (they overlap on 'bc'), then add "def" to get "abcdef". This gives us the shortest possible string of length 6.

example_2.py — Multiple Overlaps

$ Input: a = "ab" b = "bc" c = "ca"

› Output: "abc"

💡 Note: The optimal arrangement is "ca" + "ab" + "bc" = "cabc", or "ab" + "bc" + "ca" can be arranged as "abca" or we can find that "abc" contains "ab", "bc" as substrings, and if we arrange optimally, we get "abc" which contains all three as substrings with length 3.

example_3.py — No Overlap

$ Input: a = "abc" b = "def" c = "ghi"

› Output: "abcdefghi"

💡 Note: Since there are no overlaps between any of the strings, we simply concatenate them. The lexicographically smallest arrangement is "abc" + "def" + "ghi" = "abcdefghi".

Visualization

Tap to expand

Understanding the Visualization

Identify Pieces

We have 3 string pieces that need to be combined into one

Find Edge Matches

Look for overlapping patterns between the end of one string and start of another

Try Arrangements

Test all 6 possible orderings to see which produces the shortest result

Merge Optimally

For each arrangement, merge strings using maximum possible overlaps

Select Winner

Choose the shortest result, breaking ties with lexicographical order

Key Takeaway

🎯 Key Insight: With only 3 strings, we can afford to try all arrangements. The magic happens when we find overlaps - shared character sequences that let us merge strings more efficiently than simple concatenation.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

6 permutations × O(n²) for each merge operation where n is the average string length

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the result strings and temporary merged strings

⚡ Linearithmic Space

Constraints

1 ≤ length of each string ≤ 1000
All strings contain only lowercase English letters
Each string is non-empty
The total number of possible arrangements is small (6)

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 27

The optimal approach is to try all 6 permutations of the three strings and greedily merge them by finding maximum overlaps. Since we have exactly 3 strings, this brute force approach is efficient with O(n²) time complexity where n is the average string length. The key insight is that overlapping characters between strings can significantly reduce the total length of the result.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n²)	O(n)	Try all 6 possible orderings of the three strings and find the shortest result
Greedy String Merging	O(n²)	O(n)	Systematically try all arrangements and greedily merge strings with maximum overlap

Brute Force (Try All Permutations) — Algorithm Steps

Generate all 6 permutations of the three strings
For each permutation, merge the strings one by one
When merging two strings, find the maximum overlap
Keep track of the shortest result found
If multiple results have the same length, choose lexicographically smallest

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Permutation

Consider one of the 6 possible orderings of strings

Find Overlap

Look for maximum overlap between consecutive strings

Merge

Combine strings using the overlap to minimize length

Compare

Keep track of shortest result found so far

Code -

solution.c — C

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

char* mergeStrings(char* s1, char* s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    int maxOverlap = len1 < len2 ? len1 : len2;
    
    for (int i = maxOverlap; i > 0; i--) {
        if (strncmp(s1 + len1 - i, s2, i) == 0) {
            char* result = malloc(len1 + len2 - i + 1);
            strcpy(result, s1);
            strcat(result, s2 + i);
            return result;
        }
    }
    
    char* result = malloc(len1 + len2 + 1);
    strcpy(result, s1);
    strcat(result, s2);
    return result;
}

char* solution(char* a, char* b, char* c) {
    char* perms[6][3] = {
        {a, b, c}, {a, c, b}, {b, a, c},
        {b, c, a}, {c, a, b}, {c, b, a}
    };
    
    char* candidates[6];
    int minLen = 10000;
    char* result = NULL;
    
    for (int i = 0; i < 6; i++) {
        char* temp = malloc(strlen(perms[i][0]) + 1);
        strcpy(temp, perms[i][0]);
        
        char* merged = mergeStrings(temp, perms[i][1]);
        free(temp);
        temp = mergeStrings(merged, perms[i][2]);
        free(merged);
        
        candidates[i] = temp;
        
        if (strlen(temp) < minLen || 
            (strlen(temp) == minLen && (result == NULL || strcmp(temp, result) < 0))) {
            minLen = strlen(temp);
            result = temp;
        }
    }
    
    char* final = malloc(strlen(result) + 1);
    strcpy(final, result);
    
    for (int i = 0; i < 6; i++) {
        free(candidates[i]);
    }
    
    return final;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

6 permutations × O(n²) for each merge operation where n is the average string length

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the result strings and temporary merged strings

⚡ Linearithmic Space

Constraints

1 ≤ length of each string ≤ 1000
All strings contain only lowercase English letters
Each string is non-empty
The total number of possible arrangements is small (6)

28.4K Views

Medium Frequency

~18 min Avg. Time

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

Brute Force (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler