720_Longest_Word_in_Dictionary

qiyuangong · qiyuangong · commit 0536fee96cf5 · 2018-11-29T22:45:38.000+08:00
diff --git a/README.md b/README.md
@@ -1,6 +1,8 @@
 # Python & JAVA Solutions for Leetcode (inspired by [haoel's leetcode](https://github.com/haoel/leetcode))
 
-Remember solutions are only solutions to given problems. If you want full study checklist for code & whiteboard interview, please turn to [jwasham's coding-interview-university](https://github.com/jwasham/coding-interview-university).
+Remember solutions are only solutions to given problems. If you want full study checklist for code & whiteboard interview, please turn to [jwasham's coding-interview-university](https://github.com/jwasham/coding-interview-university). 
+
+Also, there are open source implementations for basic data structs and algorithms, such as [Algorithms in Python](https://github.com/TheAlgorithms/Python) and [Algorithms in Java](https://github.com/TheAlgorithms/Java). 
 
 [Python](https://github.com/qiyuangong/leetcode/tree/master/python) and [Java](https://github.com/qiyuangong/leetcode/tree/master/java) full list. &hearts; means you need a subscription.
 
@@ -149,6 +151,7 @@ Remember solutions are only solutions to given problems. If you want full study
 | 697 | [Degree of an Array](https://leetcode.com/problems/degree-of-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/697_Degree_of_an_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/697_Degree_of_an_Array.java) | 1. Find degree and value, then find smallest subarray (start and end with this value), O(n) and O(n)<br>2. Go through nums, remember left most pos and right most for each value, O(n) and O(n) |
 | 709 | [To Lower Case](https://leetcode.com/problems/to-lower-case/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/709_To_Lower_Case.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/709_To_Lower_Case.java) | String processing:<br>1. str.lower() or str.toLowerCase()<br>2. ASCII processing. O(n) and O(1) |
 | 716 | [Max Stack](https://leetcode.com/problems/max-stack/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/716_Max_Stack.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/716_Max_Stack.java) | 1. Two stacks<br> 2. Double linked list and Hash |
+| 720 | [Longest Word in Dictionary](https://leetcode.com/problems/longest-word-in-dictionary/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/720_Longest_Word_in_Dictionary.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/720_Longest_Word_in_Dictionary.java) | 1. Brute Force, O(sum(w^2)) and O(w)<br>2. Tire Tree, O(sum(w) and O(w))<br>3. Sort and word without last char, O(nlogn + sum(w)) and O(w) |
 | 743 | [Network Delay Time](https://leetcode.com/problems/network-delay-time/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/743_Network_Delay_Time.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/743_Network_Delay_Time.java) | Let V == N, then: 1. DFS, O(V^V+ElgE), O(V+E)<br>2. Dijkstra, O(V^2+E), O(V+E)|
 | 771 | [Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/771_Jewels_and_Stones.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/771_Jewels_and_Stones.java) | Count given char in string. Hash or table. [Oneline](https://leetcode.com/problems/jewels-and-stones/discuss/113574/1-liners-PythonJavaRuby) |
 | 804 | [Unique Morse Code Words](https://leetcode.com/problems/unique-morse-code-words/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/804_Unique_Morse_Code_Words.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/804_Unique_Morse_Code_Words.java) | String, Hash and Set. Set is recommended. |
diff --git a/java/720_Longest_Word_in_Dictionary.java b/java/720_Longest_Word_in_Dictionary.java
@@ -0,0 +1,78 @@
+class Solution {
+    /*public String longestWord(String[] words) {
+        String ans = "";
+        Set<String> wordset = new HashSet();
+        for (String word: words) wordset.add(word);
+        for (String word: words) {
+            if (word.length() > ans.length() ||
+                    word.length() == ans.length() && word.compareTo(ans) < 0) {
+                boolean good = true;
+                for (int k = 1; k < word.length(); ++k) {
+                    if (!wordset.contains(word.substring(0, k))) {
+                        good = false;
+                        break;
+                    }
+                }
+                if (good) ans = word;
+            }    
+        }
+        return ans;
+    }*/
+
+    public String longestWord(String[] words) {
+        Trie trie = new Trie();
+        int index = 0;
+        for (String word: words) {
+            trie.insert(word, ++index); //indexed by 1
+        }
+        trie.words = words;
+        return trie.dfs();
+    }
+}
+class Node {
+    char c;
+    HashMap<Character, Node> children = new HashMap();
+    int end;
+    public Node(char c){
+        this.c = c;
+    }
+}
+
+class Trie {
+    Node root;
+    String[] words;
+    public Trie() {
+        root = new Node('0');
+    }
+
+    public void insert(String word, int index) {
+        Node cur = root;
+        for (char c: word.toCharArray()) {
+            cur.children.putIfAbsent(c, new Node(c));
+            cur = cur.children.get(c);
+        }
+        cur.end = index;
+    }
+
+    public String dfs() {
+        String ans = "";
+        Stack<Node> stack = new Stack();
+        stack.push(root);
+        while (!stack.empty()) {
+            Node node = stack.pop();
+            if (node.end > 0 || node == root) {
+                if (node != root) {
+                    String word = words[node.end - 1];
+                    if (word.length() > ans.length() ||
+                            word.length() == ans.length() && word.compareTo(ans) < 0) {
+                        ans = word;
+                    }
+                }
+                for (Node nei: node.children.values()) {
+                    stack.push(nei);
+                }
+            }
+        }
+        return ans;
+    }
+}
diff --git a/python/720_Longest_Word_in_Dictionary.py b/python/720_Longest_Word_in_Dictionary.py
@@ -0,0 +1,36 @@
+class Solution(object):
+    # def longestWord(self, words):
+    #     words.sort()
+    #     words_set, longest_word = set(['']), ''
+    #     for word in words:
+    #         if word[:-1] in words_set:
+    #             words_set.add(word)
+    #             if len(word) > len(longest_word):
+    #                 longest_word = word
+    #     return longest_word
+
+    # def longestWord(self, words):
+    #     ans = ""
+    #     wordset = set(words)
+    #     for word in words:
+    #         if len(word) > len(ans) or len(word) == len(ans) and word < ans:
+    #             if all(word[:k] in wordset for k in xrange(1, len(word))):
+    #                 ans = word
+    #     return ans
+
+    def longestWord(self, words):
+        Trie = lambda: collections.defaultdict(Trie)
+        trie = Trie()
+        END = True
+        for i, word in enumerate(words):
+            reduce(dict.__getitem__, word, trie)[END] = i
+        stack = trie.values()
+        ans = ""
+        while stack:
+            cur = stack.pop()
+            if END in cur:
+                word = words[cur[END]]
+                if len(word) > len(ans) or len(word) == len(ans) and word < ans:
+                    ans = word
+                stack.extend([cur[letter] for letter in cur if letter != END])
+        return ans
