Maximize the Number of Partitions After Operations - Problem

You are given a string s and an integer k. First, you are allowed to change at most one character in s to another lowercase English letter. After that, you need to perform the following partitioning operation until s is empty:

Choose the longest prefix of s containing at most k distinct characters.
Delete the prefix from s and increase the number of partitions by one.
The remaining characters (if any) maintain their initial order.

Return an integer denoting the maximum number of resulting partitions after the operations by optimally choosing at most one character to change.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Without change: "ac|cc|a" gives 3 partitions. With optimal change s[4]='c': "ac|cc|c" still gives 3 partitions. Maximum is 3.

Example 2 — Change Helps

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

› Output: 5

💡 Note: Without change: "aabaa|ca" gives 2 partitions. Change s[2]='c': "aa|c|aa|c|a" gives 5 partitions.

Example 3 — Small k

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

› Output: 6

💡 Note: Each character forms its own partition since k=1. Total: 6 partitions regardless of changes.

Constraints

1 ≤ s.length ≤ 500
1 ≤ k ≤ 26
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is to try changing each character optimally and simulate partitioning. The greedy approach works because we always want the longest possible prefix with ≤ k distinct characters. Best approach uses optimized simulation with O(n² × 26) time and O(k) space for character tracking.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force with Simulation

⏱️ Time: O(n² × 26) Space: O(k)

For each possible character change (including no change), simulate the partitioning process by greedily taking the longest valid prefix at each step. Track the maximum partitions achieved.

Dynamic Programming with Memoization

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

Define a recursive function that tracks current position, whether we've used our character change, and current character set. Use memoization to cache results for the same states.

Optimized Dynamic Programming

⏱️ Time: O(n × k × 2) Space: O(n × k × 2)

Use a more efficient state representation and implement early termination conditions. Focus on the key insight that we only need to track the current partition's character set and whether we've used our change.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int countPartitions(char* s, int k) {
    int n = strlen(s);
    int partitions = 0;
    int i = 0;
    
    while (i < n) {
        int freq[26] = {0};
        int distinct = 0;
        int j = i;
        
        // Find longest prefix with at most k distinct characters
        while (j < n) {
            int charIdx = s[j] - 'a';
            if (freq[charIdx] == 0) {
                if (distinct == k) break;
                distinct++;
            }
            freq[charIdx]++;
            j++;
        }
        
        partitions++;
        i = j;
    }
    
    return partitions;
}

int maxPartitionsAfterChange(char* s, int k) {
    int n = strlen(s);
    int maxPartitions = countPartitions(s, k);
    
    // Try changing each character
    for (int i = 0; i < n; i++) {
        char original = s[i];
        
        // Try changing to each possible character
        for (char c = 'a'; c <= 'z'; c++) {
            if (c != original) {
                s[i] = c;
                int partitions = countPartitions(s, k);
                if (partitions > maxPartitions) {
                    maxPartitions = partitions;
                }
            }
        }
        
        s[i] = original; // Restore original character
    }
    
    return maxPartitions;
}

int main() {
    char s[100001];
    int k;
    
    // Read string
    if (fgets(s, sizeof(s), stdin) != NULL) {
        // Remove newline if present
        int len = strlen(s);
        if (len > 0 && s[len-1] == '\n') {
            s[len-1] = '\0';
        }
    }
    
    // Read k
    scanf("%d", &k);
    
    int result = maxPartitionsAfterChange(s, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~35 min Avg. Time

234 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