[doh6077] WEEK 11 solutions

graph-valid-tree/doh6077.py

@@ -0,0 +1,28 @@
+class Solution:
+    def validTree(self, n: int, edges: List[List[int]]) -> bool:
+        # Valid Tree
+        # 1. no loop
+        # 2. no disconnected node 
+        # Use DFS and Hashset to track visited nodes 
+        if not n:
+            return True
+
+        adj = {i:[] for i in range(n)}
+        for n1, n2 in edges:
+            adj[n1].append(n2)
+            adj[n2].append(n1)
+        visit = set()
+        def dfs(i, prev):
+            # Base case
+            if i in visit:
+                return False
+            visit.add(i)
+            # check neighbor nodes 
+            for j in adj[i]:
+                if j == prev:
+                    continue
+                if not dfs(j,i):
+                    return False
+            return True
+
+        return dfs(0, -1) and n == len(visit)

missing-number/doh6077.py

@@ -0,0 +1,16 @@
+# Missing Number
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+        # First Solution: Time Complexity: O(n^2)
+        n = len(nums)
+
+        for i in range(0,n + 1):
+            if i not in nums:
+                return i    
+
+        # Time Complexity: O(n) 
+        n = len(nums)
+        # calculate the sum of first n numbers
+        sum_val = n * (n + 1) // 2
+        return sum_val - sum(nums)
+

reorder-list/doh6077.py

@@ -0,0 +1,42 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        """
+        Do not return anything, modify head in-place instead.
+        """
+        # Time Complexity: O(N)
+        # The order: 
+        # 0, n, 1, n -1, 2, n-3 ...
+        # first Idea
+        # need to save the index of the original head 
+        # Hashmap: iterate through the head until head it none, save index as key and head.val as value 
+        head_hash = {}
+        temp = head
+        index = 0 
+        length = 0 
+        # Save index and value in the hashmap
+        while temp is not None:
+            head_hash[index] = temp.val
+            temp = temp.next 
+            index += 1
+            length += 1
+        # reset index to 0, and use it to iterate through the head again
+        index = 0 
+        # to keep track of n-1, n-2, n-3 ...
+        count = 1
+        # Iterate through the head again and change the value based on the index
+        while head is not None: 
+            res = index % 2 
+            # if the index is even number 
+            if res == 0:
+                head.val = head_hash[index/2]
+            # n, n-1, n-2 when the index is odd 
+            else:
+                head.val = head_hash[length - count]
+                count += 1 
+            index += 1
+            head = head.next