[영우] Week 1 풀이 제출

contains-duplicate/yeongu.cpp

@@ -0,0 +1,16 @@
+// Time complexity: o(n log n) 왜냐하면, for 문이 n이고 find 연산이 log n이기 때문.
+// Space complexity: O(n) 왜냐하면, 다 다른경우 n
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        set<int> unique;
+        for (int i : nums) {
+            if (unique.find(i) != unique.end()) {
+                return true;
+            }
+            unique.insert(i);
+        }
+        return false;
+    }
+};

kth-smallest-element-in-a-bst/yeongu.cpp

@@ -0,0 +1,27 @@
+TC: O(n log n) 왜냐하면, heap에 push연산이 log n이고 각 노드마다 실행하므로.
+SC: O(n) queue가 n까지 커질수 있음.
+
+    int kthSmallest(TreeNode* root, int k) {
+        priority_queue<int, vector<int>, greater<int>> minHeap;
+
+        // bfs
+        queue<TreeNode*> q;
+        if (root != nullptr) {
+            q.push(root);
+        };
+        while (!q.empty()) {
+            minHeap.push(q.front()->val);
+            if (q.front()->left != nullptr) {
+                q.push(q.front()->left);
+            }
+            if (q.front()->right != nullptr) {
+                q.push(q.front()->right);
+            }
+            q.pop();
+        }
+
+        for (int i = 0; i < k - 1; i++) {
+            minHeap.pop();
+        }
+        return minHeap.top();
+    }

number-of-1-bits/yeongu.cpp

@@ -0,0 +1,15 @@
+// Time complexity: O(n) 왜냐하면, while문
+// Space complexity: O(1)
+
+class Solution {
+public:
+    int hammingWeight(int n) {
+        int cnt = 0;
+        while(n>0){
+            int val = n%2;
+            cnt+=val;
+            n/=2;
+        }
+        return cnt;
+    }
+};

palindromic-substrings/yeongu.cpp

@@ -0,0 +1,42 @@
+// TC: O(n^2) For문 안에서 while문 사용하는 함수 호출
+// SC: O(1)
+
+class Solution {
+public:
+    int find_palindrome1(string& original_text, int index) {
+        int cnt = 0;
+        int left_ptr = index, right_ptr = index;
+
+        while (left_ptr >= 0 and right_ptr < original_text.size() and
+               original_text[left_ptr] == original_text[right_ptr]) {
+            cnt += 1;
+            left_ptr -= 1;
+            right_ptr += 1;
+        }
+        return cnt;
+    }
+
+    int find_palindrome2(string& original_text, int index) {
+        int cnt = 0;
+        int left_ptr = index, right_ptr = index + 1;
+
+        while (left_ptr >= 0 and right_ptr < original_text.size() and
+               original_text[left_ptr] == original_text[right_ptr]) {
+            cnt++;
+            left_ptr--;
+            right_ptr++;
+        }
+        return cnt;
+    }
+
+    int countSubstrings(string& s) {
+        int output = 0;
+        for (int i = 0; i < s.size(); i++) {
+            output += find_palindrome1(s, i);
+        }
+        for (int i = 0; i < s.size() - 1; i++) {
+            output += find_palindrome2(s, i);
+        }
+        return output;
+    }
+};

top-k-frequent-elements/yeongu.cpp

@@ -0,0 +1,30 @@
+// TC: O(n logn)
+// SC: O(n)
+
+vector<int> topKFrequent(vector<int>& nums, int k) {
+    unordered_map<int, int> frequency;
+    for (int n : nums) {
+        frequency[n] += 1;
+    }
+    auto comparator = [&frequency](int n1, int n2) {
+        return frequency[n1] > frequency[n2];
+    };
+
+    priority_queue<int, vector<int>, decltype(comparator)> min_heap(
+        comparator);
+
+    for (auto& entry : frequency) {
+        min_heap.push(entry.first);
+        if (min_heap.size() > k) {
+            min_heap.pop();
+        }
+    }
+
+    vector<int> output;
+
+    for (int i = 0; i < k; i++) {
+        output.push_back(min_heap.top());
+        min_heap.pop();
+    }
+    return output;
+}