[N-0] add 720

fishercoder1534 · fishercoder1534 · commit 78dd72880142 · 2017-11-05T08:48:15.000-08:00
diff --git a/README.md b/README.md
@@ -22,6 +22,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
+|720|[Longest Word in Dictionary](https://leetcode.com/problems/longest-word-in-dictionary/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_720.java) | O(∑wi) where wi is the length of words[i] | O(∑wi) where wi is the length of words[i] | Easy | Trie
 |719|[Find K-th Smallest Pair Distance](https://leetcode.com/problems/find-k-th-smallest-pair-distance/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_719.java) | O(nlogw + nlogn) | O(1) | Hard | Binary Search
 |718|[Maximum Length of Repeated Subarray](https://leetcode.com/problems/maximum-length-of-repeated-subarray/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_718.java) | O(m*n) | O(m*n) | Medium | DP
 |717|[1-bit and 2-bit Characters](https://leetcode.com/problems/1-bit-and-2-bit-characters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_717.java) | O(n) | O(1) | Easy |
diff --git a/src/main/java/com/fishercoder/solutions/_720.java b/src/main/java/com/fishercoder/solutions/_720.java
@@ -0,0 +1,89 @@
+package com.fishercoder.solutions;
+
+/**
+ * 720. Longest Word in Dictionary.
+ *
+ * Given a list of strings words representing an English Dictionary,
+ * find 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.
+
+ 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".
+
+ Note:
+ All the strings in the input will only contain lowercase letters.
+ The length of words will be in the range [1, 1000].
+ The length of words[i] will be in the range [1, 30].
+ */
+
+public class _720 {
+    public static class Solution1 {
+        public String longestWord(String[] words) {
+            TrieNode root = buildTrie(words);
+            return findLongestWord(root, words);
+        }
+
+        private String findLongestWord(TrieNode root, String[] words) {
+            String longestWord = "";
+            for (String word : words) {
+                if (longestWord.length() > word.length() || (longestWord.length() == word.length() && (longestWord.compareToIgnoreCase(word) < 0))) {
+                    continue;
+                }
+                TrieNode tmp = root;
+                boolean validWord = true;
+                for (char c : word.toCharArray()) {
+                    if (tmp.children[c - 'a'] != null) {
+                        tmp = tmp.children[c - 'a'];
+                        if (!tmp.isWord) {
+                            validWord = false;
+                            break;
+                        }
+                    }
+                }
+                if (validWord) {
+                    longestWord = word;
+                }
+            }
+            return longestWord;
+        }
+
+        private TrieNode buildTrie(String[] words) {
+            TrieNode root = new TrieNode(' ');
+            for (String word : words) {
+                TrieNode tmp = root;
+                for (char c : word.toCharArray()) {
+                    if (tmp.children[c - 'a'] == null) {
+                        tmp.children[c - 'a'] = new TrieNode(c);
+                    }
+                    tmp = tmp.children[c - 'a'];
+                }
+                tmp.isWord = true;
+            }
+            return root;
+        }
+
+        class TrieNode {
+            char val;
+            boolean isWord;
+            TrieNode[] children;
+
+            public TrieNode(char val) {
+                this.val = val;
+                this.isWord = false;
+                this.children = new TrieNode[26];
+            }
+        }
+    }
+}
diff --git a/src/test/java/com/fishercoder/_720Test.java b/src/test/java/com/fishercoder/_720Test.java
@@ -0,0 +1,30 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._720;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class _720Test {
+    private static _720.Solution1 solution1;
+    private static String[] words;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _720.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        words = new String[]{"w", "wo", "wor", "worl", "world"};
+        assertEquals("world", solution1.longestWord(words));
+    }
+
+    @Test
+    public void test2() {
+        words = new String[]{"a", "banana", "app", "appl", "ap", "apply", "apple"};
+        assertEquals("apple", solution1.longestWord(words));
+    }
+
+}
