719 - LeetCode Graph 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 方面的解題思路基本相同。

補充：下次解需要留意一個小細節 return, 或是 return None 都是有些多餘的干擾閱讀寫法，不如直接省略。

還有一個小細節需要注意：“0”, “1” 是 string 不是 int，別看太快。

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 全滿不能再新增，就結束回傳答案。

由於題目有要求回傳的答案要是 sorted，請注意先 sorted 後再回傳。

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 來幫助我們搜尋，看是否全部搜尋完全即可。

注意：這題題目中有提示我們，我們可以從 0 做為起點開始搜尋。

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 - [128] Longest Consecutive Sequence 個人解法筆記

Mon, 30 May 2022 04:09:26 +0800

題目出處

128. Longest Consecutive Sequence

難度

medium

題目分類

Array, Hash Table, Union-Find

2022-05-30 一刷

個人範例程式碼 - 2022/5/30 一刷，節省空間另解

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        if not nums:
            return 0

        hashset = set(nums) # O(N)
        current_max = 0

        while(hashset):
            num = hashset.pop()

            # hashset.remove(num)
            high, low = num+1, num-1
            while high in hashset:
                hashset.remove(high)
                high += 1 # end more + 1
            while low in hashset:
                hashset.remove(low)
                low -= 1 # end more - 1

            current_max = max(current_max, high - low - 1)

        return current_max

算法說明

這邊把下方的第一版空間使用再次簡化，
我們不用 visited 了！我們打算只使用一個 hashset 搞定全部事情！

這樣就是考驗對於 set 熟悉的程度了，我們會用到：

set.remove()：時間 O(1)
set.pop()：任意取一個 set 的內容，並刪除，時間 O(1)

input handling

處理沒有 input 的情況，return 0

Boundary conditions

用 while(set) 來檢查 set 裡面還有沒有內容，如果沒有就搜尋完畢。
(邊搜尋的過程，一邊刪除 set 的內容)

個人範例程式碼 - 2022/5/30 一刷

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        if not nums:
            return 0

        hashset = set(nums) # O(N)
        visited = set()
        current_max = 0

        for num in nums: # O(N)
            if num in visited: # O(1)
                continue

            cnt = 1
            visited.add(num)
            high, low = num+1, num-1
            while high in hashset:
                visited.add(high)
                high += 1
                cnt += 1
            while low in hashset:
                visited.add(low)
                low -= 1
                cnt += 1

            current_max = max(current_max, cnt)

        return current_max

算法說明

滿特別的一個題目。

直覺會想用 sort 來解，但題目要求 O(N) 時間內解完，
因此光是 sort 如果就會花上 O(NlogN) 就會時間超過。

因此我們採用「用空間來換取時間的方法」，
我們建立兩個 hashset，一個存 list 內的所有數字，一個存 visited。

每次當我們搜尋的過程中，就新增一個 visited。
因此如果像是題目要的搜尋 [100,4,200,1,3,2]

找到 4 時，會順便把 1, 2, 3 順便都找完，
而輪到 1, 2, 3 時就會跳過。

input handling

處理沒有 input 的情況，return 0

Boundary conditions

用 for 來控制範圍

Reference

【Leetcode】python - [332] Reconstruct Itinerary 個人解法筆記

Mon, 23 May 2022 03:00:14 +0800

題目出處

332. Reconstruct Itinerary

難度

Hard

題目分類

Array, String, Depth-First Search, Graph Theory, Sorting, Heap (Priority Queue), Eulerian Circuit

2022-05-23 一刷

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

class Solution:
    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
        graph = self.build_graph(tickets)
        self.ans = []
        self.dfs(graph, 'JFK')

        return self.ans[::-1]

    def build_graph(self, tickets):
        graph = collections.defaultdict(list)
        for _from, _to in tickets:
            graph[_from].append(_to)

        for _from in graph:
            graph[_from].sort(reverse = True)
            # dfs get reverse lexical order (since we get ans from end to start)           

        return graph

    def dfs(self, graph, _from):
        # end of recursion, when find no route
        while graph[_from]:
            # define and split
            self.dfs(graph, graph[_from].pop())

        # append ans, from end to start
        self.ans.append(_from)

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

這題要同時考到建構出一個 graph，
並 dfs 找尋路徑。

(這題還沒有靠自己完全寫出來，目前先參考下方 reference 進行仿寫)

反向建立 _to 順序，正向 dfs 搜尋

因為題目希望最後我們能夠照字母大小排序，而我們建立 graph 時，
先把「名稱排序比較後面的，放到前面順位」，
這樣「dfs 搜尋時，就會先 pop()」，
而最後「我們在把 from end to start 的路徑倒過來」。

input handling

Boundary conditions

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

Reference

重新安排行程 · Reconstruct Itinerary

【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 ""

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

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

(這題還沒有靠自己完全寫出來，目前先參考下方 reference 進行仿寫)

input handling

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

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

Boundary conditions

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

Reference

外星人字典 · Alien Dictionary

【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

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

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

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

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 - 複製所有的點 - 複製所有的邊

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

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

Boundary conditions

注意 BFS 的結束條件：

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

Reference

克隆图 · Clone Graph