Merge pull request #170 from leokim0922/main

[Leo] 10th Week solutions

Author: leokim0922

graph-valid-tree/Leo.py

@@ -0,0 +1,18 @@
+class Solution:
+    def validTree(self, n: int, edges: List[List[int]]) -> bool:
+        # filter false cases by definition of tree
+        if n - 1 != len(edges):
+            return False
+
+        nodes = set()
+
+        for i, edge in enumerate(edges):
+            nodes.add(edge[0])
+            nodes.add(edge[1])
+
+            if i + 1 > len(nodes) - 1:
+                return False
+
+        return True
+
+        ## TC: O(num(edges)), SC: P(num(nodes))

house-robber-ii/Leo.py

@@ -0,0 +1,16 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n == 1:
+            return nums[0]
+
+        def robrob(nums):
+            rob1, rob2 = 0, 0
+            for i in range(len(nums)):
+                rob1, rob2 = rob2, max(nums[i] + rob1, rob2)
+
+            return rob2
+
+        return max(robrob(nums[:n - 1]), robrob(nums[1:]))
+
+        ## TC: O(n), SC: O(1)

house-robber/Leo.py

@@ -0,0 +1,10 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        rob, not_rob = 0, 0
+
+        for i in nums:
+            rob, not_rob = not_rob + i, max(rob, not_rob)
+
+        return max(rob, not_rob)
+
+        ## TC: O(n), SC: O(1)

longest-palindromic-substring/Leo.py

@@ -0,0 +1,23 @@
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        if s == s[::-1]:
+            return s
+
+        start, max_length = 0, 1
+
+        for i in range(1, len(s)):
+            odd_s = i - max_length - 1
+            even_s = i - max_length
+            odd_p = s[odd_s:i + 1]
+            even_p = s[even_s:i + 1]
+
+            if odd_s >= 0 and odd_p == odd_p[::-1]:
+                start = odd_s
+                max_length += 2
+            elif even_p == even_p[::-1]:
+                start = even_s
+                max_length += 1
+
+        return s[start:start + max_length]
+
+        ## TC: O(n^2), SC: O(1)

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

@@ -0,0 +1,26 @@
+class Solution:
+    def countComponents(self, n: int, edges: List[List[int]]) -> int:
+
+        graph = collections.defaultdict(list)
+
+        for x, y in edges:
+            graph[x].append(y)
+            graph[y].append(x)
+
+        def dfs(node, visited):
+            visited.add(node)
+            for neighbor in graph[node]:
+                if neighbor not in visited:
+                    dfs(neighbor, visited)
+
+        count = 0
+        visited = set()
+
+        for node in range(n):
+            if node not in visited:
+                dfs(node, visited)
+                count += 1
+
+        return count
+
+        ## TC && SC: O(num(edge) + num(node))