Longest Word in Dictionary Using Trie in DSA Python - Time & Space Complexity

Time Complexity: Longest Word in Dictionary Using Trie

O(N * L)

Understanding Time Complexity

We want to understand how the time needed to find the longest word in a dictionary using a Trie grows as the dictionary size grows.

Specifically, how the operations scale when inserting words and searching for the longest valid word.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_word = False

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        node = self.root
        for char in word:
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        node.is_word = True

    def longest_word(self):
        result = ""
        def dfs(node, path):
            nonlocal result
            if len(path) > len(result):
                result = path
            for char in sorted(node.children.keys()):
                child = node.children[char]
                if child.is_word:
                    dfs(child, path + char)
        dfs(self.root, "")
        return result

words = ["a", "app", "apple", "apply", "ap", "banana"]
trie = Trie()
for w in words:
    trie.insert(w)
print(trie.longest_word())

This code builds a Trie from a list of words, then finds the longest word where every prefix is also a word in the Trie.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Inserting each word character by character into the Trie and traversing nodes during DFS.
• How many times: Insert runs once per word, each character processed once; DFS visits nodes where prefixes form words.

How Execution Grows With Input

As the number of words and their lengths grow, the insertions and DFS traversal grow roughly with total characters.

Input Size (n words)	Approx. Operations
10 (avg length 5)	~50 insert + DFS steps
100 (avg length 5)	~500 insert + DFS steps
1000 (avg length 5)	~5000 insert + DFS steps

Pattern observation: Operations grow roughly proportional to total characters in all words combined.

Final Time Complexity

Time Complexity: O(N * L)

This means the time grows linearly with the number of words (N) times the average length of each word (L).

Common Mistake

[X] Wrong: "The search for the longest word is constant time because we just follow Trie nodes."

[OK] Correct: The search uses DFS and may visit many nodes depending on the Trie size, so it depends on total characters stored, not constant time.

Interview Connect

Understanding this time complexity helps you explain how Trie operations scale and why they are efficient for prefix-based problems.

Self-Check

"What if we changed the DFS to BFS for finding the longest word? How would the time complexity change?"

Practice

1. What is the main purpose of using a Trie data structure when finding the longest word in a dictionary?

easy

A. To efficiently store and search words by their prefixes

B. To sort words alphabetically

C. To count the total number of words

D. To reverse the words in the dictionary

Solution

1. Step 1: Understand Trie usage

   A Trie stores words by breaking them into characters and linking nodes for prefixes.

2. Step 2: Relate Trie to longest word search

   This structure allows quick prefix checks, which helps find the longest word built from other words.

3. Final Answer:

   To efficiently store and search words by their prefixes -> Option A

4. Quick Check:

   Trie = prefix search [OK]

Hint: Trie is best for prefix-based word searches [OK]

Common Mistakes:

• Thinking Trie sorts words alphabetically
• Confusing Trie with simple lists
• Assuming Trie counts words only

2. Which of the following is the correct way to insert a word into a Trie node in Python?

easy

A. node.children[char] = TrieNode() if char not in node.children else node.children[char]

B. node.children.add(char)

C. node.children.append(char)

D. node.children[char] = char

Solution

1. Step 1: Understand Trie children structure

   Trie children are stored in a dictionary mapping characters to TrieNode objects.

2. Step 2: Correct insertion method

   We check if character exists; if not, create new TrieNode and assign it to children dictionary.

3. Final Answer:

   node.children[char] = TrieNode() if char not in node.children else node.children[char] -> Option A

4. Quick Check:

   Insert uses dictionary with TrieNode [OK]

Hint: Use dictionary keys for children, not list or set [OK]

Common Mistakes:

• Using add() or append() on dictionary
• Assigning character instead of TrieNode
• Not checking if child exists before insertion

3. Given the words: ["a", "app", "apple", "apply", "ap"], what is the longest word that can be built one character at a time using the Trie method?

medium

A. "apply"

B. "app"

C. "apple"

D. "ap"

Solution

1. Step 1: Check each word's prefixes

   Words must have all prefixes present: "a", "ap", "app" are present; "apple" and "apply" require "appl" which is missing.

2. Step 2: Identify longest valid word

   "app" is the longest word where all prefixes exist in the list.

3. Final Answer:

   "app" -> Option B

4. Quick Check:

   Longest word with all prefixes = "app" [OK]

Hint: Check all prefixes exist before choosing longest word [OK]

Common Mistakes:

• Assuming "apple" or "apply" are valid without "appl"
• Ignoring prefix requirement
• Choosing shortest word instead

4. What is the error in this Trie insertion code snippet for building the longest word?

for word in words:
    node = root
    for char in word:
        if char not in node.children:
            node.children[char] = TrieNode
        node = node.children[char]
    node.is_word = True

medium

A. The root node should be reset after each character

B. The loop should iterate over characters in reverse

C. node.is_word should be set before the inner loop

D. TrieNode should be called with parentheses to create an instance

Solution

1. Step 1: Identify object creation mistake

   TrieNode is a class; to create an object, parentheses () are needed.

2. Step 2: Understand impact of missing parentheses

   Without (), node.children[char] stores the class itself, not an instance, causing errors on further access.

3. Final Answer:

   TrieNode should be called with parentheses to create an instance -> Option D

4. Quick Check:

   Instantiate TrieNode with () [OK]

Hint: Always use () to create class instances in Python [OK]

Common Mistakes:

• Forgetting parentheses when creating objects
• Setting flags in wrong loop place
• Resetting root incorrectly inside loops

5. You have a list of words: ["w", "wo", "wor", "worl", "world", "banana", "ban", "bana", "banan"]. Using a Trie, which word will be returned as the longest word built one character at a time from other words in the list?

hard

A. "worl"

B. "banana"

C. "world"

D. "banan"

Solution

1. Step 1: Verify prefix chains for each candidate

   "world" prefixes: "w", "wo", "wor", "worl", "world" all exist; "banana" and "banan" missing prefixes like "b", "ba"; "worl" is shorter than "world".

2. Step 2: Choose longest word with all prefixes present

   "world" is longest with all prefixes present in the list.

3. Final Answer:

   "world" -> Option C

4. Quick Check:

   Longest word with full prefix chain = "world" [OK]

Hint: Check full prefix chain exists before longest word [OK]

Common Mistakes:

• Choosing "banana" without full prefix chain
• Ignoring prefix requirement for "banan"
• Picking shorter word "worl" over "world"