update java solution

Author: tiationg-kho

README.md

@@ -0,0 +1,66 @@
+class Trie {
+
+    TrieNode root;
+
+    public Trie() {
+        root = new TrieNode();
+    }
+    
+    public void insert(String word) {
+        TrieNode node = root;
+        for (int i = 0; i < word.length(); i++) {
+            Character c = word.charAt(i);
+            if (!node.children.containsKey(c)) {
+                node.children.put(c, new TrieNode());
+            }
+            node = node.children.get(c);
+        }
+        node.isWord = true;
+    }
+    
+    public boolean search(String word) {
+        TrieNode node = root;
+        for (int i = 0; i < word.length(); i++) {
+            Character c = word.charAt(i);
+            if (!node.children.containsKey(c)) {
+                return false;
+            }
+            node = node.children.get(c);
+        }
+        return node.isWord;
+    }
+    
+    public boolean startsWith(String prefix) {
+        TrieNode node = root;
+        for (int i = 0; i < prefix.length(); i++) {
+            Character c = prefix.charAt(i);
+            if (!node.children.containsKey(c)) {
+                return false;
+            }
+            node = node.children.get(c);
+        }
+        return true;
+    }
+}
+
+class TrieNode {
+    HashMap<Character, TrieNode> children;
+    boolean isWord;
+
+    public TrieNode() {
+        children = new HashMap<>();
+        isWord = false;
+    }
+}
+
+/**
+* Your Trie object will be instantiated and called as such:
+* Trie obj = new Trie();
+* obj.insert(word);
+* boolean param_2 = obj.search(word);
+* boolean param_3 = obj.startsWith(prefix);
+*/
+
+// time O(L) for insert(), search(), startsWith(), L is the word's length
+// space O(nL), n is the number of words, L is the max len
+// using trie and standard trie

[G]trie/[G]trie/208-implement-trie-prefix-tree.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int[] res = new int[nums.length];
+        Arrays.fill(res, 1);
+        int total = 1;
+        for (int i = 0; i < nums.length; i++) {
+            res[i] = total;
+            total *= nums[i];
+        }
+        total = 1;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            res[i] *= total;
+            total *= nums[i];
+        }
+        return res;
+    }
+}
+
+// time O(n)
+// space O(1), not counting output list
+// using array and prefix sum and standard prefix sum

[H]array/[H]array-prefix-sum/238-product-of-array-except-self.java

@@ -0,0 +1,62 @@
+class MinStack {
+    ArrayDeque<Long> stack;
+    long min;
+
+    public MinStack() {
+        stack = new ArrayDeque<>();
+        min = 0;
+    }
+    
+    public void push(int val) {
+        if (stack.isEmpty()) {
+            min = val;
+            stack.push(0L);
+        } else {
+            long diff = val - min;
+            if (diff < 0) {
+                min = val;
+                stack.push(diff);
+            } else {
+                stack.push(diff);
+            }
+        }
+    }
+    
+    public void pop() {
+        Long diff = stack.peek();
+        if (diff < 0) {
+            min += Math.abs(diff);
+            stack.pop();
+        } else {
+            stack.pop();
+        }
+        if (stack.isEmpty()) {
+            min = 0;
+        }
+    }
+    
+    public int top() {
+        Long diff = stack.peek();
+        if (diff < 0) {
+            return (int) min;
+        }
+        return (int) (min + diff);
+    }
+    
+    public int getMin() {
+        return (int) min;
+    }
+}
+
+/**
+* Your MinStack object will be instantiated and called as such:
+* MinStack obj = new MinStack();
+* obj.push(val);
+* obj.pop();
+* int param_3 = obj.top();
+* int param_4 = obj.getMin();
+*/
+
+// time O(1)
+// space O(n)
+// using stack and queue and implement stack/queue and one stack

[I]stack-queue/[I]stack-queue/155-min-stack.java

@@ -0,0 +1,39 @@
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        HashMap<Integer, List<Integer>> graph = new HashMap<>();
+        HashMap<Integer, Integer> indegrees = new HashMap<>();
+        for (int i = 0; i < numCourses; i++) {
+            graph.put(i, new ArrayList<>());
+            indegrees.put(i, 0);
+        }
+        for (int[] prereq: prerequisites) {
+            int q = prereq[0];
+            int p = prereq[1];
+            graph.get(p).add(q);
+            indegrees.put(q, indegrees.get(q) + 1);
+        }
+
+        ArrayDeque<Integer> queue = new ArrayDeque<>();
+        for (Integer node: indegrees.keySet()) {
+            if (Objects.equals(indegrees.get(node), 0)) {
+                queue.offer(node);
+            }
+        }
+        ArrayList<Integer> res = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            Integer node = queue.poll();
+            res.add(node);
+            for (Integer neighbor: graph.get(node)) {
+                indegrees.put(neighbor, indegrees.get(neighbor) - 1);
+                if (Objects.equals(indegrees.get(neighbor), 0)) {
+                    queue.offer(neighbor);
+                }
+            }
+        }
+        return res.size() == numCourses;
+    }
+}
+
+// time O(V+E)
+// space O(V+E), due to building graph
+// using graph and kahn and topological sort

[K]graph/[K]graph-kahn/207-course-schedule.java

@@ -0,0 +1,22 @@
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        int[] dp = new int[amount + 1];
+        int max = Integer.MAX_VALUE;
+        Arrays.fill(dp, max);
+        dp[0] = 0;
+
+        for (int i = 0; i < coins.length; i++) {
+            for (int j = 1; j < amount + 1; j++) {
+                if (coins[i] <= j) {
+                    int cand = dp[j - coins[i]] == max ? max : dp[j - coins[i]] + 1;
+                    dp[j] = Math.min(dp[j], cand);
+                }
+            }
+        }
+        return dp[amount] == max ? - 1 : dp[amount];
+    }
+}
+
+// time O(m * n), m is the amount and n is the number of coins
+// space O(m), due to the dp list's size
+// using dynamic programming and knapsack (complete knapsack) 

[M]dynamic-programming/[M]dynamic-programming/322-coin-change.java

@@ -2089,6 +2089,23 @@ public class Main {
         System.out.println(intFromString); // 1001
         System.out.println("-----");
 
+        // char from int in O(1)
+        int asciiForA = 65;
+        char charA = (char) asciiForA;
+        System.out.println(charA); // A
+        System.out.println("-----");
+
+        // char to int in O(1)
+        char charZ = 'Z';
+        int asciiForZ = charZ + 0;
+        System.out.println(asciiForZ); // 90
+        System.out.println("-----");
+
+        // char to String in O(1)
+        String stringZ = charZ + "";
+        System.out.println(stringZ); // Z
+        System.out.println("-----");
+
         // char related methods
         char c1 = 'a';
         char c2 = 'A';