Add solutions related to Trie

Author: rayworks

src/main/java/org/sean/stack/MyStack.java

@@ -0,0 +1,83 @@
+package org.sean.stack;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/***
+ * 225. Implement Stack using Queues
+ */
+class MyStack {
+
+    private final Queue<Integer> queue;
+    private final Queue<Integer> queueBackup;
+
+    private boolean mainQueueUsed;
+
+    public MyStack() {
+        queue = new LinkedList<>();
+        queueBackup = new LinkedList<>();
+        mainQueueUsed = true;
+    }
+
+    public void push(int x) {
+        if (mainQueueUsed)
+            queue.offer(x);
+        else
+            queueBackup.offer(x);
+    }
+
+    public int pop() {
+        return checkTopElem(true);
+    }
+
+    private int checkTopElem(boolean needPop) {
+        if (mainQueueUsed) {
+            mainQueueUsed = !mainQueueUsed;
+            while (!queue.isEmpty()) {
+                int elem = queue.poll();
+                if (queue.isEmpty()) {
+                    if (needPop)
+                        return elem;
+                    else {
+                        queueBackup.offer(elem);
+                        return elem;
+                    }
+                } else {
+                    queueBackup.offer(elem);
+                }
+            }
+        } else {
+            mainQueueUsed = !mainQueueUsed;
+            while (!queueBackup.isEmpty()) {
+                int elem = queueBackup.poll();
+                if (queueBackup.isEmpty()) {
+                    if (needPop)
+                        return elem;
+                    else {
+                        queue.offer(elem);
+                        return elem;
+                    }
+                } else
+                    queue.offer(elem);
+            }
+        }
+        throw new IllegalStateException("");
+    }
+
+    public int top() {
+        return checkTopElem(false);
+    }
+
+    public boolean empty() {
+        return queue.isEmpty() && queueBackup.isEmpty();
+    }
+}
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * MyStack obj = new MyStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.top();
+ * boolean param_4 = obj.empty();
+ */

src/main/java/org/sean/tree/HuffmanCodec.java

@@ -1,6 +1,6 @@
 package org.sean.tree;
 
-import org.sean.trie.Trie;
+import org.sean.trie.TrieEx;
 
 import java.util.*;
 import java.util.stream.Collectors;
@@ -41,7 +41,7 @@ public String toString() {
     private final Map<String, Character> decodecMap = new HashMap<>();
     private Node root = null;
 
-    private Trie trie;
+    private TrieEx trieEx;
 
     private void buildTree(String raw) {
         pq.clear();
@@ -139,15 +139,15 @@ private void printTreeByLevel(Node root) {
 
 
     private void buildTrie() {
-        trie = new Trie();
+        trieEx = new TrieEx();
 
         for (String code : decodecMap.keySet()) {
-            trie.addWord(code);
+            trieEx.addWord(code);
         }
     }
 
     private boolean encodedStrFound(String encoded) {
-        return trie.search(encoded);
+        return trieEx.search(encoded);
     }
 
     private void buildCodecMap(Set<Character> chars) {

src/main/java/org/sean/trie/CardIssuer.java

@@ -22,18 +22,18 @@
 //
 public class CardIssuer {
     // region solution 2 : Using Trie to retrieve the prefix efficiently
-    private Trie trie;
+    private TrieEx trieEx;
 
     Map<String, String> prefixCard = new HashMap<>();
     Map<String, List<Integer>> cardLengths = new HashMap<>();
 
     private void init() {
-        trie = new Trie();
+        trieEx = new TrieEx();
 
-        trie.addWord("34");
-        trie.addWord("37");
-        trie.addWord("38");
-        trie.addWord("39");
+        trieEx.addWord("34");
+        trieEx.addWord("37");
+        trieEx.addWord("38");
+        trieEx.addWord("39");
         String[] strAmex = {"34", "37"};
         String[] strDiners = {"38", "39"};
 
@@ -42,35 +42,35 @@ private void init() {
         Arrays.stream(strAmex).forEach(s -> prefixCard.put(s, "Amex"));
         Arrays.stream(strDiners).forEach(s -> prefixCard.put(s, "Diners"));
 
-        trie.addWord("4");
+        trieEx.addWord("4");
         prefixCard.put("4", "Visa");
         cardLengths.put("Visa", Arrays.asList(13, 16, 19));
 
         for (int i = 51; i < 56; i++) {
             String s = String.valueOf(i);
-            trie.addWord(s);
+            trieEx.addWord(s);
             prefixCard.put(s, "MasterCard");
         }
         cardLengths.put("MasterCard", Arrays.asList(16));
 
-        trie.addWord("6011");
+        trieEx.addWord("6011");
         prefixCard.put("6011", "Discover");
         for (int j = 622126; j <= 622925; j++) {
-            trie.addWord(String.valueOf(j));
+            trieEx.addWord(String.valueOf(j));
             prefixCard.put(String.valueOf(j), "Discover");
         }
         for (int k = 644; k < 650; k++) {
-            trie.addWord(String.valueOf(k));
+            trieEx.addWord(String.valueOf(k));
             prefixCard.put(String.valueOf(k), "Discover");
         }
-        trie.addWord("65");
+        trieEx.addWord("65");
         prefixCard.put("65", "Discover");
         cardLengths.put("Discover", Arrays.asList(16, 19));
 
-        trie.addWord("50");
+        trieEx.addWord("50");
         prefixCard.put("50", "Maestro");
         for (int i = 56; i <= 69; i++) {
-            trie.addWord(String.valueOf(i));
+            trieEx.addWord(String.valueOf(i));
             prefixCard.put(String.valueOf(i), "Maestro");
         }
         cardLengths.put("Maestro", Arrays.asList(12, 13, 14, 15, 16, 17, 18, 19));
@@ -83,7 +83,7 @@ public String detectNetwork(String cardNumber) {
 
         StringBuilder builder = new StringBuilder();
         List<String> matchedPrefixes = new ArrayList<>();
-        trie.lookupPrefix(builder, matchedPrefixes, cardNumber, 0);
+        trieEx.lookupPrefix(builder, matchedPrefixes, cardNumber, 0);
         if (matchedPrefixes.isEmpty()) return null;
 
         String longestPrefix = builder.toString();

src/main/java/org/sean/trie/SearchHelper.java

@@ -0,0 +1,73 @@
+package org.sean.trie;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/***
+ * 1268. Search Suggestions System
+ */
+public class SearchHelper {
+    private Trie trie;
+
+    public List<List<String>> suggestedProducts(String[] products, String searchWord) {
+        // Trie + DFS
+        trie = new Trie();
+
+        for (String prod : products) {
+            trie.insert(prod);
+        }
+
+        ArrayList<List<String>> out = new ArrayList<>();
+        for (int i = 0; i < searchWord.length(); i++) {
+            out.add(new ArrayList<>());
+        }
+        lookupWords(trie, searchWord, 3, 0, out);
+
+        return out;
+    }
+
+    private void lookupWords(Trie node, String prefix, int limit, int pos, List<List<String>> out) {
+        if (pos >= prefix.length())
+            return;
+
+        char ch = prefix.charAt(pos);
+        //Trie node = this;
+        Trie next = node.children[ch - 'a'];
+
+        List<String> candidatesPerPos = new ArrayList<>();
+        if (next != null) {
+            StringBuilder builder = new StringBuilder(prefix.substring(0, pos + 1));
+            addWordsWithPrefix(next, builder, limit, candidatesPerPos);
+
+            out.get(pos).addAll(candidatesPerPos);
+
+            lookupWords(next, prefix, limit, pos + 1, out);
+        }
+        // else : break from here since no matched word found
+    }
+
+    private void addWordsWithPrefix(Trie trie, StringBuilder prev, int limit, List<String> outWords) {
+        if (outWords.size() >= limit)
+            return;
+
+        if (trie.isEndOfWord()) {
+            outWords.add(prev.toString());
+
+            // check for deeper words
+            if (trie.children.length == 0)
+                return;
+        }
+
+        for (Trie t : trie.children) {
+            if (t != null) {
+                prev.append(t.getVal());
+                int addedPos = prev.length() - 1;
+                addWordsWithPrefix(t, prev, limit, outWords);
+                prev.deleteCharAt(addedPos);
+
+                if (outWords.size() >= limit)
+                    break;
+            }
+        }
+    }
+}