Palindrome Partitioning II - Practice Coding Problems

Palindrome Partitioning II - Problem

Given a string s, your task is to partition the string into substrings such that every substring in the partition is a palindrome. A palindrome reads the same forwards and backwards (like "aba" or "racecar").

The goal is to find the minimum number of cuts needed to achieve such a palindrome partitioning. For example, if s = "aab", you could partition it as ["aa", "b"] with just 1 cut, since both "aa" and "b" are palindromes.

Key Points:

Each partition must contain only palindromic substrings
We want to minimize the total number of cuts
A single character is always a palindrome
The entire string might already be a palindrome (0 cuts needed)

Input & Output

example_1.py — Basic Case

$ Input: s = "aab"

› Output: 1

💡 Note: The palindrome partitioning ["aa", "b"] could be produced using 1 cut between 'aa' and 'b'.

example_2.py — Already Palindrome

$ Input: s = "aba"

› Output: 0

💡 Note: The entire string "aba" is already a palindrome, so no cuts are needed.

example_3.py — Multiple Cuts Needed

$ Input: s = "abcde"

› Output: 4

💡 Note: Each character must be separated since no adjacent characters form palindromes: ["a", "b", "c", "d", "e"] requires 4 cuts.

Constraints

1 ≤ s.length ≤ 2000
s consists of lowercase English letters only
Optimization needed: Naive O(n³) solution may be too slow for larger inputs

Visualization

Tap to expand

Understanding the Visualization

Examine the strip

First, identify which sections of the paper have symmetric patterns (palindromes)

Plan the cuts

Use dynamic programming to determine the minimum cuts needed

Make optimal cuts

Cut at positions that result in all symmetric pieces with fewest cuts

Key Takeaway

🎯 Key Insight: Pre-compute all palindromic substrings, then use DP to find the minimum cuts by building up from smaller subproblems

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses dynamic programming with pre-computed palindrome information. First, build a 2D boolean table to identify all palindromic substrings in O(n²) time. Then, use DP where dp[i] represents the minimum cuts needed for the first i characters. For each position, try all possible previous cut positions and update using the palindrome table. This achieves O(n²) time complexity and O(n²) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with O(n³) Palindrome Check	O(n³)	O(n)	Use DP to find minimum cuts, checking palindromes on-the-fly

Dynamic Programming with O(n³) Palindrome Check — Algorithm Steps

Create a DP array where dp[i] = minimum cuts for first i characters
For each position i, try all possible previous cut positions j
Check if substring s[j:i] is a palindrome
If yes, update dp[i] = min(dp[i], dp[j] + 1)
Return dp[n] - 1 (subtract 1 because we don't count the final position)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

dp[i] = minimum cuts for first i characters

For each position i

Try all possible previous cut positions j < i

Check palindrome

If s[j:i] is palindrome, update dp[i]

Take minimum

dp[i] = min(dp[i], dp[j] + 1)

Code -

solution.c — C

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

int isPalindrome(char* s, int start, int end) {
    while (start < end) {
        if (s[start] != s[end]) {
            return 0;
        }
        start++;
        end--;
    }
    return 1;
}

int minCut(char* s) {
    int n = strlen(s);
    if (n <= 1) return 0;
    
    int dp[n + 1];
    for (int i = 0; i <= n; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < i; j++) {
            if (isPalindrome(s, j, i - 1)) {
                if (dp[j] + 1 < dp[i]) {
                    dp[i] = dp[j] + 1;
                }
            }
        }
    }
    
    return dp[n] - 1;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    printf("%d\n", minCut(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for DP iterations and O(n) for each palindrome check

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n

⚡ Linearithmic Space

89.4K Views

Medium Frequency

~25 min Avg. Time

2.8K 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 O(n³) Palindrome Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler