Palindrome Partitioning III - Practice Coding Problems

Palindrome Partitioning III - Problem

You are given a string s containing lowercase letters and an integer k.

You need to:

First, change some characters of s to other lowercase English letters.
Then divide s into k non-empty disjoint substrings such that each substring is a palindrome.

Return the minimal number of characters that you need to change to divide the string.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Change one character to create palindromes: "a" | "bb" (change 'c' to 'b') or "aa" | "c" (change 'b' to 'a'). Minimum cost is 1.

Example 2 — Already Palindromic

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

› Output: 0

💡 Note: Can partition as "a" | "aba" | "a" with no changes needed since each part is already palindromic.

Example 3 — Single Part

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

› Output: 3

💡 Note: Need to make entire string palindromic. Change positions to match: "leeecode" → "leeeeeel" requires 3 changes minimum.

Constraints

1 ≤ k ≤ s.length ≤ 100
s consists of lowercase English letters only

Visualization

Tap to expand

Understanding the Visualization

Input

String "abc" with k=2 parts needed

Process

Find optimal way to partition and make palindromes

Output

Minimum 1 change needed

Key Takeaway

🎯 Key Insight: Precompute all substring palindrome costs, then use DP to find optimal k-way partition

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to precompute palindrome conversion costs for all substrings, then use dynamic programming to find optimal partitioning. Best approach is Bottom-Up DP with Time: O(n³), Space: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Bottom-Up Dynamic Programming	O(n³ + n²k)	O(n² + nk)	Build solution iteratively using 2D DP table
Brute Force Recursion	O(k^n)	O(n)	Try all possible ways to partition string into k parts
Memoization (Top-Down DP)	O(n³ + n²k)	O(n² + nk)	Cache results of subproblems to avoid recomputation

Bottom-Up Dynamic Programming — Algorithm Steps

Precompute palindrome costs for all substrings
Initialize DP table with base cases
Fill table using optimal substructure
Return dp[n][k]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Set up DP table with base cases

Fill States

Use optimal substructure to fill table

Extract Answer

Return dp[n][k] as final result

Code -

solution.c — C

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

#define MAX_N 101

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

int solution(char* s, int k) {
    int n = strlen(s);
    
    // Precompute palindrome costs
    int cost[MAX_N][MAX_N];
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            cost[i][j] = 0;
            int left = i, right = j;
            while (left < right) {
                if (s[left] != s[right]) {
                    cost[i][j]++;
                }
                left++;
                right--;
            }
        }
    }
    
    // DP table
    int dp[MAX_N][MAX_N];
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= min(i, k); j++) {
            // Try all possible last segments
            for (int prev = j - 1; prev < i; prev++) {
                if (dp[prev][j - 1] != INT_MAX) {
                    dp[i][j] = min(dp[i][j], dp[prev][j - 1] + cost[prev][i - 1]);
                }
            }
        }
    }
    
    return dp[n][k];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³ + n²k)

O(n³) to precompute palindrome costs, O(n²k) to fill DP table with O(n) transitions

⚠ Quadratic Growth

Space Complexity

O(n² + nk)

O(n²) for palindrome cost matrix, O(nk) for DP table

⚠ Quadratic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler