[TONY] WEEK 5 Solution

3sum/TonyKim9401.java

@@ -0,0 +1,30 @@
+// TC: O(n^2)
+// SC: O(n)
+public class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        Arrays.sort(nums);
+
+        List<List<Integer>> output = new ArrayList<>();
+        Map<Integer, Integer> map = new HashMap<>();
+
+        for (int i = 0; i < nums.length; ++i) map.put(nums[i], i);
+
+        for (int i = 0; i < nums.length - 2; ++i) {
+            if (nums[i] > 0) break;
+
+            for (int j = i + 1; j < nums.length - 1; ++j) {
+                int cValue = -1 * (nums[i] + nums[j]);
+
+                if (map.containsKey(cValue) && map.get(cValue) > j) {
+                    output.add(List.of(nums[i], nums[j], cValue));
+                }
+                j = map.get(nums[j]);
+            }
+
+            i = map.get(nums[i]);
+        }
+
+        return output;
+    }
+}

best-time-to-buy-and-sell-stock/TonyKim9401.java

@@ -0,0 +1,16 @@
+// TC: O(n)
+// SC: O(1)
+class Solution {
+    public int maxProfit(int[] prices) {
+        int bestProfit = 0;
+        int buyPrice = prices[0];
+        for (int i = 1; i < prices.length; i++) {
+            if (buyPrice > prices[i]) {
+                buyPrice = prices[i];
+                continue;
+            }
+            bestProfit = Math.max(bestProfit, prices[i] - buyPrice);
+        }
+        return bestProfit;
+    }
+}

group-anagrams/TonyKim9401.java

@@ -0,0 +1,25 @@
+// TC: O(n * m log m)
+// SC: O(n * m)
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        List<List<String>> output = new ArrayList<>();
+        Map<String, List<String>> map = new HashMap<>();
+
+        for (int i = 0; i < strs.length; i++) {
+            char[] charArray = strs[i].toCharArray();
+            Arrays.sort(charArray);
+            String target = new String(charArray);
+
+            if (map.containsKey(target)) {
+                map.get(target).add(strs[i]);
+            } else {
+                List<String> inside = new ArrayList<>();
+                inside.add(strs[i]);
+                map.put(target, inside);
+            }
+        }
+
+        for (String key : map.keySet()) output.add(map.get(key));
+        return output;
+    }
+}

implement-trie-prefix-tree/TonyKim9401.java

@@ -0,0 +1,56 @@
+class TrieNode {
+    TrieNode[] children;
+    boolean isEndOfWord;
+
+    public TrieNode() {
+        children = new TrieNode[26];
+        isEndOfWord = false;
+    }
+}
+
+class Trie {
+
+    private TrieNode root;
+
+    public Trie() {
+        root = new TrieNode();
+    }
+
+    // TC: O(n)
+    // SC: O(n * m)
+    // -> word length * new TrieNode spaces
+    public void insert(String word) {
+        TrieNode node = root;
+        for (char c : word.toCharArray()) {
+            int idx = c - 'a';
+            if (node.children[idx] == null) {
+                node.children[idx] = new TrieNode();
+            }
+            node = node.children[idx];
+        }
+        node.isEndOfWord = true;
+    }
+
+    // TC: O(n)
+    // SC: O(1)
+    public boolean search(String word) {
+        TrieNode node = searchPrefix(word);
+        return node != null && node.isEndOfWord;
+    }
+
+    // TC: O(n)
+    // SC: O(1)
+    private TrieNode searchPrefix(String word) {
+        TrieNode node = root;
+        for (char c : word.toCharArray()) {
+            int idx = c - 'a';
+            if (node.children[idx] == null) return null;
+            node = node.children[idx];
+        }
+        return node;
+    }
+
+    public boolean startsWith(String prefix) {
+        return searchPrefix(prefix) != null;
+    }
+}

word-break/TonyKim9401.java

@@ -0,0 +1,22 @@
+// TC: O(n^2)
+// -> use 2 for-loops to search
+// SC: O(n)
+// -> boolean array's size
+class Solution {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        Set<String> set = new HashSet(wordDict);
+
+        boolean[] dp = new boolean[s.length() + 1];
+        dp[0] = true;
+
+        for (int i = 1; i <= s.length(); i++) {
+            for (int j = 0; j < i; j++) {
+                if (dp[j] && set.contains(s.substring(j, i))) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[s.length()];
+    }
+}