Maximize the Number of Partitions After Operations

Maximize the Number of Partitions After Operations - Problem

You are given a string s and an integer k. Your goal is to maximize the number of partitions by making one strategic character change.

Here's how the process works:

Optional Change: You can change at most one character in the string to any other lowercase English letter
Partitioning Process: Repeatedly find the longest prefix containing at most k distinct characters, remove it as a partition, and continue with the remaining string

Your task is to determine the maximum number of partitions you can create by optimally choosing which character (if any) to change.

Think of it like cutting a ribbon into pieces - you want to make strategic cuts to get as many pieces as possible, and you can change one section of the ribbon to help create more cutting opportunities!

Input & Output

example_1.py — Basic Case

$ Input: s = "accca", k = 2

› Output: 3

💡 Note: Without any change: 'acc' (2 distinct: a,c) + 'c' (1 distinct: c) + 'a' (1 distinct: a) = 3 partitions. We can change the middle 'c' to 'a' to get 'acaca', which gives us 'ac' + 'ac' + 'a' = 3 partitions. The optimal result is 3.

example_2.py — Strategic Change

$ Input: s = "aabaaca", k = 2

› Output: 5

💡 Note: Original: 'aab' (2 distinct: a,b) + 'aa' (1 distinct: a) + 'c' (1 distinct: c) + 'a' (1 distinct: a) = 4 partitions. If we change the first 'b' to 'a': 'aaaaa' + 'c' + 'a' = 3 partitions. Better strategy: change 'c' to 'a' getting 'aabaaa', then partition as 'a' + 'a' + 'b' + 'a' + 'a' + 'a' = 6 partitions. Actually optimal is 'aa' + 'b' + 'aa' + 'a' + 'a' = 5.

example_3.py — No Change Needed

$ Input: s = "abcdef", k = 1

› Output: 6

💡 Note: With k=1, each character must be in its own partition since all characters are distinct. Original string gives 'a' + 'b' + 'c' + 'd' + 'e' + 'f' = 6 partitions. Changing any character won't improve this since we'd still have 6 distinct characters total.

Visualization

Tap to expand

Understanding the Visualization

Analyze Original

Count partitions with the original string

Try Each Change

For each position, try changing to different characters

Simulate Partitioning

For each change, simulate the greedy partitioning process

Track Maximum

Keep track of the configuration that gives maximum partitions

Key Takeaway

🎯 Key Insight: The optimal solution uses dynamic programming to efficiently explore the exponential space of possibilities, using bitmasks to represent character sets and memoization to avoid redundant calculations.

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^k × 2)

n positions × 2^k possible character sets × 2 change states, with memoization

✓ Linear Growth

Space Complexity

O(n × 2^k × 2)

Memoization table storing all possible states

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁴
s consists of only lowercase English letters
1 ≤ k ≤ 26
At most one character can be changed

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses dynamic programming with bitmasks to efficiently explore all possible character changes. The key insight is that we can represent the set of distinct characters in the current partition using a bitmask, and use memoization to avoid redundant calculations. The DP state includes the current position, the character set bitmask, and whether we've used our character change. This gives us O(n × 2^k × 2) time complexity, which is much better than the brute force O(26n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n × 2^k × 2)	O(n × 2^k × 2)	Use DP to avoid redundant calculations while exploring all possibilities
Brute Force (Try All Changes)	O(26n²)	O(n)	Try changing each character to every possible letter and simulate partitioning

Dynamic Programming with Memoization — Algorithm Steps

Define DP state: (position, bitmask of current characters, used_change)
For each state, try two options: end current partition or extend it
If extending, try using original character or (if unused) change to any character
Use memoization to cache results for identical states
Return maximum partitions possible from state (0, 0, false)

Visualization

Tap to expand

Step-by-Step Walkthrough

State Definition

(position, character_mask, change_used)

State Transitions

End partition, extend partition, or use character change

Memoization

Cache results to avoid recomputation

Optimal Path

Backtrack to find the optimal sequence of decisions

Code -

solution.c — C

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

#define MAX_STATES 100000

typedef struct {
    int pos, mask;
    int changed;
    int result;
} State;

State memo[MAX_STATES];
int memoSize = 0;

int findMemo(int pos, int mask, int changed) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].pos == pos && memo[i].mask == mask && memo[i].changed == changed) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int pos, int mask, int changed, int result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].pos = pos;
        memo[memoSize].mask = mask;
        memo[memoSize].changed = changed;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int popcount(int mask) {
    int count = 0;
    while (mask) {
        count += mask & 1;
        mask >>= 1;
    }
    return count;
}

int dp(char* s, int pos, int mask, int changed, int k, int n) {
    if (pos == n) return 0;
    
    int cached = findMemo(pos, mask, changed);
    if (cached != -1) return cached;
    
    int distinct = popcount(mask);
    int result = 0;
    
    // Option 1: End current partition
    int charBit = 1 << (s[pos] - 'a');
    int temp = 1 + dp(s, pos + 1, charBit, changed, k, n);
    if (temp > result) result = temp;
    
    // Option 2: Extend with original character
    if (distinct < k || (mask & charBit)) {
        int newMask = mask | charBit;
        temp = dp(s, pos + 1, newMask, changed, k, n);
        if (temp > result) result = temp;
    }
    
    // Option 3: Use character change
    if (!changed) {
        for (int c = 0; c < 26; c++) {
            int cBit = 1 << c;
            if (cBit != charBit) {
                temp = 1 + dp(s, pos + 1, cBit, 1, k, n);
                if (temp > result) result = temp;
                
                if (distinct < k || (mask & cBit)) {
                    int newMask = mask | cBit;
                    temp = dp(s, pos + 1, newMask, 1, k, n);
                    if (temp > result) result = temp;
                }
            }
        }
    }
    
    addMemo(pos, mask, changed, result);
    return result;
}

int maxPartitionsAfterOperations(char* s, int k) {
    memoSize = 0;
    return dp(s, 0, 0, 0, k, strlen(s));
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^k × 2)

n positions × 2^k possible character sets × 2 change states, with memoization

✓ Linear Growth

Space Complexity

O(n × 2^k × 2)

Memoization table storing all possible states

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁴
s consists of only lowercase English letters
1 ≤ k ≤ 26
At most one character can be changed

26.0K Views

Medium Frequency

~35 min Avg. Time

845 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 with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler