Longest Palindrome After Substring Concatenation II

Longest Palindrome After Substring Concatenation II - Problem

Challenge: You are given two strings s and t. Your goal is to create the longest possible palindrome by selecting any substring from s (possibly empty) and any substring from t (possibly empty), then concatenating them in that exact order.

What's a palindrome? A string that reads the same forwards and backwards, like "racecar" or "aba".

Input: Two strings s and t
Output: An integer representing the length of the longest palindrome you can form

Example: If s = "abc" and t = "cba", you could take "ab" from s and "ba" from t to form "abba" (length 4), which is a palindrome!

Input & Output

example_1.py — Basic palindrome formation

$ Input: s = "abc", t = "cba"

› Output: 6

💡 Note: We can take the entire string "abc" from s and "cba" from t to form "abccba", which is a palindrome of length 6. This is the maximum possible length.

example_2.py — Partial substring selection

$ Input: s = "ab", t = "ba"

› Output: 4

💡 Note: We can take "ab" from s and "ba" from t to form "abba", which is a palindrome of length 4. We could also take "a" from s and "a" from t to get "aa" (length 2), but "abba" is longer.

example_3.py — Edge case with empty substrings

$ Input: s = "aa", t = "bb"

› Output: 2

💡 Note: The best we can do is take "aa" from s and empty string from t (or vice versa) to form "aa", which is a palindrome of length 2. Concatenating "aa" + "bb" gives "aabb" which is not a palindrome.

Constraints

0 ≤ s.length, t.length ≤ 1000
s and t consist of lowercase English letters only
At least one of s or t must be non-empty
The concatenated result must be in the form s_substring + t_substring

Visualization

Tap to expand

Understanding the Visualization

Survey Materials

Examine all available substrings from both supplier s and supplier t

Test Combinations

Try different combinations of materials, checking if each forms a symmetrical bridge

Optimize with Memory

Remember previous results to avoid testing the same combinations repeatedly

Find Maximum

Select the combination that creates the longest symmetrical bridge

Key Takeaway

🎯 Key Insight: Just like building a symmetrical bridge, we need to carefully select materials from both suppliers (substrings from s and t) such that when combined, they form a perfect mirror image. The optimal solution uses dynamic programming to efficiently explore all combinations while remembering previous results.

Asked in

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

The optimal approach uses dynamic programming with memoization to efficiently find the longest palindrome. We try all possible substring combinations from both strings, but use memoization to avoid redundant palindrome checks. The key insight is that we can store results of subproblems to achieve O(n²m) time complexity, significantly better than the brute force O(n³m³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Dynamic Programming (Optimal)	O(n²m)	O(nm)	Use advanced DP with memoization to avoid redundant calculations
Dynamic Programming with Two Pointers	O(n²m²)	O(nm)	Use DP to track palindromes and two pointers to check symmetry

Optimized Dynamic Programming (Optimal) — Algorithm Steps

Create memoization table for palindrome results
For each possible center point, try to extend palindrome
Consider both odd and even length palindromes
Use the constraint that result must be s_substring + t_substring
Memoize results to avoid recalculating same subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Memo

Look up if this subproblem was already solved

Calculate if New

Only compute palindrome check if not in memo table

Store Result

Save result in memo table for future lookups

Code -

solution.c — C

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

// Simple hash table for memoization
#define MEMO_SIZE 10000
typedef struct {
    int i, j, k, l;
    int result;
    int used;
} MemoEntry;

MemoEntry memoTable[MEMO_SIZE];

int hashKey(int i, int j, int k, int l) {
    return (i * 1000 + j * 100 + k * 10 + l) % MEMO_SIZE;
}

int getMemo(int i, int j, int k, int l) {
    int hash = hashKey(i, j, k, l);
    if (memoTable[hash].used && 
        memoTable[hash].i == i && memoTable[hash].j == j &&
        memoTable[hash].k == k && memoTable[hash].l == l) {
        return memoTable[hash].result;
    }
    return -1;
}

void setMemo(int i, int j, int k, int l, int result) {
    int hash = hashKey(i, j, k, l);
    memoTable[hash].i = i;
    memoTable[hash].j = j;
    memoTable[hash].k = k;
    memoTable[hash].l = l;
    memoTable[hash].result = result;
    memoTable[hash].used = 1;
}

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

int longestPalindrome(char* s, char* t) {
    int n = strlen(s), m = strlen(t);
    int maxLength = 0;
    char combined[2000];
    
    // Initialize memo table
    memset(memoTable, 0, sizeof(memoTable));
    
    for (int i = 0; i <= n; i++) {
        for (int j = i; j <= n; j++) {
            for (int k = 0; k <= m; k++) {
                for (int l = k; l <= m; l++) {
                    int memoResult = getMemo(i, j, k, l);
                    if (memoResult != -1) {
                        if (memoResult > maxLength) {
                            maxLength = memoResult;
                        }
                        continue;
                    }
                    
                    // Build combined string
                    int pos = 0;
                    for (int x = i; x < j; x++) {
                        combined[pos++] = s[x];
                    }
                    for (int y = k; y < l; y++) {
                        combined[pos++] = t[y];
                    }
                    combined[pos] = '\0';
                    
                    int result = 0;
                    if (pos > 0 && isPalindrome(combined)) {
                        result = pos;
                    }
                    
                    setMemo(i, j, k, l, result);
                    if (result > maxLength) {
                        maxLength = result;
                    }
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[] = "abc";
    char t[] = "cba";
    printf("%d\n", longestPalindrome(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²m)

For each position in s (O(n²) substrings) and each position in t (O(m)), with memoization

⚠ Quadratic Growth

Space Complexity

O(nm)

Memoization table storing results for each (s_pos, t_pos) combination

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Optimized Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler