Longest Word in Dictionary Using Trie in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert a word into the Trie.

DSA Java

public void insert(String word) {
    TrieNode node = root;
    for (char ch : word.toCharArray()) {
        if (node.children[ch - 'a'] == null) {
            node.children[ch - 'a'] = new TrieNode();
        }
        node = node.[1];
    }
    node.isEnd = true;
}

Drag options to blanks, or click blank then click option'

Achild

Broot

Cparent

Dchildren[ch - 'a']

Attempts:

3 left

💡 Hint

Common Mistakes

Using root instead of moving down the children array.

Trying to access a non-existent 'parent' or 'child' field.

We move to the child node corresponding to the current character by accessing children[ch - 'a'].

2fill in blank

medium

Complete the code to check if a word exists in the Trie.

DSA Java

public boolean search(String word) {
    TrieNode node = root;
    for (char ch : word.toCharArray()) {
        if (node.children[ch - 'a'] == null) {
            return false;
        }
        node = node.[1];
    }
    return node.isEnd;
}

Drag options to blanks, or click blank then click option'

Aroot

Bchildren[ch - 'a']

Cparent

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using root instead of the child node.

Not checking if the child node is null before moving.

To check each character, we move down the children array at index ch - 'a'.

3fill in blank

hard

Fix the error in the method that finds the longest word in the dictionary using DFS.

DSA Java

private void dfs(TrieNode node, StringBuilder path) {
    if (node == null) return;
    if (!node.isEnd && node != root) return;
    if (path.length() > longestWord.length() ||
        (path.length() == longestWord.length() && path.toString().compareTo(longestWord) < 0)) {
        longestWord = path.toString();
    }
    for (int i = 0; i < 26; i++) {
        if (node.children[i] != null) {
            path.append((char) (i + 'a'));
            dfs(node.[1], path);
            path.deleteCharAt(path.length() - 1);
        }
    }
}

Drag options to blanks, or click blank then click option'

Achildren[i]

Bchildren[0]

Cchild[i]

Dchildren

Attempts:

3 left

💡 Hint

Common Mistakes

Using children[0] which always goes to the first child.

Using a non-existent 'child' field.

We must recurse into the child node at index i, so use children[i].

4fill in blank

hard

Fill both blanks to complete the TrieNode class and initialize the root.

DSA Java

class TrieNode {
    boolean isEnd;
    TrieNode[] [1];
    public TrieNode() {
        isEnd = false;
        [2] = new TrieNode[26];
    }
}

TrieNode root = new [1]();

Drag options to blanks, or click blank then click option'

Achildren

Bnodes

Cchild

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the array in declaration and initialization.

Using 'root' as the array name.

The children array holds child nodes, so the field and initialization use 'children'.

5fill in blank

hard

Fill all three blanks to complete the method that finds the longest word in the dictionary.

DSA Java

public String longestWord(String[] words) {
    root = new TrieNode();
    for (String word : words) {
        insert(word);
    }
    longestWord = "";
    dfs(root, new StringBuilder());
    return longestWord;
}

private String longestWord = "";

private void dfs(TrieNode node, StringBuilder path) {
    if (node == null) return;
    if (!node.isEnd && node != [1]) return;
    if (path.length() > longestWord.length() ||
        (path.length() == longestWord.length() && path.toString().compareTo(longestWord) < 0)) {
        longestWord = path.toString();
    }
    for (int i = 0; i < 26; i++) {
        if (node.children[i] != null) {
            path.append((char) (i + 'a'));
            dfs(node.children[i], path);
            path.deleteCharAt(path.length() - 1);
        }
    }
}

Drag options to blanks, or click blank then click option'

Aroot

Bthis

ClongestWord

Dnode

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing node to 'this' or 'longestWord' instead of root.

Using wrong variables in DFS recursion.

We compare node to root to allow the empty prefix; the dfs call uses node.children[i], and the path is updated accordingly.

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 quickly

Solution

1. Step 1: Understand Trie usage

   A Trie stores words by their prefixes, allowing quick prefix checks.

2. Step 2: Relate to longest word search

   Finding the longest word with all prefixes present is easier with Trie prefix checks.

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:

• Confusing Trie with sorting structures
• Thinking Trie reverses words
• Assuming Trie counts words only

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

easy

A. node.children[word[i] - 'a'] = new TrieNode();

B. node.children[word.charAt(i) - 'a'] = new TrieNode();

