Palindrome Partitioning - Practice Coding Problems

Palindrome Partitioning - Problem

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

You need to return all possible palindrome partitionings of the string. Think of it as finding every way to "cut" the string into pieces where each piece is a palindrome.

Example: For string "aab":
• One partitioning: ["a", "a", "b"] - each single character is a palindrome
• Another partitioning: ["aa", "b"] - "aa" is a palindrome, "b" is a palindrome

The challenge is to find all such valid partitionings efficiently!

Input & Output

example_1.py — Basic Case

$ Input: s = "aab"

› Output: [["a","a","b"],["aa","b"]]

💡 Note: There are two ways to partition "aab": split each character individually ["a","a","b"] where each is a palindrome, or group the first two characters ["aa","b"] since "aa" is a palindrome.

example_2.py — Single Character

$ Input: s = "raceacar"

› Output: [["r","a","c","e","a","c","a","r"],["r","a","c","e","aca","r"],["r","a","cec","a","r"],["r","aca","c","a","r"],["raceacar"]]

💡 Note: Multiple valid partitions exist: all single characters, grouping "aca", grouping "cec", or the entire string "raceacar" which is itself a palindrome.

example_3.py — Edge Case

$ Input: s = "a"

› Output: [["a"]]

💡 Note: A single character string has only one partition - the character itself, which is always a palindrome.

Visualization

Tap to expand

Understanding the Visualization

Preprocessing Phase

Build a lookup table of all palindromic substrings, like creating a dictionary of valid words

Exploration Phase

Use backtracking to try different 'cuts' in the string, consulting our palindrome dictionary

Decision Making

At each position, decide whether to make a cut or extend the current substring

Backtrack and Continue

If we hit a dead end (non-palindrome), backtrack and try the next possibility

Key Takeaway

🎯 Key Insight: The combination of DP preprocessing with backtracking gives us the best of both worlds - we avoid redundant computation while systematically exploring all valid partitions. The preprocessing step is crucial for efficiency when the same substrings are checked multiple times.

Time & Space Complexity

Time Complexity

⏱️

O(N² + 2^N)

O(N²) for building DP table to check all substrings, plus O(2^N) for generating all possible partitions

✓ Linear Growth

Space Complexity

O(N²)

O(N²) for the DP table storing palindrome information, plus O(N) recursion stack

✓ Linear Space

Constraints

1 ≤ s.length ≤ 16
s contains only lowercase English letters
Note: The relatively small constraint on length makes backtracking feasible

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses dynamic programming preprocessing combined with backtracking. First, build a 2D DP table to store palindrome information for all substrings in O(N²) time. Then use backtracking to generate all valid partitions with O(1) palindrome lookups. This eliminates redundant palindrome checks while systematically exploring all possible partitions.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Backtracking with DP	O(N² + 2^N)	O(N²)	Use dynamic programming to precompute palindrome checks, then apply backtracking
Brute Force Backtracking	O(N × 2^N)	O(N)	Generate all possible partitions and filter valid palindrome partitions

Optimized Backtracking with DP — Algorithm Steps

Create a 2D DP table to store palindrome information
Fill the DP table: single characters are palindromes
For length 2: check if both characters are same
For length > 2: check if first and last chars match and inner substring is palindrome
Use backtracking with O(1) palindrome lookups from DP table
Generate all valid partitions using the preprocessed data

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP table

Create 2D boolean array for substring palindrome status

Fill diagonal

All single characters are palindromes

Length 2 substrings

Check if adjacent characters are equal

Longer substrings

Use previously computed results to build larger palindromes

Code -

solution.c — C

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

#define MAX_LEN 16
#define MAX_RESULTS 1000

char results[MAX_RESULTS][MAX_LEN][MAX_LEN][MAX_LEN];
int result_sizes[MAX_RESULTS];
int result_count = 0;
bool dp[MAX_LEN][MAX_LEN];

void backtrack(char* s, int n, int start, char path[][MAX_LEN], int path_size) {
    if (start == n) {
        for (int i = 0; i < path_size; i++) {
            strcpy(results[result_count][i], path[i]);
        }
        result_sizes[result_count] = path_size;
        result_count++;
        return;
    }
    
    for (int end = start; end < n; end++) {
        if (dp[start][end]) {
            strncpy(path[path_size], s + start, end - start + 1);
            path[path_size][end - start + 1] = '\0';
            backtrack(s, n, end + 1, path, path_size + 1);
        }
    }
}

void partition(char* s) {
    int n = strlen(s);
    result_count = 0;
    
    // Initialize DP table
    memset(dp, false, sizeof(dp));
    
    // Every single character is a palindrome
    for (int i = 0; i < n; i++) {
        dp[i][i] = true;
    }
    
    // Check for palindromes of length 2
    for (int i = 0; i < n - 1; i++) {
        dp[i][i + 1] = (s[i] == s[i + 1]);
    }
    
    // Check for palindromes of length 3 and more
    for (int length = 3; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            dp[i][j] = (s[i] == s[j]) && dp[i + 1][j - 1];
        }
    }
    
    char path[MAX_LEN][MAX_LEN];
    backtrack(s, n, 0, path, 0);
}

int main() {
    char s[MAX_LEN];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes if present
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    partition(s);
    
    printf("[");
    for (int i = 0; i < result_count; i++) {
        printf("[");
        for (int j = 0; j < result_sizes[i]; j++) {
            printf("\"%s\"", results[i][j]);
            if (j < result_sizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < result_count - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N² + 2^N)

O(N²) for building DP table to check all substrings, plus O(2^N) for generating all possible partitions

✓ Linear Growth

Space Complexity

O(N²)

O(N²) for the DP table storing palindrome information, plus O(N) recursion stack

✓ Linear Space

Constraints

1 ≤ s.length ≤ 16
s contains only lowercase English letters
Note: The relatively small constraint on length makes backtracking feasible

89.0K Views

High Frequency

~25 min Avg. Time

2.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Backtracking with DP — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler