Added tasks 129-135

Author: ThanhNIT

src/main/python/g0101_0200/s0129_sum_root_to_leaf_numbers/Solution0129.py

@@ -0,0 +1,27 @@
+# #Medium #Depth_First_Search #Tree #Binary_Tree #Top_Interview_150_Binary_Tree_General
+# #2025_09_14_Time_0_ms_(100.00%)_Space_17.98_MB_(15.68%)
+
+from typing import Optional
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def __init__(self):
+        self.sum_total = 0
+
+    def sumNumbers(self, root: Optional[TreeNode]) -> int:
+        self._recurseSum(root, 0)
+        return self.sum_total
+
+    def _recurseSum(self, node: Optional[TreeNode], cur_num: int):
+        if node.left is None and node.right is None:
+            self.sum_total += 10 * cur_num + node.val
+        else:
+            if node.left is not None:
+                self._recurseSum(node.left, 10 * cur_num + node.val)
+            if node.right is not None:
+                self._recurseSum(node.right, 10 * cur_num + node.val)

src/main/python/g0101_0200/s0129_sum_root_to_leaf_numbers/Solution0129_test.py

@@ -0,0 +1,17 @@
+import unittest
+from Solution0129 import Solution, TreeNode
+
+class SolutionTest(unittest.TestCase):
+    def test_sumNumbers(self):
+        root = TreeNode(1)
+        root.left = TreeNode(2)
+        root.right = TreeNode(3)
+        self.assertEqual(Solution().sumNumbers(root), 25)
+
+    def test_sumNumbers2(self):
+        root = TreeNode(4)
+        root.left = TreeNode(9)
+        root.right = TreeNode(0)
+        root.left.left = TreeNode(5)
+        root.left.right = TreeNode(1)
+        self.assertEqual(Solution().sumNumbers(root), 1026)

src/main/python/g0101_0200/s0129_sum_root_to_leaf_numbers/readme.md

@@ -0,0 +1,39 @@
+129\. Sum Root to Leaf Numbers
+
+Medium
+
+You are given the `root` of a binary tree containing digits from `0` to `9` only.
+
+Each root-to-leaf path in the tree represents a number.
+
+*   For example, the root-to-leaf path `1 -> 2 -> 3` represents the number `123`.
+
+Return _the total sum of all root-to-leaf numbers_. Test cases are generated so that the answer will fit in a **32-bit** integer.
+
+A **leaf** node is a node with no children.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/num1tree.jpg)
+
+**Input:** root = [1,2,3]
+
+**Output:** 25
+
+**Explanation:** The root-to-leaf path `1->2` represents the number `12`. The root-to-leaf path `1->3` represents the number `13`. Therefore, sum = 12 + 13 = `25`. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/num2tree.jpg)
+
+**Input:** root = [4,9,0,5,1]
+
+**Output:** 1026
+
+**Explanation:** The root-to-leaf path `4->9->5` represents the number 495. The root-to-leaf path `4->9->1` represents the number 491. The root-to-leaf path `4->0` represents the number 40. Therefore, sum = 495 + 491 + 40 = `1026`. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 1000]`.
+*   `0 <= Node.val <= 9`
+*   The depth of the tree will not exceed `10`.

src/main/python/g0101_0200/s0130_surrounded_regions/Solution0130.py

@@ -0,0 +1,50 @@
+# #Medium #Top_Interview_Questions #Array #Depth_First_Search #Breadth_First_Search #Matrix
+# #Union_Find #Algorithm_II_Day_8_Breadth_First_Search_Depth_First_Search
+# #Top_Interview_150_Graph_General #2025_09_14_Time_3_ms_(86.86%)_Space_21.58_MB_(88.48%)
+
+from typing import List
+
+class Solution:
+    def solve(self, board: List[List[str]]) -> None:
+        # Edge case, empty grid
+        if not board:
+            return
+        # Traverse first and last rows (boundaries)
+        for i in range(len(board[0])):
+            # first row
+            if board[0][i] == 'O':
+                # It will convert O and all it's touching O's to #
+                self._dfs(board, 0, i)
+            # last row
+            if board[len(board) - 1][i] == 'O':
+                # Converts O's to #'s (same thing as above)
+                self._dfs(board, len(board) - 1, i)
+        # Traverse first and last Column (boundaries)
+        for i in range(len(board)):
+            # first Column
+            if board[i][0] == 'O':
+                # Converts O's to #'s
+                self._dfs(board, i, 0)
+            # last Column
+            if board[i][len(board[0]) - 1] == 'O':
+                # Converts O's to #'s
+                self._dfs(board, i, len(board[0]) - 1)
+        # Traverse through entire matrix
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                if board[i][j] == 'O':
+                    # Convert O's to X's
+                    board[i][j] = 'X'
+                if board[i][j] == '#':
+                    # Convert #'s to O's
+                    board[i][j] = 'O'
+
+    def _dfs(self, board: List[List[str]], row: int, column: int):
+        if (row < 0 or row >= len(board) or column < 0 or 
+            column >= len(board[0]) or board[row][column] != 'O'):
+            return
+        board[row][column] = '#'
+        self._dfs(board, row + 1, column)
+        self._dfs(board, row - 1, column)
+        self._dfs(board, row, column + 1)
+        self._dfs(board, row, column - 1)

src/main/python/g0101_0200/s0130_surrounded_regions/Solution0130_test.py

@@ -0,0 +1,25 @@
+import unittest
+from Solution0130 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_solve(self):
+        board = [
+            ['X', 'X', 'X', 'X'],
+            ['X', 'O', 'O', 'X'],
+            ['X', 'X', 'O', 'X'],
+            ['X', 'O', 'X', 'X']
+        ]
+        Solution().solve(board)
+        expected = [
+            ['X', 'X', 'X', 'X'],
+            ['X', 'X', 'X', 'X'],
+            ['X', 'X', 'X', 'X'],
+            ['X', 'O', 'X', 'X']
+        ]
+        self.assertEqual(board, expected)
+
+    def test_solve2(self):
+        board = [['X']]
+        Solution().solve(board)
+        expected = [['X']]
+        self.assertEqual(board, expected)

src/main/python/g0101_0200/s0130_surrounded_regions/readme.md

@@ -0,0 +1,30 @@
+130\. Surrounded Regions
+
+Medium
+
+Given an `m x n` matrix `board` containing `'X'` and `'O'`, _capture all regions that are 4-directionally surrounded by_ `'X'`.
+
+A region is **captured** by flipping all `'O'`s into `'X'`s in that surrounded region.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/xogrid.jpg)
+
+**Input:** board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
+
+**Output:** [["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
+
+**Explanation:** Surrounded regions should not be on the border, which means that any 'O' on the border of the board are not flipped to 'X'. Any 'O' that is not on the border and it is not connected to an 'O' on the border will be flipped to 'X'. Two cells are connected if they are adjacent cells connected horizontally or vertically. 
+
+**Example 2:**
+
+**Input:** board = [["X"]]
+
+**Output:** [["X"]] 
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n == board[i].length`
+*   `1 <= m, n <= 200`
+*   `board[i][j]` is `'X'` or `'O'`.

src/main/python/g0101_0200/s0133_clone_graph/Solution0133.py

@@ -0,0 +1,28 @@
+# #Medium #Hash_Table #Depth_First_Search #Breadth_First_Search #Graph #Udemy_Graph
+# #Top_Interview_150_Graph_General #2025_09_14_Time_38_ms_(86.28%)_Space_17.94_MB_(97.41%)
+
+from typing import Dict, List, Optional
+
+class Node:
+    def __init__(self, val=0, neighbors=None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+
+class Solution:
+    def cloneGraph(self, node: Optional[Node]) -> Optional[Node]:
+        return self._cloneGraph(node, {})
+
+    def _cloneGraph(self, node: Optional[Node], processed_nodes: Dict[Node, Node]) -> Optional[Node]:
+        if node is None:
+            return None
+        elif node in processed_nodes:
+            return processed_nodes[node]
+        new_node = Node()
+        processed_nodes[node] = new_node
+        new_node.val = node.val
+        new_node.neighbors = []
+        for neighbor in node.neighbors:
+            cloned_neighbor = self._cloneGraph(neighbor, processed_nodes)
+            if cloned_neighbor is not None:
+                new_node.neighbors.append(cloned_neighbor)
+        return new_node

src/main/python/g0101_0200/s0133_clone_graph/Solution0133_test.py

@@ -0,0 +1,30 @@
+import unittest
+from Solution0133 import Solution, Node
+
+class SolutionTest(unittest.TestCase):
+    def test_cloneGraph(self):
+        node1 = Node(1)
+        node2 = Node(2)
+        node3 = Node(3)
+        node4 = Node(4)
+        node1.neighbors = [node2, node4]
+        node2.neighbors = [node1, node3]
+        node3.neighbors = [node2, node4]
+        node4.neighbors = [node1, node3]
+        
+        result = Solution().cloneGraph(node1)
+        
+        # Check that the cloned graph has the same structure
+        self.assertEqual(result.val, 1)
+        self.assertEqual(len(result.neighbors), 2)
+        self.assertEqual(result.neighbors[0].val, 2)
+        self.assertEqual(result.neighbors[1].val, 4)
+
+    def test_cloneGraph2(self):
+        node1 = Node(1)
+        result = Solution().cloneGraph(node1)
+        self.assertEqual(result.val, 1)
+        self.assertEqual(len(result.neighbors), 0)
+
+    def test_cloneGraph3(self):
+        self.assertIsNone(Solution().cloneGraph(None))

src/main/python/g0101_0200/s0133_clone_graph/readme.md

@@ -0,0 +1,69 @@
+133\. Clone Graph
+
+Medium
+
+Given a reference of a node in a **[connected](https://en.wikipedia.org/wiki/Connectivity_(graph_theory)#Connected_graph)** undirected graph.
+
+Return a [**deep copy**](https://en.wikipedia.org/wiki/Object_copying#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.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/11/04/133_clone_graph_question.png)
+
+**Input:** adjList = [[2,4],[1,3],[2,4],[1,3]]
+
+**Output:** [[2,4],[1,3],[2,4],[1,3]]
+
+**Explanation:**
+
+    There are 4 nodes in the graph.
+    1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+    2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+    3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+    4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3). 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/01/07/graph.png)
+
+**Input:** adjList = [[]]
+
+**Output:** [[]]
+
+**Explanation:** Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors. 
+
+**Example 3:**
+
+**Input:** adjList = []
+
+**Output:** []
+
+**Explanation:** This an empty graph, it does not have any nodes. 
+
+**Example 4:**
+
+![](https://assets.leetcode.com/uploads/2020/01/07/graph-1.png)
+
+**Input:** adjList = [[2],[1]]
+
+**Output:** [[2],[1]] 
+
+**Constraints:**
+
+*   The number of nodes in the graph is in the range `[0, 100]`.
+*   `1 <= Node.val <= 100`
+*   `Node.val` is unique for each node.
+*   There are no repeated edges and no self-loops in the graph.
+*   The Graph is connected and all nodes can be visited starting from the given node.

src/main/python/g0101_0200/s0134_gas_station/Solution0134.py

@@ -0,0 +1,18 @@
+# #Medium #Top_Interview_Questions #Array #Greedy #Top_Interview_150_Array/String
+# #2025_09_14_Time_15_ms_(88.80%)_Space_23.18_MB_(96.18%)
+
+from typing import List
+
+class Solution:
+    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
+        total_gas, total_cost = sum(gas), sum(cost)
+        if total_gas < total_cost:
+            return -1  # impossible
+        
+        start, tank = 0, 0
+        for i in range(len(gas)):
+            tank += gas[i] - cost[i]
+            if tank < 0:
+                start = i + 1  # reset starting point
+                tank = 0
+        return start