Medium
随便写了个自认为很暴力的方法，居然AC了而且速度排在中游吧，吃惊，真的是几百年没有不看答案写出来了，/(ㄒoㄒ)/~~

我一向是推崇逻辑最简单的方法，越straightforward越好，越general越好，总之就是越好理解使用场景越频繁越能通用就越好。我最怕那种特别fancy花哨感的方法，看过之后最多能当天重写一遍，以后完全不会自己用。

首先，确定given string的所有字符，如果dict里某个单词里有string没有的字符，那么它肯定不能由该string删除掉字母变得。这个时候用hashSet装字母，再以此遍历dict的每个单词查就可以。

光是有该单词的所有字母还不能保证就一定能由given string删除字符得到，比如字母顺序不一样， alpepa就不能删成apple. 所以我们用two pointers同时遍历given string和dict word的所有字符，从index == 0开始，如果字符相同，则同时右移；如果字符不同，我们就通过右移given string的指针来“删”， 继续比较。如果退出while循环的时候，dict word的pointer的index是word.length()时，说明我们已经在given string里找到了一个完整的dict word, 也就是说明我们确实可以由given word删字母变为dict word.

找到所有可能由given word变成的dict word之后，我们再找出最长的，并且lexicographical order靠最前的。用Collections.sort就可以实现字母排序，再遍历找maxLen的就可以。

class Solution {
    public String findLongestWord(String s, List<String> d) {
        Set<String> dict = new HashSet<>(d);
        Set<Character> chars = new HashSet<>();
        for (char c : s.toCharArray()){
            chars.add(c);
        }
        List<String> possibleWords = new ArrayList<>();
        for (String str : dict){
            if (str.length() > s.length()){
                continue;
            }
            for (Character c : str.toCharArray()){
                if (!chars.contains(c)){
                    continue;
                }
            }
            int i = 0, j = 0;
            while (i < s.length() && j < str.length()){
                if (s.charAt(i) != str.charAt(j)){
                    i++;
                } else {
                    i++;
                    j++;
                }
            }
            if (j == str.length()){
                possibleWords.add(str);
            }
        }
        int maxLen = 0;
        String res = "";
        Collections.sort(possibleWords);
        for (String st : possibleWords){
            if (st.length() > maxLen){
                maxLen = st.length();
                res = st;
            }
        }
        return res;
    }
}

我的code整理一下简化一下应该就长下面这样，可以先sort.学到了String.compareTo(another string)直接就是Compares two strings lexicographically.

class Solution {
        public String findLongestWord(String s, List<String> dict) {
            Collections.sort(dict, new Comparator<String>(){
                public int compare(String a, String b){
                    if (a.length() == b.length()){
                        return a.compareTo(b);
                    } else {
                    return b.length() - a.length();
                    }
                }
            }); 
            int maxLen = 0;
            String res = "";
            for (String word : dict){
                int i = 0, j = 0;
                while (i < s.length() && j < word.length()){
                    if (s.charAt(i) == word.charAt(j)){
                        i++;
                        j++;
                    } else {
                        i++;
                    }
                }
                if (j == word.length()){
                    if (word.length() > maxLen){
                        maxLen = word.length();
                        res = word;
                    }
                }
            }
            return res;
        }
}

注意一下 我们所说的linear time的complexity是针对于input而言的。所以这里的input就是一个np的，你是字典size，p是给的字符串的长度，所以我们的方法虽然也是np，但它相对于input就是linear time了。