[ohgyulim] WEEK 01 solutions

contains-duplicate/ohgyulim.java

@@ -0,0 +1,18 @@
+import java.util.*;
+/* 시간 복잡도: O(N), nums.length를 n이라고 할 때, 시간 복잡도는 O(N)
+ * HashSet
+ * - contains: O(1)
+ * - add: O(1)
+ * 
+ * 공간 복잡도: O(N), Set에 최대 n개의 요소를 저장할 수 있음
+ */ 
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            if (set.contains(num)) return true;
+            set.add(num);
+        }
+        return false;
+    }
+}

house-robber/ohgyulim.java

@@ -0,0 +1,18 @@
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - for 루프: O(N)
+    * 공간 복잡도: O(N), dp배열
+    */ 
+    public int rob(int[] nums) {
+        int n = nums.length;
+        int[] dp = new int[n];
+        dp[0] = nums[0];
+        if (n > 1) dp[1] = Math.max(nums[0], nums[1]);
+        for (int i = 2; i < n; i++) {
+            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
+        }
+
+        return dp[n - 1];
+    }
+}
+

longest-consecutive-sequence/ohgyulim.java

@@ -0,0 +1,32 @@
+import java.util.*;
+
+class Solution {
+    /* 시간 복잡도: O(N)
+    * - for 루프: O(N) O(N)
+    *   - HashSet(add, contains): O(1)
+    * 
+    * 공간 복잡도: O(N), HashSet에 n개
+    */ 
+    public int longestConsecutive(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+
+        int answer = 0;
+        for (int num : set) {
+            if (!set.contains(num - 1)) {
+                int cur = num;
+                int count = 1;
+                while (set.contains(cur + 1)) {
+                    cur += 1;
+                    count += 1;
+                }
+                answer = Math.max(answer, count);
+            }
+        }
+
+        return answer;
+    }
+}
+

top-k-frequent-elements/ohgyulim.java

@@ -0,0 +1,36 @@
+import java.util.*;
+
+
+class Solution {
+    /* 시간 복잡도: O(N + M * log k)
+    * - for 루프: O(N), frequency 구하기
+    * - for 루프: O(M * log k), Map 순회
+        - Map 요소: M개
+    *   - PriorityQueue 연산 (offer, poll): 평균 O(logk)
+    * 
+    * 공간 복잡도: O(N + k), HashMap에 n개 + PriorityQueue에 k개
+    */ 
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        // [num, frequency]
+        PriorityQueue<int[]> minHeap = new PriorityQueue<>((o1, o2) -> {
+            return o1[1] - o2[1];
+        });
+        for (int num : nums) {
+            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+        }
+        for (var entry: frequencyMap.entrySet()) {
+            minHeap.add(new int[]{entry.getKey(), entry.getValue()});
+            if (minHeap.size() > k) {
+                minHeap.poll();
+            }
+        }
+
+        int[] answer = new int[k];
+        for (int i = 0; i < k; i++) {
+            answer[i] = minHeap.poll()[0];
+        }
+        return answer;
+    }
+}
+

two-sum/ohgyulim.java

@@ -0,0 +1,22 @@
+import java.util.*;
+
+class Solution {
+/* 시간 복잡도: O(N), nums.length를 n이라고 할 때, 시간 복잡도는 O(N)
+ * - for 루프: O(N)
+ * - HashMap 연산 (containsKey, put): 평균 O(1)
+ * 
+ * 공간 복잡도: O(N), HashMap에 최대 n개의 요소를 저장할 수 있음
+ */ 
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> numToIndex = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            int remains = target - nums[i];
+            if (numToIndex.containsKey(remains)) {
+                return new int[]{i, numToIndex.get(remains)};
+            }
+            numToIndex.put(nums[i], i);
+        }
+        return null;
+    }
+}
+