Partition String Into Minimum Beautiful Substrings

Partition String Into Minimum Beautiful Substrings - Problem

Given a binary string s, partition the string into one or more substrings such that each substring is beautiful.

A string is beautiful if:

It doesn't contain leading zeros.
It's the binary representation of a number that is a power of 5.

Return the minimum number of substrings in such partition. If it is impossible to partition the string s into beautiful substrings, return -1.

A substring is a contiguous sequence of characters in a string.

Input & Output

Example 1 — Valid Partition

$ Input: s = "1011"

› Output: 2

💡 Note: The string "1011" can be partitioned as "101" + "1". Both "101" (binary for 5¹=5) and "1" (binary for 5⁰=1) are powers of 5, so minimum partitions = 2.

Example 2 — No Valid Partition

$ Input: s = "111"

› Output: -1

💡 Note: No way to partition "111" into beautiful substrings. "1" is valid but "11" is not a power of 5 (binary 11 = decimal 3). "111" (decimal 7) is also not a power of 5.

Example 3 — Single Character

$ Input: s = "1"

› Output: 1

💡 Note: The string "1" itself is beautiful (binary representation of 5⁰=1), so only 1 partition needed.

Constraints

1 ≤ s.length ≤ 15
s[i] is either '0' or '1'

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to precompute all valid power-of-5 binary representations and use dynamic programming to find minimum partitions. The optimal approach uses memoized backtracking or bottom-up DP. Time: O(n³), Space: O(n)

Common Approaches

✓ Backtracking with Recursion

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

At each position, try all possible substrings starting from that position. For each valid beautiful substring, recursively solve for the remaining string. Keep track of the minimum partitions found.

Dynamic Programming (Bottom-Up)

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

Use a DP array where dp[i] represents the minimum partitions needed for substring s[i:]. Fill the array from right to left, using previously computed values to build larger solutions.

Memoized Backtracking

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

Same as backtracking approach but cache the results for each starting position. This prevents redundant calculations when the same suffix is encountered multiple times during recursion.

Backtracking with Recursion — Algorithm Steps

Generate all powers of 5 in binary form up to the string length
Use recursion to try every possible partition
For each position, check all substrings starting from that position
If substring is beautiful, recursively solve for remainder

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Powers of 5

Create set of valid binary representations

Try Partitions

Recursively try all possible substring combinations

Find Minimum

Return minimum valid partitions found

Code -

solution.c — C

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

static char powersOf5[20][65];
static int powerCount = 0;
static char inputString[65];
static int memo[65];
static int memoInit[65];

void generatePowersOf5(int maxLen) {
    long long power = 1;
    powerCount = 0;
    
    while (powerCount < 20 && power > 0) {
        // Convert power to binary string
        char binary[65] = {0};
        long long temp = power;
        int pos = 0;
        
        if (temp == 0) {
            binary[pos++] = '0';
        } else {
            while (temp > 0) {
                binary[pos++] = '0' + (temp % 2);
                temp /= 2;
            }
        }
        
        // Reverse the binary string
        for (int i = 0; i < pos / 2; i++) {
            char t = binary[i];
            binary[i] = binary[pos - 1 - i];
            binary[pos - 1 - i] = t;
        }
        binary[pos] = '\0';
        
        if (pos <= maxLen) {
            strcpy(powersOf5[powerCount], binary);
            powerCount++;
        }
        
        // Check for overflow before multiplying
        if (power > LLONG_MAX / 5) break;
        power *= 5;
    }
}

int isBeautiful(const char* s, int start, int end) {
    // Leading zero check (except for "1" which is 5^0)
    if (s[start] == '0') return 0;
    
    int len = end - start;
    for (int i = 0; i < powerCount; i++) {
        int pLen = strlen(powersOf5[i]);
        if (pLen == len) {
            int match = 1;
            for (int j = 0; j < len; j++) {
                if (s[start + j] != powersOf5[i][j]) {
                    match = 0;
                    break;
                }
            }
            if (match) return 1;
        }
    }
    return 0;
}

int backtrack(int start, int totalLen) {
    if (start == totalLen) {
        return 0;
    }
    
    if (start > totalLen) {
        return -1;
    }
    
    if (memoInit[start]) {
        return memo[start];
    }
    
    int minPartitions = INT_MAX;
    
    for (int end = start + 1; end <= totalLen; end++) {
        if (isBeautiful(inputString, start, end)) {
            int result = backtrack(end, totalLen);
            if (result != -1) {
                if (1 + result < minPartitions) {
                    minPartitions = 1 + result;
                }
            }
        }
    }
    
    int finalResult = (minPartitions == INT_MAX) ? -1 : minPartitions;
    memo[start] = finalResult;
    memoInit[start] = 1;
    return finalResult;
}

int solution(char* s) {
    int len = strlen(s);
    
    if (len == 0) return -1;
    if (len >= 64) return -1;  // Safety check
    
    strcpy(inputString, s);
    
    // Initialize memoization
    for (int i = 0; i <= len; i++) {
        memoInit[i] = 0;
        memo[i] = 0;
    }
    
    generatePowersOf5(len);
    return backtrack(0, len);
}

int main() {
    char s[65];
    if (fgets(s, sizeof(s), stdin)) {
        // Remove newline if present
        s[strcspn(s, "\n")] = '\0';
        
        // Remove surrounding quotes if present
        char* start = s;
        int len = strlen(s);
        if (len >= 2 && s[0] == '"' && s[len-1] == '"') {
            s[len-1] = '\0';
            start = s + 1;
        }
        
        int result = solution(start);
        printf("%d\n", result);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each position can start a new partition, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth can go up to n levels in worst case

⚡ Linearithmic Space

23.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

Backtracking with Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler