Shortest String That Contains Three Strings

Shortest String That Contains Three Strings - Problem

Given three strings a, b, and c, your task is to find a string that has the minimum length and contains all three strings as substrings.

If there are multiple such strings, return the lexicographically smallest one.

Notes:

A string a is lexicographically smaller than a string b (of the same length) if in the first position where a and b differ, string a has a letter that appears earlier in the alphabet than the corresponding letter in b.
A substring is a contiguous sequence of characters within a string.

Input & Output

Example 1 — Basic Case

$ Input: a = "abc", b = "bca", c = "cab"

› Output: "abcab"

💡 Note: One optimal arrangement is abc + cab (overlapping 'c' and 'ab') to get "abcab". This contains all three strings: abc (0-2), bca (1-3), cab (2-4). Length is 5.

Example 2 — No Overlap

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

› Output: "abcdefghi"

💡 Note: No overlaps possible between these strings, so we concatenate in lexicographical order: abc + def + ghi = "abcdefghi". Length is 9.

Example 3 — One String Contains Others

$ Input: a = "a", b = "aa", c = "aaa"

› Output: "aaa"

💡 Note: String "aaa" already contains both "a" and "aa" as substrings, so it's the optimal superstring with length 3.

Constraints

1 ≤ a.length, b.length, c.length ≤ 50
a, b, and c consist of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22

The key insight is to try all permutations of the three strings and find optimal overlaps between adjacent strings in each arrangement. The brute force approach generates all 6 permutations and merges with maximum overlap. Time: O(n³), Space: O(n).

Common Approaches

✓ Optimized Overlap Detection

⏱️ Time: O(n²) Space: O(1)

Instead of recalculating overlaps each time, pre-compute the maximum overlap between every pair of strings, then use this information to efficiently try all permutations and find the optimal solution.

Try All Permutations

⏱️ Time: O(n³) Space: O(n)

Try all 6 permutations of the three strings, for each permutation find the optimal way to merge them by checking overlaps, then return the lexicographically smallest among all shortest results.

Optimized Overlap Detection — Algorithm Steps

Step 1: Pre-compute overlap matrix for all string pairs
Step 2: Use overlap matrix to efficiently merge strings
Step 3: Try all permutations using pre-computed overlaps

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Overlap Matrix

Calculate maximum overlap between every pair once

Use Matrix for Merging

Look up pre-computed overlaps instead of recalculating

Generate All Results

Efficiently create all permutation results

Code -

solution.c — C

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

char* solution(char* a, char* b, char* c) {
    char* strings[3] = {a, b, c};
    int n = 3;
    int overlap[3][3] = {0};
    
    // Pre-compute overlap matrix
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i != j) {
                char* s1 = strings[i];
                char* s2 = strings[j];
                int len1 = strlen(s1), len2 = strlen(s2);
                int maxOverlap = len1 < len2 ? len1 : len2;
                
                for (int k = maxOverlap; k > 0; k--) {
                    if (strncmp(s1 + len1 - k, s2, k) == 0) {
                        overlap[i][j] = k;
                        break;
                    }
                }
            }
        }
    }
    
    int perms[6][3] = {{0,1,2}, {0,2,1}, {1,0,2}, {1,2,0}, {2,0,1}, {2,1,0}};
    char* candidates[6];
    
    for (int p = 0; p < 6; p++) {
        int totalLen = strlen(strings[perms[p][0]]);
        for (int k = 1; k < 3; k++) {
            int prevIdx = perms[p][k-1];
            int currIdx = perms[p][k];
            totalLen += strlen(strings[currIdx]) - overlap[prevIdx][currIdx];
        }
        
        candidates[p] = malloc(totalLen + 1);
        strcpy(candidates[p], strings[perms[p][0]]);
        
        for (int k = 1; k < 3; k++) {
            int prevIdx = perms[p][k-1];
            int currIdx = perms[p][k];
            strcat(candidates[p], strings[currIdx] + overlap[prevIdx][currIdx]);
        }
    }
    
    // Find shortest, lexicographically smallest
    int minLen = strlen(candidates[0]);
    for (int i = 1; i < 6; i++) {
        int len = strlen(candidates[i]);
        if (len < minLen) minLen = len;
    }
    
    char* best = NULL;
    for (int i = 0; i < 6; i++) {
        if (strlen(candidates[i]) == minLen) {
            if (best == NULL || strcmp(candidates[i], best) < 0) {
                best = candidates[i];
            }
        }
    }
    
    char* result = malloc(strlen(best) + 1);
    strcpy(result, best);
    
    // Clean up
    for (int i = 0; i < 6; i++) {
        free(candidates[i]);
    }
    
    return result;
}

int main() {
    char a[1001], b[1001], c[1001];
    
    fgets(a, sizeof(a), stdin);
    fgets(b, sizeof(b), stdin);
    fgets(c, sizeof(c), stdin);
    
    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²)

Pre-computing overlaps takes O(n²) time, then 6 permutations each using O(1) lookup

⚠ Quadratic Growth

Space Complexity

O(1)

Only need 3x3 overlap matrix and temporary strings

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Optimized Overlap Detection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler