GeeksforGeeks Medium

Longest Word with All Prefixes

Among a list of words, find the longest word whose every prefix is also a word in the list. Ties are broken alphabetically.

triestring
Open on GeeksforGeeks ↗
02

Intuition

💡

The condition is about every prefix of a word, and a trie is precisely the structure where a word's prefixes are the nodes along its path. Insert everything, flagging each node that terminates a real word. Then a word qualifies if and only if every node on its path carries that flag — one walk per word, no repeated string slicing. Scanning candidates in sorted order makes the tie-break free: the first word to reach a new maximum length is already the alphabetically smallest of that length.

03

Approach

1

Build the trie with end flags

Insert every word; mark the final node of each with an end-of-word flag. Shared prefixes share nodes automatically.

2

Validate by walking

For a candidate word, walk its path and require the end flag at every single node. The first unflagged node disqualifies it immediately.

3

Sort to make ties free

Process candidates alphabetically and keep a strictly-longer rule. The alphabetical winner is then found without an explicit comparison.

04

Solution & live demo

python
1class Solution:
2 def longestWord(self, words):
3 root = {}
4 for w in words:
5 node = root
6 for ch in w:
7 node = node.setdefault(ch, {})
8 node["$"] = True
9 best = ""
10 for w in sorted(words):
11 node, ok = root, True
12 for ch in w:
13 node = node[ch]
14 if "$" not in node:
15 ok = False
16 break
17 if ok and len(w) > len(best):
18 best = w
19 return best
05

Edge cases

No word qualifies

Every candidate breaks at some prefix, so the answer is the empty string.

Single-character words

The only prefix is the word itself, so any length-1 word trivially qualifies.

Two valid words of equal length

Sorted order visits the alphabetically smaller first, and the strict length comparison prevents the later one from replacing it.

06

Complexity

Time
O(total characters)
Space
O(total characters)
Each word is walked twice — once to insert, once to validate — plus an O(n log n) sort of the word list.