Maximum Product of the Length of Two Palindromic Substrings

Maximum Product of the Length of Two Palindromic Substrings - Problem

Given a string s, you need to find two non-overlapping palindromic substrings of odd length such that the product of their lengths is maximized.

A palindrome reads the same forwards and backwards (like "aba", "racecar"). The substrings must be non-intersecting, meaning the first palindrome must end before the second one begins.

Goal: Find indices i, j, k, l where 0 ≤ i ≤ j < k ≤ l < s.length such that:

Both s[i...j] and s[k...l] are palindromes
Both have odd lengths
Their length product (j-i+1) × (l-k+1) is maximized

Example: In "ababbb", we could choose palindromes "aba" (length 3) and "bbb" (length 3) for a product of 9.

Input & Output

example_1.py — Basic case with clear palindromes

$ Input: s = "ababbb"

› Output: 9

💡 Note: We can choose palindromes "aba" (indices 0-2, length 3) and "bbb" (indices 3-5, length 3). The product is 3 × 3 = 9.

example_2.py — Overlapping vs non-overlapping choice

$ Input: s = "zaaaxbbby"

› Output: 9

💡 Note: We can choose "aaa" (indices 1-3, length 3) and "bbb" (indices 5-7, length 3). Even though "zaaaxbbby" contains longer individual palindromes, we need non-overlapping ones.

example_3.py — Single character palindromes

$ Input: s = "abcdef"

› Output: 1

💡 Note: No multi-character palindromes exist, so we choose two single characters (each of length 1). The product is 1 × 1 = 1.

Visualization

Tap to expand

Understanding the Visualization

Identify All Palindromes

Use efficient algorithms to find all palindromic substrings of odd length

Try Split Points

For each position, consider it as a boundary between the two palindromes

Find Best Left Palindrome

In the left partition, find the longest odd-length palindrome

Find Best Right Palindrome

In the right partition, find the longest odd-length palindrome

Calculate Product

Multiply the lengths and track the maximum product across all splits

Key Takeaway

🎯 Key Insight: The problem becomes manageable when we realize we can try every possible split point and use efficient palindrome detection algorithms to find the best palindromes on each side of the split.

Time & Space Complexity

Time Complexity

⏱️

O(n^5)

O(n^2) split points × O(n^2) substring pairs × O(n) palindrome verification

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ s.length ≤ 10⁵
s consists only of lowercase English letters
Both palindromic substrings must have odd length
The substrings must be non-intersecting (first ends before second begins)

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

The optimal approach uses Manacher's algorithm to find all palindromes in O(n) time, then applies dynamic programming to precompute the longest palindromes ending at or starting from each position. Finally, it tries all possible split points to find the maximum product in O(n) time, achieving overall O(n) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n^5)	O(1)	Check every possible pair of non-overlapping substrings and verify palindromes
Optimized Brute Force with Expand Around Centers	O(n^3)	O(1)	Use expand-around-centers to find palindromes more efficiently

Brute Force (Check All Pairs) — Algorithm Steps

For each possible split point k (where first palindrome ends before k)
Find all odd-length palindromic substrings in s[0...k-1]
Find all odd-length palindromic substrings in s[k...n-1]
Calculate product of lengths for each valid pair
Return the maximum product found

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Split Point

Try each position as a boundary between two palindromes

Check Left Side

Find all odd-length palindromes in the left partition

Check Right Side

Find all odd-length palindromes in the right partition

Calculate Product

Multiply the longest lengths from each side

Code -

solution.c — C

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

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

int longestPalindromes(const char* s) {
    int n = strlen(s);
    int maxProduct = 0;
    
    for (int split = 1; split < n; split++) {
        int leftMax = 0, rightMax = 0;
        
        // Find longest odd palindrome in left part
        for (int i = 0; i < split; i++) {
            for (int j = i; j < split; j++) {
                if ((j - i + 1) % 2 == 1 && isPalindrome(s, i, j)) {
                    int len = j - i + 1;
                    if (len > leftMax) leftMax = len;
                }
            }
        }
        
        // Find longest odd palindrome in right part
        for (int i = split; i < n; i++) {
            for (int j = i; j < n; j++) {
                if ((j - i + 1) % 2 == 1 && isPalindrome(s, i, j)) {
                    int len = j - i + 1;
                    if (len > rightMax) rightMax = len;
                }
            }
        }
        
        int product = leftMax * rightMax;
        if (product > maxProduct) maxProduct = product;
    }
    
    return maxProduct;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        len = strlen(s);
        if (s[len-1] == '"') s[len-1] = '\0';
    }
    
    printf("%d\n", longestPalindromes(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^5)

O(n^2) split points × O(n^2) substring pairs × O(n) palindrome verification

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ s.length ≤ 10⁵
s consists only of lowercase English letters
Both palindromic substrings must have odd length
The substrings must be non-intersecting (first ends before second begins)

52.4K Views

Medium-High Frequency

~25 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler