Concatenated Words

Concatenated Words - Problem

Array String Dynamic Programming Depth-First Search Trie Sorting Hard

Given an array of strings words (without duplicates), return all the concatenated words in the given list of words.

A concatenated word is defined as a string that is comprised entirely of at least two shorter words (not necessarily distinct) in the given array.

Note: The shorter words used to form the concatenated word must exist in the original array.

Input & Output

Example 1 — Multiple Concatenated Words

$ Input: words = ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]

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

💡 Note: "catsdogcats" = "cats" + "dog" + "cats", "dogcatsdog" = "dog" + "cats" + "dog", "ratcatdogcat" = "rat" + "cat" + "dog" + "cat"

Example 2 — No Concatenated Words

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

› Output: ["catdog"]

💡 Note: "catdog" can be formed from "cat" + "dog", which are both in the array

Example 3 — Edge Case with Single Word

$ Input: words = ["a"]

› Output: []

💡 Note: No word can be formed from at least two other words since there's only one word

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use dynamic programming to efficiently check if each word can be decomposed into valid dictionary words. The optimal approach sorts words by length and uses a 1D DP array to build solutions bottom-up. Time: O(n × m³), Space: O(m)

Common Approaches

✓ Brute Force with Recursive Check

⏱️ Time: O(n × 2^m) Space: O(m)

Check every word by trying all possible ways to split it into parts, then recursively verify if each part exists in the word list. This approach explores all combinations without optimization.

Dynamic Programming (Bottom-Up)

⏱️ Time: O(n × m³) Space: O(m)

For each word, create a DP array where dp[i] indicates if the substring from 0 to i can be formed. Build the solution bottom-up by checking all possible splits.

Memoization (Top-Down DP)

⏱️ Time: O(n × m³) Space: O(n × m²)

Optimize the recursive approach by caching the results of whether a substring can be formed from the word list. This prevents recalculating the same subproblems multiple times.

Brute Force with Recursive Check — Algorithm Steps

For each word in the array
Try every possible split position
Recursively check if both parts can be formed from the word list
Add to result if word can be completely decomposed

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Word

Select a word to check if it's concatenated

Try Splits

Try every position to split the word

Check Parts

Recursively verify each part exists or can be formed

Add Result

If valid decomposition found, add to result

Code -

solution.c — C

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

#define MAX_WORDS 10000
#define MAX_LEN 100

static char words[MAX_WORDS][MAX_LEN];
static int wordCount = 0;

bool findWord(const char* word) {
    for (int i = 0; i < wordCount; i++) {
        if (strcmp(words[i], word) == 0) {
            return true;
        }
    }
    return false;
}

bool canForm(const char* word, const char* original, int count) {
    if (strlen(word) == 0) {
        return count >= 2;
    }
    
    int len = strlen(word);
    for (int i = 1; i <= len; i++) {
        char prefix[MAX_LEN];
        strncpy(prefix, word, i);
        prefix[i] = '\0';
        
        if (findWord(prefix) && (strcmp(prefix, original) != 0 || count > 0)) {
            if (canForm(word + i, original, count + 1)) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    wordCount = 0;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == '"') {
            p++;
            int len = 0;
            while (*p && *p != '"') {
                words[wordCount][len++] = *p++;
            }
            words[wordCount][len] = '\0';
            wordCount++;
            if (*p == '"') p++;
        } else if (*p != ']') {
            p++;
        }
    }
    
    printf("[");
    bool first = true;
    for (int i = 0; i < wordCount; i++) {
        if (canForm(words[i], words[i], 0)) {
            if (!first) printf(",");
            printf("\"%s\"", words[i]);
            first = false;
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^m)

For each of n words, we try all 2^m possible splits where m is average word length

✓ Linear Growth

Space Complexity

O(m)

Recursion stack depth can go up to m (word length)

⚡ Linearithmic Space

85.0K Views

Medium Frequency

~35 min Avg. Time

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

Brute Force with Recursive Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler