Split Concatenated Strings - Practice Coding Problems

Split Concatenated Strings - Problem

Split Concatenated Strings is a fascinating string manipulation problem that combines greedy algorithms with clever optimization techniques.

You are given an array of strings strs. Your task is to create the lexicographically largest possible string by following these steps:

1. Form a loop: Concatenate all strings in the given order to form a circular loop
2. Choose orientations: For each string, decide whether to use it as-is or reverse it
3. Cut the loop: Make exactly one cut anywhere in the loop to create a linear string
4. Maximize lexicographically: Find the arrangement that produces the largest possible string

Example: With strings ["abc", "xyz"], you could form loops like "abcxyz", "abczyx", "cbaxyz", or "cbazyx". Then cut at the optimal position to get the lexicographically largest result.

The challenge lies in efficiently exploring all possible combinations of string orientations and cut positions to find the optimal solution.

Input & Output

example_1.py — Basic Case

$ Input: strs = ["abc", "xyz"]

› Output: "zyxabc"

💡 Note: We can reverse "xyz" to get "zyx", keep "abc" as is, then cut the loop "abczyx" at the beginning of "zyx" to get "zyxabc", which is lexicographically largest.

example_2.py — Multiple Strings

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

› Output: "ihgdefabc"

💡 Note: Reverse the last string to get "ihi", keep others as is, then cut at the beginning of the reversed string to get "ihgdefabc".

example_3.py — Single Character

$ Input: strs = ["a"]

› Output: "a"

💡 Note: With only one single-character string, the result is just that character regardless of cuts or reversals.

Constraints

1 ≤ strs.length ≤ 1000
1 ≤ strs[i].length ≤ 1000
1 ≤ sum of strs[i].length ≤ 10³
strs[i] consists of lowercase English letters only
Important: The result should be lexicographically largest among all possible arrangements

Visualization

Tap to expand

Understanding the Visualization

Choose Orientations

For each string, decide between original and reversed based on lexicographic value

Form Virtual Loop

Conceptually arrange strings in a circle with chosen orientations

Strategic Cutting

Try cutting within each string at each position, building optimal result around each cut

Find Maximum

Compare all possible results to find the lexicographically largest string

Key Takeaway

🎯 Key Insight: The optimal cut position will always be at the beginning of one of the strings, so we only need to try strategic positions rather than every possible cut location.

Asked in

G Google 28 a Amazon 15 ⊞ Microsoft 12 f Meta 8

The optimal approach uses a greedy strategy with smart optimization. Instead of trying all 2^n combinations, we precompute the better orientation for each string, then systematically try cutting within each string while optimally arranging the remaining parts. This reduces the time complexity from O(2^n * L) to O(n * L^2) while still finding the lexicographically largest result.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * L * n)	O(L)	Try all possible string orientations and cut positions
Optimized Greedy Approach	O(n * L^2)	O(L)	Smart greedy strategy focusing only on promising cut positions

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^n combinations of string orientations (original or reversed)
For each combination, concatenate strings to form a loop
Try cutting the loop at each of the n*avgLength positions
Track the lexicographically largest string found
Return the maximum result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Orientations

Create all 2^n combinations of original/reversed strings

Form Loop

Concatenate chosen orientations into a circular loop

Try All Cuts

Cut at each position and find lexicographically largest result

Code -

solution.c — C

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

char* reverseString(char* str) {
    int len = strlen(str);
    char* reversed = (char*)malloc((len + 1) * sizeof(char));
    for (int i = 0; i < len; i++) {
        reversed[i] = str[len - 1 - i];
    }
    reversed[len] = '\0';
    return reversed;
}

char* getMaxCut(char* s) {
    int len = strlen(s);
    char* doubled = (char*)malloc((2 * len + 1) * sizeof(char));
    strcpy(doubled, s);
    strcat(doubled, s);
    
    char* maxStr = (char*)malloc((len + 1) * sizeof(char));
    strcpy(maxStr, s);
    
    char* candidate = (char*)malloc((len + 1) * sizeof(char));
    
    for (int i = 0; i < len; i++) {
        strncpy(candidate, doubled + i, len);
        candidate[len] = '\0';
        
        if (strcmp(candidate, maxStr) > 0) {
            strcpy(maxStr, candidate);
        }
    }
    
    free(doubled);
    free(candidate);
    return maxStr;
}

char* splitLoopedString(char** strs, int strsSize) {
    char* maxResult = (char*)malloc(1000 * sizeof(char));
    maxResult[0] = '\0';
    
    // Try all 2^n combinations
    for (int mask = 0; mask < (1 << strsSize); mask++) {
        char* loop = (char*)malloc(1000 * sizeof(char));
        loop[0] = '\0';
        
        for (int i = 0; i < strsSize; i++) {
            if (mask & (1 << i)) {
                char* reversed = reverseString(strs[i]);
                strcat(loop, reversed);
                free(reversed);
            } else {
                strcat(loop, strs[i]);
            }
        }
        
        char* bestCut = getMaxCut(loop);
        if (strcmp(bestCut, maxResult) > 0) {
            strcpy(maxResult, bestCut);
        }
        
        free(loop);
        free(bestCut);
    }
    
    return maxResult;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * L * n)

2^n combinations of orientations, L characters to check per cut, n strings to cut through

⚠ Quadratic Growth

Space Complexity

O(L)

Space for storing the concatenated strings and result

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler