Merge pull request #2002 from YuuuuuuYu/main

[YuuuuuuYu] WEEK 01 solutions

Author: YuuuuuuYu

contains-duplicate/YuuuuuuYu.java

@@ -0,0 +1,24 @@
+/**
+ * Runtime: 14ms
+ * Time Complexity: O(n)
+ *
+ * Memory: 93.59MB
+ * Space Complexity: O(n)
+ *
+ * Approach: HashSet을 사용하여 중복 검사
+ * - 배열을 순회하면서 각 원소를 HashSet에 저장
+ * - 이미 존재하는 원소를 발견하면 즉시 true 반환
+ */
+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/YuuuuuuYu.java

@@ -0,0 +1,28 @@
+/**
+ * Runtime: 0ms
+ * Time Complexity: O(n)
+ *
+ * Memory: 42.72MB
+ * Space Complexity: O(1)
+ *
+ * Approach: 두 가지 변수만 사용한 DP 접근법
+ * - withoutPrevHouse: 이전 집을 털지 않았을 때의 최대 금액
+ * - withPrevHouse: 이전 집까지 고려한 최대 금액
+ * - 각 집에서 "털거나 안 털거나" 두 가지 선택지 중 최대값 선택
+ * 1) 현재 집을 안 털면: 이전 집까지의 최대값 유지
+ * 2) 현재 집을 털면: 전전 집까지의 최대값 + 현재 집 금액
+ */
+class Solution {
+    public int rob(int[] nums) {
+        int withoutPrevHouse = 0;
+        int withPrevHouse = 0;
+
+        for (int money: nums) {
+            int maxMoney = Math.max(withPrevHouse, withoutPrevHouse+money);
+            withoutPrevHouse = withPrevHouse;
+            withPrevHouse = maxMoney;
+        }
+
+        return withPrevHouse;
+    }
+}

longest-consecutive-sequence/YuuuuuuYu.java

@@ -0,0 +1,45 @@
+/**
+ * Runtime: 26ms
+ * Time Complexity: O(n)
+ * - HashSet 구성: O(n)
+ * - 모든 원소 순회: 최악 O(n), 평균적으로 더 빠름 (조기 종료)
+ * - 연속 수열 탐색: O(n)
+ *
+ * Memory: 95.11MB
+ * Space Complexity: O(n)
+ *
+ * Approach: HashSet을 이용하여 중복 제거 후 연속 수열 길이 탐색
+ * - 연속 수열의 시작점만 탐색하여 중복 작업 방지 (num-1이 없는 경우)
+ * - 각 시작점에서 연속된 다음 숫자들을 순차적으로 탐색
+ * - nums 사이즈에 도달 시 조기 종료하여 불필요한 탐색 방지
+ */
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if (nums.length == 0) return 0;
+
+        Set<Integer> set = new HashSet<>();
+        for (int num: nums) {
+            set.add(num);
+        }
+
+        int longestLength = 0;
+        for (int num: set) {
+            if (!set.contains(num-1)) {
+                int currentNum = num;
+                int currentLength = 1;
+
+                while (set.contains(currentNum+1)) {
+                    currentNum++;
+                    currentLength++;
+                }
+
+                longestLength = longestLength < currentLength ? currentLength : longestLength;
+                if (longestLength == set.size()) {
+                    return longestLength;
+                }
+            }
+        }
+
+        return longestLength;
+    }
+}

top-k-frequent-elements/YuuuuuuYu.java

@@ -0,0 +1,35 @@
+/**
+ * Runtime: 15ms
+ * Time Complexity: O(n log n)
+ * - 빈도 계산: O(n)
+ * - 정렬: O(u log u) ≤ O(n log n)
+ * - k개 추출: O(k)
+ *
+ * Memory: 47.73MB
+ * Space Complexity: O(n)
+ * - HashMap: O(u) ≤ O(n)
+ * - List: O(u) ≤ O(n)
+ *
+ * Approach: HashMap으로 빈도 계산 후 정렬하여 top k 추출
+ * - 배열 순회하여 각 원소의 빈도 계산
+ * - 빈도 기준 내림차순 정렬
+ * - 상위 k개 원소 추출
+ */
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> frequentMap = new HashMap<>();
+        for (int num: nums) {
+            frequentMap.put(num, frequentMap.getOrDefault(num, 0)+1);
+        }
+
+        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(frequentMap.entrySet());
+        list.sort((a, b) -> b.getValue() - a.getValue());
+
+        int[] result = new int[k];
+        for (int i=0; i<k; i++) {
+            result[i] = list.get(i).getKey();
+        }
+
+        return result;
+    }
+}

two-sum/YuuuuuuYu.java

@@ -0,0 +1,25 @@
+/**
+ * Runtime: 2ms
+ * Time Complexity: O(n)
+ *
+ * Memory: 47.41MB
+ * Space Complexity: O(n)
+ *
+ * Approach: HashMap을 사용하여 짝을 이루는 값(pair) 검사
+ * - 배열을 순회하면서 각 원소의 짝을 계산
+ * - 짝이 HashMap에 존재하는지 검사
+ */
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map <Integer, Integer> map = new HashMap<>();
+        for (int i=0; i<nums.length; i++) {
+            int pair = target-nums[i];
+            if (map.containsKey(pair)) {
+                return new int[]{i, map.get(pair)};
+            }
+            map.put(nums[i], i);
+        }
+
+        return new int[]{};
+    }
+}