[JeonJe] WEEK 05 Solutions

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

@@ -0,0 +1,18 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(1)
+class Solution {
+    public int maxProfit(int[] prices) {
+        int n = prices.length;
+        int maxProfit = 0;
+        int minPrice = prices[0];
+
+        for (int sellDay = 1; sellDay < n; sellDay++) {
+            minPrice = Math.min(minPrice, prices[sellDay]);
+            maxProfit = Math.max(maxProfit, prices[sellDay] - minPrice);
+        }
+
+        return maxProfit;
+    }
+}

encode-and-decode-strings/JeonJe.java

@@ -0,0 +1,34 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+
+    private static final String DELIMITER = ",";
+
+    // ["mydata"] -> "6,mydata"
+    public String encode(List<String> strs) {
+        StringBuilder sb = new StringBuilder();
+        for (String s : strs) {
+            sb.append(s.length()).append(DELIMITER).append(s);
+        }
+        return sb.toString();
+    }
+
+    // "6,mydata" -> ["mydata"]
+    public List<String> decode(String str) {
+        List<String> answer = new ArrayList<>();
+
+        int cursor = 0;
+        while (cursor < str.length()) {
+            int indexOfDelimiter = str.indexOf(DELIMITER, cursor);
+            int dataStart = indexOfDelimiter + 1;
+            int dataLength = Integer.parseInt(str.substring(cursor, indexOfDelimiter));
+
+            answer.add(str.substring(dataStart, dataStart + dataLength));
+            cursor = dataStart + dataLength;
+        }
+
+        return answer;
+    }
+}

group-anagrams/JeonJe.java

@@ -0,0 +1,24 @@
+import java.util.*;
+
+// TC: O(n * k log k)
+// SC: O(n * k)
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        List<List<String>> answer = new ArrayList<>();
+        Map<String, List<String>> map = new HashMap<>();
+
+        for (String str : strs) {
+            char[] charArray = str.toCharArray();
+            Arrays.sort(charArray);
+            String sortedStr = String.valueOf(charArray);
+
+            map.computeIfAbsent(sortedStr, k -> new ArrayList<>()).add(str);
+        }
+
+        for (String s : map.keySet()) {
+            answer.add(map.get(s));
+        }
+
+        return answer;
+    }
+}

implement-trie-prefix-tree/JeonJe.java

@@ -0,0 +1,47 @@
+// TC: O(L)
+// SC: O(N * L)
+class TrieNode {
+
+    public boolean isEnd;
+    public TrieNode[] children = new TrieNode[26];
+}
+
+class Trie {
+
+    private final TrieNode root;
+
+    public Trie() {
+        root = new TrieNode();
+    }
+
+    public void insert(String word) {
+        TrieNode node = root;
+        for (char c : word.toCharArray()) {
+            if (node.children[c - 'a'] == null) {
+                node.children[c - 'a'] = new TrieNode();
+            }
+            node = node.children[c - 'a'];
+        }
+        node.isEnd = true;
+    }
+
+    public boolean search(String word) {
+        TrieNode node = traverse(word);
+        return node != null && node.isEnd;
+    }
+
+    public boolean startsWith(String prefix) {
+        return traverse(prefix) != null;
+    }
+
+    private TrieNode traverse(String sequence) {
+        TrieNode node = root;
+        for (char c : sequence.toCharArray()) {
+            if (node.children[c - 'a'] == null) {
+                return null;
+            }
+            node = node.children[c - 'a'];
+        }
+        return node;
+    }
+}

word-break/JeonJe.java

@@ -0,0 +1,51 @@
+import java.util.*;
+
+// n = s.length(), m = wordDict.size(), L = 사전 단어의 최대 길이
+// TC: O(n * m * L)
+// SC: O(n)
+class Solution {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        int n = s.length();
+
+        // dp[i] = 인덱스 i부터 시작하는 뒷부분을 사전 단어로 빈틈없이 쪼갤 수 있는가
+        boolean[] dp = new boolean[n + 1];
+        dp[n] = true;
+
+        // dp[i]는 자기보다 오른쪽의 dp[i + word.length()]를 참조하므로 뒤에서 앞으로 채운다
+        for (int i = n - 1; i >= 0; i--) {
+            for (String word : wordDict) {
+                // startsWith(word, i)는 substring 없이 i번째부터 비교한다
+                if (s.startsWith(word, i) && dp[i + word.length()]) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+
+        return dp[0];
+    }
+}
+
+// 첫 번째 풀이 — top-down 재귀 + 메모이제이션 (TC: O(n^2 * m), SC: O(n^2))
+// 남은 뒷부분을 문자열 그대로 메모 key로 써서 substring으로 새 문자열을 만들고 그 문자열을 n개까지 저장한다.
+//
+// public boolean wordBreak(String s, List<String> wordDict) {
+//     return dfs(s, wordDict, new HashMap<>());
+// }
+//
+// private boolean dfs(String s, List<String> wordDict, Map<String, Boolean> memo) {
+//     if (s.isEmpty()) return true;
+//     if (memo.containsKey(s)) return memo.get(s);
+//
+//     for (String word : wordDict) {
+//         if (s.startsWith(word)) {
+//             if (dfs(s.substring(word.length()), wordDict, memo)) {
+//                 memo.put(s, true);
+//                 return true;
+//             }
+//         }
+//     }
+//
+//     memo.put(s, false);
+//     return false;
+// }