Merge pull request #1055 from Chaedie/main

[Chaedie] Week 12

Author: Chaedie

non-overlapping-intervals/Chaedie.py

@@ -0,0 +1,21 @@
+"""
+Solution: 직접 풀지 못해 해설을 통해 이해하고 풀었습니다. 
+    Interval 문제가 계속 어렵네요.. 😂
+Time: O(n)
+Space: O(1)
+"""
+
+
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        intervals.sort()
+
+        res = 0
+        prevEnd = intervals[0][1]
+        for start, end in intervals[1:]:
+            if start >= prevEnd:
+                prevEnd = end
+            else:
+                res += 1
+                prevEnd = min(end, prevEnd)
+        return res

number-of-connected-components-in-an-undirected-graph/Chaedie.py

@@ -0,0 +1,38 @@
+"""
+Solution: 
+    인접 그래프를 그려준다.
+    dfs 해준다.
+    중복제거를 위해 visit set 을 사용해야한다.
+    모든 노드에 대해 dfs 를 하되 갯수를 count 한다.
+Time: O(n)
+Space: O(n)
+"""
+
+
+class Solution:
+    def countComponents(self, n: int, edges: List[List[int]]) -> int:
+
+        # 인접 리스트
+        graph = {i: [] for i in range(n)}
+        for a, b in edges:
+            graph[a].append(b)
+            graph[b].append(a)
+
+        visit = set()
+
+        def dfs(node):
+            if node in visit:
+                return
+
+            visit.add(node)
+            for i in graph[node]:
+                if i not in visit:
+                    dfs(i)
+
+        count = 0
+        for i in range(n):
+            if i not in visit:
+                count += 1
+                dfs(i)
+
+        return count

remove-nth-node-from-end-of-list/Chaedie.py

@@ -0,0 +1,55 @@
+"""
+Solution:
+    재귀를 통해 끝까지 간뒤 n번째 pop 될때 노드를 삭제해준다.
+Time: O(n)
+Space: O(n)
+"""
+
+
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        dummy = ListNode()
+        dummy.next = head
+
+        count = 0
+
+        def dfs(node, prev):
+            nonlocal count
+            if not node:
+                return
+
+            dfs(node.next, node)
+            count += 1
+            if count == n:
+                prev.next = node.next
+
+        dfs(head, dummy)
+        return dummy.next
+
+
+"""
+Solution: 
+    1) 2 Pointer 로 size - n 까지 이동
+    2) prev 와 curr.next 를 연결
+Time: O(n)
+Space: O(1)
+"""
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        
+        dummy = ListNode(0, head)
+        prev = dummy
+        curr = tail = head
+
+        while n > 0:
+            tail = tail.next
+            n -= 1
+
+        while tail:
+            prev = prev.next
+            curr = curr.next
+            tail = tail.next
+        
+        prev.next = curr.next
+        
+        return dummy.next

same-tree/Chaedie.py

@@ -0,0 +1,17 @@
+"""
+Solution: val 이 같고, left, right 이 같으면 된다.
+Time: O(n)
+Space: O(n)
+"""
+
+
+class Solution:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
+
+        if q and p and q.val != p.val:
+            return False
+        if not p and not q:
+            return True
+        if (not p and q) or (p and not q):
+            return False
+        return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

serialize-and-deserialize-binary-tree/Chaedie.py

@@ -0,0 +1,47 @@
+class Codec:
+    """
+    Solution: DFS
+    Time: O(n)
+    Space: O(n)
+    """
+
+    def serialize(self, root):
+        arr = []
+
+        def dfs(node):
+            if not node:
+                arr.append("null")
+                return
+
+            arr.append(str(node.val))
+            dfs(node.left)
+            dfs(node.right)
+
+        dfs(root)
+
+        return ",".join(arr)
+
+    """
+    Solution: DFS
+    Time: O(n)
+    Space: O(n)
+    """
+
+    def deserialize(self, data):
+        vals = data.split(",")
+        self.i = 0
+
+        def dfs():
+            if vals[self.i] == "null":
+                self.i += 1
+                return None
+
+            node = TreeNode()
+            node.val = vals[self.i]
+            self.i += 1
+            node.left = dfs()
+            node.right = dfs()
+
+            return node
+
+        return dfs()