711 - LeetCode String on 嗡嗡的隨手筆記

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

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

題目出處

424. Longest Repeating Character Replacement

難度

medium

題目分類

Hash Table, String, Sliding Window

2026-07-23 二刷

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

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

        return max_window_size

算法說明

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

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

Time Complexity

O(n)

Space Complexity

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

Boundary conditions

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

2022-06-07 一刷

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

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

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

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

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

        return ans

算法說明

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

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

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

input handling

一同在 for 內處理

Boundary conditions

用 for 來控制範圍

Reference

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

【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 - [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 - [13] Roman to Integer 個人解法筆記

Sun, 12 Jun 2022 02:12:00 +0800

題目出處

13. Roman to Integer

難度

easy

題目分類

Hash Table, Math, String

2022-06-12 一刷

個人範例程式碼 - hashamp 與「照 Roman numerals 運算邏輯」推進

roman_table = {
    "I":1,
    "V":5,
    "X":10,
    "L":50,
    "C":100,
    "D":500,
    "M":1000
}

class Solution:
    def romanToInt(self, s: str) -> int:
        # "IV" 01
        ans = 0
        for i in range(len(s)-1, -1, -1):
            if i < len(s)-1 and roman_table[s[i]] < roman_table[s[i+1]]: # new i is smaller
                ans -= roman_table[s[i]]
            else:
                ans += roman_table[s[i]]

        return ans

算法說明

照 Roman numerals 的推算邏輯，我們從最小的位置開始往大的位置推進，
例外情況為：當「小位置的字母 > 大位置的字母」，我們改採減運算，

例如：

“IV”:4, I < V, 5 - 1
“XL”:40, X < L, 50 - 10

而正常情況為：

“VI”: 5 + 1
“LX”: 50 + 10

input handling

Boundary conditions

用 for 逆向控制範圍

個人範例程式碼 - 雙 hashamp

roman_table = {
    "I":1,
    "V":5,
    "X":10,
    "L":50,
    "C":100,
    "D":500,
    "M":1000
}

combination = {   
    "IV":4,
    "IX":9,
    "XL":40, 
    "XC":90, 
    "CD":400, 
    "CM":900  
}


class Solution:
    def romanToInt(self, s: str) -> int:
        ans = 0
        i = 0
        while i < len(s):
            if i+1 < len(s) and s[i:i+2] in combination:
                ans += combination[s[i:i+2]]                
                i += 2
            else:
                ans += roman_table[s[i]]
                i += 1

        return ans

算法說明

先搜尋兩個字，如果兩個字的組合存在，就拿到結果，
如果找不到兩個字，就去一個字的字典找。

input handling

Boundary conditions

用 while 控制範圍

Reference

罗马数字转整数 · Roman to Integer

【Leetcode】python - [572] Subtree of Another Tree 個人解法筆記

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

題目出處

572. Subtree of Another Tree

難度

easy

題目分類

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

2022-06-06 一刷

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

# Definition for a binary tree node.
# class TreeNode
# def __init__(self, val=0, left=None, right=None)
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
        # end of recursion
        if not root:
            return False

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

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

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

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

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

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

算法說明

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

input handling

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

Boundary conditions

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

Reference

另一个树的子树 · Subtree of Another Tree

【Leetcode】python - [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

【Lintcode】python - [659] Encode and Decode Strings 個人解法筆記

Mon, 06 Jun 2022 03:34:37 +0800

題目出處

659 · Encode and Decode Strings

難度

medium

題目分類

Array, String, Design

2022-06-06 一刷

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

class Solution:
    """
    @param: strs: a list of strings
    @return: encodes a list of strings to a single string.
    """
    def encode(self, strs):
        # write your code here
        return " ".join(strs)

    """
    @param: str: A string
    @return: dcodes a single string to a list of strings
    """
    def decode(self, str):
        # write your code here
        return str.split(" ")

算法說明

這題是應用的 design 類問題，
因為我們在傳輸數據時，大部分都沒有辦法直接傳遞「我們定義好的資料結構」，
通常我們都會先進行 encoding 把資料加密，例如把資料轉成文字化。

等待送達目的後，再對資料進行 decoding 解密，把文字化資料轉回「我們要的資料結構」，
而這題概念上大概就是要我們實作這樣的概念，方法有無限多種，
但以考題來說，這題應該是理解概念就好。

input handling

x (design 類問題)

Boundary conditions

x (design 類問題)

Reference

编码和解码字符串 · Encode and Decode Strings

【Leetcode】python - [205] Isomorphic Strings 個人解法筆記

Sat, 28 May 2022 19:43:42 +0800

題目出處

205. Isomorphic Strings

難度

easy

題目分類

Hash Table, String

2022-05-28 一刷

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

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        if not s or not t:
            return False

        if len(s) != len(t):
            return False

        s_to_t = {}
        t_to_s = {}

        for i in range(len(s)):
            if s[i] in s_to_t and t[i] in t_to_s:
                if s_to_t[s[i]] <mark> t[i] and t_to_s[t[i]] </mark> s[i]:
                    continue
                else:
                    return False
            else:
                if s[i] in s_to_t: # one side alraedy exist
                    return False

                if t[i] in t_to_s:
                    return False

                s_to_t[s[i]] = t[i]
                t_to_s[t[i]] = s[i]

        return True

算法說明

這題要注意的點就是「雙向配對」，因為如果只有單向配對時，有可能出現 “abcd” 也能 matching “ssss” 的情況。

(因為 hashmap 中存的東西，不論 a,b,c,d 都對應到 s)

input handling

處理 len(s) != len(t) 的情況，處理 s 或 t 不存在值的情況。

Boundary conditions

用 for 來控制範圍

Reference

字符同构 · Isomorphic Strings

【Leetcode】python - [2273] Find Resultant Array After Removing Anagrams 個人解法筆記 | 293rd LeetCode Weekly Contest

Wed, 18 May 2022 01:07:01 +0800

題目出處

2273. Find Resultant Array After Removing Anagrams

難度

easy

題目分類

Array, Hash Table, String, Sorting

2022-05-18 一刷

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

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

        i = 0
        last_word = ""
        while(i < len(words)):
            sort_word = "".join(sorted(words[i]))
            if sort_word == last_word:
                words.pop(i) # remove, and keep i
            else:
                last_word = sort_word
                i += 1 # go next

        return words

算法說明

讓我們先來理解題目，題目的意思簡單說就是，
我們將每個字都取 counter，如果前後 counter 相同，那我們就去把後面的刪除，

input handling

如果沒有 input words，return words

Boundary conditions

for loop 控制範圍

Reference

【Leetcode】python - [76] Minimum Window Substring 個人解法筆記

Sun, 15 May 2022 22:11:55 +0800

題目出處

76. Minimum Window Substring

難度

hard

題目分類

Hash Table, String, Sliding Window

2022-05-15 一刷

個人範例程式碼 - two pointer + sliding window

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        if not s:
            return s

        counter_t = Counter(t)

        ans = ""
        fast = 0
        queue = []
        valid_num = 0

        window_counter = defaultdict(int)
        for slow, c in enumerate(s):
            while fast < len(s) and not self.is_sub_counter(window_counter, counter_t): # correct: collections <= set(queue)
                # print(slow, fast, window_counter)
                window_counter[s[fast]] += 1
                queue.append(s[fast])
                fast += 1
            else: # window matches collection words
                if self.is_sub_counter(window_counter, counter_t):
                    ans = s[slow:fast] if ans == "" or len(s[slow:fast]) <= len(ans) else ans
            # remove start until set not match
            c = queue.pop(0)
            window_counter[c] -= 1

        return ans

    def is_sub_counter(self, counter_s, counter_t):
        # print(counter_s, counter_t)
        for key, value in counter_t.items():
            if key not in counter_s:
                return False
            if counter_s[key] < value: # "a", "aa" = 1 < 2, must >= 2
                return False
        return True

算法說明

這題最麻煩的部分是在 counter 跟 is sub counter 的關係，
如果這題單純只有設計成要找 set() 的樣子會簡單很多，

input handling

如果沒有 s，回傳 s

Boundary conditions

利用同向 two pointer: slow, fast 控制搜尋範圍。

fast：替我們決定 sliding window 的結束位置
slow：替我們決定 sliding window

個人範例程式碼 - two pointer + sliding window 優化版

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        if not s:
            return s

        counter_t = Counter(t)

        ans = ""
        fast = 0
        queue = []
        valid = 0

        window_counter = defaultdict(int)
        for slow, c in enumerate(s):
            # print(slow, fast, valid, window_counter, ans)
            while fast < len(s) and valid < len(t): # correct: collections <= set(queue)
                # print(slow, fast, valid, window_counter, ans)
                key = s[fast]
                if key in counter_t:  
                    window_counter[key] += 1
                    if window_counter[key] <= counter_t[key]:
                        valid += 1
                fast += 1
            else: # window matches collection words
                if valid == len(t):
                    ans = s[slow:fast] if ans == "" or len(s[slow:fast]) <= len(ans) else ans

            # remove start until set not match
            if c in counter_t:
                window_counter[c] -= 1
                if window_counter[c] < counter_t[c]:
                    valid -= 1

        return ans

算法說明

上面的作法其實沒什麼問題，速度慢的原因「最主要是在調用 is_sub_counter() 這個 function 太多次」，
然而，我們稍微計算一下就能知道，每次我們使用 is_sub_counter()，我們都需要花 O(N) 的時間去計算 (for counter_t)，
但這個動作其實是可以邊在我們 sliding window 的過程中順便記憶的，這樣就可以避免掉每一次重複的比對

def is_sub_counter(self, counter_s, counter_t):
    # print(counter_s, counter_t)
    for key, value in counter_t.items():
        if key not in counter_s:
            return False
        if counter_s[key] < value: # "a", "aa" = 1 < 2, must >= 2
            return False
    return True

因此在新的概念中，我們設計了一個數字 valid，
幫助我們記憶前面的 sliding window 中，現在有 valid 的數量，

我們在設計時比較兩個 counter 紀錄，只有在範圍比較小的時候紀錄有 valid，
而當「重複數字」我們不記在 valid，但 counter 仍要記錄，
「因為在 sliding 的過程中有可能會砍掉重複的，但依然保持 valid 」

input handling

如果沒有 s，回傳 s

Boundary conditions

利用同向 two pointer: slow, fast 控制搜尋範圍。

fast：替我們決定 sliding window 的結束位置
slow：替我們決定 sliding window

Reference

最小子串覆盖 · Minimum Window Substring

【Leetcode】python - [49] Group Anagrams 個人解法筆記

Thu, 12 May 2022 13:32:16 +0800

題目出處

49. Group Anagrams

難度

medium

題目分類

Array, Hash Table, String, Sorting

2022-05-12 一刷

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

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        str_dict = {}

        for each_str in strs:
            sorted_each_str = self.sort_alphabetical(each_str)
            if sorted_each_str not in str_dict:
                str_dict[sorted_each_str] = []        
            str_dict[sorted_each_str].append(each_str)

        ans = []
        for key, value in str_dict.items():
            ans.append(value)

        return ans

    def sort_alphabetical(self, s):
        return "".join(sorted(s))

另外，最後那段後來發現可以優化為一行表示，不用自己重跑一次 dict，使程式碼更為簡潔：

return list(str_dict.values())

算法說明

其實就是一個整理 set 的題目，原本想要直接用 set() 作為 key，
後來發現 key 不能使用 set 可惜了XD

變通一下，把 key 換成「排序後的字串」，就能夠發揮類似的效果了，
我們要的就是個統一的標準。

input handling

Boundary conditions

for 控制範圍

Reference

错位词分组 · Group Anagrams

【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 - [2264] Largest 3-Same-Digit Number in String 個人解法筆記 | 292nd LeetCode Weekly Contest

Tue, 10 May 2022 13:44:20 +0800

題目出處

2264. Largest 3-Same-Digit Number in String

難度

easy

題目分類

String

2022-05-10 一刷

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

class Solution:
    def largestGoodInteger(self, num: str) -> str:
        if not num or len(num) <= 2:
            return ""

        ans = -1
        for i, c in enumerate(num):
            if i <= len(num)-3 and num[i] <mark> num[i+1] and num[i] </mark> num[i+2]: # 012, 3 - 3 = 0
                ans = max(int(num[i:i+3]), ans)

        if ans == -1:
            return ""
        if ans == 0:
            return "000"
        return str(ans)

算法說明

這題就是要找連續三個數字，然後要最大，
簡單的字串處理，稍微小心細節處理即可。

我們用 int 紀錄文字，初始 -1

如果最後沒找到 (-1)，就回傳 ""
最後得到 0，回傳 “000” (轉 int 會消失)
其他回傳 str(對應數字)

input handling

如果 no input 或 input len <= 2，為不可能的 case，return ""

Boundary conditions

用 for 控制範圍

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 - [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 - [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 - [242] Valid Anagram 個人解法筆記

Thu, 28 Apr 2022 13:17:18 +0800

題目出處

242. Valid Anagram

難度

easy

題目分類

Hash Table, String, Sorting

2022-04-28 一刷

個人範例程式碼 - 2022/4/28 (與 2022/3/4 解法完全相同)

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        return Counter(s) == Counter(t)

Time Complexity

O(n)

Space Complexity

算法說明

這題目碰到 python Counter，一行再見… python 太強大了。

這題就是計算數量，看有沒有相等，相等就是 True，
而 python collection 內建的 Counter function，
快速幫我們把計算數量的 hash dictionary 完成了。

我們就不用再另外寫 hash table 做 count 的動作了。

corner case 特殊情況處理

Boundary conditions/ Edge conditions 邊際情況處理

Reference

【Leetcode】python - [3] Longest Substring Without Repeating Characters 個人解法筆記 (updated: 2022/4/27)

Wed, 27 Apr 2022 10:24:26 +0800

題目出處

https://leetcode.com/problems/longest-substring-without-repeating-characters/

難度

Medium

題目分類

Hash Table, String, Sliding Window

2022-04-27 二刷

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

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

        fast = 0
        window_element = set()
        max_length = 0
        for slow in range(len(s)):
            while fast < len(s) and s[fast] not in window_element:
                window_element.add(s[fast])
                max_length = max(max_length, len(window_element))
                fast += 1            
            window_element.remove(s[slow])

        return max_length

算法說明

使用 sliding window 的概念，我們需要使用同向的 pointer，
思路很簡單，我們透過建立一個 window_element，裡面代表著現在我們鎖定的元素範圍，

而兩個 pointer：

fast，走在前，不斷收集不重複元素
slow，走在後，當無法蒐集不重複元素時，開始邊移動，並移除 window 的元素

input handling

如果沒有 s，return 0

Boundary conditions

搜尋至 len(s) 的範圍，
兩個 pointer 用 for-loop, while 來判斷範圍

2021-03-31 一刷

個人解法筆記 - 2021/3/31

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

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

        if len(s) == 0:
            ans = 0
        else:
            ans = 0
            queue_list = []
            l = 0 # left pointer

            for r in range(len(s)): # s[r], get one new word
                # found duplicate in sliding window, remove until duplicate not found
                while s[r] in queue_list: 
                    queue_list.pop(0)
                    l += 1
                # not found or all duplicate removed, push new word s[r]
                queue_list.append(s[r]) 
                # update answer
                ans = max(ans, r-l+1)     
        return ans

sliding window

正如其名，移動的窗戶，也就是表示在 window 範圍內必須符合我們要的答案。

two pointers

我們建立兩個指標 l,r，
r 是正常的向前搜尋，
l 是當目前 l,r 所框出的 window 範圍出現不符合題目要求時，「反覆」移動 l 直到 window 符合題目要求。

示意圖：(r先跑，l依照條件變化而跑)

示意圖：(l依照條件變化而跑，為了符合條件)

我們可以發現當下長度 = (r-l) + 1

HashTable

示意圖：(用 Queue 來儲存已存在的 window 中的字)

在搜尋目前 window 是否符合條件時，我們需要建立一個 HashTable，幫助我們速查特定值是否存在表裡面，
我們建立的 HashTable 也需要達到 Queue 的功能 (因為隨著 l 的移動，會有先進先出的問題)，
我們可以看到，當 b 進來時，我們必須一直丟到 Queue 裡面沒有 b 為止，「才是正確的 window 」

Reference

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

Tue, 26 Apr 2022 16:18:50 +0800

題目出處

290. Word Pattern

難度

easy

題目分類

Hash Table, String

2022-04-26 一刷

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

class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:
        if not s:
            return True

        wordlist = s.split(" ")
        worddict = {}
        patterndict = {}

        if not len(wordlist) == len(pattern):
            return False

        for idx, each_pattern in enumerate(pattern):

            if each_pattern in patterndict:
                if not patterndict[each_pattern] == wordlist[idx]:
                    return False

            if wordlist[idx] in worddict:
                if not worddict[wordlist[idx]] == each_pattern:
                    return False
            patterndict[each_pattern] = wordlist[idx]
            worddict[wordlist[idx]] = each_pattern

        return True

算法說明

這題是考簡單的字串處理，但細節要注意很多，很難一次全對

確認同一 pattern 無重複配對 (word = a, b)

這個是要注意 word = a 且 word = b 要 return 為 False 的情況

確認同一 word 無重複配對 (word, code = a)

這個是要注意 word = a 且 code = a 要 return 為 False 的情況

確認本身長度不同的問題

這個是要注意 “aaa” 不等於 “aa aa”，等類似的狀況，需要多判斷長度是否相同。

input handling

如果沒有 s，return True

Boundary conditions

for loop 控制範圍

Reference

【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

【Leetcode】python - [208] Implement Trie (Prefix Tree) 個人解法筆記

Tue, 26 Apr 2022 03:48:14 +0800

題目出處

208. Implement Trie (Prefix Tree)

難度

medium

題目分類

Hash Table, String, Design, Trie

2022-04-26 一刷

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

class TrieNode:
    def __init__(self):
        self.children = {}
        self.hasword = False # only True if exist word, 
        # apple in dict, but app not in, False

class Trie:

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

    def insert(self, word: str) -> None:
        cur = self.root
        for c in word:
            if c not in cur.children:
                cur.children[c] = TrieNode()
            cur = cur.children[c]                
        cur.hasword = True

    def search(self, word: str) -> bool:
        cur  = self.root
        for c in word:
            if c not in cur.children:
                return False
            cur = cur.children[c]
        return cur.hasword


    def startsWith(self, prefix: str) -> bool:
        cur = self.root
        for c in prefix:
            if c not in cur.children:
                return False
            cur = cur.children[c]
        return True

# Your Trie object will be instantiated and called as such
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

算法說明

資料結構設計類型的題目，考的就是設計資料結構的能力，比較難。
這邊要實作的有三個功能，startsWith, search, insert，

我們先來了解 Trie (字典樹)

Trie (字典樹) 是用來特化搜尋「前綴文字 Prefix」用的資料結構，
特色就是我們把每個單字建成一個樹狀，而當我們搜尋一個前綴字時，能夠快速順著字典往下，

一個 TrieNode 會有，

childrens：紀錄往下的字母

hasword：到此本身是否有這個文字

特別注意 hasword 的功能，例如 apple 在字典中，
但沿著路徑我們會搜尋到 app，為了反映 app 這個字不屬於字典的字，
我們用 hasword 來記錄這個點。(apple 紀錄在 e 上，app 如果有，會記錄在最後一個 p 上。)

Trie (字典樹) 範例圖

input handling

Boundary conditions

注意搜尋的過程中，有時候可以有搜尋到路徑，但實際上沒有那個文字，所以我們會需要 hasword 這個 bool，
例如我們有 apple 在 Trie 中，
沿路會看到 app，但不表示搜尋到 app 就有 app 這個字。

Reference

实现 Trie（前缀树） · Implement Trie (Prefix Tree)

【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 - [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 - [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 - [763] Partition Labels 個人解法筆記

Fri, 22 Apr 2022 15:08:54 +0800

題目出處

763. Partition Labels

難度

medium

題目分類

Hash Table, Two Pointers, String, Greedy

2022-04-22 一刷

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

class Solution:
    def partitionLabels(self, s: str) -> List[int]:
        # partition need no word duplicate
        hashtable = self.set_hashtable(s)
        # print(hashtable)
        intervals = self.set_interval(hashtable)
        # print(intervals)
        intervals = self.merge_interval(intervals)
        # print(intervals)
        return [interval[1]-interval[0]+1 for interval in intervals] # 0~2 = 2-0+1

    def set_interval(self, hashtable):
        return [interval for interval in hashtable.values()]

    def merge_interval(self, intervals):
        ans = []

        for idx, interval in enumerate(intervals):
            if idx == 0:
                start = interval[0]
                end = interval[1]
            else:
                if end >= interval[0]:
                    end = max(interval[1], end)                    
                else: # no cross interval
                    ans.append([start, end])
                    start = interval[0]
                    end = interval[1]

        ans.append([start, end]) # last interval
        return ans

    def set_hashtable(self, s):
        hashtable = {}
        for idx, word in enumerate(s):
            if word not in hashtable:
                hashtable[word] = [idx, idx]
            else:
                hashtable[word][1] = idx
        return hashtable

算法說明

這題是 interval 系列的變化題，我們可以建立一個 hashtable，
紀錄每一個單字的 [起始, 結束] 位置。

最後因為題目要求最大化 interval 數量，但需要盡量保持不重複數字
(這邊直接就當作同一個字母，「不能出現在不同區間啦！」題目敘述太繞了!)

因此，我們先用文字組出每一個區間，然後合併區間。就是一個這樣的題目了!

討論 interval 合併的策略

主要情況有兩種：

先固定好 start 的順序，
假設後進來的 [interval[0], interval[1]]

有要合併的條件： end >= interval[0]

而合併後，有分為兩種情況：

- interval[1] >= end：類似交錯的情況，合併區間變為 [start, interval[1]] - end >= interval[1]：類似包起來的情況，合併區間變為 [start, end]

以上的 1，2 又可以合併變為 [start, max(interval[1], end)]

input handling

Boundary conditions

見上述說明

Reference

https://www.facebook.com/groups/1451299754892511/posts/5171314816224301/

【Leetcode】python - [2243] Calculate Digit Sum of a String 個人解法筆記 | 289th LeetCode Weekly Contest

Sun, 17 Apr 2022 16:34:03 +0800

題目出處

2243. Calculate Digit Sum of a String

難度

easy

題目分類

String, Simulation

2022-04-17 一刷

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

class Solution:
    def digitSum(self, s: str, k: int) -> str:
        # print(s)

        # end
        if len(s) <= k:
            return s

        # define
        end_string = ""
        start = 0
        while(start < len(s)):
            string_sum = self.get_string_sum(s[start:min(start+k, len(s))])
            end_string += string_sum
            start += k            

        # split
        return self.digitSum(end_string, k)

    def get_string_sum(self, s):
        start = 0
        string_sum = 0
        while(start <= len(s)-1):
            string_sum += int(s[start])
            start += 1

        return str(string_sum)

算法說明

- str -> int 三個一數，計算新的結果，最後處理結尾部分 - int -> str 開始下一串字的拼接

循環至長度 len(s) <= k 後結束。

input handling

處理 len(s) <= k 的情況，這裡我是直接回傳 s。

Boundary conditions

注意結束條件：

循環至長度 len(s) <= k 後結束。

Reference

✅✅C++ || Easy Solution || 0ms || Faster

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

Fri, 15 Apr 2022 18:46:13 +0800

題目出處

127. Word Ladder

難度

hard

題目分類

Hash Table, String, Breadth-First Search

2022-04-15 一刷

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

class Solution:
    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
        if endWord not in wordList:
            return 0 # not in wordlist

        wordset = set(wordList)
        this_layer = [beginWord]
        visited = set([beginWord])
        distance = 0

        # BFS, thinking of layer
        while this_layer:
            distance += 1 # new bfs layer
            next_layer = []
            for each_word in this_layer:
                if each_word == endWord: # find ans
                    return distance

                for next_word in self.get_next_word(each_word, wordset):
                    if next_word in visited:
                        pass
                    else:
                        next_layer.append(next_word)
                        visited.add(next_word)

            this_layer = next_layer

        return 0 # not found

    def get_next_word(self, each_word, wordset): # find all possible case
        words = [] 
        for i, each_char in enumerate(each_word):
            left, right = each_word[:i], each_word[i+1:]
            for char in 'abcdefghijklmnopqrstuvwxyz':
                if each_word[i] == char:
                    continue
                else:
                    new_word = left + char + right
                    if new_word in wordset:
                        words.append(new_word)

        return words

算法說明

看似 string 其實是一個 Graph 的題目，透過 BFS 來分層遍歷，找到最淺能達到目標的點。

get_next_word

這裡我們使用的方式比較單純，可以採取的策略有：

從 wordList 去反推下一層可能的文字
直接拆字去推，再去 wordList 找

個人使用的是第二種方法。

注意：加速技巧

原本題目使用的 wordList 搜尋時間為：O(n)，
若改為 set, hashmap，時間可以壓縮至 O(1)

input handling

處理 input endWord 不在 wordList 的情況，輸出 0 。

Boundary conditions

迴圈結束於

找到目標
找不到目標，且沒有下一層 layer (全部都 visited)

Reference

【Leetcode】python - [680] Valid Palindrome II 個人解法筆記

Wed, 06 Apr 2022 20:17:11 +0800

題目出處

680. Valid Palindrome II

難度

easy

題目分類

Two Pointers, String, Greedy

2022-04-06 一刷

個人範例程式碼 - two pointers

class Solution:
    def validPalindrome(self, s: str) -> bool:
        start, end = 0, len(s) - 1 
        while(start < end):
            if(s[start] == s[end]): # same
                start += 1
                end -= 1
            else: # not same, try cut one
                return self.is_palindrome(s, start+1, end) or self.is_palindrome(s, start, end-1) 

        return True

    def is_palindrome(self, s, start, end):
        while(start < end):
            if (s[start] == s[end]):
                start += 1
                end -= 1
            else:
                return False
        return True

算法說明

這題可以用比較聰明的作法，
我們既然都知道我們會需要「多次判斷」是否是「回文」，

我們可以先寫好判斷回文的 function 「is_palindrome」，
讓我們的主程式可以多次的去 call。

而刪除的概念可以理解為，如果我們找到兩端各一個「非相同的文字」，
我們就嘗試「左邊」與「右邊」都去掉嘗試判斷看看，
因為只要判斷一次刪除，因此如果回傳都沒有解，即為最終無解的情況。

input handling

處理沒有 input 的狀況，內建 start < end 條件可以處理

Boundary conditions

start < end，交錯或等於就結束

Reference

有效回文 II · Valid Palindrome II

【Leetcode】python - [409] Longest Palindrome 個人解法筆記

Wed, 30 Mar 2022 21:36:02 +0800

題目出處

409. Longest Palindrome

難度

easy

題目分類

Hash Table, String, Greedy

2022-03-30 一刷

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

class Solution:
    def longestPalindrome(self, s: str) -> int:
        if not s: # input handling
            return 0

        ans = 0
        contains_odd = 0
        word_counter = self.counter(s) # 直接使用等同於 collections.Counter(s)，就不用另外自己寫 counter
        for key, value in word_counter.items():
            if value % 2 == 0:
                ans += value
            else:
                ans = ans + value - 1
                if contains_odd:
                    pass
                else:
                    contains_odd = 1

        return ans + contains_odd

    def counter(self, s):
        counter = {}
        for char in s:
            if char not in counter:
                counter[char] = 1
            else:
                counter[char] += 1

        return counter

算法說明

原本想要直接用 counter 把這題爆出來，後來發現 Lintcode 似乎沒有內建這種東西，我就自己重寫了一個

另外要注意的事情：

當偶數的時候，直接加上去
當奇數的時候，-1後加上去，並保留最多一個中心點。

input handling

注意沒有輸入的時候的處理，input 為空白的時候 return 個 0 給他

Boundary conditions

我們這題沒辦法，「一定要把每個元素都看過」，至少 O(n)，

Reference

【Leetcode】python - [125] Valid Palindrome 個人解法筆記 | 內含 python isalpha(), isalnum() 的整理

Tue, 29 Mar 2022 13:35:55 +0800

題目出處

125. Valid Palindrome

難度

easy

題目分類

Two Pointers, String

2022-03-29 一刷

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

class Solution:
    def isPalindrome(self, s: str) -> bool:

        if not s: # input handling, include " "
            return True

        left = 0
        right = len(s)-1 
        s = s.lower()

        while(left < right):
            if not s[left].isalnum():
                left += 1
            elif not s[right].isalnum():
                right -= 1            
            elif s[left] == s[right]:
                left += 1
                right -= 1
            else:
                return False

        return True

算法說明

使用 two pointer 前後對照，並使用 isalnum() 排除非字母的內容。

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

補充 isalpha(), isalnum()

因為本題敘述中提到 removing all non-alphanumeric characters，因此需要保留「alpha 與 numeric」，
不能只判斷 “字母” 使用 isalpha()。

參考資料：

input handling

注意沒有輸入的時候的處理，另外同時處理 input 為 " " 的情況，
答案皆為 True (沒有就是 True)

Boundary conditions

搜尋範圍為 left < right 區間，此外我們來討論是否需要考慮 left right 的情況

這邊假設都是一堆特殊符號跟 c，

如果判斷等於，
則奇數 cc (自己等於自己) 會多判一次，不影響結果
偶數 cc 本來就應該要判斷的，也不影響結果。

因此本題寫 left < right 或 left <= right，都能得到正確答案。

Reference

【Leetcode】python - [28] Implement strStr() 個人解法筆記 | 內含 python None 的整理

Tue, 29 Mar 2022 12:59:31 +0800

題目出處

28. Implement strStr()

難度

easy

題目分類

Two Pointers, String, String Matching

2022-03-29 一刷

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

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        if haystack <mark> None or needle </mark> None: # input handling
            return -1

        for i in range(len(haystack)-len(needle)+1): # bounding, O(n)
            if (self.compare_strstr(haystack[i:i+len(needle)], needle)):
                return i

        return -1

    def compare_strstr(self, part_of_haystack, needle): # O(m)
        return part_of_haystack == needle

算法說明

字串比對字串，很簡單的處理

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

input handling

注意沒有輸入的時候的處理，
這裡要特別小心，「if not X」，會因為在Python中，None、False、0、""(空字符串)、、()(空元組)、{}(空字典) 都相當於 False 而出錯，
我們需要特別抓出「None」來判斷，因此我們必須要寫

if haystack <mark> None or needle </mark> None: # input handling

而不能寫

if not haystack or not needle:

Boundary conditions

本題最小的搜尋範圍為 len(source) - len(target)，
而因為 range 的語法關係，有 upper bounding 需要 +1

因此範圍為「for i in range(len(haystack)-len(needle)+1): # bounding, O(n)」

補充 - 此題最佳算法為 KMP 演算法 O(n)

我上述舉的例子為 O(mn)，但這題的最佳作法為 KMP 演算法，
但由於目前階段還沒有想要鑽研特定項目到太深，這個特殊作法日後再來補

可參考：O(m+n) and O(mn) solutions

Reference

【Leetcode】python - [20] Valid Parentheses 個人解法筆記內含用 python List 組出 Stack, Queue 的方法整理

Sun, 06 Mar 2022 21:30:19 +0800

題目出處

20. Valid Parentheses

難度

easy

題目分類

String, Stack

2022-03-06 一刷

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

我們先宣告一個字典，我們可以藉由字典查出對應的括弧。

class Solution:
    def isValid(self, s: str) -> bool:
        checkdict = {
            "(":")",
            "[":"]",
            "{":"}",

        }
        stack = [] # append <-> pop(-1) #FILO Last out!!!
        for ele in s:
            if ele in checkdict.keys():
                stack.append(checkdict[ele])
            elif not len(stack)<mark>0 and stack.pop(-1) </mark> ele:
                pass
            else:
                return False

        return len(stack)==0

Time Complexity

O(n)

Space Complexity

O(1)

算法說明

這題是非常經典的 Stack 考題

基本上我們就用一個 list 來當作 Stack 儲存，
python 裡面，撇除直接使用 package，
我們可以使用 append 與 pop 的組合，用 list 拼湊出 Queue 與 Stack

可參考：【Python】python list 清除, 移除內容元素 remove, pop, del, clear相關用法整理 sample code (內含範例程式碼)

用 List 拼出 Queue

Queue 可以由 list append + pop(0) 組合而成

用 List 拼出 Stack

Stack 可由 list append + pop(-1) 組合而成

corner case 特殊情況處理

注意：就算符合中間「運算時」的規則，結束時也必須為空

Boundary conditions/ Edge conditions 邊際情況處理

Reference

Simple Python solution with stack

【Leetcode】python - [387] First Unique Character in a String 個人解法筆記

Sat, 05 Mar 2022 18:21:11 +0800

題目出處

387. First Unique Character in a String

難度

easy

題目分類

Hash Table, String, Queue, Counting

2022-03-05 一刷

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

class Solution:
    def firstUniqChar(self, s: str) -> int:
        worddict = Counter(s)
        for idx, ele in enumerate(s):
            if worddict[ele] >= 2: # has duplicate
                pass
            else:  # no duplicate
                return idx

        return -1

Time Complexity

O(n)

Space Complexity

算法說明

透過 Counter 快速完成計算數量，
只要 Counter 計算出數量大於 2 的結果，
直接回傳最早的答案。

corner case 特殊情況處理

Boundary conditions/ Edge conditions 邊際情況處理

沒有答案時，要回傳 -1

Reference

【Leetcode】python - [383] Ransom Note 個人解法筆記

Fri, 04 Mar 2022 23:10:50 +0800

題目出處

383. Ransom Note

難度

easy

題目分類

Hash Table, String, Counting

2022-03-04 一刷

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

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        ran_dict = Counter(ransomNote)
        mag_dict = Counter(magazine)

        for idx, ele in enumerate(ran_dict.keys()):
            if ele not in mag_dict:
                return False # not found
            elif ran_dict[ele] > mag_dict[ele]:
                return False # not enough
            else:
                pass
        return True

Time Complexity

O(n)

Space Complexity

算法說明

這題本身不難，還可以體驗一下 python Counter 的強大之處。

練習一下 string 怎麼 parse，for char in string，
即可「一個一個 char」的把「string」內容一個一個字提取出來。

此外，python collection 內建的 Counter function，
快速幫我們把計算數量的 hash dictionary 完成了。

我們就不用再另外寫 hash table 做 count 的動作了。

corner case 特殊情況處理

處理「不存在」值的情況
處理「不足夠」值的情況

Boundary conditions/ Edge conditions 邊際情況處理

Reference

【Leetcode】python - [2186] Minimum Number of Steps to Make Two Strings Anagram II 個人解法筆記

Wed, 02 Mar 2022 12:06:40 +0800

題目出處

weekly-contest-282

2186. Minimum Number of Steps to Make Two Strings Anagram II

難度

Medium

題目分類

Hash Table, String, Counting

2022-03-02 一刷

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

class Solution:
    def minSteps(self, s: str, t: str) -> int:
        ans = len(s) + len(t)
        for same_word in (set(s) & set(t)):
            ans -= min(Counter(s)[same_word], Counter(t)[same_word])*2 # two side skip step

        return ans

Time Complexity

O(n)

算法說明

最大步數為 len(s) + len(t)，我們再去看要減少多少就好。
統計每個字元後，用 set 取「交集」，找出重複的字元數量

corner case 特殊情況處理

Boundary conditions/ Edge conditions 邊際情況處理

注意：因為兩組字母是雙向的減少步驟，因此在減少步數時「需要*2」

Reference

【Python】python counter() 用法整理 – 快速計算資料內容的數量

【Leetcode】python - [2185] Counting Words With a Given Prefix 個人解法筆記

Mon, 28 Feb 2022 20:05:47 +0800

題目出處

weekly-contest-282

2185. Counting Words With a Given Prefix

難度

Easy

題目分類

Array, String, String Matching

2022-02-28 一刷

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

class Solution:
    def prefixCount(self, words: List[str], pref: str) -> int:
        pref_length = len(pref)
        ans_cnt = 0
        for ele in words:
            if len(ele) < pref_length:
                continue
            else:
                if self.compare_str(ele[0: pref_length], pref):
                    ans_cnt += 1
                else:
                    pass
        return ans_cnt

    def compare_str(self, word_pref: str, pref: str) -> bool:
        return (word_pref == pref)

Time Complexity

O(n)

算法說明

沒什麼，就取子字串直接比較

corner case 特殊情況處理

Boundary conditions/ Edge conditions 邊際情況處理

python 子字串長度

str[0:n] 取得範圍為 str 的 index 0 到 index n-1(包含)

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