Longest Palindrome by Concatenating Two Letter Words

Longest Palindrome by Concatenating Two Letter Words - Problem

Imagine you have a collection of two-letter word tiles and you want to create the longest possible palindrome by arranging them strategically!

You are given an array of strings words where each string consists of exactly two lowercase English letters. Your goal is to select some of these words and concatenate them in any order to form the longest possible palindrome.

Key Rules:

Each word can be used at most once
You can arrange the selected words in any order
The final string must read the same forwards and backwards

Example: Given ["lc","cl","gg"], you can create "lcggcl" which reads the same forwards and backwards, giving a length of 6.

Return the length of the longest palindrome you can create, or 0 if impossible.

Input & Output

example_1.py — Basic Pairing

$ Input: words = ["lc","cl","gg"]

› Output: 6

💡 Note: We can form "lcggcl" by pairing "lc" with "cl" and putting "gg" in the center. This creates a palindrome of length 6.

example_2.py — Multiple Pairs

$ Input: words = ["ab","ty","yt","lc","cl","ab"]

› Output: 8

💡 Note: We can pair "ab" with "ab" (both symmetric when reversed), "ty" with "yt", and "lc" with "cl" to get maximum length of 8.

example_3.py — All Symmetric

$ Input: words = ["cc","ll","xx"]

› Output: 2

💡 Note: All words are symmetric. We can use at most one in the center, so maximum length is 2.

Visualization

Tap to expand

Understanding the Visualization

Count Word Inventory

Count how many of each two-letter word we have

Identify Symmetric vs Asymmetric

Words like 'aa' are symmetric, 'ab' needs 'ba' partner

Form Maximum Pairs

Pair asymmetric words with their reverse, pair symmetric words with themselves

Place Center Word

If any symmetric word remains unpaired, place it in center

Key Takeaway

🎯 Key Insight: Palindromes need symmetric structure - pair asymmetric words with their reverse, and use at most one symmetric word in the center

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through words array to count frequencies, then O(1) processing per unique word

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique words in worst case

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 10⁵
words[i].length == 2
words[i] consists of lowercase English letters only
Each word can be used at most once

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a hash table to count word frequencies, then strategically pairs words to maximize palindrome length. Key insight: asymmetric words like "ab" must pair with their reverse "ba", while symmetric words like "aa" can pair with themselves or sit in the center. Time complexity: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Count word frequencies and calculate palindrome length using strategic pairing
Brute Force (Try All Combinations)	O(2^n × n! × n)	O(n)	Generate all possible combinations and check which ones form palindromes

One-Pass Hash Table (Optimal) — Algorithm Steps

Count frequency of each two-letter word using hash map
For each word, check if it's self-symmetric (both letters same)
For non-symmetric words, pair with their reverse (ab pairs with ba)
Add 4 characters for each pair (2 chars × 2 words)
Allow at most one self-symmetric word to remain unpaired (goes in center)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Use hash map to count each word

Identify Word Types

Classify as symmetric (aa) or asymmetric (ab)

Pair Words

Match asymmetric words with their reverse

Handle Center

Use one symmetric word in center if available

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    char word[3];
    int count;
    struct HashNode* next;
} HashNode;

int hash(const char* word) {
    return (word[0] * 26 + word[1]) % HASH_SIZE;
}

void insert(HashNode** table, const char* word) {
    int h = hash(word);
    HashNode* node = table[h];
    
    while (node != NULL) {
        if (strcmp(node->word, word) == 0) {
            node->count++;
            return;
        }
        node = node->next;
    }
    
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    strcpy(newNode->word, word);
    newNode->count = 1;
    newNode->next = table[h];
    table[h] = newNode;
}

int getCount(HashNode** table, const char* word) {
    int h = hash(word);
    HashNode* node = table[h];
    
    while (node != NULL) {
        if (strcmp(node->word, word) == 0) {
            return node->count;
        }
        node = node->next;
    }
    return 0;
}

void setCount(HashNode** table, const char* word, int count) {
    int h = hash(word);
    HashNode* node = table[h];
    
    while (node != NULL) {
        if (strcmp(node->word, word) == 0) {
            node->count = count;
            return;
        }
        node = node->next;
    }
}

int longestPalindrome(char** words, int wordsSize) {
    HashNode* table[HASH_SIZE] = {NULL};
    
    // Count frequencies
    for (int i = 0; i < wordsSize; i++) {
        insert(table, words[i]);
    }
    
    int length = 0;
    bool centerUsed = false;
    
    // Process all words
    for (int i = 0; i < wordsSize; i++) {
        char* word = words[i];
        int freq = getCount(table, word);
        
        if (freq == 0) continue;  // Already processed
        
        if (word[0] == word[1]) {  // Self-symmetric
            int pairs = freq / 2;
            length += pairs * 4;
            
            if (freq % 2 == 1 && !centerUsed) {
                length += 2;
                centerUsed = true;
            }
            setCount(table, word, 0);
        } else {
            char reverseWord[3] = {word[1], word[0], '\0'};
            int reverseCount = getCount(table, reverseWord);
            
            if (reverseCount > 0) {
                int pairs = (freq < reverseCount) ? freq : reverseCount;
                length += pairs * 4;
                
                setCount(table, word, 0);
                setCount(table, reverseWord, 0);
            }
        }
    }
    
    return length;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through words array to count frequencies, then O(1) processing per unique word

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique words in worst case

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 10⁵
words[i].length == 2
words[i] consists of lowercase English letters only
Each word can be used at most once

42.8K Views

Medium-High Frequency

~18 min Avg. Time

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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler