Minimum Substring Partition of Equal Character Frequency

Minimum Substring Partition of Equal Character Frequency - Problem

Given a string s, you need to partition it into one or more balanced substrings.

For example, if s == "ababcc" then ("abab", "c", "c"), ("ab", "abc", "c"), and ("ababcc") are all valid partitions, but ("a", "bab", "cc"), ("aba", "bc", "c"), and ("ab", "abcc") are not valid because they contain unbalanced substrings.

Return the minimum number of substrings that you can partition s into.

Note: A balanced string is a string where each character in the string occurs the same number of times.

Input & Output

Example 1 — Basic Case

$ Input: s = "ababcc"

› Output: 3

💡 Note: We can partition into ("abab", "c", "c"). "abab" has a:2, b:2 (balanced), each "c" has c:1 (balanced). Total: 3 partitions.

Example 2 — Single Character

$ Input: s = "aaaa"

› Output: 1

💡 Note: The entire string "aaaa" has a:4, so it's balanced. We need only 1 partition.

Example 3 — All Different Characters

$ Input: s = "abc"

› Output: 3

💡 Note: Each character appears once, so "a", "b", "c" are each balanced. We need 3 partitions.

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is recognizing this as a dynamic programming problem where we need to find optimal partition points. The memoized approach is most reliable, trying all possible cuts and caching results. Best approach uses top-down DP with memoization. Time: O(n³), Space: O(n)

Common Approaches

✓ Brute Force Recursion

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

Generate all possible ways to partition the string, check if each substring is balanced, and return the minimum number of partitions among valid ones.

Dynamic Programming with Memoization

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

Use memoization to store results of already computed starting positions, avoiding recalculation of the same subproblems in the recursive solution.

Greedy Approach

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

Use a greedy strategy where we keep extending the current partition until all characters have equal frequency, then start a new partition.

Brute Force Recursion — Algorithm Steps

For each position, try making a cut
Recursively solve for remaining string
Check if current substring is balanced
Return minimum partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin from position 0

Try Cuts

Try making cuts at each position

Check Balance

Verify if each substring is balanced

Code -

solution.c — C

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

int isBalanced(char* s, int start, int end) {
    int charCount[26] = {0};
    
    for (int i = start; i < end; i++) {
        charCount[s[i] - 'a']++;
    }
    
    int frequency = 0;
    for (int i = 0; i < 26; i++) {
        if (charCount[i] > 0) {
            if (frequency == 0) {
                frequency = charCount[i];
            } else if (charCount[i] != frequency) {
                return 0;
            }
        }
    }
    
    return 1;
}

int dp[1001];

int solve(char* s, int start, int len) {
    if (start == len) return 0;
    
    if (dp[start] != -1) return dp[start];
    
    int minPartitions = INT_MAX;
    for (int end = start + 1; end <= len; end++) {
        if (isBalanced(s, start, end)) {
            int result = solve(s, end, len);
            if (result != INT_MAX && 1 + result < minPartitions) {
                minPartitions = 1 + result;
            }
        }
    }
    
    dp[start] = minPartitions;
    return minPartitions;
}

int solution(char* s) {
    memset(dp, -1, sizeof(dp));
    return solve(s, 0, strlen(s));
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position can be a cut point or not, leading to 2^n possibilities

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth can go up to n levels

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler