Maximize Palindrome Length From Subsequences

Maximize Palindrome Length From Subsequences - Problem

You are given two strings, word1 and word2. You want to construct a string in the following manner:

Choose some non-empty subsequence subsequence1 from word1.
Choose some non-empty subsequence subsequence2 from word2.
Concatenate the subsequences: subsequence1 + subsequence2, to make the string.

Return the length of the longest palindrome that can be constructed in the described manner. If no palindromes can be constructed, return 0.

A subsequence of a string s is a string that can be made by deleting some (possibly none) characters from s without changing the order of the remaining characters.

A palindrome is a string that reads the same forward as well as backward.

Input & Output

Example 1 — Basic Case

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

› Output: 5

💡 Note: Choose subsequence "ab" from word1 and "cba" from word2 to form "abcba" which is a palindrome of length 5

Example 2 — Simple Match

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

› Output: 3

💡 Note: Choose "ab" from word1 and "a" from word2 to get "aba", or "a" from word1 and "ba" from word2 to get "aba"

Example 3 — No Valid Palindrome

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

› Output: 0

💡 Note: Cannot form a palindrome that uses characters from both strings - "aab", "abb", "aabb" are not palindromes

Constraints

1 ≤ word1.length, word2.length ≤ 1000
word1 and word2 consist of lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to combine both strings and use dynamic programming to find the longest palindromic subsequence while ensuring characters from both original strings are included. Best approach uses memoized recursion with constraint tracking. Time: O((m+n)²), Space: O((m+n)²)

Common Approaches

✓ Two Pointers

⏱️ Time: N/A Space: N/A

Brute Force - Try All Subsequences

⏱️ Time: O(2^(m+n) × (m+n)) Space: O(2^(m+n) × (m+n))

Generate every possible non-empty subsequence from word1 and word2, concatenate them, and check if the result is a palindrome. Keep track of the maximum length found.

Dynamic Programming - Extended LPS

⏱️ Time: O((m+n)²) Space: O((m+n)²)

Concatenate both strings with a separator, then use dynamic programming to find the longest palindromic subsequence that includes at least one character from each original string.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char subsequences1[1024][32];
char subsequences2[1024][32];
int subseqs1_count = 0;
int subseqs2_count = 0;

void generate_subsequences(const char* s, char subseqs[][32], int* count) {
    int n = strlen(s);
    *count = 0;
    for (int mask = 1; mask < (1 << n); mask++) {
        int idx = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subseqs[*count][idx++] = s[i];
            }
        }
        subseqs[*count][idx] = '\0';
        (*count)++;
    }
}

int is_palindrome(const char* s) {
    int len = strlen(s);
    int left = 0, right = len - 1;
    while (left < right) {
        if (s[left] != s[right]) return 0;
        left++;
        right--;
    }
    return 1;
}

int solution(const char* word1, const char* word2) {
    generate_subsequences(word1, subsequences1, &subseqs1_count);
    generate_subsequences(word2, subsequences2, &subseqs2_count);
    
    int max_len = 0;
    for (int i = 0; i < subseqs1_count; i++) {
        for (int j = 0; j < subseqs2_count; j++) {
            char combined[64];
            strcpy(combined, subsequences1[i]);
            strcat(combined, subsequences2[j]);
            
            if (is_palindrome(combined)) {
                int len = strlen(combined);
                if (len > max_len) {
                    max_len = len;
                }
            }
        }
    }
    
    return max_len;
}

int main() {
    char word1[32], word2[32];
    
    fgets(word1, sizeof(word1), stdin);
    fgets(word2, sizeof(word2), stdin);
    
    // Remove newline characters
    word1[strcspn(word1, "\n")] = '\0';
    word2[strcspn(word2, "\n")] = '\0';
    
    printf("%d\n", solution(word1, word2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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