[hwi-middle] WEEK 13 solutions

find-median-from-data-stream/hwi-middle.cpp

@@ -0,0 +1,32 @@
+class MedianFinder {
+public:
+    MedianFinder() {
+    }
+
+    void addNum(int num) {
+        maxHeap.push(num);
+        minHeap.push(maxHeap.top());
+        maxHeap.pop();
+
+        if (maxHeap.size() < minHeap.size())
+        {
+            maxHeap.push(minHeap.top());
+            minHeap.pop();
+        }
+    }
+
+    double findMedian() {
+        return maxHeap.size() > minHeap.size() ? maxHeap.top() : ((double) maxHeap.top() + minHeap.top()) * 0.5;
+    }
+
+private:
+    priority_queue<int> maxHeap;
+    priority_queue<int, vector<int>, greater<int>> minHeap;
+};
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder* obj = new MedianFinder();
+ * obj->addNum(num);
+ * double param_2 = obj->findMedian();
+ */

insert-interval/hwi-middle.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
+        int n = intervals.size();
+        vector<vector<int>> res;
+
+        int i = 0;
+        while (i < n && intervals[i][1] < newInterval[0]) 
+        {
+            res.push_back(intervals[i]);
+            i++;
+        }
+
+        while (i < n && newInterval[1] >= intervals[i][0]) 
+        {
+            newInterval[0] = min(newInterval[0], intervals[i][0]);
+            newInterval[1] = max(newInterval[1], intervals[i][1]);
+            i++;
+        }
+        res.push_back(newInterval);
+
+        while (i < n) 
+        {
+            res.push_back(intervals[i]);
+            i++;
+        }
+
+        return res;
+    }
+};

kth-smallest-element-in-a-bst/hwi-middle.cpp

@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int kthSmallest(TreeNode* root, int k) {
+        int cur = 0;
+        return impl(root, k, cur);
+    }
+
+    int impl(TreeNode* root, int k, int& cur) {
+        if (root == nullptr)
+        {
+            return -1;
+        }
+
+        int l = impl(root->left, k, cur);
+        if (l != -1)
+        {
+            return l;
+        }
+
+        if (++cur == k)
+        {
+            return root->val;
+        }
+
+        int r = impl(root->right, k, cur);
+        if (r != -1)
+        {
+            return r;
+        }
+
+        return -1;
+    }
+};

lowest-common-ancestor-of-a-binary-search-tree/hwi-middle.cpp

@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        // p와 q가 root 기준 왼쪽과 오른쪽에 나뉘어 존재하면 root가 LCA
+        while ((root->val - p->val) * (long long)(root->val - q->val) > 0LL)
+        {
+            root = root->val > p->val ? root->left : root->right;
+        }
+
+        return root;
+    }
+};

meeting-rooms/hwi-middle.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    bool canAttendMeetings(vector<vector<int>>& intervals) {
+        sort(intervals.begin(), intervals.end(), [](vector<int>& a, vector<int>& b)
+        {
+            return a[0] < b[0];
+        });
+
+        int n = intervals.size();
+        for (int i = 0; i < n - 1; ++i)
+        {
+            if (intervals[i][1] > intervals[i + 1][0])
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};