Maximum Product of the Length of Two Palindromic Subsequences

Maximum Product of the Length of Two Palindromic Subsequences - Problem

Imagine you have a string of characters and need to find two separate palindromic subsequences that don't share any characters at the same positions. Your goal is to maximize the product of their lengths.

Given a string s, you need to:

Find two disjoint palindromic subsequences (they cannot pick characters from the same index)
Maximize the product of their lengths
Return this maximum possible product

Key Concepts:

A subsequence maintains the original order but can skip characters
A palindrome reads the same forwards and backwards
Disjoint means no shared character positions between the two subsequences

Example: For string "leetcodecom", you might pick subsequence "ete" from positions [1,2,7] and "coc" from positions [3,8,10], giving a product of 3 × 3 = 9.

Input & Output

example_1.py — Basic Case

$ Input: s = "leetcodecom"

› Output: 9

💡 Note: We can select palindromic subsequence "ete" from positions [1,2,7] with length 3, and palindromic subsequence "coco" from positions [3,8,9,10] with length 4. Since these don't share any positions, the product is 3 × 3 = 9.

example_2.py — Short String

$ Input: s = "bb"

› Output: 1

💡 Note: The only way to create two disjoint palindromic subsequences is to take one 'b' for each subsequence. Each subsequence has length 1, so the product is 1 × 1 = 1.

example_3.py — Complex Case

$ Input: s = "accbcaxxcxx"

› Output: 25

💡 Note: We can form palindromic subsequence "accca" from positions [0,1,2,5,6] with length 5, and palindromic subsequence "cxcxc" from positions [3,7,8,9,10] with length 5. The product is 5 × 5 = 25.

Visualization

Tap to expand

Understanding the Visualization

Choose Flowers

For each flower position, decide: Garden 1, Garden 2, or neither

Check Symmetry

Ensure each garden arrangement is palindromic (symmetric)

Calculate Score

Multiply the sizes of both gardens to get the total score

Find Maximum

Try all possible arrangements and select the one with highest score

Key Takeaway

🎯 Key Insight: Bitmask representation allows efficient checking of disjoint subsequences and systematic exploration of all valid partitions with memoization for optimization.

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

O(2^n) to generate subsequences, O(n) to check palindrome, O(2^(2n)) to check all pairs

✓ Linear Growth

Space Complexity

O(2^n)

Store all palindromic subsequences with their bitmasks

⚠ Quadratic Space

Constraints

2 ≤ s.length ≤ 12
s consists of lowercase English letters only
The two palindromic subsequences must be disjoint (no shared character positions)

Asked in

G Google 45 ⊞ Microsoft 32 a Amazon 28 f Meta 15

The optimal approach uses bitmask dynamic programming with backtracking and memoization. We represent each possible way to partition characters between two subsequences using bitmasks, then recursively explore all valid combinations while caching results to avoid redundant computations. The key insight is that two subsequences are disjoint if their bitmasks have no overlapping bits (bitwise AND equals zero).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(4^n)	O(2^n)	Generate all possible subsequences, check palindromes, find disjoint pairs
Optimized Bitmask with Memoization	O(3^n)	O(3^n)	Use dynamic programming with memoization to avoid redundant palindrome checks

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all 2^n possible subsequences using bit manipulation
For each subsequence, check if it's a palindrome
Store valid palindromic subsequences with their position bitmasks
Try all pairs of palindromic subsequences
Check if pairs are disjoint (no shared positions)
Track maximum product of lengths

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Bitmasks

Each bit represents whether to include character at that position

Create Subsequences

Build subsequence string based on bitmask

Check Palindrome

Verify if subsequence reads same forwards and backwards

Find Disjoint Pairs

Check all pairs where bitmasks have no common bits set

Code -

solution.c — C

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

int isPalindrome(char* str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        if (str[i] != str[len - 1 - i]) {
            return 0;
        }
    }
    return 1;
}

int maxProduct(char* s) {
    int n = strlen(s);
    int palindromes[1000][2]; // [length, mask]
    int palindrome_count = 0;
    
    // Generate all subsequences using bitmask
    for (int mask = 1; mask < (1 << n); mask++) {
        char subseq[20] = {0};
        int idx = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subseq[idx++] = s[i];
            }
        }
        
        // Check if palindrome
        if (isPalindrome(subseq)) {
            palindromes[palindrome_count][0] = strlen(subseq);
            palindromes[palindrome_count][1] = mask;
            palindrome_count++;
        }
    }
    
    int max_product = 0;
    // Check all pairs of palindromes
    for (int i = 0; i < palindrome_count; i++) {
        for (int j = i + 1; j < palindrome_count; j++) {
            int len1 = palindromes[i][0];
            int mask1 = palindromes[i][1];
            int len2 = palindromes[j][0];
            int mask2 = palindromes[j][1];
            
            // Check if disjoint
            if ((mask1 & mask2) == 0) {
                int product = len1 * len2;
                if (product > max_product) {
                    max_product = product;
                }
            }
        }
    }
    
    return max_product;
}

int main() {
    char input[20];
    scanf("%s", input);
    // Remove quotes if present
    if (input[0] == '"') {
        memmove(input, input + 1, strlen(input));
        input[strlen(input) - 1] = '\0';
    }
    printf("%d\n", maxProduct(input));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

O(2^n) to generate subsequences, O(n) to check palindrome, O(2^(2n)) to check all pairs

✓ Linear Growth

Space Complexity

O(2^n)

Store all palindromic subsequences with their bitmasks

⚠ Quadratic Space

Constraints

2 ≤ s.length ≤ 12
s consists of lowercase English letters only
The two palindromic subsequences must be disjoint (no shared character positions)

18.4K 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

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler