725 - LeetCode Dynamic Programming on 嗡嗡的隨手筆記

【Leetcode】python - [121] Best Time to Buy and Sell Stock 個人解法筆記

Fri, 24 Jul 2026 22:19:23 +0800

題目出處

121. Best Time to Buy and Sell Stock

難度

Easy

題目分類

Array, Dynamic Programming

2026-07-24 三刷

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

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if not prices or len(prices) == 1: # edge len(prices) = 1
            return 0

        min_buy = prices[0]
        max_profit = 0

        for i, price in enumerate(prices):
            max_profit = max(max_profit, price - min_buy)
            min_buy = min(min_buy, price) # update today

        return max_profit

算法說明

單純的數學題目，保存好最大收益跟最低入場價就可以解決。

Time Complexity

O(n)

Space Complexity

O(1)

Boundary conditions

小心題目有提到 len(prices) = 1 (需要小心處理，以上面的例子來說拿掉也可以，因為迴圈跑完一次 max 仍保持 0)

2022-04-15 二刷

個人範例程式碼 - 2022/4/15

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if not prices or len(prices) < 2:
            return 0

        min_buy = prices[0]
        best_profit = 0

        for i, today_price in enumerate(prices):
            if i == 0: # pass first day
                continue
            else:
                min_buy = min(min_buy, today_price)
                best_profit = max(best_profit, today_price - min_buy)

        return best_profit

算法說明

input handling

處理沒有 input 或 input 只有一天 (沒得賣啊!) 的情況，return 0

Boundary conditions

for 迴圈，不怕出界

2022-03-02 一刷

個人範例程式碼 - 2022/3/2

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        min_buyin_record = 999999 # min buy in 
        res_record = 0 # max result  
        for today in range(len(prices)):
            if today == 0: # first
                min_buyin_record = prices[today]
            else:
                min_buyin_record = min(min_buyin_record, prices[today])
                res_record = max(res_record, prices[today] - min_buyin_record)

        return res_record

Time Complexity

O(n)

算法說明

唯一要記錄只有兩個

到今日之前的「購入最低價」
到今日之前的「最佳結果」

corner case 特殊情況處理

當只有一天時，需要回傳 0，
這邊我在初始化時解掉了。

Boundary conditions/ Edge conditions 邊際情況處理

初始值處理

第一天時，因為沒有最大值，我特別去判斷現在進來的是不是第一天，

不過後來有使用另外一個做法，先定義最小值為「999999」，預設第一天就會被取代。

這個可以成功的原因是因為：
題目限制「0 <= prices[i] <= 10^4」

兩種作法應該都可以，我之後應該會選擇第一種，去避免自訂義值的情況。

Reference

【Leetcode】python - [53] Maximum Subarray 個人解法筆記

Thu, 23 Jul 2026 04:26:14 +0800

題目出處

53. Maximum Subarray

難度

Easy

題目分類

Array, Divide and Conquer, Dynamic Programming

2026-07-23 三刷

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

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        best_ending_here = best_so_far = nums[0]
        for i in range(1, len(nums)):
            # add best sums before will be better or not (then just take current)?
            best_ending_here = max(best_ending_here + nums[i], nums[i])
            best_so_far = max(best_so_far, best_ending_here)

        return best_so_far

算法說明

best_ending_here 比較包含這個的最大，兩種可能：

前面總和+自己比較大
自己比較大（發生於前面總和為負的情況）

這題基本上如果恆正只要一直加就能最大，只需要用以上方式處理有「前方總和有負」（不是單純此值為負）出現的情況

best_so_far 紀錄一直以來的最大

Time Complexity

O(n)

Space Complexity

O(1)

Boundary conditions

i = 1, best 為 nums[0], 拿去當預設結果
i = 2, best 可能為 nums[0], nums[1], nums[0]+nums[1], for loop 需要從 1 開始跑

2022-04-28 二刷

個人範例程式碼 - 2022/4/28

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

        current_max_with_this = [nums[0]]

        for i in range(1, len(nums)):
            current_max_with_this.append(max(current_max_with_this[i-1]+nums[i], nums[i]))

        return max(current_max_with_this)

算法說明

建一個新的 array，記錄"包含自己"的當前最大用

當前最大 = max(當前數字, 當前數字+到前一個之前最大)

input handling

如果 input not nums (沒有數字)，return 0

Boundary conditions

for 控制範圍

2022-02-24 一刷

個人範例程式碼 - 2022/2/24

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp = [] # dp = the biggest answer 'include me'
        for i in range(len(nums)):
            if i == 0:
                dp.append(nums[i])
            else:
                bigger = max(nums[i], nums[i]+dp[i-1])
                dp.append(bigger)

        return max(dp)

說明

這題我使用的是 DP 的解法，
我宣告一個 DP 來儲存「包含自己的」時最好的答案。

換句話說，我將題目拆解成到「包含每一個 index 的當下」都是一個小題目，將題目的答案儲存進 dp 中。

所以假設原來的題目變成：
nums = [1,2,-1,4]
dp = [1,3,2,6]

【Leetcode】python - [70] Climbing Stairs 個人解法筆記

Tue, 21 Jul 2026 18:29:20 +0800

題目出處

70. Climbing Stairs

難度

easy

題目分類

Math, Dynamic Programming, Memoization

2026-07-21 二刷

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

class Solution:
    def climbStairs(self, n: int) -> int:
        curr, prev = 1, 0
        for _ in range(n):
            curr, prev = curr+prev, curr

        return curr

算法說明

DP題目, 不過其實只有需要分析前一個與前兩個, 可以簡化為使用兩個變數動態存值

Time Complexity

O(n)

Space Complexity

O(1)

2022-05-04 一刷

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

class Solution:
    def climbStairs(self, n: int) -> int:
        # dp[i] = dp[i-1] + dp[i-2]
        if n == 0:
            return 0

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

        return dp[-1]

算法說明

利用 dp[i] = dp[i-1] + dp[i-2]

input handling

處理開頭 i = 0 的情況，return 0
i = 1, return 1
i = 2, return 2

Boundary conditions

控制 for-loop 的範圍

Reference

【Leetcode】C++ - [5] Longest Palindromic Substring 個人筆記 | 內含 C++ string.substr() 用法筆記

Fri, 12 Aug 2022 02:17:02 +0800

題目出處

https://leetcode.com/problems/longest-palindromic-substring/

難度

Medium

題目分類

Two Pointers, String, Dynamic Programming

2022-08-12 一刷

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

class Solution {
public:
    string longestPalindrome(string s) {
        string tmp_ans, final_ans = "";
        for(int i = 0; i < s.length() ; i++){
            tmp_ans = is_palindrome(s, i, i);
            if(tmp_ans.length() > final_ans.length())
                final_ans = tmp_ans;

            tmp_ans = is_palindrome(s, i, i+1);
            if(tmp_ans.length() > final_ans.length())
                final_ans = tmp_ans;
        }

        return final_ans;
    }

    string is_palindrome(string s, int start, int end){
        while(0 <= start && end < s.length() && s[start] == s[end]){
            start -= 1;
            end += 1;
        }

        // s.substr(start, len)
        // s[start+1:end] -> s.substr(start+1, end-(start+1))
        string split_string = s.substr(start+1, end-(start+1));
        // cout << split_string << endl;
        return split_string;   
    }
};


/* python solution
class Solution:
    def longestPalindrome(self, s: str) -> str:
        ans = ""
        for i in range(len(s)):
            tmp_ans = self.is_palindrome(s, i, i)
            if len(tmp_ans) > len(ans):
                ans = tmp_ans

            tmp_ans = self.is_palindrome(s, i, i+1)
            if len(tmp_ans) > len(ans):
                ans = tmp_ans

        return ans

    def is_palindrome(self, s, start, end):
        while(0 <= start and end < len(s) and s[start] == s[end]):
            start -= 1
            end += 1

        # print(s[start+1:end])
        return s[start+1:end]
*/

個人是從 python 練熟後，把概念帶過來練習 C++，「python 解」可參考：

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

算法說明

以中間作為 palidrome 搜尋開始的起始位置，
另外寫一個驗證 palindrome 用的 function。

corner case 特殊情況處理

一起在判斷 palindrome 的 function 中做掉。

Boundary conditions/ Edge conditions 邊際情況處理

注意搜尋範圍 0 <= start, end < len(s)
注意離開迴圈後，回傳 s[start+1:end]，而不是直覺的 s[start:end+1]

C++ substr 用法複習

在 python 裡面，我們可以比較輕鬆的使用 string split，
我們在 C++ 需要使用 string.substr() 來代替，
用法是「string.substr(start, len)」，

可以養成參考官方文件的習慣：

std::string::substr

Reference

【Leetcode】python - [5] Longest Palindromic Substring 個人筆記

Fri, 12 Aug 2022 00:37:50 +0800

題目出處

https://leetcode.com/problems/longest-palindromic-substring/

難度

Medium

題目分類

Two Pointers, String, Dynamic Programming

2022-08-12 三刷

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

class Solution:
    def longestPalindrome(self, s: str) -> str:
        ans = ""
        for i in range(len(s)):
            tmp_ans = self.is_palindrome(s, i, i)
            if len(tmp_ans) > len(ans):
                ans = tmp_ans

            tmp_ans = self.is_palindrome(s, i, i+1)
            if len(tmp_ans) > len(ans):
                ans = tmp_ans

        return ans

    def is_palindrome(self, s, start, end):
        while(0 <= start and end < len(s) and s[start] == s[end]):
            start -= 1
            end += 1

        # print(s[start+1:end])
        return s[start+1:end]

算法說明

以中間作為 palidrome 搜尋開始的起始位置，
另外寫一個驗證 palindrome 用的 function。

corner case 特殊情況處理

一起在判斷 palindrome 的 function 中做掉。

Boundary conditions/ Edge conditions 邊際情況處理

注意搜尋範圍 0 <= start, end < len(s)
注意離開迴圈後，回傳 s[start+1:end]，而不是直覺的 s[start:end+1]

2022-03-28 二刷

個人範例程式碼 - 二刷 (2022/03/28)

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s:
            return ""

        final_ans = ""
        for index in range(len(s)):
            # odd case
            tmp_ans = self.find_max_palindrome(s, index, index)
            if len(final_ans) < len(tmp_ans):
                final_ans = tmp_ans
            # even case
            tmp_ans = self.find_max_palindrome(s, index, index+1)
            if len(final_ans) < len(tmp_ans):
                final_ans = tmp_ans

        return final_ans

    def find_max_palindrome(self, s, right_index, left_index):
        while(right_index >=0 and left_index < len(s) and s[right_index] == s[left_index]):
            right_index -= 1
            left_index += 1
        # when failed, get last ans
        return s[right_index+1:left_index]

算法說明

第二次解開始注重 coding 本身能夠自己解釋出邏輯的部分。
另外還有注重邊界檢測與 input 異常處理。

分成 odd case 與 even case 分開處理，
可以同樣以中心出發，往兩側前進 (注意邊界)

邊界檢測

檢查 for-loop, while-loop 是否有可能有越界問題

input 異常處理

主要處理以下：

input s 為 “"，回傳 "”

2021-03-31 一刷

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

class Solution:
    def longestPalindrome(self, s: str) -> str:
        ans = ""
        for r in range(len(s)):
            word = self.checkPalindrome(s, r)
            # print(f"word = {word}")
            if len(word) >= len(ans):
                ans = word

        return ans

    def checkPalindrome(self, s, idx):
        # case 1: i-1, i+1
        k = 0
        word1 = ""
        while(idx-k >= 0 and idx+k < len(s) and s[idx-k] == s[idx+k]):
            # record
            word1 = s[idx-k:idx+k+1]
            # print(f"idx = {idx}, k = {k}, word1 = {word1}") # debug
            # move to next
            k += 1 


        # case 2: i, i+1
        k = 0
        word2 = ""
        while(idx-k >= 0 and (idx+1)+k < len(s) and s[idx-k] == s[(idx+1)+k]):
            # record
            word2 = s[idx-k:(idx+1)+k+1]
            # print(f"idx = {idx}, k = {k}, word2 = {word2}") # debug
            # move to next
            k += 1 

        # return longest word(substring)
        if len(word1) >= len(word2):
            return word1
        else:
            return word2

向前一個個搜尋

直覺的想，我們把每一個 index 都當作一個起點，進行各自的搜尋

單一 index 搜尋最佳解

這裡我們發現可以分成兩種 case

case1: i-1, i, i+1 類型 (也就是有包含自己跟自己相同)
case2: i-1, i, i+1, i+2 類型 (也就是自己跟自己+1相同)

回收 case1, case2 結果，更新最佳答案，直到搜尋結束。

Reference

https://leetcode.com/problems/longest-palindromic-substring/discuss/751188/Simple-Easy-to-Follow-Python

【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 - [122] Best Time to Buy and Sell Stock II 個人解法筆記

Fri, 17 Jun 2022 18:28:56 +0800

題目出處

122. Best Time to Buy and Sell Stock II

難度

medium

題目分類

Array, Dynamic Programming, Greedy

2022-06-17 一刷

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

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        max_profit = 0 
        for i, price in enumerate(prices):
            if i > 0:
                one_day_profit = prices[i] - prices[i-1]
                max_profit += one_day_profit if one_day_profit >= 0 else 0

        return max_profit

算法說明

可以一天內即時的進行買賣，我們最好的收益就是「從頭到尾都沒有損失的最佳情況」，
因此我們只要計算

當「今日 - 前日受益 > 0」，我們就加上收益，
當「收益 <= 0」，我們就 +0

input handling

Boundary conditions

用 for 來控制搜尋範圍

Reference

买卖股票的最佳时机 II · Best Time to Buy and Sell Stock II

【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 - [647] Palindromic Substrings 個人解法筆記

Mon, 06 Jun 2022 17:57:09 +0800

題目出處

647. Palindromic Substrings

難度

medium

題目分類

Two Pointers, String, Dynamic Programming

2022-06-06 一刷

個人範例程式碼 - DFS (會 TLE)

class Solution:
    def countSubstrings(self, s: str) -> int:
        ans = 0
        return self.dfs(s, 0)

    def dfs(self, s, start):
        # end of recursion
        if start >= len(s):
            return 0

        ans = 0
        # define
        for end in range(start, len(s)):
            if self.is_palindromic(s[start:end+1]):
                ans += 1

        # split 
        return ans + self.dfs(s, start+1)

    def is_palindromic(self, s):
        # print(s)

        start = 0
        end = len(s)-1
        while start <= end:
            if s[start] == s[end]:
                start += 1
                end -= 1
            else:
                return False

        return True

算法說明

DFS 的作法，應該會是最直覺地把所有可能性都舉出來，
總共會花大約 O(2^n) 的時間，會造成 TLE

input handling

一同在 DFS 內處理

Boundary conditions

在 DFS 內處理，發現 start >= end 時 return

個人範例程式碼 - DP

class Solution:
    def countSubstrings(self, s: str) -> int:
        ans = 0
        length = len(s)

        dp = [[0 for start in range(length)] for end in range(length)]

        for start in range(length):
            for end in range(start, length):
                # print(start, end)
                if dp[start][end]: # already recorded
                    ans += 1
                    continue

                if self.is_palindromic(s[start:end+1]):
                    ans += 1
                    tmp_start, tmp_end = start, end
                    while tmp_start <= tmp_end:
                        dp[tmp_start][tmp_end] = 1
                        tmp_start += 1
                        tmp_end -= 1

        return ans

    def is_palindromic(self, s):
        # print(s)

        start = 0
        end = len(s)-1
        while start <= end:
            if s[start] == s[end]:
                start += 1
                end -= 1
            else:
                return False

        return True

算法說明

在上方，我們知道 DFS 因為需要 O(2^n) 的運算時間會造成 TLE 後，
我們只好採取更快的策略，最直覺的我們會想到 DP

因為 DP 最擅長幫我們把解題時間從 O(2^n) 優化至 O(n^2) 的時間。

而要讓題目優化至 O(n^2) 時間，
我們就先建立一個 start, end 的二維查詢表。

我們更新的方式也很簡單，
如果當發現 dp[i][j] 是 palindrome，那也表示 dp[i+1][j-1] 也是 palindrome，直到 start > end，
因此我們可以劃出上圖的紅色斜線，

判斷時，我們初始化都是 0，如果之後發現已經被改成 1，
即可 continue 直接 pass 計算。

input handling

一同在 DP 內處理

Boundary conditions

兩層 DP 的 for 迴圈，
分別代表著 start, end

Reference

回文子串 · Palindromic Substrings

【Leetcode】python - [1143] Longest Common Subsequence 個人解法筆記

Mon, 06 Jun 2022 16:03:01 +0800

題目出處

1143. Longest Common Subsequence

難度

medium

題目分類

String, Dynamic Programming

2022-06-06 一刷

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

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m, n = len(text1), len(text2)

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

        for i in range(1, m+1):
            for j in range(1, n+1):
                if text1[i-1] == text2[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1 # same case, update value form text[i-1][j-1]
                else:
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1]) # default update

        return dp[-1][-1]

算法說明

經典的 LCS 問題，我們建表來進行搜索，
表格更新的邏輯為：

如果有字母相同，表示 text1, text2 一起移動： dp[i][j] = dp[i-1][j-1] + 1

其他情況(無字母相同)，只更新最大值： dp[i][j] = max(dp[i-1][j], dp[i][j-1])

input handling

一同在 dp 內處理。

Boundary conditions

用兩層 for 迴圈來控制範圍

Reference

最长公共子序列 · Longest Common Subsequence

【Leetcode】python - [152] Maximum Product Subarray 個人解法筆記

Sat, 04 Jun 2022 03:28:20 +0800

題目出處

152. Maximum Product Subarray

難度

medium

題目分類

Array, Dynamic Programming

2022-06-04 一刷

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

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

        max_product = [0 for _ in range(len(nums))]
        min_product = [0 for _ in range(len(nums))]

        for i, num in enumerate(nums):
            if i > 0:
                if num > 0:
                    max_product[i] = max(num, num * max_product[i-1]) # only me, or bigger (smaller)
                    min_product[i] = min(num, num * min_product[i-1])
                else:
                    max_product[i] = max(num, num * min_product[i-1])
                    min_product[i] = min(num, num * max_product[i-1])
            else:
                max_product[0] = nums[0]                 
                min_product[0] = nums[0]

        # print(max_product)
        # print(min_product)

        return max(max_product)

算法說明

看起來複雜的問題，想一下發現最主要在搞事的就是負號，
因為正常來說，我們一直乘整數，數字只會一直不斷變大，
因此這樣的話，「我們唯一要思考的就只有負號的處理」

為了處理負號，我們同時記錄「至當前數字的 min 與 max 的 dp」，
紀錄時，我們要比較的內容也是關鍵，

我們要比較：「當前數字，與之前的內容乘上該數字是誰大(小)」，
而保留當前數字的原因，因為保留當前數字也等於，
「表示前面我們不要了，只保留當前數字下來繼續往後乘」

因此：

當 nums[i] >= 0 :

max_dp[i] = max(nums[i], nums[i]*max[i-1])
min_dp[i] = min(nums[i], nums[i]*min[i-1])

當 nums[i] < 0 :

max_dp[i] = max(nums[i], nums[i]*min[i-1])
min_dp[i] = min(nums[i], nums[i]*max[i-1])

而初始化：

max_dp[0] = min_dp[0] = nums[0]

或者，我們也可以這樣簡化

根據我們上面的討論，其實我們都知道我們要比較的就只有

「當前數字 (表示前面我們不要了，只保留當前數字下來繼續往後乘)」、
「nums[i]min[i-1]」、
「nums[i]max[i-1]」

同時取 max, min 記錄下來即可。

因此簡化後的結果就是：

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

        max_product = [0 for _ in range(len(nums))]
        min_product = [0 for _ in range(len(nums))]

        for i, num in enumerate(nums):
            if i > 0:
                max_product[i] = max(num, num * max_product[i-1], num * min_product[i-1])
                min_product[i] = min(num, num * max_product[i-1], num * min_product[i-1])
            else:
                max_product[0] = nums[0]                 
                min_product[0] = nums[0]

        return max(max_product)

input handling

一同在 dp 內處理

Boundary conditions

用 for 迴圈控制範圍

Reference

乘积最大子序列 · Maximum Product Subarray

【Leetcode】python - [338] Counting Bits 個人解法筆記

Thu, 02 Jun 2022 17:37:20 +0800

題目出處

338. Counting Bits

難度

easy

題目分類

Dynamic Programming, Bit Manipulation

2022-06-02 一刷

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

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

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

        for i in range(1, n+1):
            if i % 2 == 0: # ood case
                dp[i] = dp[i>>1]
            else: # even case
                dp[i] = dp[i>>1] + 1

        return dp

算法說明

個人覺得算法比較偏 tricky 的題目，看看即可，
要注意的點是在題目不希望我們用 O(nlogn) 去實現，也就是不希望我們「一個一個算」，

題目希望我們用 O(n) 時間完成，也就是我們必須想辦法「找到數字之間的相關性」，
就可以猜測這個做法應該跟 dp 有關

推理 dp 相關性

推理過程我們拆成奇數跟偶數分析，我們發現

偶 -> 奇：最好討論的情況，因為末位一定是 0，dp[i] = dp[i»1] + 1，(dp[i»1] 代表左側所有位數)
奇 -> 偶：我們觀察後，比較難發現他會找到最低位的 0 第一次出現的位置 (不懂可以看圖)，我們要做有點連環式的 dp 分析

例如: '101' -> '110' ，我們可以不管他前一個數字 '101' 是啥，我們找到 '110' 的 '0' 會知道它的結果等於 dp['11']

例如: '1111' -> '10000' ，我們可以不管他前一個數字 '11111' 是啥，我們找到 '10000' 的 '0' 會知道它的結果等於 dp['1000']，而 dp['1000'] = dp['100'] = dp['10'] = dp['1'] = dp['0'] + 1，類似這樣的連鎖效應。

input handling

一同在 dp 內處理

Boundary conditions

用 for 迴圈控制範圍

Reference

数 1 · Counting Bits

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

Mon, 30 May 2022 18:22:37 +0800

題目出處

377. Combination Sum IV

難度

medium

題目分類

Array, Dynamic Programming

2022-05-30 一刷

個人範例程式碼 - 2022/5/30 一刷，DP 另解

本題是 Combinations 系列的第 5 題，前面的題目可以參考：

本題也是背包系列問題的第 6 題，建議初學者可以從第一題開始去學：

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

        nums.sort()
        dp = [0 for _ in range(target+1)]

        for each_target in range(1, target+1):
            for num in nums:
                if each_target == num:
                    dp[each_target] += 1
                if each_target - num >= 0:
                    dp[each_target] += dp[each_target - num] # add new case (with more this num)

        # 0 1 2 3 4 
        # 0 0 0 0 0 
        # 1: 1
        # 2: 2 (case 1)
        # 3: 3 (case 2) (case 1)
        # 4: (case 3+1) (case 2+2) (case 1+3)

        return dp[-1]

算法說明

其實這也是背包問題的一種，只是這類的背包問題「拿背包的順序也會影響到結果」，
因此，我們把拿背包時，分成「之前case」+ 「現在新拿的 num」，
於是，我們遇到一個新的數量時，
只需要去計算所有的「可新拿的一個 num」搭配「扣除此 num 價值後，所有可能的組合」，即為答案。

範例

以題目的數字為例：

target 為 4，我們宣告一個 dp 從 0 1 2 3 4

當 target = 0，0
當 target = 1，1 存在 num，0+1
當 target = 2，2 存在 num, 0+1, 再加上「多拿一顆 1 + (dp[1] 的所有組合)」
當 target = 3，3 存在 num, 0+1, 再加上「多拿一顆 1 + (dp[2] 的所有組合)」, 再加上「多拿一顆 2 + (dp[1] 的所有組合)」
當 target = 4，0 再加上「多拿一顆 1 + (dp[3] 的所有組合)」, 再加上「多拿一顆 2 + (dp[2] 的所有組合)」，再加上「多拿一顆 3 + (dp[1] 的所有組合)」

input handling

處理沒有 input nums 的情況，return 0

Boundary conditions

用 for 來控制範圍

個人範例程式碼 - 2022/5/30 一刷，DFS + memoization 解

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

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

    def dfs(self, nums, target, combination, ans, memo):
        # end of recursion
        if target == 0:
            return 1

        if target < 0:
            return 0

        if target in memo:
            return memo[target]

        ans = 0
        # define and split
        for num in nums:
            combination.append(num)
            cur_ans = self.dfs(nums, target - num, combination, ans, memo)
            combination.pop(-1) # backtracking

            memo[target - num] = cur_ans
            ans += cur_ans

        return ans

算法說明

純 DFS 會 TLE，會需要 memoization 輔助運算 (純計算數量，因此更容易使用。)

input handling

處理沒有 input nums 的情況，return 0

Boundary conditions

dfs 結束迴圈的條件：

k < 0，回傳 0 個結果
k = 0，回傳 1，找到 1 個結果

memoization 記憶化搜索

透過紀錄 memo[target] 有多少數量，我們可以拿過去計算的經驗告訴我們會有多少結果。

Reference

组合总和 IV · Combination Sum IV

【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

算法說明

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

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)，其實兩者是同一個意思的問題。

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 - [300] Longest Increasing Subsequence 個人解法筆記

Mon, 23 May 2022 03:07:54 +0800

題目出處

300. Longest Increasing Subsequence

難度

Medium

題目分類

Array, Binary Search, Dynamic Programming

2022-05-23 一刷

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

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        # 1 3 5 4 7
        # 1 1 1 1 1
        # 1 2 3 3 4

        dp = [1 for _ in range(len(nums))]

        for i in range(1, len(nums)):
            for j in range(i):            
                if nums[j] < nums[i]:
                    dp[i] = max(dp[i], dp[j]+1)

        return max(dp)

算法說明

經典題目 LIS，使用 DP 解題

# 1 3 5 4 7
# 1 1 1 1 1
# 1 2 3 3 4

init: dp 都 1
function: dp[i] = max(dp[i], dp[j]+1) if 0 <= j < i
ans: max(dp)

input handling

同 DP 內控制範圍

Boundary conditions

用 for loop 控制搜尋範圍

Reference

【Leetcode】python - [309] Best Time to Buy and Sell Stock with Cooldown 個人解法筆記

Sun, 22 May 2022 18:42:12 +0800

題目出處

309. Best Time to Buy and Sell Stock with Cooldown

難度

medium

題目分類

Array, Dynamic Programming

2022-05-22 一刷

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

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) <= 1:
            return 0

        buy = [0 for _ in range(len(prices))] # max profit, if buy today or not
        sell = [0 for _ in range(len(prices))] # max profit, if sell today or not
        cooldown = [0 for _ in range(len(prices))] # = sell[i-1]

        buy[0] = -prices[0] # init

        for i in range(1, len(prices)):
            cooldown[i] = sell[i-1]

            # if sell yesterday(or before) is max, or sell today will max
            sell[i] = max(sell[i-1], buy[i-1]+prices[i])

            # if buy yesterday(or before), or buy today will max
            # sell & cooldown both keep current max profit
            buy[i] = max(buy[i-1], cooldown[i-1]-prices[i])

        return max(cooldown[-1], sell[-1])

算法說明

要考慮滿多東西的 DP 問題，算是買賣股票系列問題中的複雜版

我們先定義主要的 DP

buy: 代表至當日若有任何買入，可獲得的最大 profit (可能是在今日或 n天前買入)
sell: 代表至當日若有任何賣出，可獲得的最大 profit (可能是在今日或 n天前賣出)
cooldown: 固定等於 sell[i-1]，是紀錄 sell 的 cooldown，供 buy 時參考

化成公式：

都有可能是今日不採取任何策略才是最好的情況，因此都會需要與昨日比較。

buy[i] = max(buy[i-1], cooldown[i-1]-prices[i])

sell[i] = max(sell[i-1], buy[i-1] - prices[i])

cooldown[i] = sell[i-1]

這邊我們要注意的事情是，
就算 sell 在當日選擇了賣出的策略較好，
但 buy 仍會記錄最好的買入價。

例子

例如: 1,2,3

分析到 2 時，也許 sell 在當日是最好的 sell[2] 策略，
但其實 sell 在 3 才是最好的，這個訊息被記錄在 buy[2] 裡面，
我們可以在 sell[3] 知道從 buy[2] 獲得最大利益。

初始化

buy[0] = -prices[0]
sell[0] = 0
cooldown[0] = 0

input handling

如果 len(prices) <= 1，return 0

Boundary conditions

用 for 來控制搜尋範圍

Reference

带有冷却时间的买卖股票最好时间 · Best Time to Buy and Sell Stock with Cooldown

【Leetcode】python - [509] Fibonacci Number 個人解法筆記

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

題目出處

509. Fibonacci Number

難度

Easy

題目分類

Math, Dynamic Programming, Recursion, Memoization

2022-05-22 一刷

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

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

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

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

        return dp[-1]

算法說明

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

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

初始化:

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

input handling

都在 for 裡面處理

Boundary conditions

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

Reference

【Leetcode】python - [746] Min Cost Climbing Stairs 個人解法筆記

Sat, 21 May 2022 20:13:23 +0800

題目出處

746. Min Cost Climbing Stairs

難度

Easy

題目分類

Array, Dynamic Programming

2022-05-21 一刷

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

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

        dp = []

        for i in range(len(cost)+1):
            if i <= 1:
                dp.append(0)
            else:
                dp.append(min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]))

        return dp[-1]

算法說明

算是陽春的 DP 問題，

主要目標：dp[i] = min(dp[i-2]+A[i-2], dp[i-1]+A[i-1])

初始目標:

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

input handling

如果沒有任何 cost，return 0

Boundary conditions

for 來控制範圍

Reference

最少费用的爬台阶方法 · Min Cost Climbing Stairs

【Leetcode】python - [198] House Robber 個人解法筆記

Sat, 21 May 2022 20:07:46 +0800

題目出處

198. House Robber

難度

Medium

題目分類

Array, Dynamic Programming

2022-05-21 一刷

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

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

        dp = []
        for i in range(len(nums)):
            if i == 0:
                dp.append(nums[0])
            elif i == 1:
                dp.append(max(nums[0], nums[1]))
            else:
                dp.append(max(dp[i-1], dp[i-2] + nums[i]))

        # print(dp)
        return dp[-1]

算法說明

算是陽春的 DP 問題，

主要目標：dp[i] = max(dp[i-2]+A[i], dp[i-1])

初始目標:

dp[0] = A[0]
dp[1] = max(A[0], A[1])

input handling

處理 input 沒有房子與 input 只有一棟房子的情況

沒有房子，return 0
只有一棟房子，return 那一棟房子

Boundary conditions

for 來控制範圍

Reference

打劫房屋 · House Robber

【Leetcode】python - [213] House Robber II 個人解法筆記

Sat, 21 May 2022 20:02:21 +0800

題目出處

213. House Robber II

難度

Medium

題目分類

Array, Dynamic Programming

2022-05-21 一刷

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

class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums) == 1:
            return nums[0]

        dp_no_first = [0, nums[1]]
        dp_contains_first = [nums[0], max(nums[0], nums[1])]

        return max(self.get_max_rob(nums, dp_no_first), self.get_max_rob(nums[:-1], dp_contains_first)) 

    def get_max_rob(self, nums, dp):
        for i in range(2, len(nums)):
            dp.append(max(dp[i-2] + nums[i], dp[i-1]))

        return dp[-1]

算法說明

這題的前一題為沒有循環房子的版本，可參考：

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

相比上一題，這一題因為房子的排列會變成一個圈，因此我們把頭尾的關係分為兩段來考慮，

不包含 0，一路算到 n
包含 0，一路算到 n-1

input handling

處理 input 沒有房子與 input 只有一棟房子的情況

沒有房子，return 0
只有一棟房子，return 那一棟房子

Boundary conditions

for 來控制範圍

Reference

打劫房屋 II · House Robber II

【Leetcode】python - [435] Non-overlapping Intervals 個人解法筆記

Thu, 19 May 2022 16:01:48 +0800

題目出處

435. Non-overlapping Intervals

難度

Medium

題目分類

Array, Dynamic Programming, Greedy, Sorting

2022-05-19 一刷

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

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        intervals.sort(key = lambda x: x[1])

        cnt = 0
        end = float("-inf")

        for i, interval in enumerate(intervals):
            if interval[0] >= end:
                end = interval[1] # update end
            else:
                cnt += 1

        return cnt

算法說明

這題我們使用的是 greedy 的作法，

我們先依照 end 來排序，
依據 greedy 的策略，我們把初始 end 設定為 -inf，

正常情況：如果每一次 start >= 前一個 end (表示無重疊)，且因為我們已經先將 end 排序，因此可以視為得到所有以 end 開頭的區間。
異常情況：start 比前一個 end 小，表示重疊了，此時我們 ans += 1，然後 continue 不理這一組 (視為會被刪掉的組合)

input handling

一同在 for loop 內處理。

Boundary conditions

用 for loop 控制範圍

Reference

无重叠区间 · Non-overlapping Intervals

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

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

題目出處

322. Coin Change

難度

Medium

題目分類

Array, Dynamic Programming, Breadth-First Search

2022-05-18 一刷

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

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

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

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

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

算法說明

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

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

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

input handling

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

Boundary conditions

用 for 來控制 DP 的範圍

Reference

换硬币 · Coin Change

【Leetcode】python - [42] Trapping Rain Water 個人解法筆記

Thu, 12 May 2022 14:08:29 +0800

題目出處

42. Trapping Rain Water

難度

hard

題目分類

Array, Two Pointers, Dynamic Programming, Stack, Monotonic Stack

2022-05-12 一刷

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

class Solution:
    def trap(self, height: List[int]) -> int:
        left, right = 0, len(height)-1
        max_left, max_right = height[left], height[right]
        water_contains = 0

        while(left < right):
            # print(left, right, water_contains)
            if max_left <= max_right:
                left += 1
                water_contains += self.is_positive(min(max_left, max_right) - height[left])  # current
                max_left = max(max_left, height[left])
            else:
                right -= 1
                water_contains += self.is_positive(min(max_left, max_right) - height[right]) # current
                max_right = max(max_right, height[right])

        return water_contains

    def is_positive(self, num):
        return num if num > 0 else 0

算法說明

考慮比較複雜的同向 two pointer 問題。
我們需要先推導出一個公式，
「當前水位 = min(左最高, 右最高) - 當前高度」

下圖的右邊，我們判斷左右高最矮的部分，可以計算當前「藍色最高為 1 」的水量 (必定，就算中間全空都會有)

你可能會考慮這樣的問題，問說左邊會怎麼算到 2，如果左邊真的能算到 2，那一定是從右邊一路過來，「有比 2 更高的事件發生 (下圖畫的不是很好，右側任意位置只要有出現比 2 更高的都可以!)」

否則，左邊最高會永遠維持 1，而不用擔心算錯最主要的原因是我們不會這麼早算這格，必須確定「1 or 2」才會算 (右側有比 2 高就確定了)

注意，處理時請注意負值

這裡要多注意一點，處理時，
因為我們是計算「min(left_max, right_max) - 當前高度」，因此很有可能會有計算到負值的可能。

這時候我們需要另外寫一個判斷式，專門處理 < 0 的情況，
可以用我上方的方法，或是使用以下方法，
都可以「保證最小是 0，如果 > 0 就是該值」

max(0, min(left_max, right_max))

input handling

Boundary conditions

透過 while(left < right): 處理

Reference

接雨水 · Trapping Rain Water

【Leetcode】python - [2267] Check if There Is a Valid Parentheses String Path 個人解法筆記 | 292nd LeetCode Weekly Contest (內含：Memoization 記憶化搜索筆記)

Tue, 10 May 2022 15:05:11 +0800

題目出處

2267. Check if There Is a Valid Parentheses String Path

難度

hard

題目分類

Array, Dynamic Programming, Matrix

2022-05-10 一刷

個人範例程式碼 - 純 DFS (會 TLE)

DIRECTIONS = [
    (1,0),
    (0,1)
]
class Solution:
    def hasValidPath(self, grid: List[List[str]]) -> bool:
        if not grid:
            return False

        return self.dfs(grid, 0, 0, set(), [])

    def dfs(self, grid, i, j, visited, queue):
        # print(i, j, visited, queue)
        # end of recursion
        if i <mark> len(grid)-1 and j </mark> len(grid[0])-1:
            if grid[i][j] <mark> ")" and queue and queue[-1] </mark> "(":
                return len(queue) == 1 # queue is empty
            else:
                return False # not ")" or queue[-1] not "(" 

        # define and split
        ans = False
        visited.add((i, j))
        for d_x, d_y in DIRECTIONS:
            if ans == True: # Find case, early return
                continue
            if self.is_valid(grid, i+d_x, j+d_y) and (i+d_x, j+d_y) not in visited:
                if grid[i][j] == "(":
                    queue.append("(") 
                    ans |= self.dfs(grid, i+d_x, j+d_y, visited, queue)
                    queue.pop(-1) # backtracking 
                else: # ")"
                    if not queue:
                        # return False, wrong: need remove
                        continue
                    else:
                        queue.pop(-1) # pop ")"
                        ans |= self.dfs(grid, i+d_x, j+d_y, visited, queue)
                        queue.append(")") # backtracking

        visited.remove((i, j))
        return ans

    def is_valid(self, grid, i, j):
        m, n = len(grid), len(grid[0])
        return 0 <= i < m and 0 <= j < n

算法說明

矩陣搜索，很直覺想到的就是使用 dfs 去搜尋，
不過速度上會不夠，我們需要優化一下

個人範例程式碼 - DFS + Memoization

class Solution:
    def hasValidPath(self, grid: List[List[str]]) -> bool:
        self.memo = {}
        return self.dfs(grid, 0, 0, 0)

    def dfs(self, grid, i, j, cnt):
        # end of recursion
        if i <mark> len(grid)-1 and j </mark> len(grid[0])-1 and grid[i][j] == ")":
            return cnt == 1

        if not self.is_valid(grid, i, j):
            return False
        if cnt < 0:
            return False

        # define
        if grid[i][j] == "(":
            cnt += 1
        else:
            cnt -= 1

        # split
        if (i, j, cnt) in self.memo:
            return self.memo[(i, j, cnt)]


        ans = self.dfs(grid, i+1, j, cnt) or self.dfs(grid, i, j+1, cnt)
        self.memo[(i, j, cnt)] = ans
        return ans


    def is_valid(self, grid, i, j):
        m, n = len(grid), len(grid[0])
        return 0 <= i < m and 0 <= j < n

算法說明

這個是在閱讀別人的解答後，自己重寫的解法，用 cnt 優化了 “()” 的 queue 判斷式，這個想法非常的漂亮。
另外這邊我也才注意到原題目要求的搜索方向固定只有「右」和「下」，
因此多方向的寫法其實也可以簡化得更漂亮。

判定條件

結束條件：

「i = len(grid)-1」 and 「j = len(grid[0])-1」判定結束位置在右下角
grid[i][j] = “)"，結束必須為 “)”
return cnt = 1 (我們也必須要知道的是，剩下個括弧數剛好等於 1，等於只剩「”("」)

終止條件:

當 cnt < 0 ，表示只有 “)"，retrun False
當不在範圍內時，return False

Memoization 筆記 (記憶化搜索)

Memoization 記憶化搜索是解決這個 TLE 的關鍵，
簡單來說就是我們把「重複性」且「已經解過的問題」，做解答的筆記。

如果說，DFS 是從起點往終點搜尋
Memoization，就是類似從終點往回看的過程紀錄 (類似 DP 概念)

以下面的圖片來說明，可能路線可能有非常多種，
但我們可以知道只要到「特定座標」，且「特定 cnt」，
就是一個重複性的題目，我們可以先把結果記錄下來。

下面看圖應該會更明顯，我們用兩種不同的路線都抵達了 (2, 2)，
而我們只需要計算第一次，之後就直接從 memo 找結果，不用再計算了。

你可能會想問，這樣我們怎麼省時間的?

上面我們是用 True 為舉例比較好懂，
但他更可以替我們省下大量的 False 的時間，
因為我們也能夠以同樣概念的做 (2, 2, 0) = False (我隨便舉例的，理論上不可能)
這樣我們第二次碰到 (2, 2, 0) 這題目時 (從不同路線抵達此處，也呈現同樣狀態)，
就可以不用再往下重搜了，直接回傳 False。

input handling

同 dfs 結束條件，一起在 dfs 內部處理

Boundary conditions

當上述終止條件或結束條件觸發時，return。

Reference

【Leetcode】python - [2266] Count Number of Texts 個人解法筆記 | 292nd LeetCode Weekly Contest

Tue, 10 May 2022 14:27:05 +0800

題目出處

2266. Count Number of Texts

難度

medium

題目分類

Hash Table, Math, String, Dynamic Programming

2022-05-10 一刷

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

MOD_NUM = pow(10, 9)+7
class Solution:
    def countTexts(self, pressedKeys: str) -> int:
        if not pressedKeys:
            return 0

        # cur = i = -1,  i-1=-2

        dp = [1] # init
        for i in range(len(pressedKeys)):
            dp.append(dp[-1]) # default append last, not same # dp[-1] + a
            if i > 0 and pressedKeys[i] == pressedKeys[i-1]:   # same 1+1
                dp[-1] += dp[-3] # dp[i-2] + b  
                if i > 1 and pressedKeys[i] == pressedKeys[i-2]:   # same 1+2
                    dp[-1] += dp[-4] # dp[i-3] + c
                    if i > 2 and pressedKeys[i] in ["7","9"] and pressedKeys[i] == pressedKeys[i-3]:   # same 1+3, only 79
                        dp[-1] += dp[-5] # dp[i-4] + d
            dp[-1] %= MOD_NUM

        # print(dp)
        return dp[-1]

算法說明

這題目的圖，是直接拿 leetcode 第 17 題的圖來用的嗎XDD

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

不同的是，這一題比較接近真實使用狀況，
而 17 題只是單純算組合而已。

思考上偏硬的題目，先注意到只有 7, 9 有4個文字需要處理。

我們可以知道:

新的下一個字母，都是由「之前全部組合 + 一個新字」
當新字為重複時，等同於「之"前前"全部組合 + 兩新字視為一個新字」
… 以此類推

改寫成程式碼變成：

新的下一個字母，都是由「之前全部組合 + 一個新字」

dp[i] = dp[i-1] # dp[i-1] + "a"

當新字為重複時，等同於「之前前全部組合 + 兩新字視為一個新字」

dp[i] += dp[i-2] # 加上新的可能性，前兩個組合 + 兩個字視為一個新字 (dp[i-2] + "b(aa)")

… 以此類推

(推導可從下圖觀察，過程比較亂一些)

input handling

如果沒有 input ，return 0

Boundary conditions

for loop 控制範圍

Reference

Python | DP with diagrams for beginners

【Leetcode】python - [221] Maximal Square 個人解法筆記

Wed, 04 May 2022 02:46:19 +0800

題目出處

221. Maximal Square

難度

medium

題目分類

Array, Dynamic Programming, Matrix

2022-05-04 一刷

個人範例程式碼 - BFS (會 TLE)

class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        if not matrix:
            return 0

        ans = 0
        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                if matrix[i][j] == "1":
                    ans = max(ans, self.bfs(matrix, i, j))

        return ans

    def bfs(self, matrix, start_i, start_j):
        edge = 1
        while(True):
            for i in range(start_i, start_i+edge):
                for j in range(start_j, start_j+edge):
                    # print(i, j)
                    if self.is_bounded(matrix, i, j) and matrix[i][j] == "1":
                        continue
                    else:
                        return (edge-1)**2
            edge += 1

    def is_bounded(self, matrix, i, j):
        m, n = len(matrix), len(matrix[0])

        return 0 <= i < m and 0 <= j < n

算法說明

BFS 應該是這題最直覺的解，不過會 TLE，需要再加速。

input handling

處理沒有 matrix 的情況，return 0

Boundary conditions

控制 for-loop 的範圍

個人範例程式碼 - DP

class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        if not matrix:
            return 0

        dp = [list(map(int, x)) for x in matrix] # deepcopy -> int

        for i in range(1, len(dp)):
            for j in range(1, len(dp[0])):
                dp[i][j] = self.get_max_square(dp, i, j)

        # print(dp)
        # print(max(max(x) for x in dp))
        return max(max(x) for x in dp)**2

    def get_max_square(self, dp, i, j):
        if dp[i][j] == 0:
            return 0

        # must be 1
        return min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1])+1

算法說明

概念參考自：

[Python] Thinking Process Diagrams - DP Approach

我們新建一個 dp，專門來記錄右下點的最大正方形「邊長」，

這個「邊長」，我們可以推出規律為：

如果該格是 0，就是 0 (連 1*1 正方形都不可能)
如果該格是 1，判斷 min([i-1][j-1], [i-1][j], [i][j-1]) + 1 ，即為此格，

意義為，如果任一格為 0，表示缺一角
如果情況為 1,2,2 也是，表示有缺一角，但仍滿足 2*2 的情況 = min(1,2,2)+1

input handling

處理沒有 matrix 的情況，return 0

Boundary conditions

控制 for-loop 的範圍

Reference

【Leetcode】python - [91] Decode Ways 個人解法筆記

Tue, 03 May 2022 03:20:40 +0800

題目出處

91. Decode Ways

難度

medium

題目分類

String, Dynamic Programming

2022-05-03 一刷

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

class Solution:
    def numDecodings(self, s: str) -> int:
        if not s:
            return 0

        if s[0] == "0":
            return 0

        # dp[i] = (dp[i-1], contain this word) + (dp[i-1], contain two word)
        dp = [1, 1]

        for i, c in enumerate(s):
            ans_contain_this_word = 0
            if self.is_valid(s[i]): # dp[i-1] + i, check if 0
                ans_contain_this_word += (dp[-1])

            if i > 0 and self.is_valid_2(s[i-1:i+1]): # dp[i-2] + i-1,i
                ans_contain_this_word += (dp[-2])

            dp.append(ans_contain_this_word)

        return dp[-1]

    def is_valid_2(self, s):
        if s[0] == 0:
            return False

        return 10 <= int(s) <= 26

    def is_valid(self, s):
        return 1 <= int(s) <= 9

算法說明

類似 fibonacci 數列的題目，這樣就是要用 dp 去解啦!

dp[i] = (dp[i-1], 現在數字) + (dp[i-2], 最後兩位數字)
dp[i-1] 我們去確認現在數字是否 1~9，排除 0
dp[i-2] 我們去確認是否兩位數字介於 10~26，排除 0 開頭與其他不符合規則的數字

input handling

處理沒有 s 或是「 s 以 0 為開頭的情況」， return 0

Boundary conditions

控制 for-loop 的範圍

Reference

解码方法 · Decode Ways

【Leetcode】python - [2262] Total Appeal of A String 個人解法筆記 | 291th LeetCode Weekly Contest

Tue, 03 May 2022 01:17:30 +0800

題目出處

2262. Total Appeal of A String

難度

hard

題目分類

Hash Table, String, Dynamic Programming

2022-05-03 一刷

個人範例程式碼 - dfs 解 (會 TLE)

class Solution:
    def appealSum(self, s: str) -> int:
        if not s:
            return 0

        self.ans = 0
        # decide start
        for i in range(len(s)):
            self.dfs(s, i, i, set()) # decide end

        return self.ans

    def dfs(self, s, start, end, wordset):
        # s[start:end+1] start~end
        # end of recursion
        if end >= len(s):
            return

        # define
        if s[end] in wordset:
            pass
        else:
            wordset.add(s[end])
        self.ans += len(wordset)

        # split
        self.dfs(s, start, end+1, wordset)

算法說明

dfs 解法本身概念是對的，如果這題目最終要的是全部結果的窮舉，那一定是用 dfs 去組。

而這題目只需要數數量，因此 dfs 雖然方向對了，但可以透過一些手段加速。

input handling

如果 input 是 “"，return 0 (題目沒有要求要處理)

Boundary conditions

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

個人範例程式碼 - DP 解

class Solution:
    def appealSum(self, s: str) -> int:
        # dp[i] = dp[i-1] + newword

        dp_contain_thisword = [0]
        worddict = {}

        for i, c in enumerate(s):
            if c not in worddict:
                dp_contain_thisword.append(dp_contain_thisword[-1] + i+1)
            else:
                dp_contain_thisword.append(dp_contain_thisword[-1] + i - worddict[c])
            worddict[c] = i

        # print(dp_contain_thisword)
        return sum(dp_contain_thisword)

算法說明

原作者的說明：

我們將原來的題目視作，dp[i] = dp[i-1] + i 的格式

也就是說

- 「包含此字的所有組合」=「包含前一個字的所有組合」+ 此字 - 而「全部組合」= 「包含此字的所有組合」總和

「包含此字的所有組合」=「包含前一個字的所有組合」+ 此字

正常情況，不重覆字就是「加上 idx+1」 (+1 是因為 0 開始)
有重複情況，我們可以視為，「重複之前的字母，都會少算 1 次」，因此需要多減去 prev[idx]

input handling

如果 input 是 “"，return 0 (題目沒有要求要處理)

Boundary conditions

控制 for loop

個人範例程式碼 - 歸納法解

class Solution:
    def appealSum(self, s: str) -> int:
        letter_contain_thisword = [] 
        # 1*5, 2*4, 3*3 = left_len(a,ab,abc) * right_len(c,cd,cde)
        # (a,ab,abc,abca) * (a, ab) = 4*2 -> (4-1)*2, since abca = bca (abca,bca,ca,a) = (bca,ca,a) 

        prev_idx = {}

        for i, c in enumerate(s):
            if c in prev_idx:
                letter_contain_thisword.append((i - prev_idx[c])*(len(s)-i))
            else:
                letter_contain_thisword.append((i + 1)*(len(s)-i))
            prev_idx[c] = i

        return sum(letter_contain_thisword)

算法說明

原作者的說明：

Combinatorics

這個思維的出發點是「計算包含此字母的 substring 共有幾個」

正常情況

我們計算的是「包含此字的所有 substring」，因此

abcde = 15 + 24 + 33 + 42 + 5*1

(a) * (a,ab,abc,abcd,abcde)
(ab,b) * (b,bc,bcd,bcde)
(abc,bc,c) * (c,cd,cde)

重複情況

我們計算的是「包含此字的所有 substring」，因此

abcab = 15 + 24 + 3*3 + (3-0)*2 + (4-1)*1

(abca,bca,ca,a)(a,ab)
(abcab,bcab,cab,ab,b)(b)

因為重複的關係，因此 (abca,bca,ca,a) = (bca,ca,a)，
只要是第一個 a 以前的都算在重複的範圍 (都要少算 1)，因此可以推得「i - prev[c]」

input handling

如果 input 是 “"，return 0 (題目沒有要求要處理)

Boundary conditions

控制 for loop

Reference

【Leetcode】python - [264] Ugly Number II 個人解法筆記

Sat, 30 Apr 2022 01:49:02 +0800

題目出處

264. Ugly Number II

難度

Medium

題目分類

Hash Table, Math, Dynamic Programming, Heap (Priority Queue)

2022-04-30 一刷

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

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        if not n:
            return -1

        visited = set([1])
        heap = [1]

        for _ in range(n):
            cur = heapq.heappop(heap)
            for factor in [2, 3, 5]:
                new = cur * factor
                if new not in visited:
                    visited.add(new)
                    heapq.heappush(heap, new)

        return cur

算法說明

這裡我們用 minheap 來解，因為要不斷的輸出最小，
透過 minheap 減少我們搜尋的時間。

input handling

如果 input 是 0，return -1 (題目沒有要求要處理)

Boundary conditions

for 迴圈控制數量

Reference

丑数 II · Ugly Number II

【Leetcode】python - [55] Jump Game 個人解法筆記

Thu, 28 Apr 2022 04:32:36 +0800

題目出處

55. Jump Game

難度

Medium

題目分類

Array, Dynamic Programming, Greedy

2022-04-28 一刷

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

一開始建了一個新的答案的 list

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        if len(nums) <= 1:
            return True

        max_can_reach_idx = [0 for _ in range(len(nums))]
        for i, num in enumerate(nums):
            if i == 0:
                max_can_reach_idx[0] = num+i
            if i > 0 and max_can_reach_idx[i-1] >= i:
                max_can_reach_idx[i] = max(max_can_reach_idx[i-1], num+i)

        return max_can_reach_idx[-1] > 0

後來發現可以簡化至單一個 max_idx 即可，並當發現不行時，提早 early return

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        max_idx = 0
        for i, num in enumerate(nums):
            if i > max_idx: # can not reach, first 0 > 0 
                return False
            max_idx = max(num+i, max_idx)

        return max_idx >= len(nums)-1 # 4 >= 5-1

算法說明

透過建立一個新的 list，我們紀錄

- 前一個 idx 最大可抵達的位置 - 相比前一個 idx 最大可抵達位置，看下一個位置是否能抵達，同時取 max(此位置能抵達的最遠, 上一個位置能抵達的最遠)

input handling

如果 input len <= 1，return True

Boundary conditions

後來優化的版本中，其實當發現 max_idx 已經到不了的時候，就已經可以 early return 了
第一個版本是一定會算完

Reference

1-6 lines, O(n) time, O(1) space

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

Sat, 23 Apr 2022 19:05:13 +0800

題目出處

139. Word Break

難度

medium

題目分類

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

2022-04-23 一刷

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

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

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

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

        # end of recursion
        if start > len(s):
            return False
        if start == len(s):
            return True

        # define and split
        ans = False
        for idx in range(start, len(s)):
            prefix = s[start:idx+1] # start to idx
            if prefix in word_dict:
                ans = ans or self.dfs(s, idx+1, word_dict) 
            else:
                continue

        # Memoization search
        self.memo[start] = ans        
        return ans

算法說明

這題可以先嘗試寫一個基本的版本，能夠通過大部分的 case，但是會 TLE

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

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

        return self.dfs(s, 0, wordDict)

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

        # end of recursion
        if start > len(s):
            return False
        if start == len(s):
            return True

        # define and split
        ans = False
        for idx in range(start, len(s)):
            prefix = s[start:idx+1] # start to idx
            if prefix in word_dict:
                ans = ans or self.dfs(s, idx+1, word_dict) 
            else:
                continue

        return ans

上面的方法基本沒有太大問題，只是速度太慢而已，此時我們可以用記憶化搜索的方式加速

記憶化搜索 memoization 加速

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

因此我們用一個 memo 紀錄一下，「從 start 開始往後」的結果，在之前的判斷中，答案為 True or False

input handling

當沒有 s 時，return False

Boundary conditions

搜尋至 start > len(s) 時，超過結果，為 False
搜尋至 start len(s) 時，剛好結束，為 True

Reference

单词拆分（一） · Word Break

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

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

題目出處

10. Regular Expression Matching

難度

hard

題目分類

String, Dynamic Programming, Recursion

2022-04-23 一刷

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

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

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

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

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

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

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

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

算法說明

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

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

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

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

判斷的先後順序

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

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

* 的處理

一樣也是分兩路

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

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

因此整理之後得到

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

結束條件

分成三種：

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

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

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

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

記憶化搜索 (DP)

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

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

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

拿取

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

儲存

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

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

input handling

Boundary conditions

見上述說明

Reference

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

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

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

題目出處

44. Wildcard Matching

難度

hard

題目分類

String, Dynamic Programming, Greedy, Recursion

2022-04-23 一刷

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

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

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

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

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

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

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

算法說明

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

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

記憶化搜索 (DP)

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

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

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

拿取

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

儲存

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

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

input handling

Boundary conditions

見上述說明

Reference

通配符匹配 · Wildcard Matching

【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 - [118] Pascal's Triangle 個人解法筆記 — sum of two list (list add 相加方法整理)

Thu, 03 Mar 2022 14:32:47 +0800

題目出處

118. Pascal’s Triangle

難度

easy

題目分類

Array, Dynamic Programming

2022-03-03 一刷

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

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        ans = [[1]]
        if numRows == 0:
            return [[]]
        else:
            layer = 1 # start from layer 2
            while layer < numRows:
                this_layer = self.generate_layer(ans[len(ans)-1]) 
                ans.append(this_layer)
                layer+=1

            return ans

    def generate_layer(self, last_layer):
        this_layer = []
        for idx, ele in enumerate(last_layer):
            if idx == 0:
                this_layer.append(1)
            else:
                this_layer.append(last_layer[idx-1]+last_layer[idx])
        this_layer.append(1)

        return this_layer

Time Complexity

O(n^2)

Space Complexity

O(n^2) = 剛好題目要求

算法說明

這題很直覺，我是直接用類似「dp(n) = dp(n-1) + k」的方式做出來的，
因為「上一層」與「下一層」有強烈的相關性。

算法簡單來說是：

先產生下層的第一位數字 1，
第二位開始，都是由上一層的 n-1, n 組成
最後補上一個 1

圖示如下

- 先產生 1

1 3 3 1
1

- 上一層 1+3, 3+3, 3+1 填入

1 3 3 1
1 4 6 4

- 補上最後一個1

1 3 3 1
1 4 6 4 1

corner case 特殊情況處理

雖然題目有說到「1 <= numRows <= 30」，
但我把 0, 1 的情形都考慮了進去

Boundary conditions/ Edge conditions 邊際情況處理

傳入上層 layer 時，我是以目前 ans 的 len 大小判斷，
上一層 layer 的「index 位置」會是「目前 len(ans) - 1」，
而不是「目前 len(ans) - 2」，因為目前這層尚未新增。

特殊酷解法

這是我在 leetcode 討論區看到的很酷的解法，
這邊紀錄一下

連結：

Python 4 lines short solution using map.

大概念就是，下一層的 layer 可以視為「上層補 0 與此反轉的總和」，
文字敘述太難懂了，不如我們直接看圖示。

  0 1 3 3 1
+ 1 3 3 1 0
= 1 4 6 4 1

一看圖示就懂了，真的太強了這個 Orz！！！

可以寫出來的程式碼也很簡潔：
(這邊保留註解的部分是留給我自己看的，下面會說明，實際上 2, 3 選一種即可)

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        ans = [[1]]
        for _ in range(numRows - 1): # we already have layer 1, do "numRows-1" times.
            tmp = ans[-1] + [0]
            # this_layer = tmp + tmp[::-1] # wrong! will be 1,0,0,1 
            # print(this_layer)

            this_layer2 = [x + y for x, y in zip(tmp, tmp[::-1])] # add reverse
            # print(this_layer2)

            # this_layer3 = list(map(lambda x, y: x+y, tmp, tmp[::-1])) # add reverse
            # print(this_layer3)           
            ans.append(this_layer2)

        return ans

這裡我們會碰到一個陷阱與問題，
就是 python 的 list 該如何相加？

python list add 加法 (sum of two list)

主要有兩種流派，map 流與 zip 流。
(官方文件寫 map 的方法)

這邊我先自己寫一次看看

zip 做 list sum

只需要注意 zip 出來的資料型態是 zip，
需要用 list 再轉一次格式。

可參考：

【Python】python zip 使用方法與其他寫法比較整理 (內含範例程式碼) sample code

a = [1,2]
b = [3,4]
sum =  [x + y for x,y in zip(a,b)]
print(sum)
# or you can use
sum2 =  list(x + y for x,y in zip(a,b))
print(sum2)

map 做 list sum

一樣，需要注意 map 出來的資料型態是 map，
需要用 list 再轉一次格式。

可參考：

【Python】python map 使用方法與其他寫法比較整理 (內含範例程式碼) sample code

a = [1,2]
b = [3,4]
sum =  list(map(lambda x, y: x + y,  a, b))
print(sum)

Reference

【Leetcode】C++ - [53] Contains Duplicate 個人解法筆記內含 C++ vector max 用法整理

Thu, 24 Feb 2022 22:58:52 +0800

題目出處

53. Maximum Subarray

難度

Easy

題目分類

Array, Divide and Conquer, Dynamic Programming

2022-02-24 一刷

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

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp;
        for(int i=0; i< nums.size(); i++){
            if(i == 0){
                dp.push_back(nums[i]); // record 'include me' biggest
            }
            else{
                dp.push_back((nums[i] > nums[i]+dp[i-1]) ? nums[i] : nums[i]+dp[i-1]); // record 'include me' biggest
            }
        }      
        auto it = std::max_element(dp.begin(), dp.end());  
        // std::vector<int>::iterator it;
        // cout << *it << endl;

        // int max_value = *std::max_element(dp.begin(), dp.end());
        // cout << max_value << endl;

        return *it;
    }
};

說明

這題我使用的是 DP 的解法，
我宣告一個 DP 來儲存「包含自己的」時最好的答案。

換句話說，我將題目拆解成到「包含每一個 index 的當下」都是一個小題目，將題目的答案儲存進 dp 中。

所以假設原來的題目變成：
nums = [1,2,-1,4]
dp = [1,3,2,6]

C++ vector max 用法整理

vector 想必是 C++ 最常被使用的資料型態了。
因此如何取 max 我們應該也要來好好記錄一下

以下方法基本上兩者大同小異，但因為 vector 需要透過 iterator 遍歷，
這邊就沒有像 python 那麼方便了。

vector 取 max 方法一 - iterator

基本上就是很標準的寫法，使用的是 std 裡面定義的 std::max_element，
會回傳位址，需要用 *it 取得該值。

vector<int> dp;
auto it = std::max_element(dp.begin(), dp.end());  
// std::vector<int>::iterator it;
cout << *it << endl;

vector 取 max 方法二 - 繞過 iterator 直接取值

我們直接將 max_element 取得的 iterator 直接取值，
(這也才是我們想要的)
就可以直接得到值了，不用另外宣告 iterator。

vector<int> dp;
int max_value = *std::max_element(dp.begin(), dp.end());
cout << max_value << endl;

Reference

【Leetcode】C++ - [91] Decode Ways 個人解法筆記 #medium #DP

Sun, 30 Jan 2022 18:19:13 +0800

題目出處

https://leetcode.com/problems/decode-ways/description/

難度

medium

題目分類

String, Dynamic Programming

2022-01-30 一刷

個人範例解法

class Solution {
public:
    int numDecodings(string s) {
        // dp
        int n = s.size();
        if(n <= 0){
            return 0;
        }
        vector<int> dp(n+1);
        dp[n] = 1; // ..... 1
        for(int i=n-1; i>=0 ; i--){
            if(s[i] == '0'){ // invalid case
                dp[i] = 0;
                continue;
            }  
            // default
            dp[i] = dp[i+1];

            // if special case
            int num = stoi(s.substr(i, 2)); // count 2
            // cout << num << endl;
            if( 10 <= num && num <= 26 ){
                dp[i] = dp[i+1] + dp[i+2];
            }
        }

        // for(int i=0; i<n+1; i++)
        //     cout << dp[i] << " ";
        return dp[0];
    }
}

解法重點

這題主要考的是 DP，需要先建立一張表。

以一般的 case 而言 (我們一個一個數，應該 dp[i] = dp[i+1])
特殊 case 的話，允許我們一次走兩格，所以答案會變成 dp[i] = dp[i+1] + dp[i+2]
如果碰到 0 開頭的子字串，表示為非法字串，dp[i] = 0

https://wongwongnotes.com/posts/cs-theory/algorithm-theory/algorithm/dynamic-programming/

Reference

Evolve from recursion to dp

【演算法筆記 #1】動態規劃 (Dynamic programming，DP)

Sun, 14 Feb 2021 02:07:07 +0800

前言

這是我自己理解後所做的演算法筆記。

動態規劃 (Dynamic programming，DP)

先備知識

討論動態規劃前，我們要先有 divide and conquer (將大問題化為多個小問題) 的觀念，
我們先將大問題化為多個小問題後，開始分析這些小問題裡面，
如何最佳化我們演算的效率。

觀念

動態規劃 (Dynamic programming，DP) 中，我們更著重在討論這些小問題 (或說子問題)，
怎麼樣去解決才能夠有最佳效率，我們會發現，在很多大問題化為的子問題中，
我們會碰到大量的「解決相同(重複)子問題」情況，造成演算效率變差。

例子

我們舉最經典的「費波納奇數列」為例：

f(0) = 0
f(1) = 1
f(x) = f(x-1) + f(x-2) (n >= 2)

未使用動態規劃解 f(5)

每一個箭頭，都表示我們要做一次加法，

使用動態規劃解 f(5)

我們先建立一個表格，當算出一次結果時，就保存在表中。

x	f(x)
0	0
1	1
2	1
3	2
4	3
5	5

於是透過查表產剩下面的結果：

每一個箭頭，都表示我們要做一次加法，
藍色箭頭表示我們因為已經算過一次 (並儲存答案在表中)，
所以我們直接查表找答案。

結論

雖然上面的例子看起來不會差太多，
那是因為我們舉的例子數字還小，

實際上的「時間複雜度」

未使用 DP: O(2^n) -> 約 2 的 n 次方
使用 DP: O(n)

這樣有沒有使用 DP 的差別就夠明顯了吧!