Longest Chunked Palindrome Decomposition - Practice Coding Problems

Longest Chunked Palindrome Decomposition - Problem

Two Pointers String Dynamic Programming Greedy Rolling Hash Hash Function Hard

The Longest Chunked Palindrome Decomposition is a fascinating string manipulation challenge that tests your ability to find patterns and optimize substring matching.

Given a string text, your task is to split it into k substrings such that they form a chunked palindrome. A chunked palindrome means that the first chunk equals the last chunk, the second chunk equals the second-to-last chunk, and so on.

Requirements:

Each substring must be non-empty
All substrings concatenated must equal the original text
The i-th substring must equal the (k-i+1)-th substring

Your goal is to find the maximum possible value of k - meaning you want to create as many chunks as possible while maintaining the palindromic property.

Example: For "ghiabcdefhelloadamhelloabcdefghi", one optimal decomposition could be ["ghi", "abcdef", "hello", "adam", "hello", "abcdef", "ghi"] with k = 7.

Input & Output

example_1.py — Python

$ Input: text = "ghiabcdefhelloadamhelloabcdefghi"

› Output: 7

💡 Note: One optimal decomposition is ["ghi", "abcdef", "hello", "adam", "hello", "abcdef", "ghi"] where pairs (1,7), (2,6), (3,5) match and middle element is "adam".

example_2.py — Python

$ Input: text = "merchant"

› Output: 1

💡 Note: No way to split "merchant" into matching chunks, so the entire string forms one chunk.

example_3.py — Python

$ Input: text = "antaprezatepzapreanta"

› Output: 11

💡 Note: Optimal decomposition: ["a", "n", "t", "a", "p", "re", "z", "re", "p", "a", "t", "a", "n", "t", "a"] but actually ["a", "nt", "a", "pre", "za", "t", "e", "p", "za", "pre", "a", "nt", "a"] gives 11 chunks.

Visualization

Tap to expand

Understanding the Visualization

Identify Matching Ends

Look for the shortest possible matching prefix and suffix

Peel Off Matches

Remove matched chunks and count them as 2 chunks

Repeat on Remainder

Apply the same process recursively to the remaining middle portion

Handle Final Chunk

When no more matches are possible, the remainder forms one final chunk

Key Takeaway

🎯 Key Insight: The greedy strategy works because shorter matching chunks always allow for more total chunks than longer ones, leading to the optimal decomposition.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might compare O(n) different lengths, each taking O(n) time for string comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for pointers and counters, no additional data structures

✓ Linear Space

Constraints

1 ≤ text.length ≤ 1000
text consists only of lowercase English letters
The string is guaranteed to be non-empty

Asked in

G Google 24 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a greedy approach that recursively finds the shortest matching prefix-suffix pairs. The key insight is that taking shorter matching pairs first always maximizes the total number of chunks. This approach runs in O(n²) time with O(1) extra space, making it both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with String Comparison	O(n²)	O(1)	Greedily match the shortest possible chunks from both ends

Greedy with String Comparison — Algorithm Steps

Initialize left and right pointers at string boundaries
Try progressively longer prefixes and suffixes
When we find a match, increment chunk count by 2
Move pointers inward and repeat the process
If pointers meet with remaining characters, add 1 more chunk
Return total chunk count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Start with full string, look for shortest matching prefix-suffix

First Match

Find shortest matching pair, count as 2 chunks

Recurse on Middle

Apply same process to remaining middle portion

Continue Until Done

Repeat until no more matches possible

Code -

solution.c — C

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

int solve(char* s, int start, int end) {
    if (start > end) return 0;
    
    int len = end - start + 1;
    // Try all possible matching prefix-suffix pairs
    for (int i = 1; i <= len / 2; i++) {
        int match = 1;
        for (int j = 0; j < i; j++) {
            if (s[start + j] != s[end - i + 1 + j]) {
                match = 0;
                break;
            }
        }
        if (match) {
            // Found matching pair, recursively solve middle
            return 2 + solve(s, start + i, end - i);
        }
    }
    
    // No matching pairs found, middle is one chunk
    return 1;
}

int longestDecomposition(char* text) {
    return solve(text, 0, strlen(text) - 1);
}

int main() {
    char text[1001];
    scanf("%s", text);
    int len = strlen(text);
    if (text[0] == '"' && text[len-1] == '"') {
        text[len-1] = '\0';
        memmove(text, text+1, len-1);
    }
    printf("%d\n", longestDecomposition(text));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might compare O(n) different lengths, each taking O(n) time for string comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for pointers and counters, no additional data structures

✓ Linear Space

Constraints

1 ≤ text.length ≤ 1000
text consists only of lowercase English letters
The string is guaranteed to be non-empty

28.5K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy with String Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler