重要題型 on 嗡嗡的隨手筆記

【Leetcode】python - [33] Search in Rotated Sorted Array 個人解法筆記 #重要題型

Thu, 23 Jul 2026 23:04:42 +0800

題目出處

33. Search in Rotated Sorted Array

難度

Medium

題目分類

Array, Binary Search

2026-07-23 四刷

個人範例程式碼 - 四刷 (2026/07/23)

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums)-1
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] == target:
                return mid
            
            # seperate and find asc
            if nums[left] <= nums[mid]: # left is asc side?
                if nums[left] <= target < nums[mid]: # target in asc
                    right = mid - 1
                else:
                    left = mid + 1
            else: # right is asc side
                if nums[mid] < target <= nums[right]: # target in asc
                    left = mid + 1
                else:
                    right = mid - 1

        return -1

算法說明

分邊, 先確認值是否在 Mid 位置
找 asc 那邊
判斷 asc 那側, target 是否在區間裡面不是就去另外一邊找
看哪邊需要 right = mid - 1, left = mid + 1

Time Complexity

O(logN)

Space Complexity

O(1)

Boundary conditions

單一元素：[5]
left <= right, at least check mid once
[1,3], target 3
left += 1, then found
[3,1], target 1
left += 1, then found
特別留意鎖定 asc 範圍時的邊界 nums[left] <= target, target <= nums[right]
另外一邊因為前面已經有比較過 target == nums[mid] 等於反而沒意義, 前面就會抓到
另外還需要留意找 asc 時, nums[left] <= nums[mid] 可包含等於, 這才能處理當 target 在另外一側時, 此等於的邏輯能成功的讓 left, right 更新正確的值

2022-06-07 三刷

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

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        start = 0
        end = len(nums) - 1

        while start + 1 < end:
            mid = (start + end) // 2
            # print(start, mid, end)
            # print(nums[start], nums[mid], nums[end])

            if nums[mid] == target:
                return mid

            if nums[start] < nums[mid]: # front: simple go up
                if nums[start] <= target < nums[mid]:
                    end = mid   
                else:
                    start = mid
            else: # back: simple go up
                if nums[mid] < target <= nums[end]:
                    start = mid
                else:
                    end = mid

        else:
            if nums[start] == target:
                return start
            elif nums[end] == target:
                return end
            else:
                return -1

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

算法說明

分成 2 種 case 討論，2 種 case 底下又有兩種 case，

先看 mid 的落點，
分成「start < mid」或「mid < end」

再來各自看 target 的落點，(看有沒有落在單純上升的範圍)。

最後我們可以整理成：

「start < mid」

「start < target < mid」：純上升範圍
「else」：亂的範圍 (依然是 rotated sorted array)

「mid < end」

「mid < target < end」：純上升範圍
「else」：亂的範圍 (依然是 rotated sorted array)

input handling

處理沒有輸入的時候，return -1

Boundary conditions

binary search 的結束條件

2022-04-05 二刷

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

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if not nums:
            return -1

        start, end = 0, len(nums)-1
        while(start + 1 < end):
            mid = (start + end) // 2
            if(nums[mid] >= nums[end]):
                if(nums[start] <= target <= nums[mid]):
                    end = mid
                else:
                    start = mid
            else: # (nums[mid] < nums[end]):
                if(nums[mid] <= target <= nums[end]):
                    start = mid
                else:
                    end = mid

        else:
            if(nums[start] == target):
                return start
            elif(nums[end] == target):
                return end
            else:
                return -1

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

算法說明

這題可以說是 binary search 的最 #重要問題，
主要因為要寫得出這題，基本上要對 binary search 的各種細節幾乎都已經非常清楚才寫得出來。

注意幾個討論的重點，我們可以把整個題目拆成 2*2 個 case，

比 start 還大的情況 (等同於 >= end 的情況)
比 end 還小的情況

然後再針對這兩個情況，再拆成兩種 mid 的情況：

比 start 還大的情況 (等同於 >= end 的情況)

start < target < mid 的情況
else

比 end 還小的情況

else
mid < target < end 的情況

我們要注意移動的時候要移動 start 還是 end，可以從圖上觀察而出。

此外，邊界條件的處理也是此題相當重要的關鍵。

「>= end」

這個觀念我們在【Leetcode】python – [153] Find Minimum in Rotated Sorted Array 個人解法筆記
已經有詳細討論過，如果不清楚可以去看看

「邊界有沒有等於」?

這問題也非常重要，因為這會影響我們要移動 start 或是 end，
而我們需要讓邊界「等於」，因為如果 mid 正好是解答，

我們需要讓「移動側 = mid = target」，因此邊界條件中會有「包含等於的條件」

input handling

處理沒有輸入的時候，return -1

Boundary conditions

binary search 的結束條件

2021-07-07 一刷

個人解法筆記 (解法重點) - 2021/7/7 一刷

示意圖

注意事項

注意 corner case 的處理
範例： [5, 1, 3]

需要注意判斷非 ascending 時，是否該值會出現在對應的區間。

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

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        l_idx , r_idx = 0, len(nums)-1

        while l_idx <= r_idx:
            mid_idx = (l_idx + r_idx)//2

            if nums[mid_idx] == target:
                return mid_idx

            # search left
            if nums[l_idx] <= nums[mid_idx]:
                if nums[l_idx] <= target and target < nums[mid_idx]: # ascending side
                    r_idx = mid_idx - 1
                else:
                    l_idx = mid_idx + 1

            # search right
            else: 
                if nums[mid_idx] < target and target <= nums[r_idx]: # ascending side
                    l_idx = mid_idx + 1
                else:
                    r_idx = mid_idx - 1


        return -1

Reference

【Leetcode】python - [424] Longest Repeating Character Replacement 個人解法筆記 #重要題型

Thu, 23 Jul 2026 19:28:05 +0800

題目出處

424. Longest Repeating Character Replacement

難度

medium

題目分類

Hash Table, String, Sliding Window

2026-07-23 二刷

個人範例程式碼 - 二刷 (2026/07/23)

class Solution:
    def characterReplacement(self, s: str, k: int) -> int:
        count = {}
        max_freq = 0
        max_window_size = 0
        left = 0
        for right, c in enumerate(s):
            count[c] = count.get(c, 0) + 1
            max_freq = max(max_freq, count[c])
            window_size = right - left + 1
            if window_size - max_freq > k: # invalid
                count[s[left]] -= 1
                left += 1
            # right and left move 1 step, keep the max window size same
            # and try to find the longer window
            max_window_size = max(max_window_size, right - left + 1)

        return max_window_size

算法說明

這題特別之處在於只求最長，因此當已經發現最長 window 時，當出現 invalid 的情況可以直接平移（此長度已經存在答案）
直到出現下一組合法解。

至於判斷合法的部分，透過維護 max_freq 來實驗，但也因為這題只求最長 window 的特性，
其實可以不用讓當前 max_freq 實際等於 windows 內實際的 max_freq (要也可以，但更大的 max_freq 都無法通過，更小的值一定也不會過。)

Time Complexity

O(n)

Space Complexity

O(1), 因為只有大寫字母約 O(26)

Boundary conditions

留意 invalid 條件 = window_size - max_freq > k (<= k 都可以用題目條件說明的進行文字替換而合規)

2022-06-07 一刷

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

class Solution:
    def characterReplacement(self, s: str, k: int) -> int:

        ans = 0
        window_counter = defaultdict(int)
        max_counter = 0
        start = 0

        for end in range(len(s)):
            # print(start, end, s[start:end+1])
            new_word = s[end]
            window_counter[new_word] += 1
            max_counter = max(max_counter, window_counter[new_word])

            # end - start + 1 = window length (delete max duplicate <= k)
            if (end - start + 1) - max_counter <= k:
                ans = max(ans, end - start + 1)     
            else: # wrong case, move window (first delete then move)
                delete_word = s[start] 
                window_counter[delete_word] -= 1
                start += 1

        return ans

算法說明

讓我們先來理解題目，這題目主要是在詢問我們在「允許替換最多 k 個文字的情況下」，
我們能夠組出的最長文字。

我們使用「sliding window」的概念，配合 counter，計算最多重複的字元。

我們可以藉由不斷移動 end，當發現 window 不滿足條件時，
我們「不改變 window 的大小 (已經是最大)」，去不斷的 move start 直到 window 有機會變得更大。

window 大小只會變大，「當發現不符合規則時，我們只會繼續移動 window，不會縮小 window」

input handling

一同在 for 內處理

Boundary conditions

用 for 來控制範圍

Reference

替换后的最长重复字符 · Longest Repeating Character Replacement

【Leetcode】python - [146] LRU Cache 個人解法筆記 #重要題型

Sun, 19 Jun 2022 01:49:10 +0800

題目出處

146. LRU Cache

難度

Medium

題目分類

Hash Table, Linked List, Design, Doubly-Linked List

2022-06-19 二刷

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

class Node:
    def __init__(self,key, val):
        self.key = key
        self.val = val
        self.next = None
        self.prev = None

class LRUCache:

    def __init__(self, capacity: int):
        self.capacity = capacity
        self.hash = {}
        self.head = Node(-1, -1)
        self.tail = Node(-1, -1)
        self.head.next = self.tail
        self.tail.prev = self.head


    def get(self, key: int) -> int:
        if key not in self.hash:
            return -1
        node = self.hash[key]
        self.remove_node(node)
        self.move_to_tail(node)
        return node.val


    def put(self, key: int, value: int) -> None:
        if self.get(key) != -1: # old key
            self.hash[key].val = value
            return

        # new key
        if len(self.hash) >= self.capacity:
            self.pop_front()
        node = Node(key, value)
        self.move_to_tail(node)
        self.hash[key] = node

    def remove_node(self, node):
        node.prev.next = node.next # remove front-> node
        node.next.prev = node.prev # remove node -> next

    def move_to_tail(self, node):
        node.prev = self.tail.prev # tail.prev <- node
        node.next = self.tail # node -> tail

        node.prev.next = node # tail.prev -> node
        self.tail.prev = node # node <- tail


    def pop_front(self):
        del self.hash[self.head.next.key]
        self.head.next = self.head.next.next
        self.head.next.prev = self.head



# Your LRUCache object will be instantiated and called as such
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

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

算法說明

在標準的解答中，大概念是我們要設計一個 Linked List 配合 hashtable 進行 node 的快速查找，

我們可以把功能進行拆分，大致上我們會需要：

get：(取得新元素，題目需要)
put：(加入新元素，題目需要)
remove_node：移除一個元素 node
move_to_tail：將一個元素新增至 tail
pop_front：處理當 capacity 滿的時候，將最舊的元素移除

而為了快速且方便的能在 Linked List 中移動，
我們使用雙向的 Linked List，這樣在「查找前面一個元素」時，會非常方便

input handling

此題為程式設計類題目，需要能夠保持不斷的運作
(並非單純輸入一個 testcase 得到一個結果的類型。)

Boundary conditions

此題為程式設計類題目，需要能夠保持不斷的運作
(並非單純輸入一個 testcase 得到一個結果的類型。)

2022-05-18 一刷

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

有解出來，但不是題目要的 (queue + hashtable)

class LRUCache: # recently

    def __init__(self, capacity: int):
        self.capacity = capacity
        self.hashtable = {}
        self.queue = deque()


    def get(self, key: int) -> int:
        if key not in self.queue:
            return -1

        value = self.hashtable[key]
        self.queue.remove(key)
        self.queue.append(key)
        # print(self.queue)

        return value

    def put(self, key: int, value: int) -> None:
        if key in self.queue:
            self.queue.remove(key)
        self.queue.append(key)
        self.hashtable[key] = value

        if len(self.queue) > self.capacity:
            key = self.queue.popleft()
            # del self.hashtable[key]
        # print(self.queue)


# Your LRUCache object will be instantiated and called as such
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

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

算法說明

LRU cache 的設計方式，主要是由 linked list + hashtable

概念就是透過 linked list 保持順序性，而透過 hashtable 去查詢。

input handling

此題為程式設計類題目，需要能夠保持不斷的運作
(並非單純輸入一個 testcase 得到一個結果的類型。)

Boundary conditions

此題為程式設計類題目，需要能夠保持不斷的運作
(並非單純輸入一個 testcase 得到一個結果的類型。)

Reference

LRU缓存策略 · LRU Cache

【Leetcode】python - [77] Combinations 個人解法筆記 #重要題型

Wed, 08 Jun 2022 07:36:58 +0800

題目出處

77. Combinations

難度

medium

題目分類

Backtracking

2022-06-08 一刷

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

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        if not n or not k:
            return [[]]

        elements = [i for i in range(1, n+1)]
        ans = []
        self.dfs(elements, k, [], ans)

        return ans

    def dfs(self, elements, k, combinations, ans):
        # end of recursion
        if k <= 0:
            ans.append(combinations[:]) # deepcopy
            return 

        if not elements:
            return

        # define and split
        for i, element in enumerate(elements):
            combinations.append(element)
            self.dfs(elements[i+1:], k-1, combinations, ans)
            combinations.pop() # backtracking

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

算法說明

本題是 Combinations 系列的第 1 題，其他的題目可以參考：
第 1 題：不允許重複，給定數字範圍的全部組合，目標是指定組合內固定的數量。
第 2 題：允許重複，順序不同視為相同結果，也就是說「(1,2,3) 與 (3, 2, 1) 是一個結果」
第 3 題：允許有限重複(題目指定上限數量)，求全部組合。
第 4 題：不允許重複，給定數字範圍的全部組合，目標是求指定的和。
第 5 題：允許重複，但順序不同視為不同結果，也就是說「(1,2,3) 與 (3, 2, 1) 是兩個結果」。(這題已經可以當作排列的題目了。)

組合類的問題，使用 dfs 搜尋出全部的組合，
記得當 k = 4 時，實際上我們可用的數字是「1,2,3,4」而非「0,1,2,3」。

input handling

如果沒有 k 或 n，直接 return [[]]

Boundary conditions

用 dfs 來控制搜尋範圍，直到「k <= 0」或「找不到新的元素」，return 結果

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

【Lintcode】python - [92] Backpack 個人解法筆記 | 內含背包問題模板 #重要題型

Wed, 01 Jun 2022 16:50:25 +0800

題目出處

92 · Backpack

難度

medium

2022-06-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param m: An integer m denotes the size of a backpack
    @param a: Given n items with size A[i]
    @return: The maximum size
    """
    def back_pack(self, m: int, a: List[int]) -> int:
        # write your code here
        # define: dp[i][j], i = this round take, j = volume
        # dp[i][j] = dp[i-1][j] # last round take
        #          = dp[i-1][j - A[i-1]] # inherit last take, we take new can succeed (only when j - A[i-1] >= 0)

        # ans: last True dp[i][volume?]

        # init: dp[all][0] = True, other False
        dp = [[False]*(m+1) for _ in range(len(a)+1)] # i = m, j = count nums
        dp[0][0] = True

        for i in range(1, len(a)+1):
            dp[i][0] = True
            for j in range(1, m + 1):
                dp[i][j] = dp[i-1][j]
                if j - a[i-1] >= 0: # can take this
                    dp[i][j] = dp[i][j] or dp[i-1][j - a[i-1]]

        # print(dp)
        for i in range(m+1):
            if dp[-1][m-i]: # check max volume
                return m-i

        return -1 # not found

算法說明

本題是背包系列問題的第 1 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

最經典的背包問題，我們用 dp 去解，
要理解背包問題，建議自己畫過一次表，會比較容易理解 DP 邏輯運作的奧妙。

用圖解析 DP 的分析過程

在這題目裡面，因為我們只有單純拿，因此我們不需要注意順序，不用花 O(nlogn) 的時間先 sort()

state

分析概念：我們建立一張表 dp[i][j]， i 位置表示我們這回合要處理的新增物品，j 表示背包目前已經有的大小。

init

初始化時：dp[i][0], dp[0][j] 都為 True，其他 init 為 False

define

dp[i][j] = dp[i-1][j] # default 情況，我們複製上個階段的所有結果。

特殊情況： last_volume = j - nums[i-1] # 表示如果本次我們選擇拿新東西，是否有可能有這個組合的大小。
dp[i][j] = dp[i][j] or dp[i-1][last_volume] # 任意 True 即可

ans

dp[-1][j] # 從最大直到找到第一個 True，就是結果。

input handling

一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for size (表示我們選擇新的項目)
內層 for volume (表示紀錄目前已有的選擇下，可否達到裝滿的目標)

Reference

背包问题 · Backpack

【Leetcode】python - [45] Jump Game II 個人解法筆記 #重要題型

Mon, 23 May 2022 14:38:16 +0800

題目出處

45. Jump Game II

難度

Medium

題目分類

Array, Dynamic Programming, Greedy

2022-05-23 一刷

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

class Solution:
    def jump(self, nums: List[int]) -> int:

        # record min jump, init
        dp = [float("inf")] * len(nums)

        dp[0] = 0 # start
        # function
        for i in range(len(nums)):
            for j in range(i+1, i+1 + nums[i]): # 1:3 = 12, 1:1 = 0
                if j < len(nums):
                    dp[j] = min(dp[j], dp[i]+1) # jump+1 from dp[i] 
                else: # over range
                    break

        # print(dp)
        return dp[-1]

        # 2 3 1 1 4
        # 1 inf inf inf inf
        # 1 1 1 inf inf
        # 1 1 1 2 2

算法說明

此題的前一題為不需要算步數的版本，只需要知道可不可抵達，可參考 (啊怎麼第二題的題號還比較前面?) ：

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

計算步數，我們一樣使用 DP，「紀錄最小抵達該樓層時使用步數」

function: dp[i] = min(dp[i], dp[j] + 1)

我們要比較的是，第 j 樓可以一步到此(+1) 的步數，是否比原來紀錄的可能步數還要少。

init: dp[0] = 1, 其他初始化 float(“inf”) (會被比較小的步數取代)
ans: dp[-1]

DP 變化如下

# 2 3 1 1 4 
# 0 inf inf inf inf (init)
# 0 1 1 inf inf (1F)
# 0 1 1 2 2 (2F)

優化

這裡可以做一些小優化，
因為到接近終點的樓層時， i + jump 會超過終點很多，
此時我們可以「提早先 break 迴圈」 (因為超過終點的範圍都不重要)

input handling

一同在 for 裡面處理掉

Boundary conditions

用 for 來控制 DP 的範圍

Reference

跳跃游戏 II · Jump Game II

【Leetcode】python - [63] Unique Paths II 個人解法筆記 #重要題型

Mon, 23 May 2022 14:01:17 +0800

題目出處

63. Unique Paths II

難度

Medium

題目分類

Array, Dynamic Programming, Matrix

2022-05-23 一刷

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

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m, n = len(obstacleGrid), len(obstacleGrid[0])

        if not m or not n:
            return 0

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

        # init
        if obstacleGrid[0][0] == 1:
            return 0
        else:
            dp[0][0] = 1 

        for i in range(1, m):
            if obstacleGrid[i][0] == 1:
                dp[i][0] = 0
            else:
                dp[i][0] = dp[i-1][0] 

        for j in range(1, n):
            if obstacleGrid[0][j] == 1:
                dp[0][j] = 0
            else:
                dp[0][j] = dp[0][j-1]

        # function
        for i in range(1, m):
            for j in range(1, n):
                if obstacleGrid[i][j] == 1:
                    dp[i][j] = 0
                else:
                    dp[i][j] = dp[i-1][j] + dp[i][j-1]

        # print(dp)
        # ans
        return dp[-1][-1]

算法說明

此題的前一題為無障礙物版本，可以參考：

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

也是經典的二維 DP 問題，
透過建立下方的圖片，就可以求得所有路徑的答案

(DP 記錄到達那一格的所有方法數)

而這一題我們只需要多做處理障礙物的部分，但這次我們需要特別小心，

除了中間之外，連「邊邊初始化也要處理」

處理中間

邊邊初始化 (要多注意)

input handling

如果沒有 m 或 n，return 0 (無方法)
且如果 A[0][0] 位置就是障礙物，也是 return 0 (無方法)

Boundary conditions

用 for 來控制 DP 的範圍

Reference

不同的路径 II · Unique Paths II

【Leetcode】python - [62] Unique Paths 個人解法筆記 #重要題型

Mon, 23 May 2022 13:56:05 +0800

題目出處

62. Unique Paths

難度

Medium

題目分類

Math, Dynamic Programming, Combinatorics

2022-05-23 一刷

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

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if not m or not n:
            return 0

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

        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i][j-1] + dp[i-1][j]

        return dp[-1][-1]

算法說明

也是經典的二維 DP 問題，
透過建立下方的圖片，就可以求得所有路徑的答案

(DP 記錄到達那一格的所有方法數)

input handling

如果沒有 m 或 n，return 0 (無方法)

Boundary conditions

用 for 來控制 DP 的範圍

Reference

【Leetcode】python - [518] Coin Change 2 個人解法筆記 #重要題型

Mon, 23 May 2022 13:25:06 +0800

題目出處

518. Coin Change 2

難度

Medium

題目分類

Array, Dynamic Programming

2022-05-23 一刷

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

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

        dp = [0] * (amount + 1)

        # init
        dp[0] = 1

        for coin in coins:
            for i in range(coin, amount + 1): # start from new coin
                dp[i] += dp[i - coin] # function

        return dp[-1] # answer

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

算法說明

此題的前一題為限制使用金幣數量的版本，這題的金幣數量是無限制的。可參考：

https://wongwongnotes.com/posts/algorithm-practice/dynamic-programming/761-classic-dp/leetcode-python-322/

這題要處理可以無限使用硬幣，會稍微複雜一些

我們先假設有新的硬幣種類，是一個個出現，從小一路分析到大，

DP 會變成以下的樣子：

# 0 1 2 3 4 5
# 1 0 0 0 0 0  (init)
# 1 1 1 1 1 1  (1)
# 1 1 2 2 3 3  (2)
# 1 1 2 2 3 4  (5)

我們可以推得公式：

init: 全部 = 0，dp[0] = 1
function: dp[i] += dp[i-coin] (if i-coin >= 0)
answer: dp[-1]

常見錯誤 - 處理重複時出錯

這題比較麻煩的是，我們有可能會碰到處理重複時出錯的問題，

例如: (1,2,1) 與 (1,1,2)，其實兩者是同一個意思

因此我們才需要假設「新種類的硬幣，是一個個的出現」。

錯誤程式碼範例：

下面的程式碼，因為想要「一次處理好」不同數值下，可以湊出的硬幣總數，
因此碰到了上述所說 (1,2,1) 與 (1,1,2)，其實兩者是同一個意思的問題。

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

for i in range(amount+1):
    for coin in coins:
        if i == coin:
            dp[i] += 1

        if i - coin >= 0:
            dp[i] += dp[i - coin]

return dp[-1]

input handling

如果沒有 coins，return 0，(無組合)

Boundary conditions

用 for 來控制 DP 的範圍

Reference

零钱兑换 2 · Coin Change 2

【Leetcode】python - [78] Subsets 個人解法筆記 #重要題型

Mon, 23 May 2022 13:09:00 +0800

題目出處

78. Subsets

難度

Medium

題目分類

Array, Backtracking, Bit Manipulation

2022-05-23 一刷

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

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

        ans = []
        self.dfs(nums, 0, [], ans)

        # print(ans)        
        return ans

        # [] 
        # [1] [12] [123]
        #     [13]
        # [2] [23]
        # [3]

    def dfs(self, nums, start, combination, ans):

        ans.append(combination[:]) # deepcopy

        # end of recursion        
        # define and split (use or not use)
        for i in range(start, len(nums)):       
            combination.append(nums[i])
            self.dfs(nums, i+1, combination, ans)
            combination.pop() # backtracking

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

算法說明

經典 DFS 的組合問題，思考方式如下：

每一層我們都可以決定「取特定數字或不取」，但取或不取，順序都要一直往後。

input handling

如果沒有 nums，return [[]]

Boundary conditions

用 dfs 內的 for loop 控制搜尋範圍

Reference

子集 · Subsets

【Leetcode】python - [90] Subsets II 個人解法筆記 #重要題型

Mon, 23 May 2022 13:01:52 +0800

題目出處

90. Subsets II

難度

Medium

題目分類

Array, Backtracking, Bit Manipulation

2022-05-23 一刷

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

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

        nums.sort()

        ans = []
        self.dfs(nums, 0, [], ans)
        return ans

    def dfs(self, nums, start, combination, ans):

        ans.append(combination[:]) # deepcopy

        # end of recursion, define ans split
        for i in range(start, len(nums)):
            if i > start and nums[i] == nums[i-1]: # only take first duplicate
                continue
            combination.append(nums[i])
            self.dfs(nums, i+1, combination, ans)
            combination.pop()

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

算法說明

此題的前一題為無重複版本，這題要多處理重複，可參考：

https://wongwongnotes.com/posts/algorithm-practice/search-algorithms/dfs-combination/leetcode-python-78/

經典 DFS 的組合問題，這題要多處理重複的部分，

我們先 sort() 確保有一致的順序，
我們利用 i > start 來確保跟開始項目相同時，第一組重複有被計算到

注意：不是 i > 0，而是 i > start
start 位置就是代表重複字母的第一個字，除了第一次判斷會拿之外，後面都不會再拿。

if i > start and nums[i] == nums[i-1]: # only take first duplicate
    continue

input handling

如果沒有 nums，return [[]]

Boundary conditions

用 dfs 內的 for loop 控制搜尋範圍

Reference

子集 II · Subsets II

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

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

算法說明

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

初始化，全部 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 - [47] Permutations II 個人解法筆記 #重要題型

Sun, 24 Apr 2022 03:06:44 +0800

題目出處

47. Permutations II

難度

medium

題目分類

Array, Backtracking, Sorting

2022-04-24 一刷

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

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

        nums.sort()
        self.ans = []
        self.dfs(nums, [])
        return self.ans

    def dfs(self, nums, permutations):
        # end of recursion
        if not nums:
            self.ans.append(list(permutations))
            return

        # define and split
        for i, num in enumerate(nums):
            if i > 0 and nums[i] == nums[i-1]: # if duplicate, we only record first time
                continue  

            permutations.append(num)
            self.dfs(nums[:i] + nums[i+1:], permutations)
            permutations.pop() # backtracking

算法說明

此題目的前一題，差別在這題需要多處理重複的元素，可參考：

https://wongwongnotes.com/posts/algorithm-practice/search-algorithms/dfs-permutation/leetcode-python-46/

排列類型的題目，使用 dfs 去搜尋全部的結果

處理順序

另外在處理順序時，我們使用傳入「start[0:i] + start[i+1:]」的方式，暫時移除了 start[i] 的元素，
這樣的操作方式會複製一個新的 list，而不會影響到原本的 list

處理重複

為了處理重複，我們先對 nums 進行排序，我們使用

nums.sort()

另外在處理重複的數字時，我們只採用第一組的結果，後面都 continue 掉，因此：

if i > 0 and nums[i] == nums[i-1]: # if duplicate, we only record first time
    continue

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

input handling

當沒有 nums 時，return nums

Boundary conditions

搜尋至 no nums 時，添加結果回傳 (表示元素已使用完畢)

Reference

带重复元素的排列 · Permutations II

【Leetcode】python - [46] Permutations 個人解法筆記 #重要題型

Sun, 24 Apr 2022 03:02:08 +0800

題目出處

46. Permutations

難度

medium

題目分類

Array, Backtracking

2022-04-24 一刷

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

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

        self.ans = []
        self.dfs(nums, [])
        return self.ans

    def dfs(self, nums, permutations):        
        # end of recursion
        if not nums:
            self.ans.append(list(permutations)) # deepcopy
            return 

        # define and split
        for i, num in enumerate(nums):
            permutations.append(num)
            # temporarily remove element i = start[0:i] + start[i+1:]
            self.dfs(nums[:i] + nums[i+1:], permutations)
            permutations.pop() # backtracking

算法說明

排列類型的題目，使用 dfs 去搜尋全部的結果，

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

input handling

當沒有 nums 時，return nums

Boundary conditions

搜尋至 no nums 時，添加結果回傳 (表示元素已使用完畢)

Reference

全排列 · Permutations

【Leetcode】python - [173] Binary Search Tree Iterator 個人解法筆記 #重要題型

Fri, 22 Apr 2022 12:43:34 +0800

題目出處

173. Binary Search Tree Iterator

難度

medium

題目分類

Stack, Tree, Design, Binary Search Tree, Binary Tree, Iterator

2022-04-22 二刷

個人範例程式碼 - 2022/4/22 版本 (優化版)

# 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 BSTIterator:

    def __init__(self, root: Optional[TreeNode]):
        self.stack = []
        self.to_left_bottom(root)

    def next(self) -> int:
        node = self.stack.pop()
        if node.right is not None:
            node_right = node.right
            self.to_left_bottom(node_right) 
        return node.val

    def hasNext(self) -> bool:
        return len(self.stack) > 0

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

# Your BSTIterator object will be instantiated and called as such
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()

算法說明

思路來源

與之前的相比，優化了 stack 的使用，不使用 top 的功能，只使用 pop 使程式碼更簡潔。

一樣保持往左走到底的觀念，不過這次我們不扣住頂端，這樣的好處是 pop 會直接回到頂端不用再用另外一個 while loop 檢查，
而只要發現能往右走，就往右走「一步」，然後依然「往左走到底」

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

input handling

Boundary conditions

當 stack 為空時，結束迴圈

2022-04-21 一刷

個人範例程式碼 - 2022/4/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 BSTIterator:

    def __init__(self, root: Optional[TreeNode]):
        self.stack = []
        self.to_left_bottom(root)

    def next(self) -> int:
        cur = node = self.stack[-1]
        if node.right is not None:
            node = node.right
            self.to_left_bottom(node) # do not pop parent
        else:
            node = self.stack.pop()
            while self.stack and self.stack[-1].right == node: # until parent's right = n, next node = parent
                node = self.stack.pop()

        return cur.val

    def hasNext(self) -> bool:
        return len(self.stack) > 0


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




# Your BSTIterator object will be instantiated and called as such
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()

算法說明

這題考的是程式設計，很多設計上的細節需要注意。

而大方向如下：

- 當到達一個新 node 時，往左邊存 stack 直到底 - 每 pop 一個 node 時，先檢查有沒有右側，有的話一樣往右做 1 (此 node 於 stack 尚未 pop)，沒有的話做 3 - 當已經找不到右邊時，下一個節點位於「一路 pop，直到 parent.right != node」(往右走的路都退回，找第一個左彎的點)，然後他的 parent 就是我們要的下一個 node

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

input handling

Boundary conditions

當 stack 為空時，結束迴圈

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。

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

Reference

474 · Lowest Common Ancestor II

【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

【Lintcode】python - [143] Sort Colors II 個人解法筆記 #重要題型 #常錯題型

Thu, 14 Apr 2022 20:15:54 +0800

題目出處

143 · Sort Colors II

難度

medium

2022-04-14 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param colors: A list of integer
    @param k: An integer
    @return: nothing
    """
    def sort_colors2(self, colors: List[int], k: int):
        # write your code here
        # sort 1~k
        self.partition(colors, 1, k, 0, len(colors)-1)
        return

    def partition(self, colors, color_from, color_to, start, end):
        # end
        if color_from <mark> color_to or start </mark> end:
            return 

        left, right = start, end
        pivot = (color_from + color_to) // 2

        # define
        while(left <= right):
            while(left <= right and colors[left] <= pivot): # if same, left part
                left += 1
            while(left <= right and colors[right] > pivot):
                right -= 1
            if(left <= right):
                colors[left], colors[right] = colors[right], colors[left] # careful infinite loop: left, right still can move

        else: # split
            # print(colors, start, right, left, end)
            self.partition(colors, color_from, pivot, start, right)
            self.partition(colors, pivot+1, color_to, left, end)

