Merge branch 'DaleStudy:main' into main

Author: 8804who

contains-duplicate/WHYjun.py

@@ -0,0 +1,3 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return len(set(nums)) != len(nums)

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;
+    }
+}
+

contains-duplicate/ys-han00.cpp

@@ -0,0 +1,37 @@
+#include <bits/stdc++.h>
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        
+        for(int i = 0; i < nums.size() - 1; i++)
+            if(nums[i] == nums[i+1])
+                return true;
+
+        return false;
+    }
+};
+
+// 첫 시도 및 틀린 풀이
+// 틀린 이유:
+//   leetcode는 처음 풀어보는데, 백준보다 시간 제한이 엄격함
+//   -> 20억 배열 선언하는것만으로도 시간초과 발생
+// 
+// class Solution {
+// public:
+//     bool containsDuplicate(vector<int>& nums) {
+//         vector<bool> check(2'000'000'001, false);
+//         int offset = 1'000'000'000;
+
+//         for(int i = 0; i < nums.size(); i++) {
+//             int idx = nums[i] + offset;
+            
+//             if(check[idx] == true)
+//                 return true;
+//             check[idx] = true;
+//         }
+//         return false;
+//     }
+// };
+

house-robber/WHYjun.py

@@ -0,0 +1,21 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        # memo for DP
+        dp = {}
+        return self.robs(nums, dp, len(nums) - 1)
+
+    def robs(self, nums: List[int], dp: Dict[int, int], houseToRob: int) -> int:
+        if houseToRob < 0:
+            return 0
+        
+        if houseToRob - 2 not in dp:
+            dp[houseToRob - 2] = self.robs(nums, dp, houseToRob - 2)
+        
+        if houseToRob - 1 not in dp:
+            dp[houseToRob - 1] = self.robs(nums, dp, houseToRob - 1)
+
+
+        return max(
+            dp[houseToRob - 2] + nums[houseToRob],
+            dp[houseToRob - 1]    
+        )

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;
+    }
+}

house-robber/ys-han00.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+        vector<int> dp(nums.size(), 0);
+
+        dp[0] = nums[0];
+        if(dp.size() == 1) 
+            return dp[0];
+        
+        dp[1] = nums[1];
+        int ans = max(dp[0], dp[1]);
+        
+        for(int i = 2; i < dp.size(); i++) {
+            int maxi = -1;
+            for(int j = 0; j < i - 1; j++)
+                maxi = max(dp[j], maxi);
+            dp[i] = maxi + nums[i];
+            ans = max(ans, dp[i]);
+        }
+
+        return ans;
+    }
+};
+

longest-consecutive-sequence/WHYjun.py

@@ -0,0 +1,44 @@
+import heapq
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        # remove duplicates by using set
+        numsSet = set(nums)
+        
+        if len(numsSet) == 0 or len(numsSet) == 1:
+            return len(numsSet)
+
+        # Use priority queue to sort in O(n)
+        pq = heapq.heapify(list(numsSet))
+        
+        prev = heapq.heappop(pq)
+        answer, count = 1, 1
+        for i in range(len(numsSet) - 1):
+            popped = heapq.heappop(pq)
+            if prev + 1 == popped:
+                count += 1
+            else:
+                count = 1
+            
+            prev = popped
+            answer = max(answer, count)
+    
+        return answer
+
+    def longestConsecutiveUsingSetOnly(self, nums: List[int]) -> int:
+        # remove duplicates by using set
+        numsSet = set(nums)
+
+        answer = 0
+
+        for num in numsSet:
+            # continue if it's not the longest consecutive
+            if num - 1 in numsSet:
+                continue
+            else:
+                count = 1
+                while num + count in numsSet:
+                    count += 1
+                answer = max(answer, count)
+
+        return answer

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;
+    }
+}

longest-consecutive-sequence/ys-han00.cpp

@@ -0,0 +1,25 @@
+#include <bits/stdc++.h>
+
+class Solution {
+public:
+    int longestConsecutive(vector<int>& nums) {
+        if(nums.size() == 0) 
+            return 0;
+
+        sort(nums.begin(), nums.end());
+
+        int ans = 1, cnt = 1;
+        for(int i = 1; i < nums.size(); i++) {
+            if(nums[i] == nums[i - 1])
+                continue;
+            if(nums[i] - 1 == nums[i - 1])
+                cnt++;
+            else
+                cnt = 1;
+            ans = max(cnt, ans);
+        }
+
+        return ans;
+    }
+};
+

top-k-frequent-elements/WHYjun.py

@@ -0,0 +1,17 @@
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        # Time complexity: O(nlog(n))
+        # Space Complexity: O(n)
+
+        if len(nums) <= k:
+            return list(set(nums))
+
+        counts = {}
+        for num in nums:
+            if num not in counts:
+                counts[num] = 0
+            counts[num] += 1
+        
+        # The key of dictionary is unique.
+        sortedKeys = sorted(list(counts.keys()), key=lambda key: counts[key], reverse = True)
+        return sortedKeys[:k]