Longest Chunked Palindrome Decomposition

Longest Chunked Palindrome Decomposition - Problem

Two Pointers String Dynamic Programming Greedy Rolling Hash Hash Function Hard

You are given a string text. You should split it to k substrings (subtext₁, subtext₂, ..., subtextₖ) such that:

subtextᵢ is a non-empty string.
The concatenation of all the substrings is equal to text (i.e., subtext₁ + subtext₂ + ... + subtextₖ == text).
subtextᵢ == subtextₖ₋ᵢ₊₁ for all valid values of i (i.e., 1 <= i <= k).

Return the largest possible value of k.

Input & Output

Example 1 — Palindromic Chunks

$ Input: text = "ghiabcdefhelloadefghiabcdef"

› Output: 1

💡 Note: No palindromic decomposition is possible for this string. No prefix matches any suffix, so the entire string forms one chunk.

Example 2 — Single Character

$ Input: text = "aa"

› Output: 2

💡 Note: Split into (a)(a) - two matching single character chunks

Example 3 — No Splits

$ Input: text = "abc"

› Output: 1

💡 Note: No way to split into palindromic chunks, so the whole string is one chunk

Constraints

1 ≤ text.length ≤ 1000
text consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is to use a greedy approach: start from both ends and find the shortest matching prefix-suffix pairs. This maximizes the number of chunks since shorter chunks leave more room for additional splits. Best approach uses greedy two pointers with Time: O(n²), Space: O(1).

Common Approaches

✓ Brute Force Recursion

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

For each possible prefix, check if it matches the corresponding suffix, then recursively solve for the remaining middle part. This explores all valid palindromic decompositions.

Greedy Two Pointers

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

Use two pointers starting from both ends. Find the shortest matching prefix and suffix, count them as 2 chunks, then move pointers inward to process the middle part. This greedy approach maximizes the number of chunks.

Memoized Recursion

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

Same recursive approach as brute force but with memoization to cache results for substring ranges. This eliminates redundant computations when the same substring appears multiple times in different decompositions.

Brute Force Recursion — Algorithm Steps

Try each possible prefix length
Check if prefix equals corresponding suffix
Recursively solve for middle part
Return maximum chunks found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Prefix

Test each possible prefix length

Check Match

See if prefix equals corresponding suffix

Recurse

Solve remaining middle part recursively

Code -

solution.c — C

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

int helper(char* s, int start, int end) {
    if (start >= end) return 0;
    
    int maxChunks = 1; // At minimum, whole string is one chunk
    int n = end - start;
    
    // Try all possible prefix lengths
    for (int i = 1; i <= n / 2; i++) {
        // Check if prefix matches suffix
        int match = 1;
        for (int j = 0; j < i; j++) {
            if (s[start + j] != s[end - i + j]) {
                match = 0;
                break;
            }
        }
        
        if (match) {
            // Found matching pair, recurse on middle
            int chunks = 2 + helper(s, start + i, end - i);
            if (chunks > maxChunks) {
                maxChunks = chunks;
            }
        }
    }
    
    return maxChunks;
}

int solution(char* text) {
    return helper(text, 0, strlen(text));
}

int main() {
    char line[1001];
    while (fgets(line, sizeof(line), stdin)) {
        // Remove newline if present
        int len = strlen(line);
        if (len > 0 && line[len-1] == '\n') {
            line[len-1] = '\0';
        }
        
        if (strlen(line) > 0) {
            int result = solution(line);
            printf("%d\n", result);
        }
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each position can start a new chunk, creating exponential splits

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n levels

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~25 min Avg. Time

450 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler