Fix format

Author: bhyun-kim

clone-graph/bhyun-kim.py

@@ -24,16 +24,19 @@
     - The maximum depth of the recursive call stack is the number of nodes in the graph.
 """
 
+
 # Definition for a Node.
 class Node:
-    def __init__(self, val = 0, neighbors = None):
+    def __init__(self, val=0, neighbors=None):
         self.val = val
         self.neighbors = neighbors if neighbors is not None else []
 
+
 from typing import Optional
 
+
 class Solution:
-    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+    def cloneGraph(self, node: Optional["Node"]) -> Optional["Node"]:
         if not node:
             return None
 
@@ -51,4 +54,4 @@ def dfs(node):
 
             return clone
 
-        return dfs(node)
+        return dfs(node)

course-schedule/bhyun-kim.py

@@ -31,6 +31,7 @@
 from collections import defaultdict
 from typing import List
 
+
 class Solution:
     def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
         adj_list = defaultdict(list)
@@ -45,18 +46,18 @@ def has_cycle(v):
                 return True
             if state[v] == 2:  # Node has been visited, no cycle here
                 return False
-            
+
             state[v] = 1
             for neighbor in adj_list[v]:
                 if has_cycle(neighbor):
                     return True
-            
+
             state[v] = 2
             return False
 
         for course in range(numCourses):
             if state[course] == 0:
                 if has_cycle(course):
                     return False
-        
-        return True
+
+        return True

design-add-and-search-words-data-structure/bhyun-kim.py

@@ -29,11 +29,13 @@
     - We use a trie data structure to store the words.
 """
 
+
 class TrieNode:
     def __init__(self):
         self.children = {}
         self.is_end_of_word = False
 
+
 class WordDictionary:
     def __init__(self):
         self.root = TrieNode()
@@ -50,7 +52,7 @@ def search(self, word):
         def dfs(j, node):
             for i in range(j, len(word)):
                 char = word[i]
-                if char == '.':
+                if char == ".":
                     for child in node.children.values():
                         if dfs(i + 1, child):
                             return True
@@ -60,5 +62,5 @@ def dfs(j, node):
                         return False
                     node = node.children[char]
             return node.is_end_of_word
-        
-        return dfs(0, self.root)
+
+        return dfs(0, self.root)

number-of-islands/bhyun-kim.py

@@ -23,6 +23,7 @@
 
 from typing import List
 
+
 class Solution:
     def numIslands(self, grid: List[List[str]]) -> int:
         if not grid:
@@ -33,22 +34,19 @@ def numIslands(self, grid: List[List[str]]) -> int:
         island_count = 0
 
         def dfs(i, j):
-            if i < 0 or i >= m or j < 0 or j >= n or grid[i][j] != '1':
+            if i < 0 or i >= m or j < 0 or j >= n or grid[i][j] != "1":
                 return
-            grid[i][j] = '#'
+            grid[i][j] = "#"
 
-            dfs(i - 1, j)  
-            dfs(i + 1, j)  
-            dfs(i, j - 1)  
-            dfs(i, j + 1)  
+            dfs(i - 1, j)
+            dfs(i + 1, j)
+            dfs(i, j - 1)
+            dfs(i, j + 1)
 
         for i in range(m):
             for j in range(n):
-
-                if grid[i][j] == '1':
+                if grid[i][j] == "1":
                     dfs(i, j)
                     island_count += 1
 
         return island_count
-
-        

pacific-atlantic-water-flow/bhyun-kim.py

@@ -23,9 +23,9 @@
 
 from typing import List
 
+
 class Solution:
     def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:
-        
         if not heights or not heights[0]:
             return []
 
@@ -34,7 +34,12 @@ def dfs(matrix, reachable, x, y):
             reachable.add((x, y))
             for dx, dy in directions:
                 nx, ny = x + dx, y + dy
-                if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in reachable and matrix[nx][ny] >= matrix[x][y]:
+                if (
+                    0 <= nx < m
+                    and 0 <= ny < n
+                    and (nx, ny) not in reachable
+                    and matrix[nx][ny] >= matrix[x][y]
+                ):
                     dfs(matrix, reachable, nx, ny)
 
         m, n = len(heights), len(heights[0])
@@ -49,4 +54,4 @@ def dfs(matrix, reachable, x, y):
             dfs(heights, pacific_reachable, 0, j)
             dfs(heights, atlantic_reachable, m - 1, j)
 
-        return list(pacific_reachable & atlantic_reachable)
+        return list(pacific_reachable & atlantic_reachable)