Split Concatenated Strings

Split Concatenated Strings - Problem

You are given an array of strings strs. You could concatenate these strings together into a loop, where for each string, you could choose to reverse it or not. Among all the possible loops, return the lexicographically largest string after cutting the loop.

Specifically, to find the lexicographically largest string, you need to experience two phases:

Concatenate all the strings into a loop, where you can reverse some strings or not and connect them in the same order as given.
Cut and make one breakpoint in any place of the loop, which will make the looped string into a regular one starting from the character at the cutpoint.

Your job is to find the lexicographically largest one among all the possible regular strings.

Input & Output

Example 1 — Basic Case

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

› Output: "zyxcba"

💡 Note: We can reverse both strings to get "cba" and "zyx", forming loop "cbazyx". Cutting at position 3 gives "zyxcba" which is lexicographically largest.

Example 2 — Single String

$ Input: strs = ["abc"]

› Output: "cba"

💡 Note: With one string, we can either use "abc" or reverse it to "cba". "cba" is lexicographically larger.

Example 3 — Multiple Options

$ Input: strs = ["a", "aa", "aaa"]

› Output: "aaaaaaa"

💡 Note: All strings contain only 'a', so any arrangement gives the same result: 7 consecutive 'a's.

Constraints

1 ≤ strs.length ≤ 1000
1 ≤ strs[i].length ≤ 1000
1 ≤ sum of strs[i].length ≤ 1000
strs[i] consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 f Facebook 12 M Microsoft 6

The key insight is that only strings containing the maximum character across all strings are worth flipping, since flipping others cannot lead to a lexicographically larger result. Best approach uses greedy optimization with intelligent pruning. Time: O(k × m²), Space: O(m).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^n × m²) Space: O(m)

Generate all 2^n possible combinations of original/reversed strings, then for each combination try all possible cut positions in the resulting loop to find the lexicographically largest string.

Greedy Optimization

⏱️ Time: O(k × m²) Space: O(m)

Instead of trying all combinations, we observe that only strings containing the maximum character across all strings are worth flipping. This reduces the search space dramatically while still finding the optimal solution.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: Generate all 2^n combinations of original/reversed strings
Step 2: For each combination, concatenate into a loop
Step 3: Try all possible cut positions in the loop
Step 4: Track the lexicographically largest result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all 2^n flip patterns

Form Loop

Concatenate strings in circle

Try Cuts

Test all cutting positions

Find Maximum

Select lexicographically largest

Code -

solution.c — C

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

void reverseString(char* str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

char* solution(char strs[][101], int n) {
    if (n == 0) return "";
    
    static char maxResult[10001] = "";
    
    // Try all 2^n combinations
    for (int mask = 0; mask < (1 << n); mask++) {
        // Build current combination
        char loop[10001] = "";
        for (int i = 0; i < n; i++) {
            char temp[101];
            strcpy(temp, strs[i]);
            if (mask & (1 << i)) {
                reverseString(temp);
            }
            strcat(loop, temp);
        }
        
        // Create doubled loop
        char loopDoubled[20001];
        strcpy(loopDoubled, loop);
        strcat(loopDoubled, loop);
        
        int loopLen = strlen(loop);
        // Try all cut positions
        for (int start = 0; start < loopLen; start++) {
            char candidate[10001];
            strncpy(candidate, loopDoubled + start, loopLen);
            candidate[loopLen] = '\0';
            
            if (strcmp(candidate, maxResult) > 0) {
                strcpy(maxResult, candidate);
            }
        }
    }
    
    return maxResult;
}

int main() {
    char line[10001];
    fgets(line, sizeof(line), stdin);
    
    char strs[100][101];
    int n = 0;
    
    // Simple JSON parsing
    char* token = strtok(line, "[],\"\n");
    while (token != NULL && n < 100) {
        if (strlen(token) > 0 && token[0] != ' ') {
            strcpy(strs[n], token);
            n++;
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    char* result = solution(strs, n);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m²)

2^n combinations × m² for string operations (m = total length)

✓ Linear Growth

Space Complexity

O(m)

Space to store concatenated strings and results

✓ Linear Space

18.5K Views

Medium Frequency

~35 min Avg. Time

287 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