112. Path Sum [Easy]###

在二元樹中，判斷是否存在一條從根到葉子的路徑，路徑上節點值的總和等於 targetSum。

class Solution(object):
    def hasPathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: bool
        """

        if not root:
            return False
        
        # 如果到達葉子節點，檢查 targetSum 是否等於該葉子節點的值
        if not root.left and not root.right:
            return targetSum == root.val
        
        # 減去當前節點的值，然後繼續遞迴檢查左右子樹
        remainingSum = targetSum - root.val

        leftTargetSum = self.hasPathSum(root.left, remainingSum)

        rightTargetSum = self.hasPathSum(root.right, remainingSum)

        return leftTargetSum or rightTargetSum

使用遞迴遍歷二元樹，對每個節點減去當前節點值，當到達葉子節點時檢查剩餘 targetSum 是否等於葉子節點值，若有任意路徑符合則返回 True。

733. Flood Fill [Easy]###

這道題目是「Flood Fill」算法，在處理圖像時常被用來填充某個區域的顏色。題目給我們一個 m x n 的整數網格 image，每個元素 image[i][j] 表示圖像中的像素值。題目還給了我們三個整數 sr、sc 和 color，分別表示我們的起始點 image[sr][sc] 以及要替換的目標顏色 color。

class Solution(object):
    def floodFill(self, image, sr, sc, color):
        """
        :type image: List[List[int]]
        :type sr: int
        :type sc: int
        :type color: int
        :rtype: List[List[int]]
        """
        start_color = image[sr][sc]

        if start_color == color:
            return image

        def dfs(r, c):
            if r < 0 or r >= len(image) or c < 0 or c >= len(image[0]):
                return
            if image[r][c] != start_color:
                return

            image[r][c] = color

            dfs(r + 1, c)  # 向下
            dfs(r - 1, c)  # 向上
            dfs(r, c + 1)  # 向右
            dfs(r, c - 1)  # 向左

        dfs(sr, sc)
        return image

從起點像素開始，遞迴地替換與起點顏色相同且相連的像素。使用深度優先搜尋 (DFS) 或廣度優先搜尋 (BFS) 替換目標顏色，檢查邊界避免越界。

200. Number of Islands [Medium]

這道題目叫做「島嶼的數量」，給你一個 m x n 的二維二進制網格 grid，其中 '1' 代表陸地，'0' 代表水域，你的任務是計算這個網格中「島嶼」的數量。
看到這個題目，根本就是圍棋演算法🤣🤣🤣，這題是中等難度，但我覺得用上一題的概念應該很快可以找到答案。
使用第二題的解題蓋念只能找到一座島嶼就結束程式，因此演算法流程應該如下：

1. 遍歷網格：從網格的左上角開始，逐個檢查每一個格子。
   • 如果遇到 '0'（水），跳過這個格子，繼續檢查下一個。
   • 如果遇到 '1'（陸地），說明發現了一個新的島嶼，島嶼數量加1。
2. 淹沒整個島嶼：當發現一個新的島嶼後，使用深度優先搜尋（DFS）或廣度優先搜尋（BFS）去「淹沒」這個島嶼，也就是將與這個格子相連的所有 '1' 變為 '0'。這樣可以保證不會重複計算同一個島嶼。(也就是類似於上一題的算法)
   • 搜索方向：每個陸地格子需要向上下左右四個方向擴展，來找到所有相連的 '1'。這些相連的 '1' 都屬於同一個島嶼，將其全部標記為 '0'。
3. 重複步驟：重複上述步驟，直到遍歷完整個網格。最後的島嶼數量就是答案。

class Solution(object):
    def numIslands(self, grid):
        """
        :type grid: List[List[str]]
        :rtype: int
        """
        def dfs(i, j):
            if i < 0 or i >= len(grid) or j < 0 or j >= len(grid[0]):
                return
            
            if grid[i][j] == '0':
                return
            else:
                grid[i][j] = '0'

            dfs(i + 1, j)
            dfs(i - 1, j)
            dfs(i, j + 1)
            dfs(i, j - 1)

        island_count = 0
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if grid[i][j] == "1":
                    dfs(i, j)
                    island_count += 1

        return island_count