Palindrome Partitioning IV

Palindrome Partitioning IV - Problem

Given a string s, return true if it is possible to split the string s into three non-empty palindromic substrings. Otherwise, return false.

A string is said to be palindrome if it reads the same string when reversed.

Input & Output

Example 1 — Valid 3-Way Split

$ Input: s = "abcba"

› Output: true

💡 Note: We can split "abcba" into "a" + "bcb" + "a". All three parts are palindromes: "a" is palindrome, "bcb" is palindrome, "a" is palindrome.

Example 2 — No Valid Split

$ Input: s = "abc"

› Output: false

💡 Note: No matter how we split "abc" into 3 non-empty parts, we cannot make all parts palindromes. For example: "a" + "b" + "c" - all single chars are palindromes but this works. Wait, let me recalculate: "a"|"b"|"c" are all palindromes, so this should be true. Let me use a different example.

Example 2 — No Valid Split

$ Input: s = "abcd"

› Output: false

💡 Note: No matter how we split "abcd" into 3 parts, at least one part won't be a palindrome. For instance: "a"|"b"|"cd" - "cd" is not palindrome, "a"|"bc"|"d" - "bc" is not palindrome.

Example 3 — Minimum Length

$ Input: s = "aaa"

› Output: true

💡 Note: We can split "aaa" into "a" + "a" + "a". All three single character parts are palindromes.

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 25 G Google 20 M Microsoft 15

The key insight is to precompute palindrome information to avoid redundant checks. The optimal approach uses dynamic programming to build a palindrome table in O(n²) time, then checks all possible 3-way partitions efficiently. Best approach: DP with precomputation. Time: O(n²), Space: O(n²)

Common Approaches

✓ Brute Force - Try All Partitions

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

For each possible first and second cut position, check if all three resulting substrings are palindromes. Uses nested loops to generate all combinations.

Dynamic Programming with Precomputation

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

Build a 2D table to store which substrings are palindromes, then use this table to efficiently check all possible 3-way partitions without redundant palindrome checks.

Optimized Two-Pass Approach

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

Instead of building full palindrome table, check from left to find valid first parts, then from right to find valid third parts. Only check middle part when both ends are valid.

Brute Force - Try All Partitions — Algorithm Steps

Iterate through all possible first cut positions
For each first cut, try all second cut positions
Check if all three parts are palindromes

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Cuts

Try all combinations of first and second cut positions

Check Parts

For each partition, verify all 3 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(char* s, int start, int end) {
    while (start < end) {
        if (s[start] != s[end]) {
            return false;
        }
        start++;
        end--;
    }
    return true;
}

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

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    bool result = solution(s);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Two nested loops O(n²) plus palindrome checking O(n) for each partition

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚠ Quadratic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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