D. J.:

- Added the leetcode problem and solution for 127, 130, 133, 200, 207, 210, 399, 433 and 909

Author: nobodyPerfecZ

awesome_python_leetcode/_117_populating_next_right_pointers_in_each_node_II.py

@@ -17,7 +17,6 @@ def __init__(
         self.next = next
 
     def __eq__(self, other: List[int]) -> bool:
-        """Compare the pointers to the next node."""
         if self is None or other is None:
             return True
 

awesome_python_leetcode/_127_word_ladder.py

@@ -0,0 +1,44 @@
+import collections
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
+        """
+        A transformation sequence from word beginWord to word endWord using a dictionary
+        wordList is a sequence of words beginWord -> s1 -> s2 -> ... -> sk such that:
+        - Every adjacent pair of words differs by a single letter.
+        - Every si for 1 <= i <= k is in wordList. Note that beginWord does not need to
+        be in wordList.
+        - sk == endWord
+
+        Given two words, beginWord and endWord, and a dictionary wordList, return the
+        number of words in the shortest transformation sequence from beginWord to
+        endWord, or 0 if no such sequence exists.
+        """
+        # Create adjacency matrix
+        adj = collections.defaultdict(list)
+        wordList.append(beginWord)
+        for word in wordList:
+            for j in range(len(word)):
+                pattern = word[:j] + "*" + word[j + 1 :]
+                adj[pattern].append(word)
+
+        def bfs(src, target):
+            queue = [(src, 1)]
+            visited = {src}
+            while queue:
+                word, mutations = queue.pop(0)
+                if word == target:
+                    return mutations
+                for j in range(len(word)):
+                    pattern = word[:j] + "*" + word[j + 1 :]
+                    for next_word in adj[pattern]:
+                        if next_word not in visited:
+                            queue.append((next_word, mutations + 1))
+                            visited.add(next_word)
+            return 0
+
+        return bfs(beginWord, endWord)

awesome_python_leetcode/_130_surrounded_regions.py

@@ -0,0 +1,46 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def solve(self, board: List[List[str]]) -> None:
+        """
+        You are given an m x n matrix board containing letters 'X' and 'O', capture
+        regions that are surrounded:
+        - Connect: A cell is connected to adjacent cells horizontally or vertically.
+        - Region: To form a region connect every 'O' cell.
+        - Surround: The region is surrounded with 'X' cells if you can connect the
+        region with 'X' cells and none of the region cells are on the edge of the board.
+
+        To capture a surrounded region, replace all 'O's with 'X's in-place within the
+        original board. You do not need to return anything.
+        """
+        rows, cols = len(board), len(board[0])
+
+        def capture(r: int, c: int):
+            if r < 0 or c < 0 or r >= rows or c >= cols or board[r][c] != "O":
+                return
+            board[r][c] = "T"
+            capture(r - 1, c)
+            capture(r + 1, c)
+            capture(r, c - 1)
+            capture(r, c + 1)
+
+        # Capture non surrounded regions (O -> T)
+        for r in range(rows):
+            for c in range(cols):
+                if board[r][c] == "O" and (r in [0, rows - 1] or c in [0, cols - 1]):
+                    capture(r, c)
+
+        # Replace surrounded regions (O -> X)
+        for r in range(rows):
+            for c in range(cols):
+                if board[r][c] == "O":
+                    board[r][c] = "X"
+
+        # Replace non surrounded regions (T -> O)
+        for r in range(rows):
+            for c in range(cols):
+                if board[r][c] == "T":
+                    board[r][c] = "O"

awesome_python_leetcode/_133_clone_graph.py

@@ -0,0 +1,114 @@
+import collections
+from typing import List, Optional, Dict
+
+
+class Node:
+    def __init__(self, val=0, neighbors=None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+
+    def __hash__(self) -> int:
+        return self.val
+
+    def __eq__(self, other: Optional["Node"]) -> bool:
+        if self is None and other is None:
+            return True
+        elif self is None:
+            return False
+        elif other is None:
+            return False
+        adj1 = self.adj_list()
+        adj2 = other.adj_list()
+        return adj1 == adj2
+
+    def adj_list(self) -> Dict[int, List[int]]:
+        """Return the adjacency list of the graph."""
+        adj = collections.defaultdict(list)
+        queue = [self]
+        visited = {self.val}
+        while queue:
+            node = queue.pop(0)
+            for neighbor in node.neighbors:
+                if neighbor.val not in visited:
+                    adj[node.val].append(neighbor.val)
+                    queue.append(neighbor)
+                    visited.add(neighbor.val)
+        return adj
+
+    @staticmethod
+    def build(edges: List[List[int]]) -> Optional["Node"]:
+        """Build a graph from an adjacency list."""
+        if not edges:
+            return None
+
+        nodes = {}
+        for i in range(len(edges)):
+            if i not in nodes:
+                nodes[i + 1] = Node(i + 1)
+            for j in edges[i]:
+                if j not in nodes:
+                    nodes[j] = Node(j)
+                nodes[i + 1].neighbors.append(nodes[j])
+        return nodes[1]
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def cloneGraph(self, node: Optional["Node"]) -> Optional["Node"]:
+        """
+        Given a reference of a node in a connected undirected graph.
+
+        Return a deep copy (clone) of the graph.
+
+        Each node in the graph contains a value (int) and a list (List[Node]) of its
+        neighbors.
+
+        class Node {
+            public int val;
+            public List<Node> neighbors;
+        }
+
+
+        Test case format:
+
+        For simplicity, each node's value is the same as the node's index (1-indexed).
+        For example, the first node with val == 1, the second node with val == 2, and so
+        on. The graph is represented in the test case using an adjacency list.
+
+        An adjacency list is a collection of unordered lists used to represent a finite
+        graph. Each list describes the set of neighbors of a node in the graph.
+
+        The given node will always be the first node with val = 1. You must return the
+        copy of the given node as a reference to the cloned graph.
+        """
+
+        if node is None:
+            return None
+
+        # Create all new nodes (without neighbors)
+        old_to_copy = {None: None}
+        queue = [node]
+        visited = {node}
+        while queue:
+            cur = queue.pop(0)
+            copy = Node(cur.val)
+            old_to_copy[cur] = copy
+            for nxt in cur.neighbors:
+                if nxt not in visited:
+                    queue.append(nxt)
+                    visited.add(nxt)
+
+        # Add all neighbors to new nodes
+        queue = [node]
+        visited = {node}
+        while queue:
+            cur = queue.pop(0)
+            copy = old_to_copy[cur]
+            copy.neighbors = [old_to_copy[nxt] for nxt in cur.neighbors]
+            for nxt in cur.neighbors:
+                if nxt not in visited:
+                    queue.append(nxt)
+                    visited.add(nxt)
+
+        return old_to_copy[node]

awesome_python_leetcode/_200_number_of_islands.py

@@ -0,0 +1,53 @@
+from typing import List, Tuple
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def numIslands(self, grid: List[List[str]]) -> int:
+        """
+        Given an m x n 2D binary grid grid which represents a map of '1's (land) and
+        0's (water), return the number of islands.
+
+        An island is surrounded by water and is formed by connecting adjacent lands
+        horizontally or vertically. You may assume all four edges of the grid are all
+        surrounded by water.
+        """
+        y, x = len(grid), len(grid[0])
+        num_islands = 0
+        visited = set()
+
+        def neighbors(pos: Tuple[int, int]) -> List[Tuple[int, int]]:
+            next_pos = [
+                (pos[0] - 1, pos[1]),
+                (pos[0], pos[1] - 1),
+                (pos[0] + 1, pos[1]),
+                (pos[0], pos[1] + 1),
+            ]
+            neighbors = [
+                p
+                for p in next_pos
+                if p[0] >= 0
+                and p[1] >= 0
+                and p[0] < x
+                and p[1] < y
+                and grid[p[1]][p[0]] == "1"
+                and p not in visited
+            ]
+            return neighbors
+
+        for x_ in range(x):
+            for y_ in range(y):
+                if grid[y_][x_] != "1" or (x_, y_) in visited:
+                    continue
+                # BFS
+                queue = [(x_, y_)]
+                visited.add((x_, y_))
+                while queue:
+                    pos = queue.pop(0)
+                    next_pos = neighbors(pos)
+                    for p in next_pos:
+                        visited.add(p)
+                        queue.append(p)
+                num_islands += 1
+        return num_islands

awesome_python_leetcode/_207_course_schedule.py

@@ -0,0 +1,41 @@
+import collections
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        """
+        There are a total of numCourses courses you have to take, labeled from 0 to
+        numCourses - 1. You are given an array prerequisites where prerequisites[i] =
+        [ai, bi] indicates that you must take course bi first if you want to take course
+        ai.
+
+        - For example, the pair [0, 1], indicates that to take course 0 you have to
+        first take course 1.
+
+        Return true if you can finish all courses. Otherwise, return false.
+        """
+        adj = collections.defaultdict(list)
+        for course1, course2 in prerequisites:
+            adj[course1].append(course2)
+        visited = set()
+
+        def dfs(course: int) -> bool:
+            if course in visited:
+                return False
+            if not adj[course]:
+                return True
+            visited.add(course)
+            for next_course in adj[course]:
+                if not dfs(next_course):
+                    return False
+            visited.remove(course)
+            adj[course] = []
+            return True
+
+        for course in range(numCourses):
+            if not dfs(course):
+                return False
+        return True

awesome_python_leetcode/_210_course_schedule_II.py

@@ -0,0 +1,46 @@
+import collections
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+        """
+        There are a total of numCourses courses you have to take, labeled from 0 to
+        numCourses - 1. You are given an array prerequisites where prerequisites[i] =
+        [ai, bi] indicates that you must take course bi first if you want to take
+        course ai.
+
+        - For example, the pair [0, 1], indicates that to take course 0 you have to
+        first take course 1.
+
+        Return the ordering of courses you should take to finish all courses. If there
+        are many valid answers, return any of them. If it is impossible to finish all
+        courses, return an empty array.
+        """
+        adj = collections.defaultdict(list)
+        for course1, course2 in prerequisites:
+            adj[course1].append(course2)
+
+        visited, cycle, order = set(), set(), []
+
+        def dfs(course: int) -> bool:
+            if course in cycle:
+                return False
+            if course in visited:
+                return True
+
+            cycle.add(course)
+            for next_course in adj[course]:
+                if not dfs(next_course):
+                    return False
+            cycle.remove(course)
+            visited.add(course)
+            order.append(course)
+            return True
+
+        for course in range(numCourses):
+            if not dfs(course):
+                return []
+        return order