#720 Longest Word in Dictionary

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.

Examples

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.

思路

同样是因为有目的性的刷题，所以提前知道了这题要用前缀树
题目要求找到可以组成的最长的单词
所以第一步是要对列表里的word进行排序，这里给出的要求是如果两个字符串长度一样，要给出lexicographically smaller的那个，所以排序的逻辑如下

public int compare(String o1, String o2) {
    if(o1.length() == o2.length()){
        return o1.compareTo(o2);
    }else{
        return o1.length() - o2.length();
    }
}

排序完之后，一个一个轮流进入前缀树就可以了，一个长度为n的单词，如果 substring[0, n - 1] 是前缀树中存在的单词，那么这个单词就被放入前缀树，如果这个单词长于之前被记录的“temp_最长单词”，那么它将代替原来的，被记为新的“temp_最长单词”，一直执行到最后一个，返回最终的"temp_最长单词"即可。

代码

class TreeNode {
    public TreeNode[] children = new TreeNode[26];
    public TreeNode(){
        for(TreeNode child: children){
            child = null;
        }
    }
    
    public void addChild(int num){
        children[num] = new TreeNode();
    }
    
    public boolean contains(int num){
        return children[num] != null;
    }
}
class Solution {
    public String longestWord(String[] words) {
        String answer = "";
        Arrays.sort(words, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    if(o1.length() == o2.length()){
                        return o1.compareTo(o2);
                    }else{
                        return o1.length() - o2.length();
                    }
                }
            });
        
        TreeNode root = new TreeNode();
        for(String word: words){
            TreeNode node = root;
            int i;
            for(i = 0; i < word.length() - 1; i++){
                char currentChar = word.charAt(i);
                if(!node.contains(currentChar - 'a'))
                    break;
                node = node.children[currentChar - 'a'];
            }
            if(i != word.length() - 1)
                continue;
            node.addChild(word.charAt(i) - 'a');
            if (answer.length() < word.length()){
                answer = word;
            }
        }
        return answer;
    }
}