算法說明

此題是考 partition 的綜合題。

這題會經常錯在遞迴判斷式與邊界條件，導致無法 AC。

遞迴判斷式

遞迴的定義

# define
while(left <= right):
    while(left <= right and colors[left] <= pivot): # if same, left part
        left += 1
    while(left <= right and colors[right] > pivot):
        right -= 1
    if(left <= right):
        colors[left], colors[right] = colors[right], colors[left] # careful infinite loop: left, right still can move

遞迴的拆解

這邊要處理的是邊界問題，往前我們還需要多注意 while(left <= right)，
這會導致我們是「交錯」才結束，

結束時的狀態為「start < right < left < end」，由於與 pivot 相等的在兩側都有可能出現，
拆解的搜尋條件為

start ~ right
left ~ end

self.partition(colors, color_from, pivot, start, right)
self.partition(colors, pivot+1, color_to, left, end)

遞迴的中止

如果「color_from color_to」 or 「start end」，return

「color_from color_to」：已經同顏色，不必再分
「start end」：同位置，不必再分

input handling

這題沒有特別說要怎麼處理特殊的 input，預設的 input 都給正確的。

Boundary conditions

上方已經說明完囉

另解 - 更換中止條件

from typing import (
    List,
)

class Solution:
    """
    @param colors: A list of integer
    @param k: An integer
    @return: nothing
    """
    def sort_colors2(self, colors: List[int], k: int):
        # write your code here
        # sort 1~k
        self.partition(colors, 1, k, 0, len(colors)-1)
        return

    def partition(self, colors, color_from, color_to, start, end):
        # end
        if color_from == color_to:
            return 

        left, right = start, end
        pivot = (color_from + color_to) // 2

        # define
        while(left <= right):
            while(left <= right and colors[left] <= pivot): # if same, left part
                left += 1
            while(left <= right and colors[right] > pivot):
                right -= 1
            if(left <= right):
                colors[left], colors[right] = colors[right], colors[left] # careful infinite loop: left, right still can move

        else: # split
            # print(colors, start, right, left, end)
            if start < right: # still need sorting
                self.partition(colors, color_from, pivot, start, right)
            if left < end: # still need sorting
                self.partition(colors, pivot+1, color_to, left, end)

更換部分

當顏色一樣的時候，中止

# end
if color_from == color_to:
    return

限制範圍才持續往下做 partition (其實也等同於 start end)

if start < right: # still need sorting
    self.partition(colors, color_from, pivot, start, right)
if left < end: # still need sorting
    self.partition(colors, pivot+1, color_to, left, end)

Reference

颜色分类 II · Sort Colors II

【Leetcode】python - [75] Sort Colors 個人解法筆記 #重要題型 #常錯題型

Thu, 14 Apr 2022 19:51:56 +0800

題目出處

75. Sort Colors

難度

medium

題目分類

Array, Two Pointers, Sorting

2022-04-14 一刷

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

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # only 0, 1, 2
        self.partition(nums, 2, 0, len(nums)-1)
        return 


    def partition(self, nums, pivot, start, end):
        if pivot == 0:
            return 

        left, right = start, end

        while(left <= right):
            while(left <= right and nums[left] < pivot): # 0, 1
                left += 1
            while(left <= right and nums[right] >= pivot): # 2
                right -= 1
            if(left <= right):
                nums[left], nums[right] = nums[right], nums[left]
                # check twice
                # left += 1
                # right -= 1
        else: # after left and right cross, all 0, 1 will be left, 2 will be right
            # start, right(0, 1), left(2), end            
            # start, right(0), left(1), end

            self.partition(nums, pivot-1, 0, right)

算法說明

此題是考 partition 的延伸題，也可以單純使用三指標來快速解掉，
不過之後還有一題多顏色的題目，基本上 partition 還是要會解。

這題會經常錯在遞迴判斷式與邊界條件，導致無法 AC。

遞迴判斷式

遞迴的定義

while(left <= right):
    while(left <= right and nums[left] < pivot): # 0, 1
        left += 1
    while(left <= right and nums[right] >= pivot): # 2
        right -= 1
    if(left <= right):
        nums[left], nums[right] = nums[right], nums[left]

遞迴的拆解

這邊要處理的是邊界問題，往前我們還需要多注意 while(left <= right)，
這會導致我們是「交錯」才結束，

結束時的狀態為「start < right < left < end」，由於與 pivot 相等的在兩側都有可能出現，
拆解的搜尋條件為

start ~ right
left ~ end

這題本身較簡單，但其實不需要拆到那麼複雜，
但為了後續的 partition 題目方便，這裡就先用最泛用的方式解

self.partition(nums, pivot-1, 0, right)

遞迴的中止

如果 pivot = 0，return

一樣也是因為這題題目相對單純，因此我們可以這樣寫死。

input handling

這題沒有特別說要怎麼處理特殊的 input，預設的 input 都給正確的。

Boundary conditions

上方已經說明完囉

Reference

颜色分类 · Sort Colors

【Lintcode】python - [5] Kth Largest Element 個人解法筆記 #重要題型 #常錯題型

Wed, 13 Apr 2022 23:45:45 +0800

題目出處

5 · Kth Largest Element

難度

medium

2022-04-13 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param k: An integer
    @param nums: An array
    @return: the Kth largest element
    """
    def kth_largest_element(self, k: int, nums: List[int]) -> int:
        # write your code here
        if not nums:
            return -1 # not found

        # 1, 2, 3,  first: idx = 2 = len(s)-k (k=1)
        return self.quickselect(k-1, nums, 0, len(nums)-1)

    def quickselect(self, k, nums, start, end):
        if not nums:
            return -1

        # recursion end
        if start == end:
            return nums[k]

        # recursion define
        left, right = start, end
        pivot = nums[(start + end) // 2]
        while(left <= right):
            while(left <= right and nums[left] > pivot): # bigger go to left, descending sorting
                left += 1
            while(left <= right and nums[right] < pivot):
                right -= 1
            if(left <= right):
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
                right -= 1
        else: # recursion split # start < right < left < end
            # print(nums)
            if start <= right and right >= k: # search left and still need sorting
                return self.quickselect(k, nums, start, right)
            elif left <= end and left <= k: # search right and still need sorting
                return self.quickselect(k, nums, left, end)
            else:
                return nums[k]

算法說明

此題有類似題，可參考：

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

最大的差別只在於 smallest 變 largest，簡單處理把 ascending 換成 descending 即可。

這題用到 QuickSelect 的概念，簡單來說就是藉由「每一次都切一半，減少一半的搜尋範圍」，
分出剩餘的另外一半後，再去嘗試切一半，進行 O(logN) 的快速尋找。

這題會經常錯在遞迴判斷式與邊界條件，導致無法 AC。

遞迴判斷式

遞迴的定義

這裡我自己錯好多次，總之不熟悉處理起來很麻煩，

導入 quickselect 的概念，我們把原本要搜尋的範圍切成兩半，
將比 pivot 小的往左擺，大的往右擺，一樣大的先不管

(管了會出事，會有無限迴圈：例 [3, 9, 4, 8]: 9 never moves.)

遞迴的拆解

這邊要處理的是邊界問題，往前我們還需要多注意 while(left <= right)，
這會導致我們是「交錯」才結束，

結束時的狀態為「start < right < left < end」，由於與 pivot 相等的在兩側都有可能出現，
拆解的搜尋條件為

start ~ right
left ~ end

可附加條件為「right >= k」、「left <= k」，我們可以提早結束 k 的搜尋。

start ~ right, right >= k：左側還比 k 多，需要再排序
left ~ end, left <= k：右側還比 k 少 (= 左側比 k 多)，需要再排序

遞迴的中止

如果 start end，return nums[k] ，

怎麼保證這一定會發生就是個大問題了，這也是最常出錯的地方，我錯好多次…
簡單來說我們可以想一些比較極端的 case，程式也都要能正常結束。

例如： [1,1]，k = 1 (index 0), k = 2(index 1)

這邊我暫時先這樣想，哪天有更好的想法再回來補吧。

input handling

這題沒有特別說要怎麼處理特殊的 input，預設的 input 都給正確的。

Boundary conditions

上方已經說明完囉

Reference

无序数组K小元素 · Kth Smallest Numbers in Unsorted Array

【Lintcode】python - [461] Kth Smallest Numbers in Unsorted Array 個人解法筆記 #重要題型 #常錯題型

Wed, 13 Apr 2022 14:03:08 +0800

題目出處

461 · Kth Smallest Numbers in Unsorted Array

難度

medium

2022-04-13 一刷

個人範例程式碼 - 1 (相等時結束的討論)

from typing import (
    List,
)

class Solution:
    """
    @param k: An integer
    @param nums: An integer array
    @return: kth smallest element
    """
    def kth_smallest(self, k: int, nums: List[int]) -> int:
        # write your code here
        return self.quickselect(nums, k-1, 0, len(nums)-1)



    def quickselect(self, nums, k, start, end):
        # recusion end
        if start <mark> end: # (</mark>k)
            return nums[k] 

        # recursion define
        left, right = start, end
        pivot = nums[(start + end) // 2]
        # print(nums, pivot, start, end)

        while(left <= right):
            if nums[left] < pivot: # [3, 9, 4, 8]: 9 never moves.
                left += 1
            elif nums[right] > pivot:
                right -= 1
            else:
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
                right -= 1
        else:
            # two part start < right < left < end (<= , >)
            # recursion split
            if right >= k and start <= right:  # search left
                return self.quickselect(nums, k, start, right)
            elif left <= k and left <= end: # search right
                return self.quickselect(nums, k, left, end)
            else:
                return nums[k]

算法說明

這題會經常錯在遞迴判斷式與邊界條件，導致無法 AC。

遞迴判斷式

遞迴的定義

這裡我自己錯好多次，總之不熟悉處理起來很麻煩，

導入 quickselect 的概念，我們把原本要搜尋的範圍切成兩半，
將比 pivot 小的往左擺，大的往右擺，一樣大的先不管

(管了會出事，會有無限迴圈：例 [3, 9, 4, 8]: 9 never moves.)

遞迴的拆解

這邊要處理的是邊界問題，往前我們還需要多注意 while(left <= right)，
這會導致我們是「交錯」才結束，

結束時的狀態為「start < right < left < end」，由於與 pivot 相等的在兩側都有可能出現，
拆解的搜尋條件為

start ~ right
left ~ end

可附加條件為「right >= k」、「left <= k」，我們可以提早結束 k 的搜尋。

start ~ right, right >= k：左側還比 k 多，需要再排序
left ~ end, left <= k：右側還比 k 少 (= 左側比 k 多)，需要再排序

遞迴的中止

如果 start end，return nums[k] ，

怎麼保證這一定會發生就是個大問題了，這也是最常出錯的地方，我錯好多次…
簡單來說我們可以想一些比較極端的 case，程式也都要能正常結束。

例如： [1,1]，k = 1 (index 0), k = 2(index 1)

這邊我暫時先這樣想，哪天有更好的想法再回來補吧。

input handling

這題沒有特別說要怎麼處理特殊的 input，預設的 input 都給正確的。

Boundary conditions

上方已經說明完囉

稍微修改一下解，修改一下定義式

這邊可以將上面的解答稍微修改一下，可能概念上會更漂亮一些。(因人而異)

主要修改的是迴圈的方式，上面的作法是「外圍跑完 N 輪，每一輪都會有決定要幹嘛」，
這邊的作法是「外圍只是限制，而每一次的 pointer 都直接迴圈到下一個要更改的點」。

概念大同小異，可以依個人決定哪個程式碼比較漂亮而決定採用哪一個。

while(left <= right):
    while(left <= right and nums[left] < pivot):
        left += 1
    while(left <= right and nums[right] > pivot):
        right -= 1
    if(left <= right):
        nums[left], nums[right] = nums[right], nums[left]
        left += 1
        right -= 1

Reference

无序数组K小元素 · Kth Smallest Numbers in Unsorted Array

【Lintcode】python - [31] Partition Array 個人解法筆記 #重要題型

Sat, 09 Apr 2022 20:54:57 +0800

題目出處

31 · Partition Array

難度

medium

2022-04-09 一刷

個人範例程式碼 - 1 (相等時結束的討論)

from typing import (
    List,
)

class Solution:
    """
    @param nums: The integer array you should partition
    @param k: An integer
    @return: The index after partition
    """
    def partition_array(self, nums: List[int], k: int) -> int:
        # write your code here
        if not nums:
            return 0

        start, end = 0, len(nums)-1

        while(start < end):
            if nums[start] < k:
                start += 1
            elif nums[end] >= k:
                end -= 1  
            else: 
                nums[start], nums[end] = nums[end], nums[start]
                start += 1
                end -= 1
        else:
            #  the first index i nums[i] >= k
            if nums[start] >= k:
                return start
            elif nums[end] >= k:
                return end
            else:
                return end+1 # special case, all < k

算法說明

基本的 partition 作法，#重要題型

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

input handling

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

Boundary conditions

注意結束條件，start < end ，表示當「start end」會結束。

特殊情況：全部 < k

這時候依照題目敘述，我們應該要回傳 end + 1，
但 end + 1，不會在我們的搜尋範圍，因此「我們需要特別做討論」。

個人範例程式碼 - 2 (start 超過 end 時才結束的討論)

from typing import (
    List,
)

class Solution:
    """
    @param nums: The integer array you should partition
    @param k: An integer
    @return: The index after partition
    """
    def partition_array(self, nums: List[int], k: int) -> int:
        # write your code here
        if not nums:
            return 0

        start, end = 0, len(nums)-1

        while(start <= end):
            if nums[start] < k:
                start += 1
            elif nums[end] >= k:
                end -= 1  
            else: 
                nums[start], nums[end] = nums[end], nums[start]
                start += 1
                end -= 1
        else:
            return start

算法說明

基本的 partition 作法，#重要題型
這裡展示另外一種作法，是為了處理 end + 1 搜尋

透過改變條件「start <= end」，因此只有當 start 與 end 交錯時才會終止。
當全部 < k 時，start 會走到 end + 1 並結束。

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

input handling

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

Boundary conditions

注意結束條件，start <= end ，表示當 start 與 end 相交會結束。

特殊情況：全部 < k

在這個 case 當中，我們改變了條件「start <= end」，
因此如果全部都 < k 的情況 start 會走到 end + 1，得到最終結果。

Reference

数组划分 · Partition Array