Longest Palindrome After Substring Concatenation I

Longest Palindrome After Substring Concatenation I - Problem

You are given two strings, s and t. You can create a new string by selecting a substring from s (possibly empty) and a substring from t (possibly empty), then concatenating them in order.

Return the length of the longest palindrome that can be formed this way.

A palindrome is a string that reads the same forwards and backwards.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Select substring "a" from s and "ba" from t to form "aba", which is a palindrome of length 3. This is the maximum possible.

Example 2 — Single Character

$ Input: s = "x", t = "y"

› Output: 1

💡 Note: Best we can do is select "x" from s (and empty from t) or "y" from t (and empty from s), giving palindromes of length 1.

Example 3 — Identical Strings

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

› Output: 3

💡 Note: We can select "ab" from s and "a" from t to form "aba", which is a palindrome of length 3. This is the maximum possible length.

Constraints

0 ≤ s.length, t.length ≤ 1000
s and t consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Meta 15 M Microsoft 12

The key insight is to systematically try all possible substring combinations from both strings and check for palindromes. The brute force approach works by generating all substrings from s and t, concatenating them, and checking if each result is a palindrome. Best approach is brute force enumeration with Time: O(n²m²(n+m)), Space: O(n+m).

Common Approaches

✓ Math

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

Brute Force Enumeration

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

Generate all possible substrings from s and t, concatenate them in all combinations, and check each concatenated string to see if it's a palindrome. Keep track of the maximum length found.

Expand Around Centers

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

Instead of generating all combinations, focus on potential palindrome centers. For each possible way to split the combined string into s-part and t-part, expand around that center to find the longest palindrome.

Two Pointers with Boundary Tracking

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

For each possible split between s and t portions, use two pointers approach to check if the resulting concatenation forms a palindrome. Track boundaries between s and t portions to ensure valid substring selection.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

int solution(const char* s, const char* t) {
    int max_length = 0;
    int n = strlen(s), m = strlen(t);
    char combined[2001]; // Maximum possible length
    
    // Try each possible split point between s and t portions
    for (int s_len = 0; s_len <= n; s_len++) {
        for (int t_len = 0; t_len <= m; t_len++) {
            // Try different starting positions in s and t
            for (int s_start = 0; s_start <= n - s_len; s_start++) {
                for (int t_start = 0; t_start <= m - t_len; t_start++) {
                    // Build the combined string
                    int pos = 0;
                    for (int i = s_start; i < s_start + s_len; i++) {
                        combined[pos++] = s[i];
                    }
                    for (int i = t_start; i < t_start + t_len; i++) {
                        combined[pos++] = t[i];
                    }
                    combined[pos] = '\0';
                    
                    // Check if it's a palindrome
                    if (isPalindrome(combined, pos)) {
                        if (pos > max_length) {
                            max_length = pos;
                        }
                    }
                }
            }
        }
    }
    
    return max_length;
}

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

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

30.3K Views

Medium Frequency

~25 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