Palindrome Partitioning - Practice Coding Problems

Palindrome Partitioning - Problem

Given a string s, partition s such that every substring of the partition is a palindrome. Return all possible palindrome partitioning of s.

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

Input & Output

Example 1 — Basic Case

$ Input: s = "aab"

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

💡 Note: "a" and "aa" are palindromes, "b" is palindrome. Two valid partitions: split each character separately ["a","a","b"] or group first two ["aa","b"].

Example 2 — All Partitions

$ Input: s = "raceacar"

› Output: [["r","a","c","e","a","c","a","r"],["r","a","c","e","aca","r"],["r","ace","ca","r"],["race","a","car"],["raceacar"]]

💡 Note: Multiple palindromes possible: single chars, "aca", "raceacar" (whole string), etc.

Example 3 — Single Character

$ Input: s = "a"

› Output: [["a"]]

💡 Note: Single character is always a palindrome, only one partition possible.

Constraints

1 ≤ s.length ≤ 16
s contains only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Input

String to be partitioned: "aab"

Process

Find all ways to split into palindromes

Output

All valid palindrome partitions

Key Takeaway

🎯 Key Insight: Use backtracking to build partitions incrementally, only exploring palindromic substrings

Asked in

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

The key insight is to use backtracking to explore all valid partitions while checking palindromes efficiently. The optimal approach precomputes a palindrome DP table for O(1) lookups. Time: O(2ⁿ + n²), Space: O(n²)

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking	O(2ⁿ × n)	O(n)	Build partitions incrementally, only exploring palindromic substrings
Dynamic Programming + Backtracking	O(2ⁿ + n²)	O(n²)	Precompute palindrome lookup table, then use backtracking
Brute Force with Recursion	O(2ⁿ × n²)	O(2ⁿ × n)	Try all possible partitions and check each substring for palindrome

Backtracking — Algorithm Steps

Start from index 0
Try all substrings starting at current position
If substring is palindrome, add to current partition and recurse
Backtrack and try next possibility

Visualization

Tap to expand

Step-by-Step Walkthrough

Check

Test if current substring is palindrome

Recurse

If palindrome, add to partition and continue

Backtrack

Remove last choice and try next option

Code -

solution.c — C

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

bool isPalindrome(char* s, int left, int right) {
    while (left < right) {
        if (s[left] != s[right]) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

void printResult(char*** result, int* sizes, int count) {
    printf("[");
    for (int i = 0; i < count; i++) {
        printf("[");
        for (int j = 0; j < sizes[i]; j++) {
            printf("\"%s\"", result[i][j]);
            if (j < sizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < count - 1) printf(",");
    }
    printf("]\n");
}

int backtrack(char* s, int start, char** current, int currentSize, char*** result, int* sizes, int* resultSize) {
    int len = strlen(s);
    if (start == len) {
        result[*resultSize] = (char**)malloc(currentSize * sizeof(char*));
        sizes[*resultSize] = currentSize;
        for (int i = 0; i < currentSize; i++) {
            result[*resultSize][i] = (char*)malloc((strlen(current[i]) + 1) * sizeof(char));
            strcpy(result[*resultSize][i], current[i]);
        }
        (*resultSize)++;
        return 0;
    }
    
    for (int end = start; end < len; end++) {
        if (isPalindrome(s, start, end)) {
            char* substr = (char*)malloc((end - start + 2) * sizeof(char));
            strncpy(substr, s + start, end - start + 1);
            substr[end - start + 1] = '\0';
            current[currentSize] = substr;
            backtrack(s, end + 1, current, currentSize + 1, result, sizes, resultSize);
            free(substr);
        }
    }
    return 0;
}

int solution(char* s, char**** result, int** sizes) {
    int maxResults = 1000;
    *result = (char***)malloc(maxResults * sizeof(char**));
    *sizes = (int*)malloc(maxResults * sizeof(int));
    
    char** current = (char**)malloc(strlen(s) * sizeof(char*));
    int resultSize = 0;
    
    backtrack(s, 0, current, 0, *result, *sizes, &resultSize);
    
    free(current);
    return resultSize;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char*** result;
    int* sizes;
    int count = solution(s, &result, &sizes);
    
    printResult(result, sizes, count);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

2^n possible partitions, each palindrome check takes O(n) time

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is at most n, plus current partition storage

⚡ Linearithmic Space

87.5K Views

High 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

Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler