336_Palindrome_Pairs

qiyuangong · qiyuangong · commit da6b87d5718d · 2018-11-29T22:18:29.000+08:00
diff --git a/README.md b/README.md
@@ -104,6 +104,7 @@ Remember solutions are only solutions to given problems. If you want full study
 | 298 | [Binary Tree Longest Consecutive Sequence](https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/298_Binary_Tree_Longest_Consecutive_Sequence.py) | Bottom-up or top-down recursion, O(n) and O(n) |
 | 305 | [Number of Islands II](https://leetcode.com/problems/number-of-islands-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/305_Number_of_Islands_II.py) | Quick union find with weights, O(nlogn) and O(n) |
 | 322 | [Coin Change](https://leetcode.com/problems/coin-change/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/322_Coin_Change.py) | Bottom-up or top-down DP, dp[n] = min(dp[n], dp[n - v_i]), where v_i is the coin, O(amount * n) and O(amount) |
+| 336 | [Palindrome Pairs](https://leetcode.com/problems/palindrome-pairs/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/336_Palindrome_Pairs.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/336_Palindrome_Pairs.java) | 1. Create a reverse word to index map, then for each word, check prefix and posfix, O(nk^2) and O(n)<br>2. Tire tree, O(nk^2) and O(n) |
 | 337 | [House Robber III](https://leetcode.com/problems/house-robber-iii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/337_House_Robber_III.py) | 1. Recursion with hash map, O(n) and O(n)<br>2. Recursion on two steps, O(n) and O(1) |
 | 339 | [Nested List Weight Sum](https://leetcode.com/problems/nested-list-weight-sum/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/339_Nested_List_Weight_Sum.py) | Depth-first recursion |
 | 340 | [Longest Substring with At Most K Distinct Characters](https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/340_Longest_Substring_with_At_Most_K_Distinct_Characters.py) | Maintain a sliding window with at most k distinct characters and a count for this window. Note that the start position need a loop to update.|
diff --git a/java/336_Palindrome_Pairs.java b/java/336_Palindrome_Pairs.java
@@ -0,0 +1,73 @@
+class Solution {
+    //https://leetcode.com/problems/palindrome-pairs/discuss/79195/O(n-*-k2)-java-solution-with-Trie-structure
+    private static class TrieNode {
+        TrieNode[] next;
+        int index;
+        List<Integer> list;
+            
+        TrieNode() {
+            next = new TrieNode[26];
+            index = -1;
+            list = new ArrayList<>();
+        }
+    }
+        
+    public List<List<Integer>> palindromePairs(String[] words) {
+        List<List<Integer>> res = new ArrayList<>();
+
+        TrieNode root = new TrieNode();
+            
+        for (int i = 0; i < words.length; i++) {
+            addWord(root, words[i], i);
+        }
+            
+        for (int i = 0; i < words.length; i++) {
+            search(words, i, root, res);
+        }
+        
+        return res;
+    }
+        
+    private void addWord(TrieNode root, String word, int index) {
+        for (int i = word.length() - 1; i >= 0; i--) {
+            int j = word.charAt(i) - 'a';
+                    
+            if (root.next[j] == null) {
+                root.next[j] = new TrieNode();
+            }
+                    
+            if (isPalindrome(word, 0, i)) {
+                root.list.add(index);
+            }
+                    
+            root = root.next[j];
+        }
+            
+        root.list.add(index);
+        root.index = index;
+    }
+        
+    private void search(String[] words, int i, TrieNode root, List<List<Integer>> res) {
+        for (int j = 0; j < words[i].length(); j++) {   
+            if (root.index >= 0 && root.index != i && isPalindrome(words[i], j, words[i].length() - 1)) {
+                res.add(Arrays.asList(i, root.index));
+            }
+                
+            root = root.next[words[i].charAt(j) - 'a'];
+            if (root == null) return;
+        }
+            
+        for (int j : root.list) {
+            if (i == j) continue;
+            res.add(Arrays.asList(i, j));
+        }
+    }
+        
+    private boolean isPalindrome(String word, int i, int j) {
+        while (i < j) {
+            if (word.charAt(i++) != word.charAt(j--)) return false;
+        }
+            
+        return true;
+    }
+}
diff --git a/python/336_Palindrome_Pairs.py b/python/336_Palindrome_Pairs.py
@@ -0,0 +1,21 @@
+class Solution(object):
+    def palindromePairs(self, words):
+        """
+        :type words: List[str]
+        :rtype: List[List[int]]
+        """
+        # https://leetcode.com/problems/palindrome-pairs/discuss/79219/Python-solution~
+        # reverse word and create a word to index map
+        word2index, res = dict([(w[::-1], i) for i, w in enumerate(words)]), []
+        for i, word in enumerate(words):
+            for j in xrange(len(word) + 1):
+                # Use prefix and postfix
+                # rather than going through all posible combinations
+                prefix, postfix = word[:j], word[j:]
+                # prefix + postfix + reverse(prfix)
+                if prefix in word2index and i != word2index[prefix] and postfix == postfix[::-1]:
+                    res.append([i, word2index[prefix]])
+                # reverse(postfix) + prefix + postfix
+                if j > 0 and postfix in word2index and i != word2index[postfix] and prefix == prefix[::-1]:
+                    res.append([word2index[postfix], i])
+        return res
