Concatenated Words - Practice Coding Problems

Concatenated Words - Problem

Array String Dynamic Programming Depth-First Search Trie Sorting Hard

Concatenated Words is a fascinating string manipulation problem that challenges you to identify words that can be formed by combining other words from the same collection.

Given an array of strings words (without duplicates), return all the concatenated words in the given list. A concatenated word is defined as a string that is comprised entirely of at least two shorter words (not necessarily distinct) from the given array.

Key Points:
• Words can be reused when forming concatenated words
• A concatenated word must use at least 2 other words
• The component words must exist in the original array

Example: If you have ["cat", "cats", "catsdogcats", "dog", "dogcatsdog", "hippopotamus", "rat", "ratcatdogcat"], then "catsdogcats" is concatenated because it can be formed from "cats" + "dog" + "cats".

Input & Output

example_1.py — Basic concatenation

$ Input: ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamus","rat","ratcatdogcat"]

› Output: ["catsdogcats","dogcatsdog","ratcatdogcat"]

💡 Note: "catsdogcats" can be formed by "cats"+"dog"+"cats", "dogcatsdog" can be formed by "dog"+"cats"+"dog", and "ratcatdogcat" can be formed by "rat"+"cat"+"dog"+"cat".

example_2.py — Single words

$ Input: ["cat","dog","catdog"]

› Output: ["catdog"]

💡 Note: Only "catdog" can be formed by concatenating "cat" and "dog". The individual words "cat" and "dog" are not concatenated words.

example_3.py — No concatenated words

$ Input: ["cat","dog","rat"]

› Output: []

💡 Note: None of these words can be formed by concatenating other words from the array, so the result is empty.

Visualization

Tap to expand

Understanding the Visualization

Organize Blocks

Sort building blocks by size, starting with the smallest ones

Build Foundation

Use small blocks as foundation pieces for larger constructions

Test Assembly

For each complex structure, use DP to see if it can be built from existing blocks

Identify Composites

Structures requiring 2+ blocks are composite (concatenated) words

Key Takeaway

🎯 Key Insight: By processing words in length order and using dynamic programming, we can efficiently identify which complex words are built from simpler components, ensuring optimal O(n log n + n × m²) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n × m²)

n log n for sorting, then n words each taking m² DP operations where m is average word length

⚡ Linearithmic

Space Complexity

O(n + m)

n for word set storage, m for DP array per word

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 10⁴
1 ≤ words[i].length ≤ 30
words[i] consists of only lowercase English letters
All the strings of words are unique

Asked in

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

The optimal approach uses sorting by word length combined with dynamic programming. By processing shorter words first, we build up our dictionary incrementally and can efficiently check if longer words can be formed from existing shorter words using DP in O(n log n + n × m²) time.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DP with Sorting (Optimal)	O(n log n + n × m²)	O(n + m)	Sort words by length and use DP to build up solutions incrementally
Brute Force (Recursive Backtracking)	O(n × 2^m)	O(n + m)	Try all possible ways to split each word and check if all parts exist
Dynamic Programming with Memoization	O(n × m³)	O(n × m)	Use DP to avoid recomputing the same subproblems repeatedly

Optimized DP with Sorting (Optimal) — Algorithm Steps

Sort words by length to process shorter words first
Start with an empty word set, add valid words as we process them
For each word, use DP to check if it can be formed from current word set
Only add the word to set if it's NOT concatenated (to avoid circular dependencies)
A word is concatenated if DP succeeds and uses at least 2 words

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Words

Sort by length: ['cat', 'dog', 'rat', 'cats', 'catsdogcats', ...]

Process Sequentially

For each word, check if it can be formed from previously processed words

Build Dictionary

Add non-concatenated words to dictionary for future use

Identify Concatenated

Words that can be formed are concatenated words

Code -

solution.c — C

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

#define MAX_WORDS 10000
#define MAX_LEN 1000

struct WordSet {
    char words[MAX_WORDS][MAX_LEN];
    int size;
};

int compareByLength(const void* a, const void* b) {
    return strlen(*(char**)a) - strlen(*(char**)b);
}

bool contains(struct WordSet* set, char* word) {
    for (int i = 0; i < set->size; i++) {
        if (strcmp(set->words[i], word) == 0) return true;
    }
    return false;
}

void addWord(struct WordSet* set, char* word) {
    strcpy(set->words[set->size], word);
    set->size++;
}

bool canForm(char* word, struct WordSet* wordSet) {
    if (wordSet->size == 0) return false;  // Empty set
    
    int n = strlen(word);
    bool* dp = (bool*)calloc(n + 1, sizeof(bool));
    dp[0] = true;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < i; j++) {
            if (dp[j]) {
                char prefix[MAX_LEN];
                strncpy(prefix, word + j, i - j);
                prefix[i - j] = '\0';
                if (contains(wordSet, prefix)) {
                    dp[i] = true;
                    break;
                }
            }
        }
    }
    
    bool result = dp[n];
    free(dp);
    return result;
}

char** findAllConcatenatedWordsInADict(char** words, int wordsSize, int* returnSize) {
    // Sort by length
    qsort(words, wordsSize, sizeof(char*), compareByLength);
    
    struct WordSet wordSet = {.size = 0};
    char** result = (char**)malloc(wordsSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        if (canForm(words[i], &wordSet)) {
            result[*returnSize] = (char*)malloc((strlen(words[i]) + 1) * sizeof(char));
            strcpy(result[*returnSize], words[i]);
            (*returnSize)++;
        } else {
            addWord(&wordSet, words[i]);  // Only add non-concatenated words
        }
    }
    
    return result;
}

int main() {
    char* words[] = {"cat","cats","catsdogcats","dog","dogcatsdog","hippopotamus","rat","ratcatdogcat"};
    int returnSize;
    char** result = findAllConcatenatedWordsInADict(words, 8, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("%s ", result[i]);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n × m²)

n log n for sorting, then n words each taking m² DP operations where m is average word length

⚡ Linearithmic

Space Complexity

O(n + m)

n for word set storage, m for DP array per word

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 10⁴
1 ≤ words[i].length ≤ 30
words[i] consists of only lowercase English letters
All the strings of words are unique

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized DP with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler