Maximize Palindrome Length From Subsequences

Maximize Palindrome Length From Subsequences - Problem

Imagine you have two strings word1 and word2, and you want to create the longest possible palindrome by cleverly combining parts of both strings.

Here's how it works:

Pick any non-empty subsequence from word1 (remember, a subsequence maintains the original order but can skip characters)
Pick any non-empty subsequence from word2
Concatenate them as subsequence1 + subsequence2
Check if the result is a palindrome

Your goal is to find the maximum length of such a palindrome. If no palindromes can be formed this way, return 0.

Example: If word1 = "cacb" and word2 = "cbba", you could pick "ca" from word1 and "ac" from word2 to form "caac", which is a palindrome of length 4.

Input & Output

example_1.py — Basic Case

$ Input: word1 = "cacb", word2 = "cbba"

› Output: 5

💡 Note: Choose "cab" from word1 and "ba" from word2 to form "cabba", which is a palindrome with length 5. This is the maximum possible length.

example_2.py — No Common Characters

$ Input: word1 = "ab", word2 = "de"

› Output: 0

💡 Note: No matter which subsequences we choose from each word, we cannot form a palindrome when concatenating them, so the answer is 0.

example_3.py — Single Character Match

$ Input: word1 = "aa", word2 = "bb"

› Output: 0

💡 Note: We need at least one character from each word, but 'a' ≠ 'b', so we cannot form any palindrome by concatenating subsequences from both words.

Constraints

1 ≤ word1.length, word2.length ≤ 1000
word1 and word2 consist of lowercase English letters only
You must choose at least one character from each word
The resulting string must be a valid palindrome

Visualization

Tap to expand

Understanding the Visualization

Survey Available Materials

Examine all the building blocks (characters) available in both cities (word1 and word2)

Plan the Bridge Structure

Use dynamic programming to efficiently plan all possible symmetrical bridge configurations

Ensure Cross-City Construction

Make sure the bridge uses materials from both cities by checking for palindromes that span the boundary

Find the Longest Bridge

Select the configuration that creates the longest possible symmetrical bridge

Key Takeaway

🎯 Key Insight: The secret is to use dynamic programming on the concatenated string while ensuring our palindrome crosses the boundary between the two original words, guaranteeing we use materials from both cities.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 18

The optimal solution uses dynamic programming to find the longest palindromic subsequence that spans across both input strings. The key insight is to concatenate both words and find palindromes that include at least one character from each original word. This approach runs in O(n²) time and O(n²) space, making it much more efficient than the brute force approach while handling all edge cases correctly.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n²)	Use DP on concatenated string to find longest palindromic subsequence crossing boundary

Dynamic Programming (Optimal) — Algorithm Steps

Concatenate word1 and word2 to form a single string
Create a DP table where dp[i][j] represents longest palindromic subsequence in substring from i to j
Fill the DP table using standard longest palindromic subsequence algorithm
Ensure the result includes at least one character from each original word by checking boundary crossing
Use additional DP to track palindromes that span across the word1-word2 boundary

Visualization

Tap to expand

Step-by-Step Walkthrough

Concatenate strings

Combine word1 and word2 into a single string

Build DP table

Fill table with longest palindromic subsequence lengths

Find cross-boundary matches

Look for palindromes spanning both original words

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int longestPalindrome(char* word1, char* word2) {
    int len1 = strlen(word1);
    int len2 = strlen(word2);
    int n = len1 + len2;
    
    char* s = (char*)malloc((n + 1) * sizeof(char));
    strcpy(s, word1);
    strcat(s, word2);
    
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Fill diagonal
    for (int i = 0; i < n; i++) {
        dp[i][i] = 1;
    }
    
    // Fill DP table
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            if (s[i] == s[j]) {
                if (length == 2) {
                    dp[i][j] = 2;
                } else {
                    dp[i][j] = dp[i+1][j-1] + 2;
                }
            } else {
                dp[i][j] = max(dp[i+1][j], dp[i][j-1]);
            }
        }
    }
    
    // Find cross-boundary palindromes
    int maxLen = 0;
    for (int i = 0; i < len1; i++) {
        for (int j = len1; j < n; j++) {
            if (s[i] == s[j]) {
                if (i + 1 <= j - 1) {
                    maxLen = max(maxLen, dp[i+1][j-1] + 2);
                } else {
                    maxLen = max(maxLen, 2);
                }
            }
        }
    }
    
    // Clean up
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    free(s);
    
    return maxLen;
}

int main() {
    char word1[1001], word2[1001];
    scanf("\"%1000[^\"]s", word1);
    scanf("\"%1000[^\"]s", word2);
    printf("%d\n", longestPalindrome(word1, word2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Where n is the total length of both strings combined, due to nested loops filling DP table

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table of size n×n where n is the total length of concatenated string

⚠ Quadratic Space

31.5K Views

Medium-High Frequency

~25 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler