Google 面试题分析 | 字典里面的最长单词

Posted 2022-10-29 汤高

Google 面试题分析 | 字典里面的最长单词

描述

给定一个字符串列表words，找到words最长的word，使得这个word可用words中的其他word一次一个字符地构建。如果有多个可选答案，则返回最长的且具有最小字典序的word。

样例

Ⅰ. Input: words =["w","wo","wor","worl","world"]

    Output: "world"

    Explanation: “world”可通过”w”, “wo”, “wor”, “worl”一次一个字符进行构建。

 

Ⅱ . Input: words =["a", "banana", "app", "appl","ap", "apply", "apple"]

     Output:"apple"

    Explanation: “apply”和”apple”都可以由其他字符构建。但”apple”的字典序要小于”apply”。

注意：

    所有的输入字符只包含小写字符。

    words的长度在[1, 1000]范围内。

    words[i]的长度在[1, 30]范围内。

解题思路

方法一：直接采用暴力搜索。

对于每一个word，检查是否其前缀都在words中。可以用words构建set。初始化ans=””，words，对每个元素，在set中寻找是否有其所有前缀。如果当前word合题，且长度大于ans，或长度等于ans但字典序小于ans，则修改ans为当前word。也可以先对words排序，按照长度从小到大，长度相同按照字典顺序。这样只要word合题就修改ans。 

时间复杂度：O(sum(w_i^2)),w_i表示words[i]的长度。对于每一个word，通过哈希表检查是否所有的前缀都在set当中需要O(w_i^2)。

空间复杂度：O(sum(w_i))用于创建set。

方法二：因为涉及到了字符串的前缀，所以使用Trie结构（一种字符串前缀树）。

trie树的介绍参见 Trie树介绍

把每个word放入Trie中，对Trie进行DFS，只搜索终结节点。每个找到的节点中（除了根）从根到该节点路径代表该节点的word。之后同方法一：如果当前word合题，且长度大于ans，或长度等于ans但字典序小于ans，则修改ans为当前word。

 时间复杂度：O(sum(w_i))，w_i是words[i]的长度。这是构建和便利Trie的复杂度。如果使用BFS而不是DFS，并且把每个节点的子节点进行排序，那么我们就不需要再去检查当前的word时候比ans要好，后访问的节点一定要好于先访问的节点，但复杂度不变。

空间复杂度：O(sum(w_i))用于构建Trie。

代码实现

package trie;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;


public class Solution 

    class Trie 
        //待构建的字符串列表
        private String words[];
        private Node root;
        
        public Trie(String[] words)
            this.root=new Node();
            this.words=words;
        
        public Node builtTrie()
            int index=0;
            for (int i=0;i<words.length;i++)
                insert(words[i],++index);
            
            return root;
        
        /**
         *@param index表示在words数组中的索引,方便在trie节点中快速获取该单词
         */
        public void insert(String word,int index)
            if(word==""||word==null)
                return;
            
            Node cur=root;
            char [] chars=word.toCharArray();
            for(int i=0;i<chars.length;i++)
                //如果不存在该值,则创建新节点
                char val=chars[i];
                if(!cur.getChildrens().containsKey(val))
                    Node newNode=new Node();
                    newNode.setVal(val);
                    cur.getChildrens().put(val, newNode);
                
                //如果已经存在则pass
                cur=cur.getChildrens().get(val);
            
            cur.setEnd(index);
            
        
        
       public  String DFS()
            String result="";
            Stack<Node> stack=new Stack<Node>();
            stack.push(root);
            while(!stack.isEmpty())
                Node node=stack.pop();
                if(node.getEnd()>0||node==root)
                    if(node!=root)
                        String word= this.words[node.getEnd()-1];
                        if(word.length()>result.length()||
                                word.length()==result.length()&&result.compareTo(word)>0)//最长的且具有最小字典序的word
                            result=word;
                        
                    
                    for(Node n:node.getChildrens().values())//拿到子节点
                        stack.push(n);
                    
                
            
            return result;
            
        
    
       
    class Node 
        // 节点字符值
        private char val;
        // 节点的子节点,即以根节点到该节点的值组成的字符串为前缀的字符串构建的节点
        private Map<Character, Node> childrens = new HashMap<Character, Node>();
        // 是否为结束节点,即一个字符串是否到达末尾节点 当end>0时表示结束节点  该节点存储单词在words列表中的位置
        private int end = 0;
       
        public char getVal() 
            return val;
        

        public void setVal(char val) 
            this.val = val;
        

        public Map<Character, Node> getChildrens() 
            return childrens;
        

        public void setChildrens(Map<Character, Node> childrens) 
            this.childrens = childrens;
        

        public int getEnd() 
            return end;
        

        public void setEnd(int end) 
            this.end = end;
        
    

   
   
    public static void main(String[] args) 
        String[] words=new String[]"a", "banana", "app", "appl", "ap", "apply", "apple";
        //String[] words=new String[]"w","wo","wor","worl", "world";
        Solution s=new Solution();
        Trie t=s.new Trie(words);
        t.builtTrie();
        System.out.println( t.DFS());  
         
     

转载请指明出处http://blog.csdn.net/tanggao1314/article/details/79004972
参考 https://mp.weixin.qq.com/s/WTXUt9C0YEl6171HbVWXWQ