Partition String Into Minimum Beautiful Substrings

Partition String Into Minimum Beautiful Substrings - Problem

Given a binary string s, your task is to partition it into the minimum number of beautiful substrings.

A substring is considered beautiful if it satisfies two conditions:

No leading zeros: The substring cannot start with '0' (unless it's just "0" itself, but "0" is not a power of 5)
Power of 5: When converted from binary to decimal, the number must be a power of 5 (1, 5, 25, 125, ...)

Goal: Find the minimum number of partitions needed, or return -1 if impossible.

Example: The binary string "101" represents decimal 5, which is 5¹, so it's beautiful. The string "11001" can be split into "1" (decimal 1 = 5⁰) and "1001" (decimal 9, not a power of 5), so we need to try different partitions.

Input & Output

example_1.py — Simple Valid Case

$ Input: s = "1011"

› Output: 2

💡 Note: We can partition "1011" into "101" (decimal 5 = 5¹) and "1" (decimal 1 = 5⁰). Both are powers of 5, so minimum partitions = 2.

example_2.py — Single Beautiful String

$ Input: s = "111"

› Output: 3

💡 Note: "111" (decimal 7) is not a power of 5. We must partition it as "1" + "1" + "1", where each "1" represents 5⁰ = 1. Minimum partitions = 3.

example_3.py — Impossible Case

$ Input: s = "0"

› Output: -1

💡 Note: "0" has a leading zero and 0 is not a power of 5. It cannot form any beautiful substring, so return -1.

Constraints

1 ≤ s.length ≤ 15
s[i] is either '0' or '1'
Powers of 5 in binary: 1₂=1₁₀, 101₂=5₁₀, 11001₂=25₁₀, 1111101₂=125₁₀

Visualization

Tap to expand

Understanding the Visualization

Identify Powers of 5

Pre-compute: 1₂=1, 101₂=5, 11001₂=25, 1111101₂=125...

Try All Cuts

At each position, attempt to cut and create valid beautiful substrings

Validate Substrings

Check if each piece has no leading zeros and represents a power of 5

Minimize Partitions

Use DP to find the minimum number of cuts needed

Handle Impossible Cases

Return -1 if no valid partitioning exists

Key Takeaway

🎯 Key Insight: Pre-compute all powers of 5 in binary and use memoized DP to find minimum cuts. The binary representations of powers of 5 follow a pattern that we can leverage for efficient checking.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

This problem is best solved using dynamic programming with memoization. Pre-compute all powers of 5 in binary form, then use recursive DP to find the minimum partitions. The key insight is that we only need to try cuts where the resulting substring is a valid power of 5 (no leading zeros). Time complexity: O(n² × k) where k is the cost of checking if a substring is beautiful.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoized)	O(n² × k)	O(n)	Use memoization to avoid recalculating the same subproblems
Backtracking (Brute Force)	O(2^n)	O(n)	Try all possible ways to partition the string using recursion

Dynamic Programming (Memoized) — Algorithm Steps

Pre-compute all powers of 5 in binary representation
Use a memo dictionary to store results of subproblems
For each starting position, try all possible cuts
If substring is beautiful, recursively solve remaining part
Store and return the minimum partitions from memo

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize memo table

Create cache for storing results

Check memo first

Before computing, check if result already cached

Compute if needed

Only calculate if not in memo

Store result

Cache the result for future use

Reuse cached values

Subsequent calls return cached results instantly

Code -

solution.c — C

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

#define MAX_LEN 16
#define MAX_POWERS 10

char powersOf5[MAX_POWERS][MAX_LEN];
int numPowers;
int memo[MAX_LEN];
int memoInitialized[MAX_LEN];

void computePowersOf5(int maxLen) {
    long long power = 1;
    numPowers = 0;
    
    while (power <= (1LL << maxLen) && numPowers < MAX_POWERS) {
        long long temp = power;
        int idx = 0;
        char binary[MAX_LEN] = {0};
        
        while (temp > 0) {
            binary[idx++] = '0' + (temp % 2);
            temp /= 2;
        }
        
        for (int i = 0; i < idx / 2; i++) {
            char temp = binary[i];
            binary[i] = binary[idx - 1 - i];
            binary[idx - 1 - i] = temp;
        }
        
        strcpy(powersOf5[numPowers], binary);
        numPowers++;
        power *= 5;
    }
}

int isBeautiful(char* substring) {
    int len = strlen(substring);
    if (len > 1 && substring[0] == '0') {
        return 0;
    }
    
    for (int i = 0; i < numPowers; i++) {
        if (strcmp(substring, powersOf5[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

int dp(char* s, int start, int len) {
    if (start == len) {
        return 0;
    }
    
    if (memoInitialized[start]) {
        return memo[start];
    }
    
    int minPartitions = INT_MAX;
    
    for (int end = start + 1; end <= len; end++) {
        char substring[MAX_LEN] = {0};
        strncpy(substring, s + start, end - start);
        
        if (isBeautiful(substring)) {
            int remaining = dp(s, end, len);
            if (remaining != INT_MAX) {
                int current = 1 + remaining;
                if (current < minPartitions) {
                    minPartitions = current;
                }
            }
        }
    }
    
    memo[start] = minPartitions;
    memoInitialized[start] = 1;
    return minPartitions;
}

int main() {
    char input[100];
    fgets(input, sizeof(input), stdin);
    
    char* s = input + 1;
    int len = strlen(s) - 2;
    s[len] = '\0';
    
    memset(memoInitialized, 0, sizeof(memoInitialized));
    computePowersOf5(len);
    
    int result = dp(s, 0, len);
    if (result == INT_MAX) {
        printf("-1\n");
    } else {
        printf("%d\n", result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

n² substrings to check, k is the time to verify if each is a power of 5

⚠ Quadratic Growth

Space Complexity

O(n)

Memoization table stores results for each starting position

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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

Dynamic Programming (Memoized) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler