[parkhojeong] WEEK 12 Solutions

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

@@ -0,0 +1,22 @@
+class Solution:
+    def countComponents(self, n: int, edges: List[List[int]]) -> int:
+        edge_dic = {i: [i] for i in range(n)}
+
+        for edge in edges:
+            start, end = sorted(edge)
+            edge_dic[start].append(end)
+            edge_dic[end].append(start)
+
+        def traverse(idx: int):
+            while edge_dic[idx]:
+                end = edge_dic[idx].pop()
+                traverse(end)
+
+        cnt = 0
+        for i in range(n):
+            if len(edge_dic[i]) > 0:
+                cnt += 1
+                traverse(i)
+
+        return cnt
+

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

@@ -0,0 +1,28 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        cnt = 0
+        cur = head
+        while cur:
+            cnt += 1
+            cur = cur.next
+
+        dummy = ListNode()
+        dummy.next = head
+        prev = dummy
+        cur = head
+        i = 0
+        while cur:
+            if cnt - n == i:
+                prev.next = cur.next
+                break
+
+            prev = cur
+            cur = cur.next
+            i += 1
+
+        return dummy.next

same-tree/parkhojeong.py

@@ -0,0 +1,22 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
+        if p is None and q is None:
+            return True
+
+        if (p is None and q is not None) or (p is not None and q is None):
+            return False
+
+        if (p.left or q.left) and not self.isSameTree(p.left, q.left):
+            return False
+
+        if (p.right or q.right) and not self.isSameTree(p.right, q.right):
+            return False
+
+        return p.val == q.val
+