721 - LeetCode BFS on 嗡嗡的隨手筆記

【Leetcode】python - [994] Rotting Oranges 個人解法筆記

Sat, 25 Jul 2026 01:44:02 +0800

題目出處

994. Rotting Oranges

難度

medium

題目分類

Array, Breadth-First Search, Matrix

2026-07-25 一刷

個人範例程式碼 - 一刷 (2026/07/25)

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        if not grid or not grid[0]:
            return 0 # no orange

        h, w = len(grid), len(grid[0])
        fresh_oranges = 0
        curr_rotten_oranges = []
        max_steps = 0

        for i in range(h):
            for j in range(w):
                if grid[i][j] == 1:
                    fresh_oranges += 1
                elif grid[i][j] == 2:
                    curr_rotten_oranges.append((i, j))

        def valid_fresh_orange(i, j):
            return 0 <= i < h and 0 <= j < w and grid[i][j] == 1

        directions = [(1,0),(-1,0),(0,1),(0,-1)]
        while fresh_oranges > 0 and curr_rotten_oranges:
            next_rotten_oranges = []

            for i, j in curr_rotten_oranges:
                for dx, dy in directions:
                    if valid_fresh_orange(i+dx, j+dy):
                        grid[i+dx][j+dy] = 2
                        fresh_oranges -= 1
                        next_rotten_oranges.append((i+dx, j+dy))

            curr_rotten_oranges = next_rotten_oranges
            max_steps += 1


        return -1 if fresh_oranges else max_steps

算法說明

這題偏複雜，直覺可能會想 DFS 但不對，

DFS 解的意義會變成：我要找最深，也就是腐敗橘子最常鏈，但物理規則沒有繞遠路（最深），因此不該是 DFS
BFS 透過分層（一層代表前進一步，腐敗多一層），找到最短次數

簡單來說 DFS 找最長、最深，BFS 找最短、最淺。

小技巧： Directions 先定義好，用 for dx, dy in directions 跑不同方向的更新
BFS 實作：This layer (此時間點)，Next Layer (下一個時間點)，然後交替直到無法再有更新

Time Complexity

O(m*n)

Space Complexity

O(m*n) 一樣有可能要幾乎把整個 grid 繞完

Boundary conditions

小心 [], [[]]，not grid or not grid[0] 已經處理

Reference

<待補>

【Leetcode】python - [200] Number of Islands 個人解法筆記

Fri, 24 Jul 2026 23:45:32 +0800

題目出處

200. Number of Islands

難度

medium

題目分類

Array, Depth-First Search, Breadth-First Search, Union-Find, Matrix

2026-07-24 一刷

個人範例程式碼 - 一刷 (2026/07/24)

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        if not grid or not grid[0]:
            return 0

        ans = 0
        h, w = len(grid), len(grid[0])

        def dfs(i, j):
            if i < 0 or i >= h or j < 0 or j >= w or grid[i][j] == "0":
                return

            grid[i][j] = "0"
            dfs(i-1, j)
            dfs(i, j-1)
            dfs(i+1, j)
            dfs(i, j+1)

            return

        for i in range(h):
            for j in range(w):
                if grid[i][j] == "1":
                    ans += 1
                    dfs(i, j)

        return ans

算法說明

基礎的 DFS 題目，跟前幾天做的【Leetcode】python - [695] Max Area of Island 個人解法筆記在 DFS 方面的解題思路基本相同。

Time Complexity

O(m*n) (整個 grid 掃過)

Space Complexity

O(m*n) (最壞情況，像是一條蛇，stack 需要把整個 grid 掃過，全部存進 stack)

Boundary conditions

注意邊界條件：i < 0 or i >= h or j < 0 or j >= w 這些出界都不合法
注意 [], [[]] 題目沒特別講, 但謹慎起見還是一開始就防呆處理

【Leetcode】python - [695] Max Area of Island 個人解法筆記

Fri, 24 Jul 2026 15:20:26 +0800

題目出處

695. Max Area of Island

難度

medium

題目分類

Array, DFS, Matrix

2026-07-24 一刷

個人範例程式碼 - 一刷 (2026/07/24)

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        if not grid or not grid[0]: # edge: [], [[]]
            return 0

        h, w = len(grid), len(grid[0])
        max_area = 0

        def dfs(grid, i, j):
            if i < 0 or i >= h or j < 0 or j >= w or grid[i][j] != 1:
               return 0

            else: # grid[i][j] == 1:
                grid[i][j] = 0
                return 1 + dfs(grid, i-1, j) + \
                       dfs(grid, i, j-1) + \
                       dfs(grid, i+1, j) + \
                       dfs(grid, i, j+1)

        for i in range(h):
            for j in range(w):
                if grid[i][j] == 1:
                    cur_area = dfs(grid, i, j)
                    max_area = max(max_area, cur_area)

        return max_area

算法說明

以 DFS 進行鄰近的搜尋，搜尋到後就修改值代表已經 visited

Time Complexity

O(m*n)

Space Complexity

O(m*n)（DFS 會進行遞迴的最壞情況，可能是一條龍那種，那 stack 深度就會是整張 grid 的面積）

Boundary conditions

[]：not grid 提前 return 0
[[]]：not grid[0] 提前 return 0
處理邊界：i < 0 or i >= h or j < 0 or j >= w，優先排除不合法範圍在進行後續判斷

Reference

【Lintcode】python - [431] Connected Component in Undirected Graph 個人解法筆記 | 內含 BFS 模板 #重要題型

Wed, 08 Jun 2022 03:23:11 +0800

題目出處

431 · Connected Component in Undirected Graph

難度

medium

題目分類

Depth-First Search, Breadth-First Search, Union-Find, Graph Theory

2022-06-08 三刷

個人範例程式碼 - 三刷 (2022/06/08)

from typing import (
    List,
)
from lintcode import (
    UndirectedGraphNode,
)

"""
class UndirectedGraphNode:
     def __init__(self, x):
         self.label = x
         self.neighbors = []
"""

class Solution:
    """
    @param nodes: a array of Undirected graph node
    @return: a connected set of a Undirected graph
    """
    def connectedSet(self, nodes: List[UndirectedGraphNode]) -> List[List[int]]:
        # write your code here
        if not nodes:
            return nodes

        visited = set()
        ans = []
        for node in nodes:
            if node not in visited:
                ans.append(self.get_connected_parts(nodes, visited, node))

        return ans

    def get_connected_parts(self, nodes, visited, start_node):
        queue = [start_node]
        ans = []
        visited.add(start_node)

        while queue:
            node = queue.pop(0)
            ans.append(node.label)
            for neighbor in node.neighbors:
                if neighbor not in visited:
                    queue.append(neighbor)
                    visited.add(neighbor)

        return sorted(ans)

算法說明

BFS 搜尋圖，並把同一組的歸類再一起。

input handling

Boundary conditions

用 for 配合 visited 來尋找 start_node，
bfs 內部用 queue 來掌控搜尋範圍。

2022-06-07 二刷

個人範例程式碼 - 二刷 (2022/06/07)

from typing import (
    List,
)
from lintcode import (
    UndirectedGraphNode,
)

"""
class UndirectedGraphNode:
     def __init__(self, x):
         self.label = x
         self.neighbors = []
"""

class Solution:
    """
    @param nodes: a array of Undirected graph node
    @return: a connected set of a Undirected graph
    """
    def connectedSet(self, nodes: List[UndirectedGraphNode]) -> List[List[int]]:
        # write your code here

        visited = set()
        ans = []
        for node in nodes:
            if node not in visited:
                ans.append(self.bfs(nodes, node, visited))

        return ans

    def bfs(self, nodes, start_node, visited):
        ans = []
        queue = [start_node]
        visited.add(start_node)

        while queue:
            node = queue.pop(0)
            ans.append(node.label)
            for neighbor in node.neighbors:
                if neighbor not in visited:
                    queue.append(neighbor)
                    visited.add(neighbor)

        return sorted(ans)

算法說明

BFS 搜尋圖，並把同一組的歸類再一起。

input handling

Boundary conditions

用 for 配合 visited 來尋找 start_node，
bfs 內部用 queue 來掌控搜尋範圍。

2022-06-01 一刷

個人範例程式碼 - 一刷 (2022/06/01)

from typing import (
    List,
)
from lintcode import (
    UndirectedGraphNode,
)

"""
class UndirectedGraphNode:
     def __init__(self, x):
         self.label = x
         self.neighbors = []
"""

class Solution:
    """
    @param nodes: a array of Undirected graph node
    @return: a connected set of a Undirected graph
    """
    def connectedSet(self, nodes: List[UndirectedGraphNode]) -> List[List[int]]:
        # write your code here
        if not nodes:
            return []

        ans = []
        visited = set()
        for node in nodes:
            if node in visited:
                continue
            visited.add(node)
            ans.append(self.bfs(node, visited))

        return ans

    def bfs(self, start_node, visited):
        ans = []
        queue = [start_node]
        while(queue):
            node = queue.pop(0)
            ans.append(node.label)
            for neighbor in node.neighbors: # add all not visited neighbor
                if neighbor not in visited:
                    queue.append(neighbor)
                    visited.add(neighbor)

        return sorted(ans)

算法說明

經典的 bfs 問題，可以複製此架構變化的 BFS 題目很多。

最外圈，先透過 for 確保所有 node 都會被搜尋，再搭配上 visited，確保不重複搜尋。
內圈的 BFS，我們透過 while 不斷地新增 nighbor，直到 visited 全滿不能再新增，就結束回傳答案。

input handling

處理沒有 input 的情況，return []

Boundary conditions

用 for 配合 visited 來尋找 start node，
bfs 內部用 queue 來掌控搜尋範圍。

Reference

找无向图的连通块 · Connected Component in Undirected Graph

【Leetcode】python - [103] Binary Tree Zigzag Level Order Traversal 個人解法筆記

Tue, 07 Jun 2022 18:42:04 +0800

題目出處

103. Binary Tree Zigzag Level Order Traversal

難度

medium

題目分類

Tree, Breadth-First Search, Binary Tree

2022-06-07 一刷

個人範例程式碼 - 一刷 (2022/06/07)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []

        ans = []
        this_layer = [root]
        reverse_flag = False

        while this_layer:
            this_layer_ans = []
            next_layer = []
            for node in this_layer:
                this_layer_ans.append(node.val)

                if node.left:
                    next_layer.append(node.left)
                if node.right:
                    next_layer.append(node.right)

            if reverse_flag:
                this_layer_ans.reverse()

            ans.append(this_layer_ans[:]) # deepcopy
            this_layer = next_layer
            reverse_flag = not reverse_flag

        return ans

算法說明

類似 level order traversal 的邏輯，只不過在 zigzag 中我們要做的是間隔 layer 反轉輸出的結果。

至於要反轉的話，加一個反轉 flag 即可輕鬆完成

input handling

如果沒有 root，return []

Boundary conditions

透過 layer 一層一層循環，直到下一層 layer 無東西為止。

Reference

Python List reverse()

【Lintcode】python - [178] Graph Valid Tree 個人解法筆記 #重要題型

Tue, 07 Jun 2022 02:26:49 +0800

題目出處

178 · Graph Valid Tree

難度

medium

題目分類

Depth-First Search, Breadth-First Search, Union-Find, Graph Theory

2022-06-07 一刷

個人範例程式碼 - 一刷 (2022/06/07)

from typing import (
    List,
)

class Solution:
    """
    @param n: An integer
    @param edges: a list of undirected edges
    @return: true if it's a valid tree, or false
    """
    def valid_tree(self, n: int, edges: List[List[int]]) -> bool:
        # write your code here
        if len(edges) != n-1: 
            return False # not completed graph

        graph = self.build_graph(edges)

        return self.bfs(graph, n)

    def bfs(self, graph, n):
        visited = {0}
        queue = [0]
        while queue:
            node = queue.pop(0)
            for neighbor in graph[node]:
                if neighbor not in visited:
                    queue.append(neighbor)
                    visited.add(neighbor)

        return len(visited) == n

    def build_graph(self, edges):
        graph = collections.defaultdict(list)
        for edge in edges:
            graph[edge[0]].append(edge[1])
            graph[edge[1]].append(edge[0])

        return graph

算法說明

這題的存在，直接地告訴了我們 graph 與 tree 的差別，
簡單來說，tree 就等於「沒有環的 graph」，

我們使用 bfs 來幫助我們搜尋，看是否全部搜尋完全即可。

input handling

因為 n 的點至少需要有 n-1 條邊，且我們「tree 又必定沒有環」，
因此我們可以先判斷 len(edges) 是否等於 n-1，沒有可以直接 return False

Boundary conditions

用 while queue 搭配做出 bfs，把全部可找到的點都加入 visited 後，
比較 len(visited) 是否等於 n，作為我們最後的答案。

Reference

图是否是树 · Graph Valid Tree

【Leetcode】python - [226] Invert Binary Tree 個人解法筆記

Mon, 06 Jun 2022 16:57:53 +0800

題目出處

226. Invert Binary Tree

難度

easy

題目分類

Tree, Depth-First Search, Breadth-First Search, Binary Tree

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root

        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left

        return root

算法說明

單純的一路一直把左右交換就好，
把題目切分成「更小的子樹，也需做一樣的事情」。

input handling

if not root (None)，直接 return root (None)

Boundary conditions

一路 DFS Tree 直到底部，中間過程 swap 「left, right」

Reference

【Lintcode】python - [892] Alien Dictionary 個人解法筆記

Mon, 23 May 2022 02:54:58 +0800

題目出處

892 · Alien Dictionary

難度

Hard

題目分類

Array, String, Depth-First Search, Breadth-First Search, Graph Theory, Topological Sort

2022-05-23 一刷

個人範例程式碼 - 一刷 (2022/05/23)

import heapq

from typing import (
    List,
)

class Solution:
    """
    @param words: a list of words
    @return: a string which is correct order
    """
    def alien_order(self, words: List[str]) -> str:
        # Write your code here
        graph = self.build_graph(words)
        if not graph:
            return ""

        return self.topological_sort(graph)

    def build_graph(self, words):
        graph = {} # node: neighbors

        # init graph
        for word in words:
            for c in word:
                if c not in graph:
                    graph[c] = set()

        # add edges
        n = len(words)
        for i in range(n-1): # compare i, i+1
            max_compare_length = min(len(words[i]), len(words[i+1]))
            for j in range(max_compare_length):
                if words[i][j] != words[i+1][j]: # compare two words, if different [i]->[i+1]
                    graph[words[i][j]].add(words[i+1][j])
                    break # finish add edge

                if j == max_compare_length - 1: # already last word, but edge not found
                    # case: err, errt (next must be longer)
                    if len(words[i]) > len(words[i+1]): 
                        return None # error case, early return 

        return graph

    def topological_sort(self, graph): 
        # init indegree, all node = 0
        indegree = {
            node: 0 for node in graph
        }

        # calculate indegree
        for node in graph:
            for neighbor in graph[node]:
                indegree[neighbor] = indegree[neighbor] + 1

        # find 0 indegree
        heap = [node for node in graph if indegree[node] == 0]
        heapq.heapify(heap) # smallest in lexicographical order`

        # bfs - topological sorting
        ans_order = ""
        while heap:
            node = heapq.heappop(heap)
            ans_order += node
            for neighbor in graph[node]:
                indegree[neighbor] -= 1
                if indegree[neighbor] == 0:
                    heapq.heappush(heap, neighbor)

        # if all nodes popped
        if len(ans_order) == len(graph):
            return ans_order

        return ""

算法說明

這題要同時考到建構出一個 graph，
並還需要做 topological sorting (BFS) 找出路徑。

input handling

建構 graph 時，注意有沒有例外狀況

例如：沒有找到任何的不同，且 length word[i] > word[i+1]
(errt, err) 此類順序是有問題的

Boundary conditions

在 graph 與 bfs 中控制搜尋範圍，搜尋完全部 node 就正常結束。
(沒有全部搜尋完，就沒有結果)

Reference

外星人字典 · Alien Dictionary

【Leetcode】python - [322] Coin Change 個人解法筆記 | 內含 DP 背包問題模板 #重要題型

Wed, 18 May 2022 02:28:31 +0800

題目出處

322. Coin Change

難度

Medium

題目分類

Array, Dynamic Programming, Breadth-First Search

2022-05-18 一刷

個人範例程式碼 - 一刷 (2022/05/18)

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        if not coins:
            return -1

        dp = [float("inf") for _ in range(amount+1)]
        dp[0] = 0

        for i in range(1, amount+1):
            for coin in coins:
                if i >= coin and dp[i-coin] != float("inf"):
                    dp[i] = min(dp[i], dp[i-coin]+1) # last dp add this coin

        return -1 if dp[-1] == float("inf") else dp[-1]

算法說明

完全背包問題可以把公式解開

初始化，全部 INF，多留一個欄位

dp[0] = 0
dp[i] = INF (無解的情況，保持原樣)
dp[i] = min(dp[i], dp[i-可行的目標]+1) (+1 就是代表替換為此目標，例如可以用5元「換一次 [i-5]+1 個五元」的結果)

input handling

如果沒有 coins，return -1，
最後 dp[-1] 即為答案 (如果是保持 INF 不變，那就回傳 -1)

Boundary conditions

用 for 來控制 DP 的範圍

Reference

换硬币 · Coin Change

【Leetcode】python - [1091] Shortest Path in Binary Matrix 個人解法筆記

Tue, 17 May 2022 18:10:21 +0800

題目出處

1091. Shortest Path in Binary Matrix

難度

Medium

題目分類

Array, Breadth-First Search, Matrix

2022-05-17 一刷

個人範例程式碼 - 一刷 (2022/05/17)

DIRECTIONS = [(1,1), (1,0), (0,1), (-1,1), (1,-1), (-1,0), (0,-1), (-1,-1)]
class Solution:
    def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:
        self.m = len(grid)
        self.n = len(grid[0])

        return self.bfs(grid) 

    def bfs(self, grid):  
        length = 0
        visited = set()
        layer = [(0, 0)] # first layer
        while(layer):
            next_layer = []
            for i, j in layer:
                if self.is_valid(grid, i, j, visited):
                    visited.add((i, j))

                    if i <mark> self.m - 1 and j </mark> self.n - 1:
                        return length+1

                    for dx, dy in DIRECTIONS: # prepare for next layer
                        next_layer.append((i+dx, j+dy))
                else:
                    continue

            length += 1
            layer = next_layer
        else:
            return -1 # not found

    def is_valid(self, grid, i, j, visited):
        return 0 <= i < self.m and 0 <= j < self.n and (i,j) not in visited and grid[i][j] == 0

算法說明

最短路徑，我們用 BFS 去找，
因為要計算最短路徑的長度，我選擇用 layer 的方式分析，

此外，因為題目有指定 8 個方向，我另外把這 8 個變數獨立寫出來。

手動的最短路徑策略

這邊注意我在設計最短路徑上是有策略的。

搜尋上，為了求最短路徑，我們當然會優先選擇「圖上往右下的部分」，
再來往下或往右，
再來往左下或右上，

以此類推，這樣我們就能優先確保先進 visited 的都是最短路徑。

換作程式碼如下：

DIRECTIONS = [(1,1), (1,0), (0,1), (-1,1), (1,-1), (-1,0), (0,-1), (-1,-1)]

input handling

在 bfs 一起處理，這邊注意我有踩到一個小雷。

Boundary conditions

當 bfs 搜尋到結果後，直接 return 就是最短路徑。

Reference

Easy and Neat Python Solution

【Leetcode】python - [100] Same Tree 個人解法筆記

Tue, 10 May 2022 21:11:47 +0800

題目出處

100. Same Tree

難度

easy

題目分類

Tree, Depth-First Search, Breadth-First Search, Binary Tree

2022-05-10 一刷

個人範例程式碼 - 一刷 (2022/05/10)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        return self.dfs(p, q)

    def dfs(self, p, q):
        # end of recursion
        if not p and not q:
            return True
        if not p or not q: 
            return False

        # define
        if p.val == q.val: # True
            # split
            return self.dfs(p.left, q.left) and self.dfs(p.right, q.right)
        else:
            return False

算法說明

基本的 Tree traverse 變形，用 dfs 實作。

input handling

一同在 dfs 內部處理

Boundary conditions

dfs 結束條件

正確結束:

if not p and not q, return True

錯誤情況:

not p 但還有 q，或相反，return False
p.val 不等於 q.val，return False

Reference

Shortest+simplest Python

【Leetcode】python - [126] Word Ladder II 個人解法筆記

Tue, 26 Apr 2022 22:04:21 +0800

題目出處

126. Word Ladder II

難度

hard

題目分類

Hash Table, String, Backtracking, Breadth-First Search

2022-04-26 一刷

個人範例程式碼 - 一刷 (2022/04/26)

class Solution:
    def findLadders(self, beginWord: str, endWord: str, wordList: List[str]) -> List[List[str]]:
        if endWord not in wordList:
            return []

        wordList.append(beginWord)
        distance = {}

        self.bfs(endWord, distance, wordList) # from end to start
        self.ans = []
        self.dfs(beginWord, endWord, distance, wordList, [beginWord]) # from start to end

        return self.ans

    def bfs(self, start, distance, worddict):
        distance[start] = 0
        queue = deque([start])
        while queue:
            word = queue.popleft()
            print(self.get_next_words(word, worddict))
            for next_word in self.get_next_words(word, worddict):
                if next_word not in distance:
                    distance[next_word] = distance[word] + 1
                    queue.append(next_word)

    def get_next_words(self, word, worddict):
        words = []
        for i in range(len(word)):
            for c in 'abcdefghijklmnopqrstuvwxyz':
                next_word = word[:i] + c + word[i+1:]
                if next_word != word and next_word in worddict:
                    words.append(next_word)
        # print(words)
        return words

    def dfs(self, cur, target, distance, worddict, path):
        # print(distance)
        if cur == target:
            self.ans.append(path[:])
            return

        for word in self.get_next_words(cur, worddict): # different way will see other things
            if word not in distance: # single node
                continue
            if distance[word] != distance[cur] - 1:
                continue
            path.append(word)
            self.dfs(word, target, distance, worddict, path)
            path.pop() # backtracking

算法說明

超難的一題，考了非常多概念，對細節處理的要求也非常多
我們先從建立圖片下手。

從 BFS 先找到最短路徑

題目的做成的文字圖有可能會有循環，我們需要先找最短路徑

透過最短路徑，反向 DFS 尋找所有結果

知道最短路徑後，我們才能用 DFS 將整個圖走過，
看在最短路徑的範圍當中，能夠找到有幾種結果。

先從 endWord 找回 start，再從 start 順便存路徑會最順。

注意處

從兩個起點搜尋的注意事項

這邊要處理在從兩端搜尋時，還是都要把每個點都看過一次，
例如上圖中下方的 graph 結構，我們會發現會有一些只靠單向搜尋「會距離很遠」的位置

獨立的點

有一種特殊的 case 是從起點開始，就根本就沒有任何的連線，
雖然這題的測資沒有考到，但這邊一樣有處理。

狀況大概如下圖：

只能說，這個就是細節處理的部分，萬一真的有這樣的情況，我們還是要回傳 []

input handling

如果 endWord 不在 worddict 中，return []

Boundary conditions

BFS 找最短路徑

搜尋至 queue 沒有東西的時候
「while queue」幫忙控制結束

DFS 找所有結果

反向搜尋至 distance 為 0 時結束，
我們在上一步驟中的 BFS，有順便記錄了 distance 最大的長度，
這邊就是反向操作到 0。

Reference

【Leetcode】python - [112] Path Sum 個人解法筆記

Wed, 20 Apr 2022 00:02:52 +0800

題目出處

112. Path Sum

難度

easy

題目分類

Tree, Depth-First Search, Breadth-First Search, Binary Tree

2022-04-20 一刷

個人範例程式碼 - 一刷 (2022/04/20)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:

        return self.dfs(root, targetSum, [])

    def dfs(self, root, target, path):
        # Null
        if not root:
            return False

        path.append(root.val)
        # leaf
        if not root.left and not root.right:
            if sum(path) == target:
                path.pop()
                return True

        # not leaf
        ans = self.dfs(root.left, target, path) or self.dfs(root.right, target, path) # need pop path before return
        path.pop()

        return ans

算法說明

基礎的 DFS 用來 traverse Tree 裡面的內容，並沿路計算總和。

input handling

如果沒有正確結果，回傳 False

Boundary conditions

end of recursion

判斷 Null 或是 Leaf

Null

False

# Null
if not root:
    return False

Leaf

判斷是否總和正確，如果是回傳 True

# leaf
if not root.left and not root.right:
    if sum(path) == target:
        path.pop()
        return True

define of recursion

增加路過的路徑。

path.append(root.val)

重要：這邊務必注意，因為 list 在 python function 中，pass by assignment 可以變更 mutable object，所以勢必要注意對應的 pop() 位置在哪。

path.pop()

split of recursion

拆成兩路，同樣的也如同我們上面說要注意的點。
我們先把結果拿回來，再把 path 的內容先 pop 出來後，再把 ans 回傳。

# not leaf
ans = self.dfs(root.left, target, path) or self.dfs(root.right, target, path) # need pop path before return

Reference

【Leetcode】python - [210] Course Schedule II 個人解法筆記

Tue, 19 Apr 2022 23:27:58 +0800

題目出處

210. Course Schedule II

難度

medium

題目分類

Depth-First Search, Breadth-First Search, Graph Theory, Topological Sort

2022-04-19 一刷

個人範例程式碼 - 一刷 (2022/04/19)

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        return self.bfs(numCourses, prerequisites)


    def bfs(self, num_courses, prerequisites):
        next_courses, indegree = self.get_indegree(num_courses, prerequisites)
        start_courses = [course for course, degree in indegree.items() if degree == 0]
        learned_courses = [] 

        queue = collections.deque(start_courses)
        visited = set()

        while queue:
            course = queue.popleft()
            learned_courses.append(course)
            visited.add(course)
            for next_course in next_courses[course]:
                indegree[next_course] -= 1
                if indegree[next_course] == 0 and next_course not in visited:
                    queue.append(next_course)

        else:
            return learned_courses if num_courses == len(learned_courses) else []



    def get_indegree(self, num_courses, prerequisites):
        next_courses = {x:[] for x in range(num_courses)}
        indegree = {x:0 for x in range(num_courses)}

        for course, next_course in prerequisites:
            next_courses[next_course].append(course)
            indegree[course] += 1

        # print(next_courses, indegree)
        return next_courses, indegree

算法說明

此問題的前一個問題，主要差別是在有沒有要求輸出一個明確的結果，可以參考： https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-207/

這題考的是 BFS 中的拓樸排序法，個人認為比較難的是在 graph 操作的部分，其他的概念相對來說還好。

另外處理 start_courses ，去尋找 indegree 為 0 的 node

input handling

如果 Graph 有 loop，會導致無法上完全部課程，此時回傳 []

Boundary conditions

當 queue 為空時，結束迴圈，並判斷是否上完全部課程。

Reference

课程表 · Course Schedule

【Leetcode】python - [207] Course Schedule 個人解法筆記

Tue, 19 Apr 2022 23:17:27 +0800

題目出處

207. Course Schedule

難度

medium

題目分類

Depth-First Search, Breadth-First Search, Graph Theory, Topological Sort

2022-04-19 一刷

個人範例程式碼 - 一刷 (2022/04/19)

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        if not prerequisites: # no course
            return True

        return self.bfs(numCourses, prerequisites)


    def bfs(self, num_courses, prerequisites):
        # init
        pre_courses, next_courses = self.get_table(num_courses, prerequisites)
        start_courses = []
        learned_course = []
        for course, pre in pre_courses.items():
            if not pre:
                start_courses.append(course)

        queue = collections.deque(start_courses)
        visited = set()

        while queue:
            course = queue.popleft()
            learned_course.append(course)
            visited.add(course)

            for next_course in next_courses[course]:
                pre_courses[next_course].remove(course)
                if not pre_courses[next_course] and next_course not in visited: # no pre-courses
                    queue.append(next_course)

        else:
            return num_courses == len(learned_course)

    def get_table(self, num_courses, prerequisites):
        pre_courses = {x:[] for x in range(num_courses)} # for record studied
        next_courses = {x:[] for x in range(num_courses)} # for search

        for course in prerequisites:
            pre_courses[course[1]].append(course[0])
            next_courses[course[0]].append(course[1])

        return pre_courses, next_courses

算法說明

這題考的是 BFS 中的拓樸排序法，個人認為比較難的是在 graph 操作的部分，其他的概念相對來說還好。

另外處理 start_courses ，去尋找 indegree 為 0 的 node

input handling

如果沒有 prerequisites，則必 True (無課程或無先修課)

Boundary conditions

當 queue 為空時，如果還沒有辦法上完全部的課程，則為 False
(可能 Graph 有 loop)

Reference

课程表 · Course Schedule

【Leetcode】python - [133] Clone Graph 個人解法筆記 | Graph 的基本操作 #重要題型

Sat, 16 Apr 2022 22:06:51 +0800

題目出處

133. Clone Graph

難度

medium

題目分類

Hash Table, Depth-First Search, Breadth-First Search, Graph Theory

2022-04-16 一刷

個人範例程式碼 - 一刷 (2022/04/16)

"""
# Definition for a Node.
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: 'Node') -> 'Node':
        root = node
        if node is None:
            return node

        # traverse, get all nodes by BFS
        old_nodes = self.get_all_nodes(node)
        # print(len(nodes))

        # clone all nodes
        mapping = {}
        for old_node in old_nodes:
            mapping[old_node] = Node(old_node.val)

        # clone all edges
        for old_node in old_nodes: # 
            new_node = mapping[old_node]
            for neighbor in old_node.neighbors:
                new_neighbor = mapping[neighbor]
                new_node.neighbors.append(new_neighbor)

        return mapping[root]


    def get_all_nodes(self, node):
        queue = [node]
        result = set([node])
        while queue:
            head = queue.pop(0)
            for neighbor in head.neighbors:
                if neighbor not in result:
                    result.add(neighbor)    
                    queue.append(neighbor)

        return result

算法說明

不好處理的題目，題目本身不難，但基本上可以視為 Graph 的基本操作題型。

我們分成三大步驟

- 找到所有的點，透過 BFS traverse - 複製所有的點 - 複製所有的邊

input handling

處理 input 為空的情況，這裡我是直接回傳 node。

Boundary conditions

注意 BFS 的結束條件：

當 queue 為空，所有的點都為 visited

Reference

克隆图 · Clone Graph

【Leetcode】python - [127] Word Ladder 個人解法筆記

Fri, 15 Apr 2022 18:46:13 +0800

題目出處

127. Word Ladder

難度

hard

題目分類

Hash Table, String, Breadth-First Search

2022-04-15 一刷

個人範例程式碼 - 一刷 (2022/04/15)

class Solution:
    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
        if endWord not in wordList:
            return 0 # not in wordlist

        wordset = set(wordList)
        this_layer = [beginWord]
        visited = set([beginWord])
        distance = 0

        # BFS, thinking of layer
        while this_layer:
            distance += 1 # new bfs layer
            next_layer = []
            for each_word in this_layer:
                if each_word == endWord: # find ans
                    return distance

                for next_word in self.get_next_word(each_word, wordset):
                    if next_word in visited:
                        pass
                    else:
                        next_layer.append(next_word)
                        visited.add(next_word)

            this_layer = next_layer

        return 0 # not found

    def get_next_word(self, each_word, wordset): # find all possible case
        words = [] 
        for i, each_char in enumerate(each_word):
            left, right = each_word[:i], each_word[i+1:]
            for char in 'abcdefghijklmnopqrstuvwxyz':
                if each_word[i] == char:
                    continue
                else:
                    new_word = left + char + right
                    if new_word in wordset:
                        words.append(new_word)

        return words

算法說明

看似 string 其實是一個 Graph 的題目，透過 BFS 來分層遍歷，找到最淺能達到目標的點。

get_next_word

這裡我們使用的方式比較單純，可以採取的策略有：

從 wordList 去反推下一層可能的文字
直接拆字去推，再去 wordList 找

個人使用的是第二種方法。

注意：加速技巧

原本題目使用的 wordList 搜尋時間為：O(n)，
若改為 set, hashmap，時間可以壓縮至 O(1)

input handling

處理 input endWord 不在 wordList 的情況，輸出 0 。

Boundary conditions

迴圈結束於

找到目標
找不到目標，且沒有下一層 layer (全部都 visited)

Reference

【Leetcode】python - [107] Binary Tree Level Order Traversal II 個人解法筆記

Thu, 07 Apr 2022 21:03:10 +0800

題目出處

107. Binary Tree Level Order Traversal II

難度

medium

題目分類

Tree, Breadth-First Search, Binary Tree

2022-04-07 一刷

個人範例程式碼 - 一刷 (2022/04/07)

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []

        ans = []
        queue = [root]
        while(queue):
            tmp_ans = []
            tmp_queue = []
            for node in queue:
                tmp_ans.append(node.val)
                if node.left is not None:
                    tmp_queue.append(node.left)
                if node.right is not None:
                    tmp_queue.append(node.right)
            ans.append(tmp_ans)
            queue = tmp_queue
        else:
            return ans[::-1]

算法說明

這題有幾乎相同的類似題，可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-102/

BFS traversal，搭配 Queue 即可完成。
這題沒有發揮 Queue 的 FIFO 特性，但要使用也是可以的。

無聊記：Queue = pop(0)，Q 長的很像 0…
比較 Stack = pop(-1) 或 pop ()

input handling

處理 input 為 None 的情況，輸出 []。

Boundary conditions

注意：BFS 結束條件為，「當 Queue 不再有東西的時候」。

Reference

二叉树的层次遍历 II · Binary Tree Level Order Traversal II

【Leetcode】python - [102] Binary Tree Level Order Traversal 個人解法筆記

Thu, 07 Apr 2022 12:43:11 +0800

題目出處

102. Binary Tree Level Order Traversal

難度

medium

題目分類

Tree, Breadth-First Search, Binary Tree

2022-04-07 二刷

個人範例程式碼 - 第二版：2022/4/7

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []

        queue = [root]
        ans = []
        while(queue):
            tmp_queue = []
            tmp_ans = []
            for ele in queue:
                tmp_ans.append(ele.val)
                if ele.left is not None:
                    tmp_queue.append(ele.left)
                if ele.right is not None:
                    tmp_queue.append(ele.right)
            ans.append(tmp_ans)
            queue = tmp_queue
        else:
            return ans

算法說明

BFS traversal，搭配 Queue 即可完成。
這題沒有發揮 Queue 的 FIFO 特性，但要使用也是可以的。

無聊記：Queue = pop(0)，Q 長的很像 0…
比較 Stack = pop(-1) 或 pop ()

input handling

處理 input 為 None 的情況，輸出 []。

Boundary conditions

注意：BFS 結束條件為，「當 Queue 不再有東西的時候」。

2022-03-19 一刷

個人範例程式碼 - 第一版：2022/3/19

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        ans = []
        this_level = [root]
        if root:
            while(this_level):
                this_level_val = []
                next_level = []   
                for node in this_level:
                    this_level_val.append(node.val)
                    if node.left:
                        next_level.append(node.left)
                    if node.right:
                        next_level.append(node.right)
                ans.append(this_level_val)
                this_level = next_level

        return ans

算法說明

既然是 level order，我們的思路是使用一層一層的方式下去把答案兜出來。

corner case 特殊情況處理

當樹為空 [] 或為只有 root [1] 時，需要注意。

Boundary conditions/ Edge conditions 邊際情況處理

原本的做法我是到最後一層才做檢查「if root」，
不過如果是採取這樣的作法，會多一層只有「None 的 layer」，
我們需要特別留意儲存的最後一層。

Reference

【Leetcode】python - [104] Maximum Depth of Binary Tree 個人手繪解法筆記

Fri, 02 Apr 2021 00:34:35 +0800

題目出處

https://leetcode.com/problems/maximum-depth-of-binary-tree/

難度

Easy

題目分類

Tree, Depth-First Search, Breadth-First Search, Binary Tree

2021-04-02 一刷

個人手繪解法筆記 (解法重點)

這題就是簡單考樹的遍歷，
用 while 來一層一層刷出深度。

從 list 翻譯樹的長相

示意圖: (我們就是照著紅色箭頭方向一個個節點看左右的。)

基本的確認，我們先確認有沒有這棵樹

總是會有一些要多考慮的事情… 沒有樹的話我們要先處理
(很討厭這種整個算法幾乎都寫對，結果錯「最簡單現象」的感覺XDD)

一層層的遍歷，每個節點左右都看一下

每一層遍歷各節點的左右，這邊可以抓一個感覺，
樹的成長 (level)，大概是照著 1 -> 2 -> 4 -> 8 -> 16
這樣的數值在快速變化的。

個人範例程式碼 - 一刷 (2021/04/02)

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        depth = 0
        if root:
            level = [root]
        else:
            level = []

        while(level):
            depth += 1
            next_level = []
            for ele in level:
                if ele.left:
                    next_level.append(ele.left)
                if ele.right:
                    next_level.append(ele.right)

            level = next_level 

        return depth

Reference

https://leetcode.com/problems/maximum-depth-of-binary-tree/discuss/34345/Python-BFS-solution