携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第16天，点击查看活动详情

1.描述

720. 词典中最长的单词 - 力扣（LeetCode） (leetcode-cn.com)

给出一个字符串数组 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" 

提示：

• 1 <= words.length <= 1000
• 1 <= words[i].length <= 30
• 所有输入的字符串 words[i] 都只包含小写字母。

2.分析

借助前缀树这个数据结构来辅助存储字典单词数据，构建好字典树之后，采用广度优先搜索的方式来快速搜索满足条件的最长字符串

借助队列来进行广度优先搜索：

如果当前节点是某个单词，说明满足条件，加入队列
如果当前节点不是单词结尾，说明不满足条件可以不加入队列
每次遍历当前深度的时候，可以先存储队列中的第一个元素作为当前深度的结果，一定可以保证是字典序最小的那一个

3.AC代码

class Solution {
    // 字典树的根节点
    Node root = new Node();
    // 存储广度搜索结果的字符串变量
    String res = "";


    public String longestWord(String[] words) { 
        // 构建自字典树
        for (String word:words) {
            insert(word);
        }
        // 广度优先搜索
        bfs(root);
        return res;
    }

    // 字典树节点定义
    class Node {
        Node[] child;    // 存储当前节点的26个字母的子节点
        String word;     // 存储当前节点是不是某个字符串的结尾，是就存储当前的这个字符串，否则为空字符串

        public Node(){
            child = new Node[26];
            word="";
        }
    }

    // 定义一个方法向字典树中插入字符串
    public void insert(String str) {
        Node node = root;
        // 循环遍历字符串直至每一个字符都插入字典树中
        for (char c:str.toCharArray()) {
            // 如果当前节点还没有插入，就初始化一个节点
            if (node.child[c-'a']==null) {
                node.child[c-'a']=new Node();
            }
            node = node.child[c-'a'];
        }
        node.word=str;
    }

    // 深度优先搜索方法定义
    public void bfs(Node root) {
        // 借助队列辅助广度优先搜索
        Queue<Node> queue = new LinkedList<>();
        // 现将满足条件的第一个节点加入队列
        for (Node node:root.child) {
            if (node!=null && !"".equals(node.word))  {
                queue.offer(node);
            }
        }
        // 深度优先搜索主逻辑
        while (!queue.isEmpty()) {
            // 按层遍历判断
            int size = queue.size();
            for (int i=0;i<size;i++) {
                root = queue.poll();
                // 只会将每一层的第一个节点的字符串作为结果
                if (i==0) {
                    res=root.word;
                }
                // 判断是否还有满足条件的节点
                for (Node node:root.child) {
                    if (node!=null && !"".equals(node.word))  {
                        queue.offer(node);
                    }
                }
            }
        }
    }
}