722 - LeetCode DFS on 嗡嗡的隨手筆記

【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

【Leetcode】python - [543] Diameter of Binary Tree 個人解法筆記

Tue, 21 Jun 2022 01:43:54 +0800

題目出處

543. Diameter of Binary Tree

難度

easy

題目分類

Tree, Depth-First Search, Binary Tree

2022-06-21 一刷

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

# 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 diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:

        return self.helper(root)[0]

    def helper(self, root):
        # end of recursion
        if not root:
            return 0, 0

        # define and split
        left_longest, left_diameter = self.helper(root.left)
        right_longest, right_diameter = self.helper(root.right)

        longest = max(left_longest, right_longest, left_diameter + right_diameter)
        diameter = max(left_diameter, right_diameter) + 1

        return longest, diameter

算法說明

我們先來理解題意，這題目主要是在詢問在 Tree 中「最長可組成的邊 (diameter)」，
主要有兩種情況：

最長邊包含 root
最長邊不包含 root (最長存在子樹中)

因此我們需要同時記錄「子樹中，目前最長」與「目前最長的邊」。

目前最長的邊 + 1 = 向上一層的最長邊

input handling

在 dfs 內處理

Boundary conditions

在 dfs 內控制範圍，如果搜尋至 root = None，return 0, 0

Reference

二叉树的直径 · Diameter of Binary Tree

【Leetcode】python - [110] Balanced Binary Tree 個人解法筆記

Mon, 20 Jun 2022 17:24:02 +0800

題目出處

110. Balanced Binary Tree

難度

easy

題目分類

Tree, Depth-First Search, Binary Tree

2022-06-20 一刷

個人範例程式碼 - 一刷 (2022/06/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 isBalanced(self, root: Optional[TreeNode]) -> bool:
        return self.isBalanced_and_get_height(root)[0]


    def isBalanced_and_get_height(self, root):        
        # end of recursion
        if not root:
            return True, 0

        # split
        left_is_balanced, left_height = self.isBalanced_and_get_height(root.left) 
        right_is_balanced, right_height = self.isBalanced_and_get_height(root.right)

        # define
        if not (left_is_balanced and right_is_balanced):
            return False, -1

        if abs(left_height - right_height) > 1:
            return False, -1

        return True, max(left_height, right_height)+1

算法說明

正常直接的想法是，我們的「所有子樹都必須要是 balanced」，
因此直覺會需要 recursion。

但因為要決定這個結果，我們還需要知道「當前子樹的最大高度」，
設計時，我們可以同時回傳「子樹的答案」+「當前子樹的最大高度」

input handling

一同在 dfs 內處理

Boundary conditions

如果沒有 root，結束遞迴

Reference

平衡二叉树 · Balanced Binary Tree

【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

【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 - [572] Subtree of Another Tree 個人解法筆記

Mon, 06 Jun 2022 18:21:27 +0800

題目出處

572. Subtree of Another Tree

難度

easy

題目分類

Tree, Depth-First Search, String Matching, Binary Tree, Hash Function

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 isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
        # end of recursion
        if not root:
            return False

        # define
        if self.is_same_tree(root, subRoot):
            return True

        # split
        return self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)

    def is_same_tree(self, root, subroot):
        # end of recursion
        if not root and not subroot:
            return True

        if not root or not subroot: # only one side left
            return False

        if root.val != subroot.val: 
            return False

        return self.is_same_tree(root.left, subroot.left) and self.is_same_tree(root.right, subroot.right)

算法說明

原本的 is_sub_tree，就已經可以幫助我們把大題目拆成小題目了，
我們只需要再多補上一個，比較兩個 tree 是否相同的函數即可。

input handling

if not root，return False (上層只要有一次 True 即可，因此用 or 比較其他答案)

Boundary conditions

用 not root，來判斷 Tree 的結尾。

Reference

另一个树的子树 · Subtree of Another 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 - [509] Fibonacci Number 個人解法筆記

Sun, 22 May 2022 00:45:37 +0800

題目出處

509. Fibonacci Number

難度

Easy

題目分類

Math, Dynamic Programming, Recursion, Memoization

2022-05-22 一刷

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

class Solution:
    def fib(self, n: int) -> int:

        dp = [0 for _ in range(n+1)]

        # define
        for i in range(n+1):
            # init
            if i == 0:
                dp[i] = 0
            elif i == 1:
                dp[i] = 1
            else: # define
                dp[i] = dp[i-1] + dp[i-2]

        return dp[-1]

算法說明

基本的經典費波納契數列問題。

主定義: dp[i] = dp[i-1] + dp[i-2]

初始化:

dp[0] = 0
dp[1] = 1

input handling

都在 for 裡面處理

Boundary conditions

for 來控制範圍，「注意當題目問 n 時，我們需要宣告 n + 1」

Reference

【Leetcode】python - [98] Validate Binary Search Tree 個人解法筆記

Tue, 10 May 2022 22:24:51 +0800

題目出處

98. Validate Binary Search Tree

難度

medium

題目分類

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

2022-05-10 一刷

個人範例程式碼 - DFS

# 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
        return self.dfs(root, float("-inf"), float("inf"))

    def dfs(self, root, lowerbound, upperbound):
        # end of recursion
        # define and split
        ans = True
        if root.left: # left: update upperbound
            if lowerbound < root.left.val < root.val: 
                ans &= self.dfs(root.left, lowerbound, root.val) 
            else:
                return False

        if root.right: # right: update lowerbound
            if root.val < root.right.val < upperbound:
                ans &= self.dfs(root.right, root.val, upperbound)
            else:
                return False

        return ans

算法說明

DFS 中，我們需要特別注意 BST 的特性，也就是他上下的範圍，常見錯誤如下

如果「只注意他與上層的關係」，會出現下圖中「三角形的錯誤」，因此我們需要同時考慮上下界

然而，在 BST 中處理上下界並不難，上下界的特性也十分容易分析。
我們只需要注意兩個重點：

往左走時：更新 upperbound
往右走時：更新 lowerbound

見下圖：

input handling

同 DFS 一起處理

Boundary conditions

每個點都必須同時界於 lowerbound ~ upperbound，不然 return False

個人範例程式碼 - inorder traversal

# 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True

        stack = []
        node = root
        # 1. to left bottom
        while node:
            stack.append(node)
            node = node.left

        ans = []
        # 2. pop right, see right, to left bottom
        while stack:
            node = stack.pop(-1)
            ans.append(node.val)
            if node.right:
                node = node.right
                while node: # to left bottom
                    stack.append(node)
                    node = node.left

        # print(ans)
        # return ans == sorted(ans)
        for i, num in enumerate(ans):
            if i > 0 and ans[i-1] >= ans[i]:
                return False

        return True

算法說明

直接用 inorder traversal 把整個順序列出來，然後再依序比較後者必須比前者大。

input handling

如果沒有 root，return 0

Boundary conditions

inorder traversal 的 stack 流派

使用 stack

左到底
pop，找右一個，然後一樣往左邊底

在 pop 時紀錄，就會得到最終答案。

Reference

验证二叉查找树 · Validate Binary Search Tree

【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 - [79] Word Search 個人解法筆記

Wed, 27 Apr 2022 04:05:03 +0800

題目出處

79. Word Search

難度

medium

題目分類

Array, String, Backtracking, Depth-First Search, Matrix

2022-04-27 一刷

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

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

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        if not board:
            return False

        # first point
        for i in range(len(board)):
            for j in range(len(board[0])):
                if board[i][j] == word[0] and self.dfs(board, word[1:], i, j, {(i,j)}):
                    return True
        return False # after all search

    def dfs(self, board, word, i, j, visited):
        # end of recursion
        if not word:
            return True

        # define and split
        for (dx, dy) in DIRECTIONS:
            next_x, next_y = i+dx, j+dy
            # print(next_point)
            if self.is_valid_point(next_x, next_y, board, visited, word[0]):
                visited.add((next_x, next_y))
                if self.dfs(board, word[1:], next_x, next_y, visited):
                    return True
                visited.remove((next_x, next_y)) # backtracking

        return False

# def dfs(self, board, word, start_point, visited)
#         # end of recursion
# if not word
#             return True

#         # define and split
# for (dx, dy) in DIRECTIONS
#             next_point = (start_point[0]+dx, start_point[1]+dy)
#             # print(next_point)
# if self.is_valid_point(next_point, board, visited, word[0])
#                 visited.add(next_point)
# if self.dfs(board, word[1:], next_point, visited)
#                     return True
#                 visited.remove(next_point) # backtracking

#         return False

    def is_valid_point(self, x, y, board, visited, word):
        if (x, y) in visited:
            return False
        r = len(board)
        c = len(board[0])
        return 0 <= x < r and 0 <= y < c and board[x][y] == word

算法說明

這題是學習矩陣內的四方向搜尋，類似題目可參考：

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

不過這題目有個難點是很容易 TLE，在處理上我們需要稍微優化一下：

優化比較的項目長度

例如說可能不要比較整個 prefix，而是只比較單一個 word

不要使用 tuple 實作

我註解掉的部分是使用 tuple 實作的，概念上應該會更清楚，
但因為會影響到時間，後來取消掉註解後才沒有 TLE

input handling

當沒有 matrix 時，return False

Boundary conditions

搜尋到目標後，就可以 return True 了。
沿路上發現字母不對，就直接 return False

Reference

单词搜索 · Word Search

【Leetcode】python - [10] Regular Expression Matching 個人解法筆記

Sat, 23 Apr 2022 03:21:45 +0800

題目出處

10. Regular Expression Matching

難度

hard

題目分類

String, Dynamic Programming, Recursion

2022-04-23 一刷

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

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        self.memo = {}
        return self.dfs(s, p, 0, 0)

    def dfs(self, s, p, start_s, start_p):
        # print(start_s, start_p)
        if (start_s, start_p) in self.memo:
            return self.memo[(start_s, start_p)]

        # end of recursion
        if len(s) <= start_s and len(p) <= start_p:
            return True
        if len(s) > start_s and len(p) <= start_p: # s left
            return False
        if len(s) <= start_s and len(p) > start_p: # p left # must be a* case
            return self.is_empty(p[start_p:])

        if start_p+1 < len(p) and p[start_p+1] == "*":
            # if * means nothing, self.dfs(s, p, start_s, start_p+2) # skip a*
            # if * means duplicate, self.dfs(s, p, start_s+1, start_p) # keep a*, if s[i] == p[i]
            ans = (self.is_char_matched(s[start_s], p[start_p]) and self.dfs(s, p, start_s+1, start_p)) or self.dfs(s, p, start_s, start_p+2) 
        elif self.is_char_matched(s[start_s], p[start_p]):
            ans = self.dfs(s, p, start_s+1, start_p+1)
        else:
            ans = False

        self.memo[(start_s, start_p)] = ans
        return ans

    def is_char_matched(self, s, p):
        return s <mark> p or p </mark> "."

    def is_empty(self, p):
        for idx in range(1, len(p), 2):
            if p[idx] == "*":             
                continue
            else:
                return False
        return True if p[-1] == "*" else False

算法說明

此題有類似題，但這題判斷更難寫，可參考：

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

超難的配對問題，比上面那題還更難，首先我們先不管加速，嘗試先寫一個能解的版本

基本版的寫完後，就會發現能 pass，但超慢，
原因是因為我們的搜索時間是「指數等級」的，看來是要稍微優化一下。

判斷的先後順序

這裡的 * 沒有像上一題那麼萬用，他必須要搭配合理的「前綴字」才能發揮效力。

在處理上，我們需要先判斷「i+1」是否為，
免得我們一個衝動讓「c != a」，return False 就糗大了

* 的處理

一樣也是分兩路

如果 * 代表的是沒有東西，則判斷 self.dfs(s, p, start_s, start_p+2)
如果 * 代表的是重複的東西，則判斷 self.dfs(s, p, start_s+1, start_p)

但注意!!!! 這裡還有一個陷阱!!!
我們需要多保證 s[i] p[i]，不能直接寫，
否則在碰到 cab 與 aab 這種 case ，就會出錯了。(被 c* 干擾了，c 沒有重複)

因此整理之後得到

如果 * 代表的是沒有東西，則判斷 self.dfs(s, p, start_s, start_p+2)
如果 * 代表的是重複的東西，則判斷 self.is_char_matched(s[start_s], p[start_p]) and self.dfs(s, p, start_s+1, start_p)

結束條件

分成三種：

如果 start_s, start_p 同時 >= len(s), len(p)，屬正常情況 return True
只有 start_p >= len(p)，表示有剩餘 s，return False
只有 start_s >= len(s)，表示有剩餘 p，要特別處理

我們要判斷 p 是否可以代表 “"，

最後要多判斷一個 [-1] “*"，確保尾巴沒有殘留的東西 (因為 range 2 有可能會漏掉一個)

def is_empty(self, p):
    for idx in range(1, len(p), 2):
        if p[idx]  "*":             
            continue
        else:
            return False
    return True if p[-1]  "*" else False

記憶化搜索 (DP)

我們用一個策略紀錄我們搜尋的結果，主要因為我們進行的「重複搜尋」太多了，
我們透過記憶 start_p, start_q 的兩個起始位置，與對應結果。

當遞迴再一次回到此位置時，直接去 hashtable 拿 (start_p, start_q) 的結果來用。

這邊我們強調一下增加的部分：

拿取

if (start_s, start_p) in self.memo_matched_begin:
    return self.memo_matched_begin[(start_s, start_p)]

儲存

self.memo_matched_begin[(start_s, start_p)] = ans

於是我們就能完成這道 hard 的題目。

input handling

Boundary conditions

見上述說明

Reference

[正则表达式匹配 · Regular Expression Matching](https://www.jiuzhang.com/solution/regular-expression-matching/)

【Leetcode】python - [44] Wildcard Matching 個人解法筆記

Sat, 23 Apr 2022 02:05:31 +0800

題目出處

44. Wildcard Matching

難度

hard

題目分類

String, Dynamic Programming, Greedy, Recursion

2022-04-23 一刷

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

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        self.memo_matched_begin = {}
        return self.dfs(s, p, 0, 0)

    def dfs(self, s, p, start_s, start_p):
        if (start_s, start_p) in self.memo_matched_begin:
            return self.memo_matched_begin[(start_s, start_p)]

        # end of recursion
        if start_s >= len(s) and start_p >= len(p):
            return True
        if start_s < len(s) and start_p >= len(p): # s left
            return False        
        if start_s >= len(s) and start_p < len(p): # p left
            for idx in range(start_p, len(p)):
                if p[idx] == "*":
                    continue
                else:
                    return False
            return True

        # define and split
        if self.is_char_matched(s[start_s], p[start_p]): # normal pattern
            ans = self.dfs(s, p, start_s+1, start_p+1)
        elif p[start_p] == "*":
            # can be nothing to anything(keep *)
            # * = nothing, self.dfs(s, p, start_s, start_p+1)
            # * = anything, self.dfs(s, p, start_s+1, start_p)
            ans = self.dfs(s, p, start_s, start_p+1) or self.dfs(s, p, start_s+1, start_p)
        else:
            ans = False

        self.memo_matched_begin[(start_s, start_p)] = ans
        return ans

    def is_char_matched(self, s, p):
        return s <mark> p or p </mark> "?"

算法說明

超難的配對問題，首先我們先不管加速，嘗試先寫一個能解的版本

基本版的寫完後，就會發現簡單的都能 pass，比較難的 case 會 TLE，
原因是因為我們的搜索時間是「指數等級」的，看來是要稍微優化一下。

記憶化搜索 (DP)

我們用一個策略紀錄我們搜尋的結果，主要因為我們進行的「重複搜尋」太多了，
我們透過記憶 start_p, start_q 的兩個起始位置，與對應結果。

當遞迴再一次回到此位置時，直接去 hashtable 拿 (start_p, start_q) 的結果來用。

這邊我們強調一下增加的部分：

拿取

if (start_s, start_p) in self.memo_matched_begin:
    return self.memo_matched_begin[(start_s, start_p)]

儲存

self.memo_matched_begin[(start_s, start_p)] = ans

於是我們就能完成這道 hard 的題目。

input handling

Boundary conditions

見上述說明

Reference

通配符匹配 · Wildcard Matching

【Lintcode】python - [900] Closest Binary Search Tree Value 個人解法筆記

Fri, 22 Apr 2022 13:33:30 +0800

題目出處

900 · Closest Binary Search Tree Value

難度

easy

題目分類

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

2022-04-22 一刷

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

from lintcode import (
    TreeNode,
)

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: the given BST
    @param target: the given target
    @return: the value in the BST that is closest to the target
    """
    def closest_value(self, root: TreeNode, target: float) -> int:
        # write your code here
        if not root:
            return -1

        upper = float("inf")
        lower = float("-inf") 

        stack = collections.deque([root])
        while stack:
            node = stack.pop()
            if node.val > target:
                upper = min(node.val, upper)
                if node.left:
                    stack.append(node.left)
            elif node.val < target:
                lower = max(node.val, lower)
                if node.right:
                    stack.append(node.right)
            else: # same value
                return node.val

        return upper if (upper - target < target - lower) else lower

算法說明

算是考 BST 的基本定義，這邊可以用圖來說明一下發生的現象。

由圖上我們可以發現隨著搜尋過程中，target 區間正在不斷的縮小，此題就是利用這個特性。

input handling

root 沒東西時，回傳 -1

Boundary conditions

搜尋到沒有東西，或是搜尋到「等於 target (必定為最近)」，直接 return 了

Reference

二叉搜索树中最接近的值 · Closest Binary Search Tree Value

【Lintcode】python - [448] Inorder Successor in BST 個人解法筆記

Fri, 22 Apr 2022 03:09:03 +0800

題目出處

448 · Inorder Successor in BST

難度

medium

題目分類

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

2022-04-22 一刷

個人範例程式碼 - recursive 版本

"""
Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
"""


class Solution:
    """
    @param: root: The root of the BST.
    @param: p: You need find the successor node of p.
    @return: Successor of p.
    """
    def inorderSuccessor(self, root, p):
        # write your code here

        if not root:
            return None

        self.found = False
        self.ans = None
        self.dfs(root, p)
        return self.ans

    def dfs(self, node, p):
        if not node:
            return

        self.dfs(node.left, p)
        if self.found == True: # next node
            self.ans = node
            self.found = False
        if node == p:
            self.found = True
        self.dfs(node.right, p)

算法說明

inorder 排序的延伸，這裡要先知道 Successor 的定義比較好解

而討論可能的相對位置 (不清楚可以想一下 inorder 定義)
：

如果有右子樹，就是右樹的第一個 node
如果沒有右樹，就是往上方的 node 尋找第一個左彎的 node

借一下 BST iterator 的圖3，相對位置就是 next

不過說實在，這樣還要討論太麻煩了，不如就直接無腦開始 traverse 還比較快XD

這也是我最後的做法，只需要注意修改 inorder 的中間位置，
這邊要增加讀取 val，且發現上一個為 p 時，需要做一下記號。

input handling

找不到對應結果時，回傳 -1 (題目沒有要求這部份)

Boundary conditions

Reference

Finding the In-Order Successor of a Node

【Leetcode】python - [230] Kth Smallest Element in a BST 個人解法筆記

Fri, 22 Apr 2022 02:09:26 +0800

題目出處

230. Kth Smallest Element in a BST

難度

medium

題目分類

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

2022-04-22 一刷

個人範例程式碼 - recursive 版本

# 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 kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        self.k = k
        self.final_ans = -1
        self.dfs(root)

        return self.final_ans

    def dfs(self, root):
        if not root:
            return 

        self.dfs(root.left)
        self.k -= 1
        if self.k == 0:
            self.final_ans = root.val
        self.dfs(root.right)

        return

算法說明

建立一個 global 的計數器 (這設計可能不太好)，然後照 BST 的概念下去找第 K 小的值。

input handling

找不到對應結果時，回傳 -1 (題目沒有要求這部份)

Boundary conditions

個人範例程式碼 - iterative 版本

# 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 kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        self.stack = deque()
        self.to_left_bottom(root)

        while(k > 0):
            cur = node = self.stack[-1]
            if node.right is not None:
                node = node.right
                self.to_left_bottom(node)
            else:
                node = self.stack.pop()
                while self.stack and self.stack[-1].right == node:
                    node = self.stack.pop()

            k -= 1 # get one node
            if k == 0:
                return cur.val
        else:
            return -1

    def to_left_bottom(self, node):
        while(node):
            self.stack.append(node)
            node = node.left

算法說明

iterative 的解法，我們借用 Binary Search Tree Iterator 的概念來使用，可參考：

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

input handling

找不到對應結果時，回傳 -1 (題目沒有要求這部份)

Boundary conditions

Reference

【Leetcode】python - [236] Lowest Common Ancestor of a Binary Tree 個人解法筆記 #重要題型

Thu, 21 Apr 2022 04:01:12 +0800

題目出處

236. Lowest Common Ancestor of a Binary Tree

難度

medium

題目分類

Tree, Depth-First Search, Binary Tree

2022-04-21 一刷

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

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, x)
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        return self.lca(root, p, q)

    def lca(self, root, p, q):
        if not root:
            return None
        if root <mark> p or root </mark> q:
            return root

        # divide
        found_left = self.lca(root.left, p, q)
        found_right = self.lca(root.right, p, q)

        # conquer
        if found_left is not None and found_right is not None:
            return root
        elif found_left:
            return found_left
        elif found_right:
            return found_right
        else: # not found
            return None

算法說明

這已經是系列題目的第三題了，前面可參考

此系列題目的第一題，由於設計上多了 parent node，相對來說比較沒有考到 LCA 的經常考點：

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

此系列題目的第二題，BST 與 BT 只多了比較好找數字，基本上有正確實作 LCA 其實也不用管數字排序：

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

LCA 的基本寫法，非常重要的題目。

拆成四路分析，左右返回是否有找到 A or B

討論 case 如下

如果兩側各返回 found，表示一邊各找到一個，此 node 即為答案
如果只有 left/right 返回 found，表示已經在下層找到答案，正在往上回傳。
如果都沒有 found，表示目前往下還找不到，返回 None

而特殊的 case 為

當 A 為 root，而 B 在此 root 之下，或相反的情況，
此時我們做的處理為返回 root，因為兩者的交集就是在 root 是兩者同時的 LCA。

Reference

474 · Lowest Common Ancestor II

【Leetcode】python - [235] Lowest Common Ancestor of a Binary Search Tree 個人解法筆記

Thu, 21 Apr 2022 03:48:49 +0800

題目出處

235. Lowest Common Ancestor of a Binary Search Tree

難度

easy

題目分類

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

2022-04-21 一刷

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

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, x)
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        return self.lca(root, p, q)

    def lca(self, root, p, q):
        if not root:
            return None
        if p <mark> root or q </mark> root:
            return root

        # divide
        found_left = self.lca(root.left, p, q)
        found_right = self.lca(root.right, p, q)

        # conquer
        if found_left is not None and found_right is not None: # two side found
            return root
        elif found_left: # found left
            return found_left
        elif found_right: # found right
            return found_right
        else: # not found
            return None

算法說明

此題的前一題，由於設計上多了 parent node，相對來說比較沒有考到 LCA 的經常考點：

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

LCA 的基本寫法，非常重要的題目。

拆成四路分析，左右返回是否有找到 A or B

討論 case 如下

如果兩側各返回 found，表示一邊各找到一個，此 node 即為答案
如果只有 left/right 返回 found，表示已經在下層找到答案，正在往上回傳。
如果都沒有 found，表示目前往下還找不到，返回 None

而特殊的 case 為

當 A 為 root，而 B 在此 root 之下，或相反的情況，
此時我們做的處理為返回 root，因為兩者的交集就是在 root 是兩者同時的 LCA。

Reference

474 · Lowest Common Ancestor II

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

Wed, 20 Apr 2022 00:21:55 +0800

題目出處

113. Path Sum II

難度

medium

題目分類

Backtracking, Tree, Depth-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 pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        ans = []
        self.dfs(root, targetSum, [], ans)
        return ans

    def dfs(self, root, target, path, ans):
        # None
        if not root:
            return 

        path.append(root.val)
        # Leaf
        if not root.left and not root.right:
            if sum(path) == target:
                ans.append(path[:]) # copy a new one
                path.pop()
                return

        # not leaf
        self.dfs(root.left, target, path, ans)
        self.dfs(root.right, target, path, ans)
        path.pop()

        return

算法說明

此題的前一個題目，不同處在於需要多求出完整路徑，可參考：

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

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

input handling

如果沒有正確結果，回傳 []

Boundary conditions

end of recursion

判斷 Null 或是 Leaf

Null

False

if not root:
    return

Leaf

判斷是否總和正確，如果是則加入目前的 path

# Leaf
if not root.left and not root.right:
    if sum(path) == target:
        ans.append(path[:]) # copy a new one
        path.pop()
        return

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
self.dfs(root.left, target, path, ans)
self.dfs(root.right, target, path, ans)
path.pop()

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 - [257] Binary Tree Paths 個人解法筆記

Tue, 19 Apr 2022 23:43:34 +0800

題目出處

257. Binary Tree Paths

難度

easy

題目分類

String, Backtracking, Tree, Depth-First Search, Binary Tree

2022-04-19 一刷

個人範例程式碼 - 一刷 (2022/04/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 binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        ans = []
        self.dfs(root, "", ans)
        return ans

    def dfs(self, root, path, ans):
        if not root: # Null point
            return

        if not root.left and not root.right: # last point
            path += f"{root.val}"
            ans.append(path)
            return

        path += f"{root.val}->"
        self.dfs(root.left, path, ans)            
        self.dfs(root.right, path, ans)

        return

算法說明

基礎的 DFS 用來 traverse Tree 裡面的內容，並回傳路徑。

input handling

如果沒有內容，回傳 []

Boundary conditions

end of recursion

判斷 Null 或是 Leaf

Null

if not root: # Null point

Leaf

if not root.left and not root.right: # last point

define of recursion

單純增加路過的路徑。

path += f"{root.val}->"

split of recursion

拆成兩路

self.dfs(root.left, path, ans)            
self.dfs(root.right, path, ans)

Reference

480 · Binary Tree Paths

【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 - [2] Add Two Numbers 個人解法筆記

Sat, 16 Apr 2022 22:37:42 +0800

題目出處

2. Add Two Numbers

難度

medium

題目分類

Linked List, Math, Recursion

2022-04-16 一刷

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

基本版本

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:

        dummy = head = ListNode(0)
        carry = 0

        while(l1 and l2):
            this_val = l1.val + l2.val + carry
            carry = this_val // 10            
            head.next = ListNode(this_val % 10)
            l1 = l1.next
            l2 = l2.next
            head = head.next
        else:
            while(l1):
                this_val = l1.val + carry
                carry = this_val // 10            
                head.next = ListNode(this_val % 10)
                l1 = l1.next
                head = head.next
            while(l2):
                this_val = l2.val + carry
                carry = this_val // 10            
                head.next = ListNode(this_val % 10)
                l2 = l2.next
                head = head.next
            if carry:
                head.next = ListNode(carry)

        return dummy.next

算法說明

- 當 l1, l2 還有值時，為第一階段 - 其中一個沒有值時，用 while 去將剩下的 l1 或 l2 掃完 - 最後判定有沒有剩餘的 carry

input handling

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

Boundary conditions

注意 LinkList 的結束條件：

結束的 None 也算是一個節點。會被 if node 判為 False。

優化版本

優化，將 l1, l2, carry 有無剩餘的內容一起看，一路處理到沒剩餘內容為止。

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:

        dummy = head = ListNode(0)
        carry = 0
        while(l1 or l2 or carry): # something still exist
            if l1:
                carry += l1.val
                l1 = l1.next
            if l2:
                carry += l2.val
                l2 = l2.next

            head.next = ListNode(carry % 10)
            head = head.next
            carry = carry // 10
        else:
            return dummy.next

Reference

Is this Algorithm optimal or what?

【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 - [50] Pow(x, n) 個人解法筆記

Tue, 05 Apr 2022 20:43:38 +0800

題目出處

50. Pow(x, n)

難度

medium

題目分類

Math, Recursion

2022-04-05 一刷

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

class Solution:
    def myPow(self, x: float, n: int) -> float:
        # write your code here
        # 2 = 1 + 0
        # 7 = 1 + 1 + 1
        # 5 = 1 + 1 + 0
        # 13 = 1 + 1 + 0 + 1
        ans = 1
        minus_flag = False
        if n == 0:
            return 1
        if n < 0:
            minus_flag = True
            n = -n

        while(n > 0):
            if n % 2 == 0:
                pass # print(0)
            else:
                # print(1)
                ans *= x
            x = x * x
            n = n >> 1 # // 2
        else:
            if minus_flag:
                return 1/ans
            else:
                return ans

算法說明

核心概念為，將 n 次方拆成二進位的方式計算 (這樣就不用重複算)

例如 9 = 8 + 0 + 0 + 1，

我們只重複計算 1^2^2^2^2…. 可以減少一半的計算次數，複雜度為 O(n) -> O(logN)

另外處理負數要特別注意。

input handling

處理輸入 n = 0 ，return 1,
與輸入 n < 0 ，作負數處理。

Boundary conditions

循環直到當 n 0 時 ( 1//2 = 0 )

Reference

x的n次幂 · Pow(x, n)

【Leetcode】python - [145] Binary Tree Postorder Traversal 個人解法筆記

Sat, 19 Mar 2022 10:10:49 +0800

題目出處

145. Binary Tree Postorder Traversal

難度

easy

題目分類

Stack, Tree, Depth-First Search, Binary Tree

2022-03-19 一刷

解 Tree 樹問題的重點整理

這一篇的前身是以下連結，我們繼續在這篇整理重點

【Leetcode】python – [144] Binary Tree Preorder Traversal 個人解法筆記 (內含範例程式碼) 內含處理 Tree 樹問題的重點

Tree 基本中的基本，我們一定至少需要學會兩種 parse tree 的方式，

一種是 iterative (直接的取)
另一種是 recursive (遞迴的取)

基本上這兩種都務必熟悉，未來解題時萬一一種解不出來，就可以嘗試用另外一種方法。

個人範例程式碼 - recursive 版

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        self.dfs(root, ans)
        return ans

    def dfs(self, root, ans):
        if root:
            self.dfs(root.left, ans)
            self.dfs(root.right, ans)
            ans.append(root.val)

算法說明

recursive 的 parse tree 基本上可以結合 dfs 的概念，
而我們需要另外寫一個 function dfs()，因為我們會需要把答案帶著走，原題目的函數沒辦法直接遞迴。

主要變化的範圍如下，然後依照 (M)RL、R(M)L、RL(M) 改一下順序，全部的解法就都出來了!

self.dfs(root.left, ans)
self.dfs(root.right, ans)
ans.append(root.val)

corner case 特殊情況處理

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

Boundary conditions/ Edge conditions 邊際情況處理

處理沒有節點的情況， if not root 直接回傳。

個人範例程式碼 - iterative 版

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        stack = [root]     
        # LR(M) -> (M)RL
        while(stack):
            if root: # left to leaf
                ans.append(root.val) # add M first
                stack.append(root.left) # record later
                root = root.right
            else: # can not left
                root = stack.pop(-1)       

        return ans[::-1]

算法說明

我們要處理的問題變得比較麻煩一些，變成 LR(M),
但因為我們其實都是在控制 (M) 出現的時機，
因此比較好的方式是我們把它提造最前面去做，

因此我們以 (M)RL 去做一棵樹，而最後「再反序」。
我們分兩個 part

可以往下走的情況， (此處是往右先)

我們可以往右就右到底。

if root: # left to leaf
   ans.append(root.val) # add M first
   stack.append(root.left) # record later
   root = root.right

不能往下走，就往左走的情況

表示上述「if root」找不到結果的情況，
pop 出「最後一個」「分歧點」，
也就是「回到上一個岔路往左走」。

else: # can not left
   root = stack.pop(-1)

corner case 特殊情況處理

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

Boundary conditions/ Edge conditions 邊際情況處理

結束條件為 Stack 為空，我們運用 Stack 可以幫我們保存的概念。

Reference

此系列解法個人的其他文章

個人認為整理的最完整的解法

Summary of preorder, inorder, postorder, four traversal ways for each

很用心的 DFS 製圖

All DFS traversals (preorder, inorder, postorder) in Python in 1 line

結合 visited 的很酷的 solution

Python 3 - All Iterative Traversals - InOrder, PreOrder, PostOrder - Similar Solutions

- [Python solutions (recursively and iteratively).](https://leetcode.com/problems/binary-tree-preorder-traversal/discuss/45290/Python-solutions-(recursively-and-iteratively).) - [Python recursive and iterative solutions.](https://leetcode.com/problems/binary-tree-postorder-traversal/discuss/45786/Python-recursive-and-iterative-solutions.)

【Leetcode】python - [94] Binary Tree Inorder Traversal 個人手寫解法筆記內含處理 Tree 樹問題的重點

Sun, 13 Mar 2022 22:26:12 +0800

題目出處

94. Binary Tree Inorder Traversal

難度

easy

題目分類

Stack, Tree, Depth-First Search, Binary Tree

2022-03-13 一刷

解 Tree 樹問題的重點整理

這一篇的前身是以下連結，我們繼續在這篇整理重點

【Leetcode】python – [144] Binary Tree Preorder Traversal 個人解法筆記 (內含範例程式碼) 內含處理 Tree 樹問題的重點

Tree 基本中的基本，我們一定至少需要學會兩種 parse tree 的方式，

一種是 iterative (直接的取)
另一種是 recursive (遞迴的取)

基本上這兩種都務必熟悉，未來解題時萬一一種解不出來，就可以嘗試用另外一種方法。

個人範例程式碼 - recursive 版

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ans = []
        self.dfs(root, ans)
        return ans

    def dfs(self, root, ans):
        if root:
            self.dfs(root.left, ans)            
            ans.append(root.val)
            self.dfs(root.right, ans)

        else:
            return

算法說明

recursive 的 parse tree 基本上可以結合 dfs 的概念，
而我們需要另外寫一個 function dfs()，因為我們會需要把答案帶著走，原題目的函數沒辦法直接遞迴。

主要變化的範圍如下，然後依照 (M)RL、R(M)L、RL(M) 改一下順序，全部的解法就都出來了!

self.dfs(root.left, ans)
ans.append(root.val)
self.dfs(root.right, ans)

corner case 特殊情況處理

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

Boundary conditions/ Edge conditions 邊際情況處理

處理沒有節點的情況， if not root 直接回傳。

個人範例程式碼 - iterative 版

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # left mid right
        nodeStack = []
        ans = []
        while root or nodeStack:
            if root:
                nodeStack.append(root) 
                root = root.left # repeat put left if exist
            else: # nothing left
                curNode = nodeStack.pop()
                ans.append(curNode.val) # append left
                root = curNode.right              

        return ans

算法說明

以下筆記手寫，字醜傷眼注意XDD

由上圖，我們可以發現，我們會先

向左走到底，一邊存 node 進 stack 當中，
發現沒辦法向左之後，pop一個值，此值就是我們拿 inorder 中間值的時候
pop 後往右

注意：由於「後處理要先放」，因此順序會是「先右後左」

你可能會想問這麼注意順序為什麼不用 Queue?
因為「先進先出」的結構我們沒辦法保存應該要後處理的東西。

例如第一層的左右，加入第二層後，
第一層的右一定會先出後，才會做第二層，因此沒辦法。

corner case 特殊情況處理

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

Boundary conditions/ Edge conditions 邊際情況處理

結束條件為 Stack 為空，我們運用 Stack 可以幫我們保存的概念。

結論 - 處理樹的重點

直接的解法我們需要配合 Stack，遞迴的做法我們需要配合 DFS

Stack 為 pop() 或 pop(-1) 就可以直接實現，注意「後處理要先放」。

interative 的重點

我們可以發現，不論是哪一種 interative 方法，「向左走到底都是必須的」，
因此，我們就只要專心的看何時是我們該拿值的地方，
就可以順著把這三題都解出來

我們 traversal tree 主要分成兩種情況

向左走到底，一邊存 node 值 (preorder 此時取值) <– (M)RL
無法向左的情況，從 stack pop 出一個值 (inorder 此時取值)，並向右

而我們也可以分析出，類似相關的題目中

inorder - R(M)L：拿時存答案
preorder - (M)RL：先放值(mid)，再拿
postoreder - RL(M)：先放值(mid)，再拿，最後反序

postorder我們處理時會比較特別，因為他是 RL(M) 的結構，
而我們 traversal tree 時，通常都一定會先從根開始看，
因此比較好的處理方式，我們會一開始就先把順序倒過來看，
變成我們處理 (M)LR，最後再反序。

Reference

個人認為整理的最完整的解法

Summary of preorder, inorder, postorder, four traversal ways for each

很用心的 DFS 製圖

All DFS traversals (preorder, inorder, postorder) in Python in 1 line

結合 visited 的很酷的 solution

Python 3 - All Iterative Traversals - InOrder, PreOrder, PostOrder - Similar Solutions

【Leetcode】python - [144] Binary Tree Preorder Traversal 個人解法筆記內含處理 Tree 樹問題的重點

Wed, 09 Mar 2022 16:43:45 +0800

題目出處

144. Binary Tree Preorder Traversal

難度

easy

題目分類

Stack, Tree, Depth-First Search, Binary Tree

2022-03-09 一刷

個人範例程式碼 - recursive 版

Tree 基本中的基本，我們一定至少需要學會兩種 parse tree 的方式，

一種是 iterative (直接的取)
另一種是 recursive (遞迴的取)

基本上這兩種都務必熟悉，未來解題時萬一一種解不出來，就可以嘗試用另外一種方法。

# 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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # pre = m l r
        if not root:
            return []
        else:
            ans = [] # in-place change
            self.dfs(root, ans)
            return ans

    def dfs(self, node, ans):
        if not node:
            return
        else:
            ans.append(node.val) # mid
            self.dfs(node.left, ans) # l
            self.dfs(node.right, ans) # r

        return ans

算法說明

recursive 的 parse tree 基本上可以結合 dfs 的概念，
而我門需要另外寫一個 function dfs()，因為我們會需要把答案帶著走，原題目的函數沒辦法直接遞迴。

corner case 特殊情況處理

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

Boundary conditions/ Edge conditions 邊際情況處理

處理沒有節點的情況， if not root 直接回傳。

個人範例程式碼 - iterative 版

# 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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # pre = m l r
        ans = []
        node_stack = [root]
        while node_stack:
            cur_node = node_stack.pop()
            if cur_node:
                ans.append(cur_node.val)
                node_stack.append(cur_node.right)
                node_stack.append(cur_node.left)

        return ans

算法說明

注意：由於「後處理要先放」，因此順序會是「先右後左」

你可能會想問這麼注意順序為什麼不用 Queue?
因為「先進先出」的結構我們沒辦法保存應該要後處理的東西。

例如第一層的左右，加入第二層後，
第一層的右一定會先出後，才會做第二層，因此沒辦法。

corner case 特殊情況處理

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

Boundary conditions/ Edge conditions 邊際情況處理

結束條件為 Stack 為空，我們運用 Stack 可以幫我們保存的概念。

結論 - 處理樹的重點

直接的解法我們需要配合 Stack，遞迴的做法我們需要配合 DFS

Stack 為 pop() 或 pop(-1) 就可以直接實現，注意「後處理要先放」。

Reference

Python solutions (recursively and iteratively).

【Leetcode】python - [206] Reverse Linked List 個人解法筆記內含 Linked List reverse 反轉操作 part 3 (for 新手教學)

Sun, 06 Mar 2022 19:33:52 +0800

題目出處

206. Reverse Linked List

難度

easy

題目分類

Linked List, Recursion

2022-03-06 一刷

Linked List reverse 反轉操作 part 3

part1 基本概念請參考： [【Leetcode】python – [21] Merge Two Sorted Lists 個人解法筆記 (內含範例程式碼) 內含 Linked List 基本操作 (for 新手教學)](https://wongwongnotes.com/posts/algorithm-practice/data-structures/linked-list/leetcode-python-21/)

part2 remove 操作請參考： [【Leetcode】python – [203] Remove Linked List Elements 個人解法筆記 (內含範例程式碼) 內含 Linked List remove 操作 part 2 (for 新手教學)](https://wongwongnotes.com/posts/algorithm-practice/data-structures/linked-list/leetcode-python-203/)

這邊我們要來研究 Linked list 的反轉操作，
一樣的，這操作硬要說也不難，但只要思緒不夠清楚，
一定是轉了半天轉不出來XDD 最後絕望放棄XD

我們試著來把概念講的簡單一點吧!

這裡作者有找到一個超棒的動畫解釋，有興趣可以看，「真的很讚的動畫」： Easy [C++/Java/Python/JavaScript] Explained+Animated

試試看講簡單一點

做反轉動作來說，最簡單我們都需要「三個紀錄點」，
分別代表「過去」、「現在」、「未來」，
每一個記錄點都非常重要，
我們一定要注意「不能在過程中失去任何重要紀錄點，一旦被蓋掉就再也找不回來了!」

因此我們基本的策略就有了下圖，1 ~ 3，
我們移動的方式一定是：

- 過去 = 現在 - 現在 = 未來 - 未來 = 更未來

到這邊，「務必務必謹守上述這個原則」，
再來我們再來討論反轉，什麼時候適合做反轉呢?
就是在做上述的「移動 1~3」之前，所以「更改」反轉的線，就是在第 0 步驟，

初始化

這裡有個小重點，不論如何，我們的 Linklist 最終「必須結束於 None」，
因此我們要先宣告個「新結束點」給他，
那想當然，可以讓一開始 prev 擔任這個步驟。

而我們真正作為起頭的 head ，可以先給予他 cur (代表現在)，
由於此時我們還不確定有沒有 head 存在，因此還不能直接給 head.next (會跳錯)

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

記得上述所說的，我們需要先宣告 None 作為結尾

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev = None # must have a None end.
        if head: # init 
            cur = head
            head = head.next
            cur.next = prev # must have a None end.
        else: # special case
            return head

        # loop
        while head:   
            prev = cur
            cur = head  
            head = head.next
            cur.next = prev # reverse

        return cur

Time Complexity

O(n)

Space Complexity

O(1)

算法說明

遍歷一次 head 是一定要的，問題是我們該怎麼移除，
移除的方法我們上面也提到過了，
只需要把「下個」替換成「下下個」就可以輕鬆解決，
只是要多考慮一些「不存在的邊際情況」，這邊我們下面會提。

corner case 特殊情況處理

一同整理在下方「邊際情況處理」

Boundary conditions/ Edge conditions 邊際情況處理

我們把題目稍微分析一下，我這裡大概把題目分類成於以下三種情況，

- [None] - [1] - [1,2,3] <- 正常情況

其中我們來看看 1.2. 我們該怎麼辦。

1. [None]

如果一開始 if head 就沒東西，我們就直接 return head

2. [1]

我們已經把 cur = head，而 while head 會直接判找不到東西，
因此回傳 cur，沒有問題。

Reference

【Leetcode】python - [203] Remove Linked List Elements 個人解法筆記內含 Linked List remove 操作 part 2 (for 新手教學)

Sat, 05 Mar 2022 15:36:05 +0800

題目出處

203. Remove Linked List Elements

難度

easy

題目分類

Linked List, Recursion

2022-03-05 一刷

Linked List remove 操作 part 2

part1 請參考： [【Leetcode】python – [21] Merge Two Sorted Lists 個人解法筆記 (內含範例程式碼) 內含 Linked List 基本操作 (for 新手教學)](https://wongwongnotes.com/posts/algorithm-practice/data-structures/linked-list/leetcode-python-21/)

這邊我們要來研究 Linked list 的 remove，
說 remove 其實也不難，最麻煩的應該是要考慮的邊際情況很多，

大觀念來說，我們只要「把下一個替換成下下一個」，就可以順利完成，
這觀念聽起來就超簡單的XDDD

但問題就是在要處理一些特殊狀況
這個我們在後續的「邊際問題處理」再來提

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

我們會習慣宣告假開頭為 dummy，並給予任意值 (這裡給 -1)，
反正我們要用的是 dummy.next 之後的東西，
就當是一種解題習慣吧。

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy = cur = ListNode(-1)
        cur.next = head # start from head, if wrong will pass later

        while cur.next: # head exist, we need to parse all Linkedlist
            if cur.next.val == val: # check next
                cur.next = cur.next.next # pass next (remove)
            else:
                cur = cur.next # save one ans
            head = head.next # move        

        return dummy.next

Time Complexity

O(n)

Space Complexity

O(1)

算法說明

corner case 特殊情況處理

一同整理在下方「邊際情況處理」

Boundary conditions/ Edge conditions 邊際情況處理

這題問題本身不難，麻煩的是在考慮的邊際情況很多，
這些問題是我自己想的，「一定有些對於讀者來說是可以不用思考的問題」，
總之只要考慮周全就是好方法，不一定要照我的XD

0. (一般情況) 在中間，要移除

沒什麼問題，當 cur.next = cur.next.next 我們就會看到下一個不是的了
-> 我們觀察的值為 (cur.next).val

1. 如果你要移除的，已經是最後一個?

當 cur.next = cur.next.next 我們就會看到 None 了
-> 我們觀察的值為 (cur.next).val

2. 如果最後連續 N 個，都是要移除的?

當 cur.next = cur.next.next ，不斷替換 cur.next 我們遲早就會看到 None 了
-> 我們觀察的值為 (cur.next).val

3. 如果全部都是要移除的?

當 cur.next = cur.next.next 直到我們看到 None，而我們要確保「cur 與 cur 之前的答案都是可行的」
-> 我們觀察的值為 (cur.next).val

4. 如果沒有值?

cur.next 為 None 我們會發現。

5. 如果開頭就是要移除的?

我們的開頭設為「cur.next = head」，也就是說我們只希望讓 cur 之後的答案為正確的。

Reference

【Leetcode】python - [21] Merge Two Sorted Lists 個人解法筆記內含 Linked List 基本操作 (for 新手教學)

Sat, 05 Mar 2022 14:31:19 +0800

題目出處

21. Merge Two Sorted Lists

難度

easy

題目分類

Linked List, Recursion

2022-03-05 一刷

Linked List 操作 (for 新手教學)

新手如我，最不熟悉 Linked List 的操作，剛好網路上有其他大神分享，
我們來簡單的重新敘述一下他教學的內容：

參考：Python3 Solution with a Detailed Explanation - dummy explained

pointer 跟著移動?

假設我們定義一個 head = temp = ListNode(0)，
(這樣寫太難懂的話，請理解為 temp = ListNode(0)， head = temp)

在 Linked List 操作中可能最讓人困惑的就是，當我們去移動 temp 時，head 會不會跟著移動?
在 python 裡面，我們進行 temp = temp.next 的動作，
實際上我們只有移動「temp 指向的位置」，我們可以理解「temp.next」在此只是一個「位置的代稱」，
就像我們說
b = 1
a = b
b = 2
最後會知道 a = 1, b = 2 而不是 a, b = 2，

不要像作者我在一開始因為開始有點複雜，就被搞亂了。

好啊，那 pointer 不移動，為啥 temp 去改能影響到 head?

head 一開始指到的記憶體位置與 temp 是相同的，
而我們控制 temp 在此點的指向，因此 head 確實可以從這個記憶體位置往下找。

比喻

我們可以想像我們現在正在挖金礦，我們順著線索 1 -> 2 -> 3 不斷往前，
但我們如果要告訴後來的人這條路該怎麼走，我們是必要紀錄起始點的位置。
因此這裡就會分為 head, temp， head 幫助我們保留起始位置，而 temp 負責幫我們移動。
中間的每一個線索都已經由 temp 在過程中建立好正確連結，
因此 head 尋著 temp 打通的道路再走一次，就是走 temp 開過的路。

ListNode(0)? return head.next

不用想那麼多，這只是建立一個供我們參考的基準點。
從我們最後 return head.next 就知道，我們只在乎這個基準點之後的事情。

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

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        head = temp = ListNode(0)
        while list1 and list2: 
            if list1.val < list2.val:
                temp.next = list1 # ans next Node
                list1 = list1.next
            else:
                temp.next = list2 # ans next Node
                list2 = list2.next # move next
            temp = temp.next # ans move next
        temp.next = list1 or list2 # remain things
        return head.next

Time Complexity

O(m+n)

Space Complexity

O(1)

算法說明

如上面介紹所述

corner case 特殊情況處理

注意沒有值的情況，例如開頭就沒有的時候

Boundary conditions/ Edge conditions 邊際情況處理

終止條件

注意沒有值的情況，
我們大原則是每次都會檢查「this Node 是否為 None」再開始接續動作。

提取剩餘內容

另外最後的 list1 or list2 是個非常漂亮的做法，
可以快速把剩餘的內容提取出來。

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