Palindrome Partitioning III - Practice Coding Problems

Palindrome Partitioning III - Problem

You're given a string s containing lowercase letters and an integer k. Your mission is to transform this string into exactly k palindromic substrings with the minimum number of character changes possible.

Here's what you need to do:
1. Change some characters of s to other lowercase English letters
2. Divide the modified string into exactly k non-empty, non-overlapping substrings
3. Ensure each substring is a palindrome

Your goal is to find the minimum number of character changes needed to achieve this partitioning. This is a classic dynamic programming problem that combines string manipulation with optimization techniques.

Example: For string "abc" and k=2, you could change 'b' to 'a' to get "aac", then partition it as ["aa", "c"] - requiring only 1 change!

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: We can change 'b' to 'a' to get "aac", then partition as ["aa", "c"]. Both "aa" and "c" are palindromes, and we only needed 1 character change.

example_2.py — No Changes Needed

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

› Output: 0

💡 Note: We can partition the string as ["aa", "bb", "c"] without any changes. All three parts are already palindromes.

example_3.py — Multiple Changes

$ Input: s = "leetcode", k = 8

› Output: 0

💡 Note: Since k equals the string length, each character forms its own part: ["l","e","e","t","c","o","d","e"]. Single characters are always palindromes, so no changes needed.

Constraints

1 ≤ k ≤ s.length ≤ 100
s contains only lowercase English letters
k ≤ number of characters in s
Each partition must be non-empty

Visualization

Tap to expand

Understanding the Visualization

Pre-compute Costs

Calculate the cost to make every possible substring palindromic

Define DP State

dp[i][j] = minimum cost to partition first i characters into j parts

State Transition

For each state, try all possible positions for the last partition

Build Solution

Use memoization to avoid recalculating the same subproblems

Key Takeaway

🎯 Key Insight: Pre-computing palindrome costs enables efficient DP where we try all possible last partitions and choose the minimum cost path. The time complexity is O(n²k) with O(n²) space.

Asked in

G Google 32 a Amazon 28 ⊞ Microsoft 15 f Meta 12

This problem requires dynamic programming with pre-computed palindrome costs. The optimal approach uses O(n²) preprocessing to calculate the cost of making any substring palindromic, followed by DP with memoization where dp[i][j] represents the minimum changes needed to partition the first i characters into j palindromic parts. The key insight is that we can try all possible positions for the last partition and choose the one with minimum total cost.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n^2 + n^2*k)	O(n^2 + n*k)	Pre-compute palindrome costs and use DP to find optimal partitioning

Dynamic Programming with Memoization — Algorithm Steps

Pre-compute cost matrix for making any substring [i,j] palindromic
Define DP state: dp[i][j] = min cost for first i chars into j parts
For each state, try all possible positions for the last partition
Use memoization to avoid recalculating subproblems
Return dp[n][k] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Pre-compute Costs

Calculate cost to make each substring palindromic

DP State Transition

dp[i][j] = min cost for first i characters into j parts

Build Solution

Use memoization to avoid recalculation

Code -

solution.c — C

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

#define MAX_N 101
#define MAX_MEMO 10001

char s[MAX_N];
int n, k;
int cost[MAX_N][MAX_N];
int memo[MAX_N][MAX_N];
int memo_set[MAX_N][MAX_N];

int min(int a, int b) {
    return a < b ? a : b;
}

int dp(int i, int parts) {
    if (parts == 1) {
        return cost[0][i-1];
    }
    if (parts > i) {
        return INT_MAX;
    }
    
    if (memo_set[i][parts]) {
        return memo[i][parts];
    }
    
    int result = INT_MAX;
    for (int prev = parts - 1; prev < i; prev++) {
        int subResult = dp(prev, parts - 1);
        if (subResult != INT_MAX) {
            result = min(result, subResult + cost[prev][i-1]);
        }
    }
    
    memo[i][parts] = result;
    memo_set[i][parts] = 1;
    return result;
}

int palindromePartition() {
    // Pre-compute palindrome costs
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int left = i, right = j;
            cost[i][j] = 0;
            while (left < right) {
                if (s[left] != s[right]) {
                    cost[i][j]++;
                }
                left++;
                right--;
            }
        }
    }
    
    // Initialize memoization
    memset(memo_set, 0, sizeof(memo_set));
    
    return dp(n, k);
}

int main() {
    fgets(s, sizeof(s), stdin);
    scanf("%d", &k);
    
    // Remove quotes and newline
    char* p = s;
    char* q = s;
    while (*p) {
        if (*p != '"' && *p != '\n') {
            *q++ = *p;
        }
        p++;
    }
    *q = '\0';
    
    n = strlen(s);
    printf("%d\n", palindromePartition());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^2 + n^2*k)

O(n^2) to pre-compute palindrome costs + O(n^2*k) for DP transitions

⚠ Quadratic Growth

Space Complexity

O(n^2 + n*k)

O(n^2) for cost matrix + O(n*k) for DP memoization table

⚠ Quadratic Space

42.3K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Code -

Time & Space Complexity

Select Compiler