LeetCode 0720. Longest Word in Dictionary Solution in Java, C++, Python & More | Explanation + Code

Description

Given an array of strings words representing an English Dictionary, return the longest word in words that can be built one character at a time by other words in words.

If there is more than one possible answer, return the longest word with the smallest lexicographical order. If there is no answer, return the empty string.

Note that the word should be built from left to right with each additional character being added to the end of a previous word. 

 

Example 1:

Input: words = ["w","wo","wor","worl","world"]
Output: "world"
Explanation: The word "world" can be built one character at a time by "w", "wo", "wor", and "worl".

Example 2:

Input: words = ["a","banana","app","appl","ap","apply","apple"]
Output: "apple"
Explanation: Both "apply" and "apple" can be built from other words in the dictionary. However, "apple" is lexicographically smaller than "apply".

 

Constraints:

• 1 <= words.length <= 1000
• 1 <= words[i].length <= 30
• words[i] consists of lowercase English letters.

Solutions

Solution 1: Trie

We can use a trie to store all the words, then traverse all the words to determine if the current word can be formed by adding one letter at a time from other words in the trie. Find the longest word that meets the condition and has the smallest lexicographical order.

The time complexity is O(L), and the space complexity is O(L), where L is the sum of the lengths of all words.

PythonJavaC++GoTypeScriptRustJavaScript

class Trie: def __init__(self): self.children: List[Optional[Trie]] = [None] * 26 self.is_end = False def insert(self, w: str): node = self for c in w: idx = ord(c) - ord("a") if node.children[idx] is None: node.children[idx] = Trie() node = node.children[idx] node.is_end = True def search(self, w: str) -> bool: node = self for c in w: idx = ord(c) - ord("a") if node.children[idx] is None: return False node = node.children[idx] if not node.is_end: return False return True class Solution: def longestWord(self, words: List[str]) -> str: trie = Trie() for w in words: trie.insert(w) ans = "" for w in words: if trie.search(w) and ( len(ans) < len(w) or (len(ans) == len(w) and ans > w) ): ans = w return ans(code-box)

class Trie { private Trie[] children = new Trie[26]; private boolean isEnd = false; public void insert(String w) { Trie node = this; for (char c : w.toCharArray()) { int idx = c - 'a'; if (node.children[idx] == null) { node.children[idx] = new Trie(); } node = node.children[idx]; } node.isEnd = true; } public boolean search(String w) { Trie node = this; for (char c : w.toCharArray()) { int idx = c - 'a'; if (node.children[idx] == null || !node.children[idx].isEnd) { return false; } node = node.children[idx]; } return true; } } class Solution { public String longestWord(String[] words) { Trie trie = new Trie(); for (String w : words) { trie.insert(w); } String ans = ""; for (String w : words) { if (trie.search(w) && (ans.length() < w.length() || (ans.length() == w.length() && w.compareTo(ans) < 0))) { ans = w; } } return ans; } }(code-box)

class Trie { public: Trie* children[26] = {nullptr}; bool isEnd = false; void insert(const string& w) { Trie* node = this; for (char c : w) { int idx = c - 'a'; if (node->children[idx] == nullptr) { node->children[idx] = new Trie(); } node = node->children[idx]; } node->isEnd = true; } bool search(const string& w) { Trie* node = this; for (char c : w) { int idx = c - 'a'; if (node->children[idx] == nullptr || !node->children[idx]->isEnd) { return false; } node = node->children[idx]; } return true; } }; class Solution { public: string longestWord(vector<string>& words) { Trie trie; for (const string& w : words) { trie.insert(w); } string ans = ""; for (const string& w : words) { if (trie.search(w) && (ans.length() < w.length() || (ans.length() == w.length() && w < ans))) { ans = w; } } return ans; } };(code-box)

type Trie struct { children [26]*Trie isEnd bool } func (t *Trie) insert(w string) { node := t for i := 0; i < len(w); i++ { idx := w[i] - 'a' if node.children[idx] == nil { node.children[idx] = &Trie{} } node = node.children[idx] } node.isEnd = true } func (t *Trie) search(w string) bool { node := t for i := 0; i < len(w); i++ { idx := w[i] - 'a' if node.children[idx] == nil || !node.children[idx].isEnd { return false } node = node.children[idx] } return true } func longestWord(words []string) string { trie := &Trie{} for _, w := range words { trie.insert(w) } ans := "" for _, w := range words { if trie.search(w) && (len(ans) < len(w) || (len(ans) == len(w) && w < ans)) { ans = w } } return ans }(code-box)

class Trie { children: (Trie | null)[] = new Array(26).fill(null); isEnd: boolean = false; insert(w: string): void { let node: Trie = this; for (let i = 0; i < w.length; i++) { const idx: number = w.charCodeAt(i) - 'a'.charCodeAt(0); if (node.children[idx] === null) { node.children[idx] = new Trie(); } node = node.children[idx]!; } node.isEnd = true; } search(w: string): boolean { let node: Trie = this; for (let i = 0; i < w.length; i++) { const idx: number = w.charCodeAt(i) - 'a'.charCodeAt(0); if (node.children[idx] === null || !node.children[idx]!.isEnd) { return false; } node = node.children[idx]!; } return true; } } function longestWord(words: string[]): string { const trie = new Trie(); for (const w of words) { trie.insert(w); } let ans = ''; for (const w of words) { if (trie.search(w) && (ans.length < w.length || (ans.length === w.length && w < ans))) { ans = w; } } return ans; }(code-box)

struct Trie { children: [Option<Box<Trie>>; 26], is_end: bool, } impl Trie { fn new() -> Self { Trie { children: Default::default(), is_end: false, } } fn insert(&mut self, w: &str) { let mut node = self; for c in w.chars() { let idx = (c as usize) - ('a' as usize); if node.children[idx].is_none() { node.children[idx] = Some(Box::new(Trie::new())); } node = node.children[idx].as_mut().unwrap(); } node.is_end = true; } fn search(&self, w: &str) -> bool { let mut node = self; for c in w.chars() { let idx = (c as usize) - ('a' as usize); if node.children[idx].is_none() || !node.children[idx].as_ref().unwrap().is_end { return false; } node = node.children[idx].as_ref().unwrap(); } true } } impl Solution { pub fn longest_word(words: Vec<String>) -> String { let mut trie = Trie::new(); for w in &words { trie.insert(w); } let mut ans = String::new(); for w in words { if trie.search(&w) && (ans.len() < w.len() || (ans.len() == w.len() && w < ans)) { ans = w; } } ans } }(code-box)

/** * @param {string[]} words * @return {string} */ var longestWord = function (words) { const trie = new Trie(); for (const w of words) { trie.insert(w); } let ans = ''; for (const w of words) { if (trie.search(w) && (ans.length < w.length || (ans.length === w.length && w < ans))) { ans = w; } } return ans; }; class Trie { constructor() { this.children = Array(26).fill(null); this.isEnd = false; } insert(w) { let node = this; for (let i = 0; i < w.length; i++) { const idx = w.charCodeAt(i) - 'a'.charCodeAt(0); if (node.children[idx] === null) { node.children[idx] = new Trie(); } node = node.children[idx]; } node.isEnd = true; } search(w) { let node = this; for (let i = 0; i < w.length; i++) { const idx = w.charCodeAt(i) - 'a'.charCodeAt(0); if (node.children[idx] === null || !node.children[idx].isEnd) { return false; } node = node.children[idx]; } return true; } }(code-box)