[parkhojeong] WEEK 01 Solutions

contains-duplicate/parkhojeong.cpp

@@ -0,0 +1,17 @@
+// Time Complexity: O(n) on average
+// Space Complexity: O(n)
+
+#include <unordered_set>
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_set<int> seen;
+        for(int n: nums) {
+            if(seen.count(n)) return true;
+            seen.insert(n);
+        }
+
+        return false;
+    }
+};

house-robber/parkhojeong.cpp

@@ -0,0 +1,23 @@
+// Time Complexity: O(n)
+// Space Complexity: O(n), including memoization and recursion stack
+
+class Solution {
+public:
+
+    int rob(vector<int>& nums) {
+        int N = nums.size();
+        vector<int> cache(N, -1);
+
+        function<int(int)> recur = [&](int cur) -> int {
+            if (cur >= N) return 0;
+            if (cache[cur] != -1) return cache[cur];
+
+            int a = recur(cur + 1);
+            int b = recur(cur + 2) + nums[cur];
+
+            return cache[cur] = max(a, b);
+        };
+
+        return recur(0);
+    }
+};

longest-consecutive-sequence/parkhojeong.cpp

@@ -0,0 +1,20 @@
+// Time Complexity: O(n) on average
+// Space Complexity: O(n)
+
+class Solution {
+public:
+    int longestConsecutive(vector<int>& nums) {
+        int N = nums.size();
+        unordered_set<int> s(nums.begin(), nums.end());
+        int best = 0;
+        for(int x: s) {
+            if(s.count(x - 1)) continue;
+
+            int len = 1;
+            while(s.count(x + len)) len++;
+            best = max(best, len);
+        }
+
+        return best;
+    }
+};

top-k-frequent-elements/parkhojeong.cpp

@@ -0,0 +1,22 @@
+// Time Complexity: O(n) on average
+// Space Complexity: O(n)
+
+#include <unordered_map>
+
+class Solution {
+public:
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        unordered_map<int, int> freq;
+        for(int n: nums) freq[n]++;
+
+        vector<vector<int>> bucket(nums.size() + 1);
+        for (auto& [num, f]: freq) bucket[f].push_back(num);
+
+
+        vector<int> res;
+        for (int f = nums.size(); f >= 1 && res.size() < k; f--)
+            for (int n: bucket[f]) res.push_back(n);
+
+        return res;
+    }
+};

two-sum/parkhojeong.cpp

@@ -0,0 +1,21 @@
+// Time Complexity: O(n) on average
+// Space Complexity: O(n)
+
+#include <unordered_map>
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> index_of;
+
+        for (int i = 0; i < nums.size(); i++) {
+            int complement = target - nums[i];
+
+            if (index_of.count(complement)) {
+                return {index_of[complement], i};
+            }
+            index_of[nums[i]] = i;
+        }
+        return {};
+    }
+};