C. node.children[word.charAt(i)] = new TrieNode();

D. node.children[word.charAt(i) + 'a'] = new TrieNode();

Solution

1. Step 1: Understand character indexing

   Characters are converted to index by subtracting 'a' to map 'a' to 0, 'b' to 1, etc.

2. Step 2: Check Java syntax for charAt

   Java uses word.charAt(i) to get character at index i.

3. Final Answer:

   node.children[word.charAt(i) - 'a'] = new TrieNode(); -> Option B

4. Quick Check:

   Correct char indexing = node.children[word.charAt(i) - 'a'] = new TrieNode(); [OK]

Hint: Use charAt(i) - 'a' for array index in Java [OK]

Common Mistakes:

• Using word[i] instead of charAt(i)
• Adding 'a' instead of subtracting
• Using char directly without index conversion

3. What will be the output of the following Java code snippet that uses a Trie to find the longest word?

String[] words = {"a", "app", "ap", "apply", "apple"};
LongestWordInDictionaryUsingTrie trie = new LongestWordInDictionaryUsingTrie();
System.out.println(trie.longestWord(words));

medium

A. "app"

B. "apply"

C. "apple"

D. "ap"

Solution

1. Step 1: Insert all words into Trie

   Words inserted: "a", "app", "ap", "apply", "apple".

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

   "app" is longest where all prefixes "a", "ap", "app" exist. "apple" and "apply" prefixes "appl" missing.

3. Final Answer:

   "app" -> Option A

4. Quick Check:

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

Hint: Longest word must have all prefixes present [OK]

Common Mistakes:

• Choosing longest word ignoring prefix condition
• Confusing "apple" and "apply" as valid
• Ignoring shorter prefix words

4. Identify the error in this Java method snippet for searching the longest word in a Trie:

public String longestWord(String[] words) {
  TrieNode root = new TrieNode();
  for (String w : words) insert(root, w);
  String result = "";
  dfs(root, new StringBuilder(), result);
  return result;
}

private void dfs(TrieNode node, StringBuilder path, String result) {
  if (node == null) return;
  if (!node.isWord && path.length() != 0) return;
  if (path.length() > result.length()) result = path.toString();
  for (int i = 0; i < 26; i++) {
    if (node.children[i] != null) {
      path.append((char)(i + 'a'));
      dfs(node.children[i], path, result);
      path.deleteCharAt(path.length() - 1);
    }
  }
}

medium

A. The insert method is missing

B. The dfs method does not check for null children

C. The result string is not updated correctly inside dfs due to pass-by-value

D. The path StringBuilder is not cleared after recursion

Solution

1. Step 1: Analyze result parameter usage

   String is immutable and passed by value, so updating result inside dfs does not affect outer variable.

2. Step 2: Understand effect on final output

   Result remains empty because changes inside dfs do not persist outside recursion.

3. Final Answer:

   The result string is not updated correctly inside dfs due to pass-by-value -> Option C

4. Quick Check:

   String immutability causes result update failure [OK]

Hint: Use a mutable object or class field for result [OK]

Common Mistakes:

• Assuming String updates persist in recursion
• Ignoring missing insert method
• Overlooking null checks in children

5. Given a list of words, how would you modify the Trie-based algorithm to return the lexicographically smallest longest word when multiple longest words exist?

hard

A. Store all words in a list and pick the smallest after Trie traversal

B. Sort the input words first and insert into Trie in reverse order

C. Use a max heap to store all longest words and pop the smallest lexicographically

D. Traverse children in alphabetical order during DFS and update result only if new word is longer or lex smaller

Solution

1. Step 1: Traverse children in alphabetical order

   DFS visits children from 'a' to 'z' ensuring lex order traversal.

2. Step 2: Update result conditionally

   Update result only if new word is longer or same length but lex smaller.

3. Step 3: Ensure final result is lex smallest longest word

   This approach naturally picks lex smallest among longest words.

4. Final Answer:

   Traverse children in alphabetical order during DFS and update result only if new word is longer or lex smaller -> Option D

5. Quick Check:

   Lex order DFS + conditional update = Traverse children in alphabetical order during DFS and update result only if new word is longer or lex smaller [OK]

Hint: DFS children from 'a' to 'z' and update result carefully [OK]

Common Mistakes:

• Sorting input but not controlling DFS order
• Using data structures that add unnecessary complexity
• Ignoring lex order during traversal