720. 词典中最长的单词 (tire 应用)

 

难度简单306

给出一个字符串数组 words 组成的一本英语词典。返回 words 中最长的一个单词，该单词是由 words 词典中其他单词逐步添加一个字母组成。

若其中有多个可行的答案，则返回答案中字典序最小的单词。若无答案，则返回空字符串。

 

示例 1：

输入：words = ["w","wo","wor","worl", "world"]
输出："world"
解释： 单词"world"可由"w", "wo", "wor", 和 "worl"逐步添加一个字母组成。

示例 2：

输入：words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
输出："apple"
解释："apply" 和 "apple" 都能由词典中的单词组成。但是 "apple" 的字典序小于 "apply" 

from collections import defaultdict
class Trie:
    def __init__(self):
        self.children = defaultdict(Trie)
        self.is_end = False
    def insert(self,word):
        node = self
        for ch in word:
            node = node.children[ch]
        node.is_end = True
        

class Solution:
    def __init__(self):
        self.root = Trie()
        self.res = ""
    def longestWord(self, words: List[str]) -> str:
        for word in words:
            self.root.insert(word)
        def dfs(path,root):
            if root == None:
                return
            if root.is_end and len(path) > len(self.res):
                self.res = path
            for i in range(26):
                ch = chr(ord('a') + i)
                if root.children and root.children[ch].is_end:
                    dfs(path+ch,root.children[ch])
        dfs("",self.root)
        return self.res

 

struct TrieNode {
    bool is_end;
    std::vector<TrieNode*> children;
    TrieNode() {
        this->is_end = false;
        this->children = std::vector<TrieNode*>(26);
    }
};


class Solution {
    TrieNode* root = new TrieNode();
    string long_str = "";
public:
    void insert(string word) {
        TrieNode* node = root;
        for(auto ch : word) {
            if (node->children[ch - 'a'] == nullptr) {
                node->children[ch - 'a'] = new TrieNode();
            }
            node = node->children[ch - 'a'];
        }
        node->is_end = true;
    }
    void dfs(TrieNode* node,string& path) {
        if (path.size() > long_str.size()) {
            long_str = path;
        }
        for(int i = 0; i < 26;i++) {
            if (node->children[i] != nullptr && node->children[i]->is_end ) {
                path+=('a' + i);
                dfs(node->children[i],path);
                path.pop_back();
            }
        }
    }
    string longestWord(vector<string>& words) {
        for(auto word : words) {
            insert(word);
        }
        string path = "";
        dfs(root,path);
        return long_str;
    }
};