Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

find-median-from-data-stream/shinsj4653.py

@@ -0,0 +1,15 @@
+"""
+[문제풀이]
+# Inputs
+
+# Outputs
+
+# Constraints
+
+# Ideas
+
+[회고]
+
+"""
+
+

find-median-from-data-stream/sungjinwi.cpp

@@ -0,0 +1,68 @@
+/*
+    풀이 :
+        maxHeap과 minHeap 사용
+
+        heap에 담긴 총 수 : N
+
+        addNum()
+            작은 수 집합은 maxHeap, 큰 수 집합은 minHeap에 담는다
+            minHeap과 maxHeap의 개수차이를 1로 유지하면서 addNum
+
+            TC : O (log N)
+                힙에 넣고 뺄 때 O (logN) 의 시간 소요
+
+            SC : O (N)
+                총 힙 크기는 N에 비례
+
+        findMedian()
+            더 크게 유지되는 것은 minHeap이므로 둘 의 개수가 같지 않을경우(총 홀수개) minHeap.top() 리턴
+            같을 경우 총개수가 짝수개이므로 두 힙.top()의 평균을 리턴
+
+            TC : O (1)
+                각 힙에서 root값 확인은 O(1)의 시간 소요
+            SC : O (1)
+*/
+
+#include <queue>
+#include <vector>
+using namespace std;
+
+class MedianFinder {
+    public:
+        priority_queue<int> maxHeap;
+        priority_queue<int, vector<int>, greater<int>> minHeap;
+        
+        MedianFinder() {
+            
+        }
+        
+        void addNum(int num) {
+            if (minHeap.empty() || num >= minHeap.top())
+                minHeap.push(num);
+            else
+                maxHeap.push(num);
+            
+            if (minHeap.size() > maxHeap.size() + 1) {
+                maxHeap.push(minHeap.top());
+                minHeap.pop();
+            }
+            else if (maxHeap.size() > minHeap.size()) {
+                minHeap.push(maxHeap.top());
+                maxHeap.pop();
+            }
+        }
+        
+        double findMedian() {
+            if (maxHeap.size() == minHeap.size())
+                return static_cast<double>(maxHeap.top() + minHeap.top()) / 2;
+            else
+                return minHeap.top();
+        }
+    };
+    
+    /**
+     * Your MedianFinder object will be instantiated and called as such:
+     * MedianFinder* obj = new MedianFinder();
+     * obj->addNum(num);
+     * double param_2 = obj->findMedian();
+     */

insert-interval/shinsj4653.py

@@ -0,0 +1,16 @@
+"""
+[문제풀이]
+# Inputs
+
+# Outputs
+
+# Constraints
+
+# Ideas
+
+[회고]
+
+"""
+
+
+

insert-interval/sungjinwi.cpp

@@ -0,0 +1,43 @@
+/*
+    풀이 :
+        기존 배열 중 start가 newInterval보다 빠르면서 newInterval과 겹치지 않는 요소들 result에 push
+        겹치는 요소들은 newInterval에 통합 후 result에 push
+        그 후 나머지 겹치지 않는 부분 result에 push
+
+    intervals 개수 : N
+
+    TC : O (N)
+    
+    SC : O (1)
+        리턴하는 배열 외에 추가 공간 사용 X
+*/
+
+#include <vector>
+using namespace std;
+
+class Solution {
+    public:
+        vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
+            vector<vector<int>> result;
+            int i = 0;
+            int n = intervals.size();
+    
+            while (i < n && intervals[i][1] < newInterval[0]) {
+                result.push_back(intervals[i]);
+                i++;
+            }
+    
+            while (i < n && intervals[i][0] <= newInterval[1]) {
+                newInterval[0] = min(intervals[i][0], newInterval[0]);
+                newInterval[1] = max(intervals[i][1], newInterval[1]);
+                i++;
+            }
+            result.push_back(newInterval);
+    
+            while (i < n) {
+                result.push_back(intervals[i]);
+                i++;
+            }
+            return result;
+        }
+    };

kth-smallest-element-in-a-bst/shinsj4653.py

@@ -0,0 +1,15 @@
+"""
+[문제풀이]
+# Inputs
+
+# Outputs
+
+# Constraints
+
+# Ideas
+
+[회고]
+
+"""
+
+

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

@@ -0,0 +1,44 @@
+/*
+    풀이 : 
+        중위순회로 트리를 순회하면서 순서대로 vector에 담는다
+        BST는 중위순회 시 크기 순서로 탐색되므로 vector에서 k번째인 요소를 return
+
+    트리 개수 : N
+
+    TC : O (N)
+        모든 트리 dfs로 순회
+
+    SC : O (N)
+        배열 크기는 트리 개수에 비례
+*/
+
+#include <vector>
+using namespace std;
+/**
+ * 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) {
+            vector<int> v;
+            dfs(root, v);
+            return v[k - 1];
+        }
+        void dfs(TreeNode* root, vector<int>& v) {
+            if (!root)
+                return ;
+            if (root->left)
+                dfs(root->left, v);
+            v.push_back(root->val);
+            if (root->right)
+                dfs(root->right, v);
+        }
+    };

lowest-common-ancestor-of-a-binary-search-tree/shinsj4653.py

@@ -0,0 +1,15 @@
+"""
+[문제풀이]
+# Inputs
+
+# Outputs
+
+# Constraints
+
+# Ideas
+
+[회고]
+
+"""
+
+

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

@@ -0,0 +1,44 @@
+/* 
+    풀이 : 
+        현재 root를 기준으로 p, q가 어딨는지 판별
+        p, q값이 모두 root 보다 작으면 왼쪽, 모두 root 보다 크면 오른쪽 노드로 이동
+        그 외의 경우 (root 값이 p 또는 q와 같을 경우, p와 q사이에 있는 경우)에는
+        현재 root가 LCA이므로 root 리턴
+
+    트리 높이 : H
+    
+    TC : O (H)
+        반복문이 트리 높이에 비례
+
+    SC : O (1)
+*/
+
+
+#include <algorithm>
+using namespace std;
+/**
+ * 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) {
+            int small = min(p->val, q->val);
+            int big = max(p->val, q->val);
+            while (root) {
+                if (root->val > big)
+                    root = root->left;
+                else if (root->val < small)
+                    root = root->right;
+                else
+                    break;
+            }
+            return root;
+        }
+    };

meeting-rooms/YoungSeok-Choi.java

@@ -0,0 +1,39 @@
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+class Interval {
+    int start, end;
+
+    Interval(int start, int end) {
+        this.start = start;
+        this.end = end;
+    }
+}
+
+class Solution {
+
+    public boolean canAttendMeetings(List<Interval> intervals) {
+        Collections.sort(intervals, new Comparator<Interval>() {
+            @Override
+            public int compare(Interval i1, Interval i2) {
+                if (i1.start == i2.start) {
+                    return i1.end - i2.end;
+                }
+
+                return i1.start - i2.start;
+            }
+        });
+
+        int prevEnd = -987654321;
+        for (Interval anInt : intervals) {
+            if (anInt.start < prevEnd) {
+                return false;
+            }
+
+            prevEnd = anInt.end;
+        }
+
+        return true;
+    }
+}

meeting-rooms/shinsj4653.py

@@ -0,0 +1,43 @@
+"""
+[문제풀이]
+# Inputs
+[(0, 8), (8, 10)] -> 튜플 배열
+
+# Outputs
+모든 미팅 시간에 대해 참여할 수 있는지에 대한 여부
+
+# Constraints
+0 <= intervals 배열 <= 10^4
+구간 길이 : 2
+
+
+# Ideas
+정렬 후 각 요소 순회히면서, 첫번째 오른쪽 값보다 두번째 왼쪽 값이 크거나 같으면 통과
+아니면 false?
+
+[회고]
+
+"""
+
+
+class Solution:
+    """
+    @param intervals: an array of meeting time intervals
+    @return: if a person could attend all meetings
+    """
+
+    def can_attend_meetings(self, intervals: List[Interval]) -> bool:
+        # Write your code here
+
+        intervals.sort(key=lambda x: (x[0]))
+        for i in range(len(intervals) - 1):
+            if intervals[i][1] > intervals[i + 1][0]:
+                return False
+
+        return True
+
+
+# 해설
+# 제출 코드와 동일!
+
+