Palindrome Partitioning IV - Practice Coding Problems

Palindrome Partitioning IV - Problem

Given a string s, you need to determine if it's possible to split the string into exactly three non-empty palindromic substrings.

A palindrome is a string that reads the same forwards and backwards, like "racecar" or "aba".

Goal: Return true if the string can be partitioned into exactly 3 palindromic parts, false otherwise.

Example: For string "abccba", we can split it as "a" + "bccb" + "a" - all three parts are palindromes, so return true.

Challenge: You must find exactly three parts - no more, no less!

Input & Output

example_1.py — Basic Valid Partition

$ Input: "abcbdd"

› Output: true

💡 Note: We can split it as "a" + "bcb" + "dd". All three parts are palindromes: "a" is a palindrome, "bcb" is a palindrome, and "dd" is a palindrome.

example_2.py — No Valid Partition

$ Input: "bcbddxy"

› Output: false

💡 Note: No matter how we split this string into exactly three parts, at least one part will not be a palindrome. For example, "b" + "cb" + "ddxy" has "cb" and "ddxy" as non-palindromes.

example_3.py — Edge Case Minimum Length

$ Input: "aaa"

› Output: true

💡 Note: We can split it as "a" + "a" + "a". Each single character is a palindrome, so this is a valid partition into three palindromic substrings.

Constraints

3 ≤ s.length ≤ 2000
s consists of only lowercase English letters
Must partition into exactly three non-empty parts

Visualization

Tap to expand

Understanding the Visualization

Build Recipe Book

First, create a reference book noting which ingredient combinations are 'balanced'

Try Cut Positions

Systematically try different positions to make the first and second cuts

Check Balance

For each partition attempt, quickly look up if all three courses are balanced

Success or Failure

Return true if any valid three-course arrangement is found

Key Takeaway

🎯 Key Insight: By preprocessing which substrings are palindromes, we avoid redundant checks and achieve optimal O(n²) time complexity while trying all possible three-way partitions.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal approach uses dynamic programming to precompute all palindromic substrings in O(n²) time, then tries all possible ways to partition into exactly three parts. The key insight is that precomputing palindromes eliminates redundant checks and provides O(1) lookup time during partitioning.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Partitions)	O(n³)	O(1)	Try every possible way to split into three parts and check if all are palindromes
Precomputed Palindrome Table	O(n²)	O(n²)	First build a table of all palindromic substrings, then try partitions

Brute Force (Try All Partitions) — Algorithm Steps

Use two nested loops to try all possible cut positions
For each partition attempt, extract the three substrings
Check if each substring is a palindrome using a helper function
Return true if any valid partition is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try First Cut

Place first cut at position i, creating first part

Try Second Cut

For each first cut, try all positions j for second cut

Check All Parts

Verify if all three resulting parts are palindromes

Return Result

Return true if any valid partition found

Code -

solution.c — C

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

bool isPalindrome(const char* str, int start, int end) {
    while (start < end) {
        if (str[start] != str[end]) {
            return false;
        }
        start++;
        end--;
    }
    return true;
}

bool checkPalindromes(const char* s) {
    int n = strlen(s);
    // Try all possible ways to split into 3 parts
    for (int i = 1; i < n - 1; i++) {  // First cut position
        for (int j = i + 1; j < n; j++) {  // Second cut position
            if (isPalindrome(s, 0, i-1) && 
                isPalindrome(s, i, j-1) && 
                isPalindrome(s, j, n-1)) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes if present
    s[strcspn(s, "\n")] = '\0';
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s+1, len-2);
        s[len-2] = '\0';
    }
    printf("%s\n", checkPalindromes(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for trying all partitions × O(n) for checking each palindrome

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.5K Views

Medium-High Frequency

~18 min Avg. Time

892 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

Brute Force (Try All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler