Minimum Substring Partition of Equal Character Frequency

Minimum Substring Partition of Equal Character Frequency - Problem

Balanced String Partitioning Challenge

Given a string s, you need to partition it into the minimum number of balanced substrings.

A balanced string is one where each character appears the same number of times. For example:
• "ab" is balanced (both 'a' and 'b' appear once)
• "aabb" is balanced (both 'a' and 'b' appear twice)
• "abc" is balanced (all characters appear once)
• "aab" is not balanced ('a' appears twice, 'b' appears once)

Example: For s = "ababcc":
✅ Valid partitions: ["abab", "c", "c"], ["ab", "abc", "c"], ["ababcc"]
❌ Invalid partitions: ["a", "bab", "cc"] ("bab" is unbalanced)

Goal: Return the minimum number of balanced substrings needed to partition the entire string.

Input & Output

example_1.py — Basic Example

$ Input: s = "ababcc"

› Output: 3

💡 Note: One optimal partition is ["abab", "c", "c"]. The substring "abab" has 'a' and 'b' each appearing 2 times (balanced), and each "c" is trivially balanced with frequency 1.

example_2.py — All Same Characters

$ Input: s = "aaaa"

› Output: 1

💡 Note: The entire string "aaaa" is already balanced since only 'a' appears (frequency 4). No partitioning needed.

example_3.py — Force Multiple Partitions

$ Input: s = "abcabc"

› Output: 2

💡 Note: We can partition as ["abc", "abc"]. Each substring has 'a', 'b', and 'c' appearing once (balanced). We cannot do better than 2 partitions.

Visualization

Tap to expand

Understanding the Visualization

Identify the string

Start with string 'ababcc' that needs to be partitioned

Try different cuts

Attempt cuts at different positions to create substrings

Check balance

Verify each substring has equal character frequencies

Find minimum

Use dynamic programming to find the minimum number of parts

Key Takeaway

🎯 Key Insight: Use dynamic programming to try all possible balanced starting substrings and memoize results to avoid redundant calculations, achieving O(n³) complexity instead of exponential.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subproblems, each taking O(n) time to check balance

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table and character frequency counting

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters
The string will always have at least one valid partition

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses dynamic programming with memoization to achieve O(n³) time complexity. The key insight is that we can try all possible balanced substrings starting at each position and recursively solve for the remainder. Memoization prevents recomputing the same subproblems, making this approach much more efficient than brute force exponential solutions.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n³)	O(n²)	Use memoization to avoid recomputing overlapping subproblems
Brute Force (Try All Partitions)	O(2^n * n^2)	O(n)	Generate all possible partitions and find the minimum valid one

Dynamic Programming (Optimal) — Algorithm Steps

Use memoization to cache results for each starting position
For each position, try all possible ending positions
Check if the substring is balanced using character frequency counts
Recursively solve for the remaining string and take minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from position 0

Try all balanced substrings starting at position 0

Check substring balance

For each potential substring, verify all characters have equal frequency

Recursive solve with memo

For each valid cut, recursively solve remainder using memoization

Return minimum

Cache and return the minimum partitions for each starting position

Code -

solution.c — C

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

#define MAX_N 1001

char str[MAX_N];
int memo[MAX_N];
int n;

int isBalanced(int start, int end) {
    int counts[26] = {0};
    
    for (int i = start; i < end; i++) {
        counts[str[i] - 'a']++;
    }
    
    int firstFreq = -1;
    for (int i = 0; i < 26; i++) {
        if (counts[i] > 0) {
            if (firstFreq == -1) {
                firstFreq = counts[i];
            } else if (counts[i] != firstFreq) {
                return 0;
            }
        }
    }
    
    return 1;
}

int dp(int start) {
    if (start == n) {
        return 0;
    }
    
    if (memo[start] != -1) {
        return memo[start];
    }
    
    int minPartitions = INT_MAX;
    
    for (int end = start + 1; end <= n; end++) {
        if (isBalanced(start, end)) {
            int result = dp(end);
            if (result != INT_MAX && result + 1 < minPartitions) {
                minPartitions = result + 1;
            }
        }
    }
    
    memo[start] = minPartitions;
    return minPartitions;
}

int minimumSubstringsInPartition(char* s) {
    n = strlen(s);
    strcpy(str, s);
    
    for (int i = 0; i <= n; i++) {
        memo[i] = -1;
    }
    
    return dp(0);
}

int main() {
    char s[MAX_N];
    scanf("%s", s);
    
    // Remove quotes if present
    int len = strlen(s);
    if (s[0] == '"' && s[len-1] == '"') {
        s[len-1] = '\0';
        memmove(s, s+1, len-1);
    }
    
    printf("%d\n", minimumSubstringsInPartition(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subproblems, each taking O(n) time to check balance

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table and character frequency counting

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists only of lowercase English letters
The string will always have at least one valid partition

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler