723 - LeetCode Backtracking on 嗡嗡的隨手筆記

【Leetcode】python - [494] Target Sum 個人解法筆記

Mon, 20 Jun 2022 18:40:47 +0800

題目出處

494. Target Sum

難度

medium

題目分類

Array, Dynamic Programming, Backtracking

2022-06-20 一刷

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

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

        memo = {}
        return self.dfs(nums, 0, target, memo)

    def dfs(self, nums, start_idx, target, memo):
        # end of recursion
        if start_idx >= len(nums):
            if target == 0:
                return 1
            else:
                return 0

        # memoization
        if (start_idx, target) in memo:
            return memo[(start_idx, target)]

        # define and split
        ans = self.dfs(nums, start_idx+1, target-nums[start_idx], memo) + self.dfs(nums, start_idx+1, target+nums[start_idx], memo)

        # memoization
        memo[(start_idx, target)] = ans

        return ans

算法說明

仔細看發現是很單純的「2 指數」的題目，
每一次我們都只要多延伸出「+」或「-」的新情況，

memoization

純 DFS 會 TLE，需要搭配 DP 的記憶化搜索，
我們紀錄的是，(目前 target 的值，目前的 idx)，
當進行一樣的 target 與同 idx 搜尋時，我們可以直接查表。

input handling

在 dfs 內處理

Boundary conditions

在 dfs 內控制範圍，我們在「搜尋 start_idx >= nums 總長」的情況下停止遞迴。

Reference

目标和 · Target Sum

【Leetcode】python - [22] Generate Parentheses 個人解法筆記

Thu, 16 Jun 2022 14:38:15 +0800

題目出處

22. Generate Parentheses

難度

medium

題目分類

String, Dynamic Programming, Backtracking

2022-06-16 一刷

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

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:

        ans = []
        self.dfs(n, n, "", ans)
        return ans

    def dfs(self, left, right, current_str, ans):
        # end of recursion
        if left == 0:
            for _ in range(right):
                current_str += ")"
            ans.append(current_str)
            return

        # define and split
        if left >= 0:
            self.dfs(left-1, right, current_str + "(", ans)

        if right > left: # (3, 2), (3, 1)
            self.dfs(left, right-1, current_str + ")", ans)

        return

算法說明

用 dfs 把所有狀況窮舉出來，我們以 left, right 代替左右括弧剩餘的數量，

可新增 left 的條件：left > 0
可新增 right 的條件：right > left # (3, 2), (3, 1)
終止條件：left = 0，放上所有剩餘的 right

input handling

一同在 dfs 內處理，基本上是處理 n = 0 的情況

Boundary conditions

用 dfs 控制範圍，終止條件為當 left = 0

Reference

【Leetcode】python - [216] Combination Sum III 個人解法筆記

Wed, 08 Jun 2022 07:52:42 +0800

題目出處

216. Combination Sum III

難度

medium

題目分類

Array, Backtracking

2022-06-08 一刷

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

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

        if k > 9: # only 1-9 can use
            return []

        ans = []
        self.dfs(1, n, k, [], ans)
        return ans

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

        if k < 0:
            return

        # define and split
        for i in range(start_num, 10): # 1 - 9
            combinations.append(i) 
            self.dfs(i+1, target-i, k-1, combinations, ans)
            combinations.pop() # backtracking

算法說明

組合類的問題，使用 dfs 搜尋出全部的組合

input handling

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

Boundary conditions

用 dfs 來控制搜尋範圍，直到「k = 0 時，進行結果判斷」或「k < 0 時，直接 return」

Reference

【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

算法說明

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

input handling

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

Boundary conditions

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

Reference

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

算法說明

經典 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()

算法說明

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

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

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

我們先 sort() 確保有一致的順序，
我們利用 i > 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 - [2259] Remove Digit From Number to Maximize Result 個人解法筆記 | 291th LeetCode Weekly Contest

Tue, 03 May 2022 02:20:50 +0800

題目出處

2259. Remove Digit From Number to Maximize Result

難度

easy

題目分類

String, Greedy, Enumeration

2022-05-03 一刷

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

class Solution:
    def removeDigit(self, number: str, digit: str) -> str:
        if not number or not digit:
            return -1

        if digit not in number:
            return -1

        max_num = 0
        for i in range(len(number)):
            if number[i] == digit:
                max_num = max(max_num, int(number[:i]+number[i+1:]))

        return str(max_num)

算法說明

先來說明一下題目的意思，題目敘述有點小複雜，

簡單來說就是，digit 是我們要刪除的目標，
從原本的 number 中刪除一個 digit 使結果最大。

因為是 easy，應該窮舉直接比較大小即可。

input handling

處理 digit 不在 number 的情況， return -1
處理 not digit or not number 的情況， return -1

Boundary conditions

控制 for-loop 的範圍

Reference

python - easy solution

【Leetcode】python - [2261] K Divisible Elements Subarrays 個人解法筆記 | 291th LeetCode Weekly Contest (內含 substring 常見作法)

Tue, 03 May 2022 02:09:01 +0800

題目出處

2261. K Divisible Elements Subarrays

難度

medium

題目分類

Array, Hash Table, Trie, Rolling Hash, Hash Function, Enumeration

2022-05-03 一刷

個人範例程式碼 - 同向 two pointers, 正三角

class Solution:
    def countDistinct(self, nums: List[int], k: int, p: int) -> int:
        self.ans = set()

        # decide start (one side)
        for i in range(len(nums)):
            self.dfs(nums, i, i, k, p) # decide end

        # print(self.ans)
        return len(self.ans)

    def dfs(self, nums, start, end, k, p):
        # end of recursion
        if end >= len(nums):
            return

        # define
        if nums[end] % p == 0:
            k -= 1
        if k < 0:
            return
        self.is_valid_ans(nums, start, end, k, p)

        # split
        self.dfs(nums, start, end+1, k, p)

    def is_valid_ans(self, nums, start, end, k, p):            
        if k < 0:
            return

        subset = tuple(nums[start:end+1]) # start~end
        # print(subset, k)
        if subset in self.ans:
            return
        else:
            self.ans.add(subset)

算法說明

用 dfs 搭配同向的 two pointers 控制頭尾(dfs 控制尾巴移動)，組出全部的結果。

input handling

x (題目沒有特別要求要處理)

Boundary conditions

控制 recursion 結束條件 if end >= len(nums)

個人範例程式碼 - 反向 two pointers, 反三角

class Solution:
    def countDistinct(self, nums: List[int], k: int, p: int) -> int:
        self.ans = set()

        # decide start (one side)
        for i in range(len(nums)-1, -1, -1):
            self.dfs(nums, i, i, k, p) # decide end

        # print(self.ans)
        return len(self.ans)

    def dfs(self, nums, start, end, k, p):
        # end of recursion
        if start < 0:
            return

        # define
        if nums[start] % p == 0:
            k -= 1
        if k < 0:
            return
        self.is_valid_ans(nums, start, end, k, p)

        # split
        self.dfs(nums, start-1, end, k, p)

    def is_valid_ans(self, nums, start, end, k, p):            
        if k < 0:
            return

        subset = tuple(nums[start:end+1]) # start~end
        # print(subset, k)
        if subset in self.ans:
            return
        else:
            self.ans.add(subset)

算法說明

用 dfs 搭配反向的 two pointers 控制頭尾(dfs 控制頭移動)，組出全部的結果。

input handling

x (題目沒有特別要求要處理)

Boundary conditions

控制 recursion 結束條件 if start < 0

Reference

[Python3] DFS

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

Wed, 27 Apr 2022 04:00:00 +0800

題目出處

LeetCode 版本，標準非常高，基本上沒實作出 Trie 一定 TLE： [212. Word Search II](https://leetcode.com/problems/word-search-ii/)

LintCode 版本，基本版先通過這個就好 (本文的內容)： [132 · Word Search II](https://www.lintcode.com/problem/132/)

難度

hard

題目分類

Array, String, Backtracking, Trie, Matrix

2022-04-27 一刷

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

from typing import (
    List,
)

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

class TrieNode():
    def __init__(self):
        self.children = {}
        self.isWord = False

class Trie():
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        node = self.root
        for c in word:
            if c not in node.children:
                node.children[c] = TrieNode()
            node = node.children[c]
        node.isWord = True

    def search(self, word):
        node = self.root
        for c in word:
            if c in node.children:
                node = node.children[c]
            else:
                return False
        return node.isWord

    def startswith(self, prefix):
        # print(prefix)
        node = self.root
        for c in prefix:
            if c in node.children:
                node = node.children[c]
            else:
                return False
        return True

class Solution:
    """
    @param board: A list of lists of character
    @param words: A list of string
    @return: A list of string
    """
    def word_search_i_i(self, board: List[List[str]], words: List[str]) -> List[str]:
        if not board:
            return []

        # self.prefix_set = self.make_prefix_set(words)
        self.trie = Trie()
        for word in words:
            self.trie.insert(word)
        self.ans = []


        for x in range(len(board)):
            for y in range(len(board[0])):
                self.dfs(board, words, x, y, set(), "")

        return self.ans        


    def dfs(self, board, words, x, y, visited, prefix):
        # print(prefix)
        # end of recursion
        if not words: # all finished
            return

        if prefix in words:
            self.ans.append(prefix[:])
            words.remove(prefix[:]) # prevent duplicate

        # if prefix != "" and prefix not in self.prefix_set:
        if prefix != "" and not self.trie.startswith(prefix):
            return 


        # define and split
        if not self.is_in_bound(x, y, board):
            return 

        if (x,y) in visited:
            return 

        visited.add((x, y))
        for dx, dy in DIRECTIONS:
            self.dfs(board, words, x+dx, y+dy, visited, prefix+board[x][y])
        visited.remove((x, y)) # backtracking


    def is_in_bound(self, x, y, board):
        m, n = len(board), len(board[0])
        return 0 <= x < m and 0 <= y < n

# def make_prefix_set(self, words)
#         prefix_set = set()
# for word in words
# for i in range(len(word))
#                 prefix_set.add(word[:i+1])

#         return prefix_set

算法說明

此題目的前一題為「單純找一個單字」就好，並只需要回傳 True/False，可參考：

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

非常難的題目，最主要難的點是在會 TLE 的部分，特別是 LeetCode 設定的標準，
對使用 python 而言非常的嚴苛。

最主要是實作 Trie 的內容與矩陣的四方向移動，
在矩陣的四方向移動，可以先參考以下比較簡單的題目：

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

注意：可繼續搜尋的項目

例如： [“app”, “apple”]，不能搜尋到 app 就 return，會找不到 apple

input handling

當沒有 matrix 時，return []

Boundary conditions

用 Trie 判斷全部搜尋結果是很簡單的，只是需要各種的搶時間以避免 TLE。

Reference

這邊我試跑 Leetcode 其他人的解答也幾乎都 TLE…，這 Leetcode 標準到底設定有多硬…

【Lintcode】python - [829] Word Pattern II 個人解法筆記

Tue, 26 Apr 2022 22:15:50 +0800

題目出處

829 · Word Pattern II

難度

hard

題目分類

Hash Table, String, Backtracking

2022-04-26 一刷

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

class Solution:
    """
    @param pattern: a string,denote pattern string
    @param str: a string, denote matching string
    @return: a boolean
    """
    def word_pattern_match(self, pattern: str, str: str) -> bool:
        # write your code here
        self.pattern_to_str = {}
        self.str_to_pattern = {}

        return self.dfs(pattern, str, 0)

    def dfs(self, pattern, str, start):
        # print(pattern, start, self.pattern_to_str)
        # end of recursion
        if not pattern:
            if start == len(str):
                return True
            return False

        # define and split
        # match pattern
        if pattern[0] in self.pattern_to_str:
            match_pattern = self.pattern_to_str[pattern[0]]
            end_idx = start + len(match_pattern)
            if end_idx <= len(str) and match_pattern == str[start:end_idx]: 
                return self.dfs(pattern[1:], str, end_idx) # to end_idx-1, from end_idx
            else: # pattern not match 
                return False

        # find next word
        for i in range(start+1, len(str)+1):
            substr = str[start:i] # to i-1
            if substr in self.str_to_pattern:
                if not self.str_to_pattern[substr] == pattern[0]: # match to another character
                    continue # find next
            else: # add new word
                self.pattern_to_str[pattern[0]] = substr
                self.str_to_pattern[substr] = pattern[0]
                if self.dfs(pattern[1:], str, i): # to i-1, from i
                    return True

                # backtracking
                del self.pattern_to_str[pattern[0]]
                del self.str_to_pattern[substr]

        return False

算法說明

這題與前一題的差別為，前一題已經都幫忙把 string 切好了，而這題目連切都要自己切，還考了怎麼切：

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

這題我們透過 dfs 的方式不斷的去進行往下的切割，直到完成

注意要判斷是否結束字時 pattern 已經使用完

有一種特殊狀況是 “aaa” 與 “aaaa”

如果沒有特別處理，容易會漏掉最後一個配對，卻回傳 True。

這邊我們是判斷 start = len(str)，因為我們的 start 會不斷移動，
最後當移動超過範圍時。就是找到了正確結果的情況下，結束了我們的配對任務。

input handling

Boundary conditions

上方說明了，當 DFS 的 start point 超過了可搜尋範圍，就結束 DFS。

Reference

字模式 II · Word Pattern II

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

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

題目出處

126. Word Ladder II

難度

hard

題目分類

Hash Table, String, Backtracking, Breadth-First Search

2022-04-26 一刷

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

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

        wordList.append(beginWord)
        distance = {}

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

        return self.ans

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

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

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

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

算法說明

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

從 BFS 先找到最短路徑

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

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

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

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

注意處

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

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

獨立的點

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

狀況大概如下圖：

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

input handling

如果 endWord 不在 worddict 中，return []

Boundary conditions

BFS 找最短路徑

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

DFS 找所有結果

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

Reference

【Leetcode】python - [2249] Count Lattice Points Inside a Circle 個人解法筆記 | 290th LeetCode Weekly Contest

Tue, 26 Apr 2022 15:01:01 +0800

題目出處

2249. Count Lattice Points Inside a Circle

難度

medium

題目分類

Array, Hash Table, Math, Geometry, Enumeration

2022-04-26 一刷

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

class Solution:
    def countLatticePoints(self, circles: List[List[int]]) -> int:
        self.ans_set = set()
        for circle in circles:
            self.get_lattice_for_each(circle)

        return len(self.ans_set) 

    def get_lattice_for_each(self, circle):
        cx, cy, r = circle
        for x in range(cx, cx+r+1):
            for y in range(cy, cy+r+1):
                if (cx - x)**2 + (cy - y)**2 <= r**2:
                    self.ans_set.add((x, y))
                    self.ans_set.add((x-2*(x-cx), y))
                    self.ans_set.add((x, y-2*(y-cy)))
                    self.ans_set.add((x-2*(x-cx), y-2*(y-cy)))

算法說明

搜尋範圍內有哪些點，直接的去抓 top, down, left, right，並找尋出現的點

速度優化

這邊我們可以進行一次數學加速，我們只需要分析 1/4 圓，就能進行後續分析。

優化前

def get_lattice_for_each(self, circle):
    x, y, r = circle
    down, top = y-r, y+r
    left, right = x-r, x+r
    for c_x in range(left, right+1):
        for c_y in range(down, top+1):
            if (x - c_x)**2 + (y - c_y)**2 <= r**2:
                self.ans_set.add((c_x, c_y))

優化後

def get_lattice_for_each(self, circle):
    cx, cy, r = circle
    for x in range(cx, cx+r+1):
        for y in range(cy, cy+r+1):
            if (cx - x)**2 + (cy - y)**2 <= r**2:
                self.ans_set.add((x, y))
                self.ans_set.add((x-2*(x-cx), y))
                self.ans_set.add((x, y-2*(y-cy)))
                self.ans_set.add((x-2*(x-cx), y-2*(y-cy)))

錯誤的討論

這邊我第一次不小心想的太單純，順便記錄一下，
我一開始想說直接把 (cx, cy) 當原點，然後直接加即可，

問題在於「計算出的 (x, y)」，「並不是從 (cx, cy) 出發，而是從 (0, 0) 出發」，
因此才會導致不能直接像我們下圖想的那麼單純，直接減 x

input handling

如果沒有 nums，return nums

Boundary conditions

for loop 控制範圍

Reference

[Java/C++/Python] O(1) Space

【Leetcode】python - [17] Letter Combinations of a Phone Number 個人解法筆記

Tue, 26 Apr 2022 03:51:36 +0800

題目出處

17. Letter Combinations of a Phone Number

難度

medium

題目分類

Hash Table, String, Backtracking

2022-04-26 一刷

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

letter_dict = {
    "2":["a","b","c"],
    "3":["d","e","f"],
    "4":["g","h","i"],
    "5":["j","k","l"],
    "6":["m","n","o"],
    "7":["p","q","r","s"],
    "8":["t","u","v"],
    "9":["w","x","y","z"]
}

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if not digits:
            return []

        return self.dfs(digits, [""])

    def dfs(self, digits, combinations):
        # end of recursion
        if not digits:
            return combinations

        # define and split
        new_combinations = []
        for letter in letter_dict[digits[0]]:
            for prefix in combinations:
                new_combinations.append(prefix + letter)

        return self.dfs(digits[1:], new_combinations)

算法說明

還算基礎的 dfs 題目，透過不斷的 dfs，每一次處理掉一個 digits

(除了一開始建那個 table 可能還比較麻煩一些XD)

input handling

如果沒有 input，return []

Boundary conditions

我們每搜尋一層就減去一個對應的 digit，最後當沒有 digit 時，回傳結果

Reference

【Lintcode】python - [862] Next Closest Time 個人解法筆記 | 內有 set 判斷是否 subset 的用法

Tue, 26 Apr 2022 03:11:45 +0800

題目出處

862 · Next Closest Time

難度

medium

題目分類

Hash Table, String, Backtracking, Enumeration

2022-04-26 一刷

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

class Solution:
    """
    @param time: the given time
    @return: the next closest time
    """
    def next_closest_time(self, time: str) -> str:
        # write your code here
        digits = set(time)
        hr, m = int(time[0:2]), int(time[3:5])
        current = hr*60+m
        # 0 - 1440
        for i in range(1, 1441):
            next_time = (current + i)%1440
            next_time = self.change_format(next_time)
            print(next_time)
            if set(next_time) <= digits:
                return next_time

    def change_format(self, x):
        hr, m = x//60, x%60
        return f"{hr:02}:{m:02}"

算法說明

這題基本上可以直接照題目的要求做，但因為時間格式的關係，不是那麼好直接處理，
當然也是可以使用 datetime 之類的 library，但這樣也許有失題目本身想考的東西XD

最後採取的策略是換算 24hr*60 = 1440 min，
用 for 去跑 1440 次，並 %1440，並找到最近的符合結果即可。

subset 用法

這邊可以使用 subset 處理，可以使用「<=」取子集合。

例如：{a,b,c} <= {a,b,c,d} 這樣的概念。

input handling

Boundary conditions

當符合結果時，return 結果

Reference

下一个最近的时间 · Next Closest Time

【Leetcode】python - [52] N-Queens II 個人解法筆記

Tue, 26 Apr 2022 02:17:15 +0800

題目出處

52. N-Queens II

難度

hard

題目分類

Backtracking

2022-04-26 一刷

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

class Solution:
    def totalNQueens(self, n: int) -> int:
        if n == 0:
            return [[]]

        self.ans = 0
        self.used_horizontal = set()
        self.used_diagonal_x_add_y = set()
        self.used_diagonal_x_minus_y = set()

        board_set = set()
        self.dfs(n, board_set, 0)
        return self.ans

    def dfs(self, n, board_set, floor):
        # end of recursion
        if floor == n:
            self.ans += 1
            return

        # define and split
        for i in range(n):
            queen = (floor, i)
            if self.check_board_conditions(queen):
                board_set.add(queen)
                self.add_board_conditions(queen)
                self.dfs(n, board_set, floor+1)
                self.remove_board_conditions(queen) # backtracking
                board_set.remove(queen) # backtracking

    def check_board_conditions(self, queen):
        (floor, i) = queen
        if i in self.used_horizontal:
            return False
        if floor + i in self.used_diagonal_x_add_y:
            return False
        if floor - i in self.used_diagonal_x_minus_y:
            return False
        return True

    def remove_board_conditions(self, queen):
        (floor, i) = queen
        self.used_horizontal.remove(i)
        self.used_diagonal_x_add_y.remove(floor + i)
        self.used_diagonal_x_minus_y.remove(floor - i)

    def add_board_conditions(self, queen):
        (floor, i) = queen
        self.used_horizontal.add(i)
        self.used_diagonal_x_add_y.add(floor + i)
        self.used_diagonal_x_minus_y.add(floor - i)

算法說明

此題目的前一題要求列出全部結果，而這題只須回傳結果數量，但做法相同，前一題可參考：

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

經典的 N-皇后難題，可以參考的 wiki 在這邊：

八皇后問題 wiki

這邊採用的策略是先把座標存在 set() 當中，
最後等結果都確定了，再把 set() 轉為 board。

board 正確的判斷條件

總共分成三種

橫的不重複
直的不重複
斜的不重複

橫的不重複

橫的不重複：我們在 for 環圈的時候，一橫只允許一個，因此不用另外判斷

直的不重複

直的不重複：我們紀錄直的座標到 used，每次嘗試擺上一個新皇后時，看一下有沒有 used

斜的不重複

斜的不重複：這個比較複雜，基本還是使用 used 的概念，細節我們下面細講

斜的不重複，這邊我們會提到一些數學的技巧：

我們稍微看一下，會發現斜線上的特性：

正斜線：x+y
負斜線：x-y

這邊我們計算圖片上的座標，我們就會發現，同一條斜線上的結果，規律會是 x-y 或 x+y 為定值

我們嘗試區分析範圍，這邊我們就會知道

正斜線：x+y，範圍介於 0 ~ 2n
負斜線：x-y，範圍介於 -n ~ n

我們透過紀錄 used，只要確保數值不重覆即可。

input handling

當 n = 0 時，return [[]]

Boundary conditions

我們以 floor 來紀錄層數，我們每次 dfs floor 不斷增加，
搜尋至 floor = n 時，添加結果回傳 (表示已經排完全部結果，且因為我們是邊放 queen 邊檢查，能到這層必為正確結果)

Reference

N皇后问题（一） · N-Queens

【Leetcode】python - [51] N-Queens 個人解法筆記

Tue, 26 Apr 2022 02:12:02 +0800

題目出處

51. N-Queens

難度

hard

題目分類

Array, Backtracking

2022-04-26 一刷

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

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        if n == 0:
            return [[]]

        self.ans = []
        self.used_horizontal = set()
        self.used_diagonal_x_add_y = set()
        self.used_diagonal_x_minus_y = set()

        board_set = set()
        n = 5
        self.dfs(n, board_set, 0)
        return self.ans

    def dfs(self, n, board_set, floor):
        # end of recursion
        if floor == n:
            self.make_board(n, board_set)
            return

        # define and split
        for i in range(n):
            queen = (floor, i)
            if self.check_board_conditions(queen):
                board_set.add(queen)
                self.add_board_conditions(queen)
                self.dfs(n, board_set, floor+1)
                self.remove_board_conditions(queen) # backtracking
                board_set.remove(queen) # backtracking

    def check_board_conditions(self, queen):
        (floor, i) = queen
        if i in self.used_horizontal:
            return False
        if floor + i in self.used_diagonal_x_add_y:
            return False
        if floor - i in self.used_diagonal_x_minus_y:
            return False
        return True

    def remove_board_conditions(self, queen):
        (floor, i) = queen
        self.used_horizontal.remove(i)
        self.used_diagonal_x_add_y.remove(floor + i)
        self.used_diagonal_x_minus_y.remove(floor - i)

    def add_board_conditions(self, queen):
        (floor, i) = queen
        self.used_horizontal.add(i)
        self.used_diagonal_x_add_y.add(floor + i)
        self.used_diagonal_x_minus_y.add(floor - i)

    def make_board(self, n, board_set):
        print(board_set)
        board = []
        for i in range(n):
            each_floor = ["Q" if (i, j) in board_set else "." for j in range(n)]
            board.append("".join(each_floor))

        self.ans.append(board)

算法說明

經典的 N-皇后難題，可以參考的 wiki 在這邊：

八皇后問題 wiki

這邊採用的策略是先把座標存在 set() 當中，
最後等結果都確定了，再把 set() 轉為 board。

board 正確的判斷條件

總共分成三種

橫的不重複
直的不重複
斜的不重複

橫的不重複

橫的不重複：我們在 for 環圈的時候，一橫只允許一個，因此不用另外判斷

直的不重複

直的不重複：我們紀錄直的座標到 used，每次嘗試擺上一個新皇后時，看一下有沒有 used

斜的不重複

斜的不重複：這個比較複雜，基本還是使用 used 的概念，細節我們下面細講

斜的不重複，這邊我們會提到一些數學的技巧：

我們稍微看一下，會發現斜線上的特性：

正斜線：x+y
負斜線：x-y

這邊我們計算圖片上的座標，我們就會發現，同一條斜線上的結果，規律會是 x-y 或 x+y 為定值

我們嘗試區分析範圍，這邊我們就會知道

正斜線：x+y，範圍介於 0 ~ 2n
負斜線：x-y，範圍介於 -n ~ n

我們透過紀錄 used，只要確保數值不重覆即可。

input handling

當 n = 0 時，return [[]]

Boundary conditions

Reference

N皇后问题（一） · N-Queens

【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

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 去搜尋全部的結果，

input handling

當沒有 nums 時，return nums

Boundary conditions

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

Reference

全排列 · Permutations

【Leetcode】python - [140] Word Break II 個人解法筆記

Sat, 23 Apr 2022 19:55:23 +0800

題目出處

140. Word Break II

難度

hard

題目分類

Array, Hash Table, String, Dynamic Programming, Backtracking, Trie, Memoization

2022-04-23 一刷

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

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:
        if not s:
            return []

        self.memo = {}
        return self.dfs(s, wordDict)

    def dfs(self, s, word_dict):
        if s in self.memo:
            return self.memo[s]

        # end of recursion
        if len(s) == 0:
            return []

        # define and split
        partitions = []

        # full match
        if s in word_dict:
            partitions.append(s)

        # part match
        for idx in range(0, len(s)):
            prefix = s[:idx+1] # 0 to idx
            # print(prefix)
            if prefix not in word_dict:
                continue

            sub_partitions = self.dfs(s[idx+1:], word_dict) # start from idx+1
            for partition in sub_partitions:
                partitions.append(prefix + " " + partition)

        self.memo[s] = partitions
        return partitions

算法說明

此題的前一題，只需要判斷可不可行就好，可參考：

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

這題可以先嘗試寫一個基本的版本，用 dfs 搜索出全部的結果，
這題很佛心不會 TLE，但真的很慢XDDD

思考方式為用一個 start 作為 pointer，切出「到目前為止之前的全部內容」

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:
        if not s:
            return False

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

    def dfs(self, s, start, word_dict, prefix_words):

        # end of recursion
        if start > len(s):
            return
        if start == len(s):
            self.ans.append(" ".join(prefix_words))
            return 

        # define and split
        for idx in range(start, len(s)):
            prefix = s[start:idx+1] # start to idx
            if prefix in word_dict:
                prefix_words.append(prefix)
                self.dfs(s, idx+1, word_dict, prefix_words)
                prefix_words.pop() # backtracking
            else:
                continue
        return

記憶化搜索 memoization 加速

加速的思路，是來自我們思考每次在遞迴的過程中，
最終都會有一段處理相同文字的過程。
(可以想像，每次的開頭不同時，結尾我們都在反覆處理一樣的東西)

因此我們用一個 memo 紀錄一下，紀錄「相同的文字」，我們上次處理的結果

input handling

當沒有 s 時，return []

Boundary conditions

搜尋至 start = len(s) 時，剛好抵達結束搜尋的範圍 (其他狀況應該是無法抵達的)

Reference

单词拆分II · Word Break II

【Leetcode】python - [131] Palindrome Partitioning 個人解法筆記

Sat, 23 Apr 2022 00:55:21 +0800

題目出處

131. Palindrome Partitioning

難度

medium

題目分類

String, Dynamic Programming, Backtracking

2022-04-23 一刷

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

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        if not s:
            return []

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

    def dfs(self, s, partitions, start, end):
        # end of recursion
        if start >= end:
            self.ans.append(list(partitions))
            return

        # define and spliit
        for idx in range(start, end):
            split_s = s[start:idx+1] # least one word, max = [start:(end-1+1)] = [start:end]
            if self.is_palindrome(split_s):
                partitions.append(split_s)
                self.dfs(s, partitions, idx+1, end) # go next
                partitions.pop()

        return

    def is_palindrome(self, s):
        print(s)
        start = 0
        end = len(s)-1
        while(start <= end and s[start] == s[end]): 
            start += 1
            end -= 1
        else:
            if start <= end: # check
                return False
            else:
                return True

算法說明

組合類的變化題，使用 dfs，嘗試窮舉所有的組合。

由 start 開始，計算至 end
取 split 時記得要取 [start:idx+1] 才會是 start~idx
而往下走時，要指定的下一個座標也是 idx+1 (因為目前只判斷到包含 idx)

input handling

如果沒有 s，直接 return []

Boundary conditions

見上述說明

Reference

分割回文串 · Palindrome Partitioning

【Leetcode】python - [40] Combination Sum II 個人解法筆記

Fri, 22 Apr 2022 22:45:30 +0800

題目出處

40. Combination Sum II

難度

medium

題目分類

Array, Backtracking

2022-04-22 一刷

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

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        if not candidates:
            return []

        ans = []
        self.dfs(sorted(candidates), target, 0, [], ans)
        return ans

    def dfs(self, candidates, target, start_idx, combination, ans):
        # end of recursion
        if target < 0:
            return
        if target == 0:
            ans.append(list(combination)) # deepcopy
            return

        # define
        for idx in range(start_idx, len(candidates)):
            if idx != start_idx and candidates[idx] == candidates[idx-1]: # remove duplicate
                continue
            combination.append(candidates[idx])
            self.dfs(candidates, target-candidates[idx], idx+1, combination, ans) # no duplicate use
            combination.pop()

算法說明

組合類的問題，使用 dfs 搜尋出全部的組合，在判斷可行的方案。

與允許使用重複的前一題比較，這題要多處理「數組內建重複」的部分，

因此我們多使用了

「idx != start_idx」：當 idx 不等於「起始位置」

這個判斷條件非常重要，
我們只判斷起始位置，因為有可能會有 [1,1,6] 這種 case 要處理

我們讓頭兩組 [1, 1] 能夠被計算為一個結果，是第一組也被我們控制在唯一的一組。

如果數組有 [1, 1, 1]，我們在搜尋前兩個 [1, 1] 就會決定了這唯一的結果。

「candidates[idx] candidates[idx-1]」

判斷重複的時候，用 continue 直接略過。
(for 搭配 continue，比起直接用 while 略過，感覺程式可讀性會更好。)

input handling

如果沒有 candidates，直接 return []

Boundary conditions

見上述說明

Reference

数字组合 II · Combination Sum II

【Leetcode】python - [39] Combination Sum 個人解法筆記

Fri, 22 Apr 2022 22:37:14 +0800

題目出處

39. Combination Sum

難度

medium

題目分類

Array, Backtracking

2022-04-22 一刷

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

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        if not candidates:
            return []

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

    def dfs(self, candidates, target, start_idx, combination, ans):

        # end of recursion
        if target < 0:
            return

        if target == 0:
            ans.append(list(combination)) # deepcopy
            return 

        # define and split
        for idx in range(start_idx, len(candidates)):
            combination.append(candidates[idx])
            self.dfs(candidates, target-candidates[idx], idx, combination, ans) # idx + 1 = next index
            combination.pop()

算法說明

組合類的問題，使用 dfs 搜尋出全部的組合，在判斷可行的方案。

input handling

如果沒有 candidates，直接 return []

Boundary conditions

見上述說明

Reference

数字组合 · Combination Sum

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