Special Binary String

Special Binary String - Problem

String Recursion Hard

Special binary strings are binary strings with the following two properties:

The number of 0's is equal to the number of 1's.
Every prefix of the binary string has at least as many 1's as 0's.

You are given a special binary string s. A move consists of choosing two consecutive, non-empty, special substrings of s, and swapping them. Two strings are consecutive if the last character of the first string is exactly one index before the first character of the second string.

Return the lexicographically largest resulting string possible after applying the mentioned operations on the string.

Input & Output

Example 1 — Basic Rearrangement

$ Input: s = "11011000"

› Output: "11100100"

💡 Note: We can identify groups "110" and "1100" and "00". After sorting optimally: "1100" + "110" + "00" = "11100100".

Example 2 — Already Optimal

$ Input: s = "10"

› Output: "10"

💡 Note: The string is already the lexicographically largest possible since it's a single balanced group.

Example 3 — Multiple Groups

$ Input: s = "1100101001"

› Output: "1100101001"

💡 Note: Groups are "1100", "10", "1001". After sorting: "1100" comes first, then "1001", then "10" giving "1100100110".

Constraints

1 ≤ s.length ≤ 1000
s consists of only '0' and '1'
s is guaranteed to be a special binary string

Visualization

Tap to expand

Asked in

G Google 25 F Facebook 18

The key insight is treating special binary strings like balanced parentheses (1s as '(' and 0s as ')'). We can recursively divide the string into independent balanced groups, optimize each group's interior, then sort groups in descending order for maximum lexicographic value. Best approach is recursive divide and conquer. Time: O(n²), Space: O(n)

Common Approaches

✓ Brute Force - Try All Swaps

⏱️ Time: O(2^n) Space: O(n)

Try every possible pair of consecutive special substrings, perform swaps, and track the lexicographically largest result. This requires finding all valid substrings and testing all combinations.

Recursive Divide and Conquer

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

Each special binary string can be viewed as balanced parentheses. We recursively find independent balanced groups, sort their inner contents, then arrange the groups in descending order for maximum lexicographic value.

Brute Force - Try All Swaps — Algorithm Steps

Find all special substrings
Generate all possible swap combinations
Apply swaps and track best result

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Substrings

Identify all valid special binary substrings

Try Swaps

Test every consecutive pair swap

Track Best

Keep lexicographically largest result

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    char* str1 = *(char**)a;
    char* str2 = *(char**)b;
    
    // Create concatenations str1+str2 and str2+str1
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    
    char* concat1 = malloc(len1 + len2 + 1);
    char* concat2 = malloc(len1 + len2 + 1);
    
    strcpy(concat1, str1);
    strcat(concat1, str2);
    
    strcpy(concat2, str2);
    strcat(concat2, str1);
    
    int result = strcmp(concat2, concat1); // Note: reversed for descending order
    
    free(concat1);
    free(concat2);
    
    return result;
}

char* makeMax(char* s) {
    int len = strlen(s);
    if (len <= 2) {
        char* result = malloc(len + 1);
        strcpy(result, s);
        return result;
    }
    
    // Find all balanced groups at this level
    char** groups = malloc(1000 * sizeof(char*));
    int groupCount = 0;
    int count = 0;
    int start = 0;
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '1') {
            count++;
        } else {
            count--;
        }
        
        // When count becomes 0, we found a complete balanced group
        if (count == 0) {
            int groupLen = i - start + 1;
            groups[groupCount] = malloc(groupLen + 1);
            strncpy(groups[groupCount], s + start, groupLen);
            groups[groupCount][groupLen] = '\0';
            groupCount++;
            start = i + 1;
        }
    }
    
    // If there's only one group, process its inner content
    if (groupCount == 1) {
        char* group = groups[0];
        int groupLen = strlen(group);
        if (groupLen > 2) {
            char* inner = malloc(groupLen - 1);
            strncpy(inner, group + 1, groupLen - 2);
            inner[groupLen - 2] = '\0';
            
            if (strlen(inner) > 0) {
                char* innerMax = makeMax(inner); // Recursively optimize
                char* result = malloc(strlen(innerMax) + 3);
                sprintf(result, "1%s0", innerMax);
                free(inner);
                free(innerMax);
                free(group);
                free(groups);
                return result;
            }
            free(inner);
        }
        char* result = malloc(groupLen + 1);
        strcpy(result, group);
        free(group);
        free(groups);
        return result;
    }
    
    // If there are multiple groups, optimize each and sort
    char** optimizedGroups = malloc(1000 * sizeof(char*));
    for (int j = 0; j < groupCount; j++) {
        char* group = groups[j];
        int groupLen = strlen(group);
        if (groupLen > 2) {
            char* inner = malloc(groupLen - 1);
            strncpy(inner, group + 1, groupLen - 2);
            inner[groupLen - 2] = '\0';
            
            if (strlen(inner) > 0) {
                char* innerMax = makeMax(inner);
                optimizedGroups[j] = malloc(strlen(innerMax) + 3);
                sprintf(optimizedGroups[j], "1%s0", innerMax);
                free(innerMax);
            } else {
                optimizedGroups[j] = malloc(3);
                strcpy(optimizedGroups[j], "10");
            }
            free(inner);
        } else {
            optimizedGroups[j] = malloc(groupLen + 1);
            strcpy(optimizedGroups[j], group);
        }
        free(group);
    }
    
    // Sort groups for maximum lexicographic value
    qsort(optimizedGroups, groupCount, sizeof(char*), compare);
    
    // Join all optimized groups
    int totalLen = 0;
    for (int j = 0; j < groupCount; j++) {
        totalLen += strlen(optimizedGroups[j]);
    }
    
    char* result = malloc(totalLen + 1);
    result[0] = '\0';
    for (int j = 0; j < groupCount; j++) {
        strcat(result, optimizedGroups[j]);
        free(optimizedGroups[j]);
    }
    
    free(groups);
    free(optimizedGroups);
    return result;
}

char* solution(char* s) {
    return makeMax(s);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each valid substring pair, we have choice to swap or not, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for substring positions and current best result

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 min Avg. Time

485 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 Swaps — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler