Longest Word in Dictionary - Practice Coding Problems

Longest Word in Dictionary - Problem

Longest Word in Dictionary is a fascinating string manipulation problem that challenges you to find the longest word that can be built incrementally from other words in the dictionary.

Given an array of strings words representing an English dictionary, you need to return the longest word that can be constructed one character at a time by other words in the same dictionary. The key constraint is that each word must be built from left to right, adding one character at a time to form valid words that exist in the dictionary.

If multiple words have the same maximum length, return the one with the smallest lexicographical order. If no such word exists, return an empty string.

Example: Given ["w", "wo", "wor", "worl", "world"], the answer is "world" because it can be built as: w → wo → wor → worl → world, where each intermediate step exists in the dictionary.

Input & Output

example_1.py — Basic word building

$ Input: ["w", "wo", "wor", "worl", "world"]

› Output: "world"

💡 Note: The word 'world' can be built one character at a time: w → wo → wor → worl → world, where each intermediate step exists in the dictionary.

example_2.py — Multiple valid words

$ Input: ["a", "banana", "app", "ap", "appl", "apple", "apply"]

› Output: "apple"

💡 Note: Both 'apple' and 'apply' can be built incrementally (a → ap → app → appl → apple/apply), but 'apple' comes first lexicographically.

example_3.py — No buildable words

$ Input: ["abc", "def", "ghi"]

› Output: ""

💡 Note: None of these words can be built one character at a time since their prefixes don't exist in the dictionary.

Visualization

Tap to expand

Understanding the Visualization

Foundation Check

Start with single letters (like 'w') that exist in our dictionary - these are our foundation blocks

Build Layer by Layer

Add one character at a time ('w' → 'wo' → 'wor') ensuring each intermediate word exists

Track the Tallest

Keep track of the longest valid word found, preferring alphabetically earlier words when tied

Use Smart Structure

A Trie organizes words like a building blueprint, making it easy to verify all construction steps

Key Takeaway

🎯 Key Insight: Use a Trie to organize words hierarchically, then DFS traverse only through valid word nodes to find the longest buildable path efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Building Trie takes O(n × m) where n is number of words and m is average length, DFS is also O(n × m)

✓ Linear Growth

Space Complexity

O(n × m)

Space for Trie structure storing all characters of all words

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 30
words[i] consists of lowercase English letters only
All words[i] are unique
The answer is guaranteed to be unique, or empty string if no valid word exists

Asked in

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

The optimal approach uses a Trie (prefix tree) data structure to efficiently organize words and find the longest buildable word. Build the Trie from all dictionary words, then use DFS traversal to find the deepest path where every intermediate node represents a complete word. This achieves O(n × m) time complexity and naturally handles the lexicographical ordering requirement.

Common Approaches

Approach	Time	Space	Notes
✓ Trie-based Solution (Optimal)	O(n × m)	O(n × m)	Use Trie data structure to efficiently build and traverse all possible words
Two-Pass with Sorting	O(n log n + n × m)	O(n × m)	Sort by length, then build words incrementally using hash set
Brute Force (Check All Prefixes)	O(n × m²)	O(n × m)	For each word, check if all its prefixes exist in the dictionary

Trie-based Solution (Optimal) — Algorithm Steps

Build a Trie from all words in the dictionary
Mark nodes that represent complete words
Perform DFS traversal from root
Only traverse paths where each node is a complete word
Return the longest word found (lexicographically smallest if tied)

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Insert all words into Trie structure

Mark complete words

Flag nodes that represent complete dictionary words

DFS traversal

Only follow paths through complete word nodes

Find longest path

Return deepest reachable complete word

Code -

solution.c — C

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

typedef struct TrieNode {
    struct TrieNode* children[26];
    bool isWord;
    char word[101];
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    for (int i = 0; i < 26; i++) {
        node->children[i] = NULL;
    }
    node->isWord = false;
    node->word[0] = '\0';
    return node;
}

void insert(TrieNode* root, char* word) {
    TrieNode* curr = root;
    for (int i = 0; word[i]; i++) {
        int index = word[i] - 'a';
        if (!curr->children[index]) {
            curr->children[index] = createNode();
        }
        curr = curr->children[index];
    }
    curr->isWord = true;
    strcpy(curr->word, word);
}

char result[101];

void dfs(TrieNode* node) {
    if (!node->isWord) return;
    
    if (strlen(node->word) > strlen(result) || 
        (strlen(node->word) == strlen(result) && strcmp(node->word, result) < 0)) {
        strcpy(result, node->word);
    }
    
    for (int i = 0; i < 26; i++) {
        if (node->children[i]) {
            dfs(node->children[i]);
        }
    }
}

char* longestWord(char** words, int wordsSize) {
    TrieNode* root = createNode();
    root->isWord = true; // Root represents empty string
    
    for (int i = 0; i < wordsSize; i++) {
        insert(root, words[i]);
    }
    
    result[0] = '\0';
    dfs(root);
    
    char* ans = (char*)malloc(101 * sizeof(char));
    strcpy(ans, result);
    return ans;
}

int main() {
    char** words = (char**)malloc(1000 * sizeof(char*));
    int wordsSize = 0;
    
    printf("%s\n", longestWord(words, wordsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Building Trie takes O(n × m) where n is number of words and m is average length, DFS is also O(n × m)

✓ Linear Growth

Space Complexity

O(n × m)

Space for Trie structure storing all characters of all words

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 30
words[i] consists of lowercase English letters only
All words[i] are unique
The answer is guaranteed to be unique, or empty string if no valid word exists

42.4K Views

Medium 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

Trie-based Solution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler