Palindrome Partitioning II

Palindrome Partitioning II - Problem

Given a string s, partition s such that every substring of the partition is a palindrome.

Return the minimum number of cuts needed for a palindrome partitioning of s.

A palindrome is a string that reads the same backward as forward.

Input & Output

Example 1 — Basic Partition

$ Input: s = "aab"

› Output: 1

💡 Note: The string can be partitioned as "aa|b". "aa" and "b" are both palindromes, requiring only 1 cut.

Example 2 — Already Palindrome

$ Input: s = "aba"

› Output: 0

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

Example 3 — Multiple Cuts Needed

$ Input: s = "abcde"

› Output: 4

💡 Note: Each character must be its own partition: "a|b|c|d|e", requiring 4 cuts.

Constraints

1 ≤ s.length ≤ 2000
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is using dynamic programming to build up minimum cuts from smaller substrings. We can precompute palindromes or use expand-around-centers approach. Best approach is Optimized DP with Expand Around Centers for optimal space usage. Time: O(n²), Space: O(n).

Common Approaches

✓ 1D Dynamic Programming

⏱️ Time: O(n²) Space: O(n²)

Use dynamic programming where dp[i] represents minimum cuts needed for substring s[0:i]. Precompute palindrome information for efficiency.

Brute Force Recursion

⏱️ Time: O(2ⁿ) Space: O(n)

Generate all possible ways to partition the string and check if each partition consists entirely of palindromes. Keep track of the minimum cuts needed.

Optimized DP with Expand Around Centers

⏱️ Time: O(n²) Space: O(n)

Instead of precomputing all palindromes, expand around each character (and between characters) to find palindromes on-demand while updating minimum cuts.

Recursion with Memoization

⏱️ Time: O(n³) Space: O(n²)

Optimize brute force by storing results of subproblems. Once we compute minimum cuts for a substring, we cache it to avoid recalculating.

1D Dynamic Programming — Algorithm Steps

Step 1: Precompute palindrome table
Step 2: Initialize DP array
Step 3: For each position, try all possible last palindrome
Step 4: Update minimum cuts

Visualization

Tap to expand

Step-by-Step Walkthrough

Palindrome Table

Precompute which substrings are palindromes

DP Array

dp[i] = minimum cuts for s[0:i+1]

Fill DP

For each position, find minimum cuts

Result

Return dp[n-1]

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    if (n <= 1) return 0;
    
    // Precompute palindrome table
    bool isPalindrome[n][n];
    memset(isPalindrome, false, sizeof(isPalindrome));
    
    // Single characters are palindromes
    for (int i = 0; i < n; i++) {
        isPalindrome[i][i] = true;
    }
    
    // Check for palindromes of length 2
    for (int i = 0; i < n - 1; i++) {
        if (s[i] == s[i + 1]) {
            isPalindrome[i][i + 1] = true;
        }
    }
    
    // Check for palindromes of length 3 and above
    for (int length = 3; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            if (s[i] == s[j] && isPalindrome[i + 1][j - 1]) {
                isPalindrome[i][j] = true;
            }
        }
    }
    
    // DP to find minimum cuts
    int dp[n];
    for (int i = 0; i < n; i++) {
        dp[i] = INT_MAX;
    }
    
    for (int i = 0; i < n; i++) {
        if (isPalindrome[0][i]) {
            dp[i] = 0;
        } else {
            for (int j = 0; j < i; j++) {
                if (isPalindrome[j + 1][i]) {
                    if (dp[j] + 1 < dp[i]) {
                        dp[i] = dp[j] + 1;
                    }
                }
            }
        }
    }
    
    return dp[n - 1];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop runs n times, inner loop averages n/2 iterations

⚠ Quadratic Growth

Space Complexity

O(n²)

Palindrome table requires n×n space plus DP array of size n

⚠ Quadratic Space

125.0K Views

Medium-High Frequency

~25 min Avg. Time

3.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

1D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler