Longest Palindrome After Substring Concatenation I

Longest Palindrome After Substring Concatenation I - Problem

You're a word puzzle master creating the longest possible palindrome by combining pieces from two different strings!

Given two strings s and t, you can pick any substring (including empty ones) from each string and concatenate them to form: substring_from_s + substring_from_t.

Goal: Find the length of the longest palindrome you can create this way.

Example: If s = "abc" and t = "cba", you could take "ab" from s and "a" from t to make "aba" (length 3), or take "a" from s and "ba" from t to make "aba" again!

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: We can take empty string from s and "d" from t to form "d" (length 1), or "a" from s and empty string from t to form "a" (length 1). Both are palindromes of length 1.

example_2.py — Perfect Match

$ 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. This is the maximum possible.

example_3.py — Partial Overlap

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

› Output: 3

💡 Note: We can take "a" from s and "ba" from t to form "aba" (length 3), or "ab" from s and "a" from t to form "aba" (length 3). Both give us palindromes of length 3.

Visualization

Tap to expand

Understanding the Visualization

Enumerate Substrings

Generate all possible substring combinations from both input strings

Virtual Concatenation

Conceptually combine substrings without creating new strings

Palindrome Verification

Use two pointers to check if the combination forms a palindrome

Track Maximum

Keep track of the longest palindrome found during enumeration

Key Takeaway

🎯 Key Insight: We systematically enumerate all possible substring combinations and use efficient two-pointer palindrome checking to find the maximum length palindrome without creating temporary strings.

Time & Space Complexity

Time Complexity

⏱️

O(n²m²(n+m))

Same enumeration complexity but with optimized palindrome checking

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses constant extra space for pointers, no string concatenation

✓ Linear Space

Constraints

1 ≤ s.length, t.length ≤ 1000
s and t consist of lowercase English letters only
Substrings can be empty (length 0)
The concatenation order is always s_substring + t_substring

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses enumeration with optimized palindrome checking. We systematically try all possible substring combinations from both strings and use two pointers technique to efficiently verify palindromes without creating temporary strings. While the time complexity remains O(n²m²(n+m)), the space complexity improves to O(1) and constant factors are better.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Enumeration with Two Pointers	O(n²m²(n+m))	O(1)	Use two pointers to efficiently check palindromes while enumerating substrings
Brute Force (All Substring Combinations)	O(n²m²(n+m))	O(n+m)	Generate all possible substring pairs and check each concatenation for palindrome

Optimized Enumeration with Two Pointers — Algorithm Steps

Generate all possible substring ranges from both strings
For each combination, use two pointers to check palindrome property without creating new strings
Start pointers from both ends of the concatenated virtual string
Move pointers inward, comparing characters until they meet or find mismatch
Track the maximum palindrome length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Virtual Concatenation

Consider substring combination without actually creating new string

Two Pointers Setup

Place pointers at start and end of virtual combined string

Compare & Move

Compare characters at pointer positions, move inward

Palindrome Decision

If all comparisons match, it's a palindrome

Code -

solution.c — C

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

int isPalindromeRange(char* s1, int start1, int end1, char* s2, int start2, int end2) {
    int totalLen = (end1 - start1) + (end2 - start2);
    if (totalLen == 0) return 1;
    
    for (int i = 0; i < totalLen / 2; i++) {
        // Get left character
        char leftChar;
        if (i < (end1 - start1)) {
            leftChar = s1[start1 + i];
        } else {
            leftChar = s2[start2 + i - (end1 - start1)];
        }
        
        // Get right character
        int rightIdx = totalLen - 1 - i;
        char rightChar;
        if (rightIdx < (end1 - start1)) {
            rightChar = s1[start1 + rightIdx];
        } else {
            rightChar = s2[start2 + rightIdx - (end1 - start1)];
        }
        
        if (leftChar != rightChar) {
            return 0;
        }
    }
    return 1;
}

int longestPalindrome(char* s, char* t) {
    int maxLength = 0;
    int n = strlen(s), m = strlen(t);
    
    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++) {
                    if (isPalindromeRange(s, i, j, t, k, l)) {
                        int currentLength = (j - i) + (l - k);
                        if (currentLength > maxLength) {
                            maxLength = currentLength;
                        }
                    }
                }
            }
        }
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²m²(n+m))

Same enumeration complexity but with optimized palindrome checking

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses constant extra space for pointers, no string concatenation

✓ Linear Space

Constraints

1 ≤ s.length, t.length ≤ 1000
s and t consist of lowercase English letters only
Substrings can be empty (length 0)
The concatenation order is always s_substring + t_substring

28.4K Views

Medium Frequency

~25 min Avg. Time

886 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

Optimized Enumeration with Two Pointers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler