717 - LeetCode Hash Table on 嗡嗡的隨手筆記

【Leetcode】python - [238] Product of Array Except Self 個人解法筆記

Fri, 24 Jul 2026 16:47:45 +0800

題目出處

238. Product of Array Except Self

難度

medium

題目分類

Array, Prefix Sum

2026-07-24 二刷

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

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        ans = [1] * len(nums)
        
        # forward
        prefix = 1
        for i in range(len(nums)):
            ans[i] *= prefix
            prefix *= nums[i]

        # backward
        suffix = 1
        for i in range(len(nums)-1, -1, -1):
            ans[i] *= suffix
            suffix *= nums[i]

        return ans

算法說明

藉由兩個 prefix, suffix 的 forward, backward 進行 array 掃過，
並用計算順序的時間差，可以先避開乘積，儲存答案。

Time Complexity

O(n)

Space Complexity

O(1) 只有使用兩個變數 prefix, suffix 協助解題

Boundary conditions

先後順序很重要，先處理 ans 避免污染，
當 ans 已經先處理好（避開乘積），就可以更新 prefix, suffix

2022-06-04 一刷

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

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

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

        prefix_product = 1
        for i in range(len(nums)):
            result[i] *= prefix_product # first *= 1
            prefix_product *= nums[i]                        

        postfix_product = 1
        for i in range(len(nums)-1, -1, -1):
            result[i] *= postfix_product # first *= 1
            postfix_product *= nums[i]   

        return result

算法說明

這題要 O(n^2) 時間做出來非常容易，但題目先是希望要求 O(n) 時間算完，
既然都要求這樣的時間，我們勢必要做一些特殊的處理。

這裡我們用到類似 prefixSum 的概念 (我們用的是 prefixProduct)
因為仔細觀察，我們會發現答案就等於「前面積*後面積」，而數字分布是「前面積、(該數字)、後面積」，
因此我們可以簡單的用一個數字紀錄答案。

input handling

如果沒有 nums, 回傳 [] (題目沒特別要求)

Boundary conditions

用兩次 for 迴圈控制範圍

Reference

数组除了自身的乘积 · Product of Array Except Self

【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】python - [1] Two Sum 個人解法筆記 | 內有 list comprehesion / dict comprehesion 整理

Thu, 16 Jul 2026 15:56:50 +0800

題目出處

https://leetcode.com/problems/two-sum/

難度

Easy

題目分類

Array, Hash Table

2026-07-16 四刷

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

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        seen = {}
        for i, v in enumerate(nums):
            if v in seen:
                return [seen[v], i]
            seen[target-v] = i

        return [-1, -1]

算法說明

把「還缺的值 (target - v)」當 key 存進 seen，每輪檢查目前的 v 是否正好是先前某個數字還缺的另一半，是就用 seen 反查 index 直接回傳

Time Complexity

O(n)

Space Complexity

O(n)

2022-04-06 三刷

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

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        list_number_and_index = [(ele, idx) for idx, ele in enumerate(nums)]
        list_number_and_index.sort()

        start, end = 0, len(nums)-1   
        while(start < end):
            if list_number_and_index[start][0] + list_number_and_index[end][0] == target:
                return sorted([list_number_and_index[start][1], list_number_and_index[end][1]])
            elif list_number_and_index[start][0] + list_number_and_index[end][0] < target: # need bigger
                start += 1
            else: # nums[start] + nums[end] > target: # need smaller
                end -= 1
        else:
            return [-1, -1]

算法說明 - two pointers

這次使用 two pointers 的作法，這個做法的優點是可以比較下表，
基本上就是能節省掉 hashmap 的空間，取而代之的是比較多的時間

	hashmap	two pointers
空間複雜度	O(n)	O(1)
時間複雜度	O(1)	O(n), 但有前置步驟 sort = O(nlogN)

input handling

處理沒有結果的狀況 [-1, -1]

Boundary conditions

two pointers 循環條件 while(start < end)

補充：list comprehesion

list_number_and_index = [(ele, idx) for idx, ele in enumerate(numbers)]

補充：dict comprehesion

dict_number_to_index = {ele: idx for idx, ele in enumerate(numbers)}

2022-02-24 二刷

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

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        mydict = {}
        for idx in range(len(nums)):     
            # print(mydict.keys())       
            if nums[idx] in mydict.keys():
                return [mydict[nums[idx]], idx]
            else:
                mydict[target - nums[idx]] = idx

2021-03-16 一刷

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

class Solution:
    def twoSum(self, nums, target): # 2 7 11 15
        my_dict = {}
        for idx, ele in enumerate(nums):
            rest = target - ele
            if rest in my_dict:
                return [my_dict[rest], idx]
            else:
                my_dict[ele] = idx # record

解法 - HashTable

這題主要考的是 HashTable，
需要先建立一張表 (此處建立 dict)，
利用「key -> value」的特性保存「剩餘值對應 index」
因此當後續的計算，發現剩餘值存在 dict 的 key 中，
就能快速反查表得到 index。

示意圖

(將找不到 remain value 的值，作為 key 存進 dict 中)

Reference

两数之和 · Two Sum

dict comprehesion

Create a dictionary with list comprehension

【演算法筆記 #5】Hash 筆記，為什麼要使用 bash，與常見的密碼查詢驗證

Sun, 25 Dec 2022 01:23:56 +0800

前言

這篇是我個人的筆記，因此不會是完整的教學，
只紀錄個人認為重要的部分。

hash 的介紹與特性

我們在使用 hash 的時候，
主要在做的事情是把 Input 經過 hash function 運算之後得到一個 output，

可以表示為 input -> hash function -> output

hash 最重要的特性「不可逆」

hash 最重要的特性就是「不可逆」
我們在設計 hash function 時，要注意我們設計的 hash function 要有不可逆的特性，
這樣才符合 hash 的精神，
我們這裡簡單舉例怎麼設計不可逆的 hash function，但實際上設計只會更複雜。
這裡只為解釋「不可逆的特性」舉例。

例如，我們的密碼是 18，hash function 是 x mod 10，
因此透過計算我們會得到 8。

所謂不可逆的特性是指我們無法從 8 回推至 18，
稍微思考之後我們能知道，回推的可能有太多種，8、18、28 都是有可能的結果。

因此利用這個特性，我們可以設計一種密碼驗證機制，
「使我們可以在不儲存真實的密碼情況下，進行密碼驗證」

collision

講完上面的例子後，來講個題外話，
你可能會有疑惑，那如果猜密碼的人去猜 hash function 後的結果就好啦！
甚至還比原來的 18 更好猜，因為 8, 18, 28 都算對耶！！
這裡就會帶出一個新的概念，就是 hash 後的 collison (碰撞)，也代表著出現一樣結果的機率。

一個好的 hash function，發生 collison 的機率也必須要低，
例如我們可以透過增加 hash function output 的位元數，
把所有可能的密碼對應到，全部可能有 2^256 種結果，
不要小看這數字，「表示上」看起來很小，他可是「天文等級的數量級」，
有興趣的話，推薦閱讀這篇：加密貨幣世界裡最強大的數字：2 的 256 次方

而這個算法就可以提到超級有名的 hash 算法 SHA-256，
細節就先不在此文章多提了，有興趣可以自己去查詢。

而 SHA-256 發生 collision 的機率，雖然不為 0，
但那機率超級無限接近 0 … 不知道怎麼解釋好的數量級XDDD，
因此我們就幾乎可以直接假定這件事情不會發生！
(我是抓個感覺，比被雷劈到的機率更低? 比你所有認為發生機率超級低的事情，機率都還要更更低！)

有興趣的話一樣可以參考其他網友們的分享！

hash 在密碼上的應用

因為上述提到的不可逆特性，使得我們輸入的密碼，例如 password，
經過 hash function 後可能變成一個特殊值，

而 hash function 的另外一個特色是，不論我們進行多少次 hash function 計算，
「hash function 出來的結果必須要是一樣的」，也就是必須都能算出一樣的結果

而這樣我們就能安心的儲存密碼，因為就算駭客駭入主機拿得到密碼，
拿到的密碼也是永遠沒辦法被還原成原始的樣子。

而像我們作為使用者，只要我們每次輸入一樣的密碼，
透過 hash function 都會得到一樣的特殊值，進而比對密碼的正確性。

比較：加/解密與 hash 的不同

「加解密」：重點是可逆，可以還原出原始結果。
「Hash」：重點是不可逆，不能還原出原始結果，只用來單向計算，比對一致性。

Reference

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

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

題目出處

146. LRU Cache

難度

Medium

題目分類

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

2022-06-19 二刷

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

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

class LRUCache:

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


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


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

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

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

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

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


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



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

算法說明

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

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

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

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

input handling

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

Boundary conditions

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

2022-05-18 一刷

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

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

class LRUCache: # recently

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


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

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

        return value

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

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


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

算法說明

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

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

input handling

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

Boundary conditions

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

Reference

LRU缓存策略 · LRU Cache

【Leetcode】python - [846] Hand of Straights 個人解法筆記

Fri, 17 Jun 2022 16:21:35 +0800

題目出處

846. Hand of Straights

難度

medium

題目分類

Array, Hash Table, Greedy, Sorting

2022-06-17 一刷

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

class Solution:
    def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
        if not len(hand) % groupSize == 0:
            return False

        counter = Counter(hand)
        # print(counter.items())
        for key in sorted(counter.keys()):
            if counter[key] == 0:
                continue
            if counter[key] > 0:
                num_of_cards = counter[key]
                for delta_i in range(groupSize):
                    # print(key + delta_i)
                    counter[key + delta_i] -= num_of_cards
                    if counter[key + delta_i] < 0:
                        return False

        return True

算法說明

先處理不整除的狀況，直接 return False

如果是整除的情況，我們先進行排序，
從小的卡片開始，往後「扣除最小卡片的數量」，

搜尋卡片的過程中，我們順便判斷剩餘的卡片數量是否大於 0，
等於 0 表示沒有剩餘，我們採取 continue 的動作。

input handling

先處理不整除的狀況，直接 return False

Boundary conditions

用 for 控制搜尋範圍

Reference

一手顺子 · Hand of Straights

【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 - [202] Happy Number 個人解法筆記

Tue, 07 Jun 2022 19:29:12 +0800

題目出處

202. Happy Number

難度

easy

題目分類

Hash Table, Math, Two Pointers

2022-06-07 一刷

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

class Solution:
    def isHappy(self, n: int) -> bool:
        if not n:
            return False

        visited = set([n])
        while True:
            n = self.get_square_sum(n)
            if n == 1 or n in visited:
                break
            visited.add(n)

        return n == 1

    def get_square_sum(self, n):
        total_sum = 0
        for each_n in str(n):
            total_sum +=  int(each_n)**2

        return total_sum

算法說明

這題我覺得是題目還比較難懂… 簡單解釋一下，
一個數字能被稱作「Happy number」，
表示這個數字在「無限重複”把每一個單一數字平方並加總“的過程中，最終可以到達 1 這個數字」

舉例 - 成功的例子 (不斷的把每個單一數字平方並加總)

7 =>
49 =>
97 (16+81) =>
130 (81+49) =>
10 (1+9+0) =>
1 (發現答案，是 Happy number)

舉例 - 失敗的例子 (不斷的把每個單一數字平方並加總，會循環，永遠到不了 1)

2 =>
4 =>
16 =>
37 (1+36) =>
58 (9+49) =>
89 (25+64) =>
145 (64+81) =>
42 (1+16+25) =>
20 (16+4) =>
4 (開始循環，不是 Happy number)

input handling

如果沒有 n，return False

Boundary conditions

一直循環，直到發現重複的數字

Reference

快乐数 · Happy Number

【Leetcode】python - [496] Next Greater Element I 個人解法筆記

Mon, 06 Jun 2022 01:51:25 +0800

題目出處

496. Next Greater Element I

難度

easy

題目分類

Array, Hash Table, Stack, Monotonic Stack

2022-06-06 一刷

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

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:

        ans_hashtable = {}
        stack = []

        for num in nums2:
            while stack and stack[-1] < num: # new is greater
                ans_hashtable[stack[-1]] = num # last number's answer = this num
                del stack[-1]            
            stack.append(num)

        for rest_element in stack:
            ans_hashtable[rest_element] = -1

        return [ans_hashtable[num] for num in nums1]

算法說明

像這類有「找後續/前綴」中比較大或比較小的第一個數字，
我們通常會用 stack 來保存「等待被決定的內容」。

當我們發現「stack[-1]」<「新的數字」，表示找到答案，
我們 pop[-1] 出 stack，並記錄「 pop 的答案就是當前數字」。

最後剩下在 stack 的內容，答案都是 -1

input handling

如果沒有 nums, 回傳 [] (題目沒特別要求)

Boundary conditions

用 for 迴圈控制範圍

Reference

下一个更大的数 I · Next Greater Element I

【Leetcode】python - [128] Longest Consecutive Sequence 個人解法筆記

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

題目出處

128. Longest Consecutive Sequence

難度

medium

題目分類

Array, Hash Table, Union-Find

2022-05-30 一刷

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

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

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

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

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

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

        return current_max

算法說明

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

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

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

input handling

處理沒有 input 的情況，return 0

Boundary conditions

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

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

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

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

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

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

            current_max = max(current_max, cnt)

        return current_max

算法說明

滿特別的一個題目。

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

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

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

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

input handling

處理沒有 input 的情況，return 0

Boundary conditions

用 for 來控制範圍

Reference

【Leetcode】python - [105] Construct Binary Tree from Preorder and Inorder Traversal 個人解法筆記

Mon, 30 May 2022 03:40:04 +0800

題目出處

105. Construct Binary Tree from Preorder and Inorder Traversal

難度

medium

題目分類

Array, Hash Table, Divide and Conquer, Tree, Binary Tree

2022-05-30 一刷

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

# 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 buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if not preorder or not inorder:
            return None

        # preorder (M) L R
        # inorder L (M) R
        # use preorder get first node

        val = preorder[0] #  pre  [(3),9,20,15,7], [(20),15,7]
        root = TreeNode(val) 
        root_idx = inorder.index(val) # in [9,(3),15,20,7], [15,(20),7]]

        # preorder[1:root_idx+1] del first, inorder[:root_idx]) del idx
        root.left = self.buildTree(preorder[1:root_idx+1], inorder[0:root_idx]) 

        # preorder[root_idx+1:], inorder[root_idx+1:]) del idx
        root.right = self.buildTree(preorder[root_idx+1:], inorder[root_idx+1:])

        return root

算法說明

看似複雜的問題，其實我們可以從「拆成很多子問題下手」，

有上面的觀念之後，看來就是 recursion 的回合了！

我們決定好怎麼定義我們的左右子樹，

root.left 的部分

我們直接拿題目來分析，

preorder 我們先拿了第一個，作為我們的 root [(3),9,20,15,7]，
之後我們要去找，有多少東西在左樹內，
我們需要去 inorder 找所有 root 左側的內容，

root_idx = inorder.index(val) # inorder [9,(3),15,20,7]

因此我們知道左側的 inorder 範圍：
inorder[:root_idx])，我們刪除已經被我們當 root 的點，位於 idx

而左側的 preorder 範圍：
我們必須刪除第一個點，因為他是我們的 root，剩下的範圍會到 root，
(取範圍時要注意取到 idx+1，才會是到「包含」 idx 的範圍)，
因此，preorder 我們取 preorder[1:root_idx+1]

合併後得到 root.left = self.buildTree(preorder[1:root_idx+1], inorder[0:root_idx])

root.right 的部分

右側的部分稍微簡單一點，在上方取得 idx 後，我們後面的範圍都是 right 的範圍了。

一樣以題目來舉例：

preorder [(3),9,20,15,7]
inorder [9,(3),15,20,7]

inorder idx 3 以後的內容，都會是我們右子樹的內容，包含 preorder 範圍也是如此。

因此我們得到 root.right = self.buildTree(preorder[root_idx+1:], inorder[root_idx+1:])

input handling

處理沒有 input 的情況，return None
或是處理只有一個值的情況 [-1]，return [-1]

Boundary conditions

用 not list 來控制範圍，表示已經沒有內容物

Reference

前序遍历和中序遍历树构造二叉树 · Construct Binary Tree from Preorder and Inorder Traversal

【Leetcode】python - [73] Set Matrix Zeroes 個人解法筆記

Sun, 29 May 2022 20:50:12 +0800

題目出處

73. Set Matrix Zeroes

難度

medium

題目分類

Array, Hash Table, Matrix

2022-05-29 一刷

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

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        hash_column = set()
        hash_row = set()

        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                if matrix[i][j] == 0:
                    hash_column.add(i)
                    hash_row.add(j)

        for i in list(hash_column):
            for j in range(len(matrix[0])):
                 matrix[i][j] = 0

        for i in range(len(matrix)):
            for j in list(hash_row):
                 matrix[i][j] = 0

算法說明

用兩組 row, column 的 hashset 去儲存有 0 的 column, row，
最後再依照 hashset 裡面儲存的內容，更新矩陣內容為 0。

input handling

題目沒有特別要求

Boundary conditions

用兩層 for loop 來控制範圍

Reference

矩阵归零 · Set Matrix Zeroes

【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 - [217] Contains Duplicate 個人解法筆記

Wed, 18 May 2022 00:29:33 +0800

題目出處

217. Contains Duplicate

難度

Easy

題目分類

Array, Hash Table, Sorting

2022-05-18 三刷

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

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

        record = set()
        for num in nums:
            if num in record:
                return True
            else:
                record.add(num)

        return False

算法說明

找重複，有重複 return True

input handling

如果沒有 input，return False

Boundary conditions

for 迴圈控制範圍

2022-03-03 二刷

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

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        loopuptable = {}
        for ele in nums:
            if ele in loopuptable.keys():
                return True
            else:
                loopuptable[ele] = True

        return False

說明

dictionary search 的時間只需要 O(1)，
透過建立 dict 可以幫助我們快速查找已經出現的元素。

2022-02-24 一刷

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

class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        return (len(set(nums)) != len(nums))

說明

這題考的東西很簡單，就是找有沒有重複的東西，
「找重複」非常適合使用 set 來做，我們只需要比較 set 之後的大小是否等於原長度即可。

Reference

One line solution in python

【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 - [142] Linked List Cycle II 個人解法筆記 | 內含 python while-else 用法介紹

Thu, 12 May 2022 14:57:22 +0800

題目出處

142. Linked List Cycle II

難度

medium

題目分類

Hash Table, Linked List, Two Pointers

2022-05-12 一刷

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

# Definition for singly-linked list.
# class ListNode
# def __init__(self, x)
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return None

        slow = fast = head
        while(fast and fast.next):
            slow = slow.next
            fast = fast.next.next
            if fast == slow: # find loop
                break # out of while-else, no else
        else:
            return None

        while (head != slow):
            head = head.next
            slow = slow.next
        return head

算法說明

首先我們先找出是否有 loop，找到後我們在開始找迴圈的起點。

證明

假設迴圈的長度為 l
起點到迴圈入口的距離為 a
slow, fast 相遇處為 a+b (相距迴圈入口 b)

fast 走的距離，
= 可以是 a+l(走了一圈迴圈)+b
= 也等於 2*(a+b) = 兩倍的 slow 移動距離

這樣我們可以推得 a+l+b = 2*(a+b), 得到 l = a+b

我們現在想要求 a

a = l-b，注意圖上 l-b，也就是把相遇處剩下的路再繼續走完。

因此我們只要

從 head 走 a
從相遇處走 l-b

走到下一個相遇處就是我們要的 a。

input handling

如果沒有 head 或沒有 head.next，return None

Boundary conditions

透過 while(fast and fast.next) 控制搜尋範圍

python while-else 用法說明

一般來說，我們通常都只會使用到 while，
但其實在 python 中，while 是可以搭配 else 使用的。

邏輯如下：

while(條件成立):
    # 成立時循環
else: # 當不成立時，出現在這
    # 當條件不成立時，開始作這邊的事情

沒有錯!!!! 但是這個小細節，卻可以讓我們的程式碼邏輯更漂亮!

例如說當我們有無關 while 的相關內容，我們才應該擺在外面，
但有時候是剛結束迴圈時有一些收尾的相關內容要處理，這時候用 else 的寫法就相當漂亮了!

範例

假設我們要把一個 mylist 「純手動」印成 [1,2,3] 的樣子，
最後還要印出一個 finish!

mylist = [1,2,3]
idx = 0
print('[', end = '')
while(idx < len(mylist)):
    print(mylist[idx], ',')
    idx += 1
else:
    print(']')
print('finish!')

這個例子應該就很好懂了，我們集中「把要處理 list 列印的動作」放在 while-else 裡面，
最後比較無關的 finish! 放在 while-else 外面，
這樣看起來程式碼邏輯有沒有比都放在外面更清楚了呢? (當然，見仁見智啦XDDD，我覺得有XD)

特殊用法 - while-else 搭配 break 使用的情況

這也是我近期解題才發現的，當 while - else 搭配 break 使用時，能發揮更好閱讀的效果!

請讀者先想像一下，下面的程式碼會印出什麼呢?

while(True):
    break
else:
    print(1)
print(2)

這樣我們就能夠更進階的使用這個功能了，

「透過 while 迴圈條件結束的，寫在 else 裡面」
「如果是透過 break 結束的，寫在最外面」

Reference

【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 - [2260] Minimum Consecutive Cards to Pick Up 個人解法筆記 | 291th LeetCode Weekly Contest

Tue, 03 May 2022 02:16:03 +0800

題目出處

2260. Minimum Consecutive Cards to Pick Up

難度

medium

題目分類

Array, Hash Table, Sliding Window

2022-05-03 一刷

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

class Solution:
    def minimumCardPickup(self, cards: List[int]) -> int:
        visited = set()
        min_window = float("inf")
        slow, fast = 0, 0

        for fast, card in enumerate(cards):
            if card not in visited:
                visited.add(card)
            else:
                while card in visited:
                    visited.remove(cards[slow])
                    slow += 1
                visited.add(card)
                min_window = min(min_window, len(visited) + 1) # add duplicate                              

        return -1 if min_window == float("inf") else min_window

算法說明

用同向的 two pointers slow, fast 控制頭尾，
控制 sliding window 的移動

fast 往前走，slow 走在後，
發現有重複的項目時，slow 一直 pop 直到去掉重複

計算 window 大小時，計算 fast-slow+2 (+1 是範圍的關係，+1 是計算去掉的重複項)

input handling

如果沒有找到結果，回傳 -1
(沒有重複文字的 window)

Boundary conditions

控制 fast for-loop 的範圍

Reference

[Python] O(n) time & space, by using dict

【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

【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 - [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 - [2249] Count Lattice Points Inside a Circle 個人解法筆記 | 290th LeetCode Weekly Contest

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

題目出處

2249. Count Lattice Points Inside a Circle

難度

medium

題目分類

Array, Hash Table, Math, Geometry, Enumeration

2022-04-26 一刷

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

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

        return len(self.ans_set) 

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

算法說明

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

速度優化

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

優化前

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

優化後

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

錯誤的討論

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

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

input handling

如果沒有 nums，return nums

Boundary conditions

for loop 控制範圍

Reference

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

【Leetcode】python - [2248] Intersection of Multiple Arrays 個人解法筆記 | 290th LeetCode Weekly Contest

Tue, 26 Apr 2022 14:51:52 +0800

題目出處

2248. Intersection of Multiple Arrays

難度

easy

題目分類

Array, Hash Table, Sorting, Counting

2022-04-26 一刷

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

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

        ans = set(nums[0])
        for num in nums:
            ans &= set(num)
        return sorted(list(ans))

算法說明

原本以為是要用 priotity queue 或 pointer 解的題目，
後來發現題目沒有預先排序，那直接暴力解吧，
全部轉 set() 後直接取交集。

得到結果的 set() 之後，記得排序。

input handling

如果沒有 nums，return nums

Boundary conditions

for loop 控制範圍

Reference

[Python3] - 1 LINE Solution || Simple Explanation

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

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

題目出處

17. Letter Combinations of a Phone Number

難度

medium

題目分類

Hash Table, String, Backtracking

2022-04-26 一刷

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

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

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

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

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

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

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

算法說明

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

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

input handling

如果沒有 input，return []

Boundary conditions

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

Reference

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

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

題目出處

862 · Next Closest Time

難度

medium

題目分類

Hash Table, String, Backtracking, Enumeration

2022-04-26 一刷

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

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

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

算法說明

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

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

subset 用法

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

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

input handling

Boundary conditions

當符合結果時，return 結果

Reference

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

【Leetcode】python - [2244] Minimum Rounds to Complete All Tasks 個人解法筆記 | 289th LeetCode Weekly Contest

Sun, 17 Apr 2022 17:42:19 +0800

題目出處

2244. Minimum Rounds to Complete All Tasks

難度

medium

題目分類

Array, Hash Table, Greedy, Counting

2022-04-17 一刷

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

class Solution:
    def minimumRounds(self, tasks: List[int]) -> int:
        # 1: -1 round
        # 2: 1 round
        # 3: 2 rounds
        # 3k: k rounds
        # 3k+1: 4=3(k-1)+2+2, k+1 times
        # 3k+2: 5=3(1)+2, k+1 times
        counters = Counter(tasks)
        ans = 0
        for num_of_task in counters.values():
            if num_of_task <= 1:
                return -1
            else:
                # 3 = 1 
                # 4 = 2
                # 5 = 2
                # 6 = 2
                ans += (num_of_task+2)//3
        return ans

算法說明

這題考的是數學歸納法的概念，比較是數學的範圍

我們推論：

1: -1 round
2: 1 round
3: 2 rounds
3k: k rounds
3k+1: 4=3(k-1)+2+2, k+1 times
3k+2: 5=3(1)+2, k+1 times

而為了計算方便，我們可以做一些使計算上方便的技巧。

3 = 1
4 = 2
5 = 2
6 = 2

我們透過移動 k+2 使得 // 3 後能夠直接得到我們要的數字。

input handling

Boundary conditions

只要發現其中一個任務不可能執行完成，提早 return -1。

Reference

[Java/C++/Python] Sum up (freq + 2) / 3

【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 - [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 - [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 - [141] Linked List Cycle 個人解法筆記

Sat, 05 Mar 2022 13:04:23 +0800

題目出處

141. Linked List Cycle

難度

easy

題目分類

Hash Table, Linked List, Two Pointers

2022-03-05 一刷

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

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        slow = fast = head 
        # while slow.next and fast.next.next:  # check exist
        # while fast.next and fast.next.next:  # check exist
        while fast and fast.next:  # check exist
            slow = slow.next
            fast = fast.next.next
            if slow is fast: # has cycle
                return True
        return False # no cycle

Time Complexity

Space Complexity

算法說明

這題考 Linked List 的遍歷操作，
最麻煩的應該是邊界控制，這我們下面再提。

Floyd Cycle Detection Algorithm, Tortoise and Hare Algorithm (龜兔賽跑演算法)

演算法使用的是「Floyd Cycle Detection Algorithm, Tortoise and Hare Algorithm (龜兔賽跑演算法)」

或簡稱 Floyd Cycle 之類的，簡單來說就是當一個東西有環，
我們放一個跑比較快(step2)的兔子跟跑比較慢(step1)的烏龜，
兔子跟烏龜在有環的情況下，它們遲早會相會。

corner case 特殊情況處理

要處理沒有東西 [] 的情況… 被搞到

Boundary conditions/ Edge conditions 邊際情況處理

這題我犯了兩次錯誤，

第一次我寫 while slow.next and fast.next.next:

會跳錯，因為 slow 並不重要，fast 跑在前都會先檢查過了，
當會跳錯的地方在於「fast.next」不存在。

第二次我寫 while fast.next and fast.next.next:

還是錯，原因是這樣沒有處理到當「fast」不存在的情況。

第三次 while fast and fast.next 就是正確的了，

補充 - 系統思維加速 (面試題)

也可以用 hashset() 的方式來實作，hash pointer。

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

Fri, 04 Mar 2022 02:44:27 +0800

題目出處

36. Valid Sudoku

難度

Medium

題目分類

Array, Hash Table, Matrix

2022-03-04 一刷

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

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:

        # Each row must contain the digits 1-9 without repetition.
        for each_row in board:
            if self.checknums(each_row):
                pass
            else:
                return False # early return

        # Each column must contain the digits 1-9 without repetition.
        transpose_board = list(zip(*board)) # unpack list, then rezip by column
        for each_row in transpose_board:
            if self.checknums(each_row):
                pass
            else:
                return False # early return   

        # Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition.
        for y_idx in range(0, 9, 3):
            for x_idx in range(0, 9, 3): 
                collection = self.getsubbox(board, x_idx, y_idx)
                if self.checknums(collection):
                    pass
                else:
                    return False # early return

        return True

    def getsubbox(self, board, start_x ,start_y):
        collection = []
        for y_idx in range(3):
            for x_idx in range(3):
                collection.append(board[start_y+y_idx][start_x+x_idx])
        return collection

    def checknums(self, nums: List[str]) -> bool:
        keep = set()
        for ele in nums:
            if ele == ".":
                pass
            elif ele in keep:
                return False
            else:
                keep.add(ele)

        return True

Time Complexity

算法說明

這題，基本上就是條件多了一點，
要比較有耐心的處理，並且把指定的項目都拿出來，
除此之外難度不高。

我的算法基本上就依照題目敘述，
先建立一個檢查的函數，之後我們都以「9個位置為單位」傳入，
檢查出結果並回傳。

比較麻煩的大概是小的 sub-box，這裡要有點耐心處理。

幾個小細節可以注意：

「轉置矩陣」好用技巧：用「*」拆開 list後，再用「zip」重組。

簡單來說，想快速得到轉置矩陣(像這題我們為了把 column 拉出來)，
我們可以用「*」拆開 list後，再用「zip」重組。

a = [[1,2],[3,4]]
print(*a)  #  [1,2],[3,4] <- 拆開 list
print(list(zip(*a))) # [[1,3],[2,4]]  <- 拆開 list，zip 重組，從 zip 轉 list 格式

詳情可以看我的另外一篇：

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

early return：只要發現不合規則，即可以 return。

相對於此方法的就是建立一個 flag，過程中全檢查，最後才回傳這個 flag，但因為我們早知道結果，不需要全部組合都檢查才 return。

搜尋請用 set/ dict 而不要用 list：set/dict 的查找速度為 O(1)，list 為 O(n)。

一提再提的重點：只要有「找重複」的事情，幾乎必使用 set()

這題換句話說就是「找有沒有重複數字」，這部分應該會使用到 set。

corner case 特殊情況處理

Boundary conditions/ Edge conditions 邊際情況處理

討論區看到的一些酷解法 - 1

這個作者很聰明的，把在 sudoku 出現的每一個元素都弄成一個 set，
依據規則總共有三種：

Each row must contain the digits 1-9 without repetition. 單一元素建立 set (出現過的數字, y)

Each column must contain the digits 1-9 without repetition. 單一元素建立 set (x, 出現過的數字)

Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition. 單一元素建立 set (x//3, y//3, 出現過的數字)

可以參考：

1-7 lines Python, 4 solutions

範例程式碼

看完解答後我自己也照他的概念重寫了自己的，真的快又準確，好猛…

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:

        # Each row must contain the digits 1-9 without repetition.
        rule1_set = set()
        # Each column must contain the digits 1-9 without repetition.
        rule2_set = set()    
        # Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition.
        rule3_set = set()

        for y, each_row in enumerate(board):
            for x, ele in enumerate(each_row):
                if ele != '.': 
                    rule1_ele = (ele, y)
                    rule2_ele = (x, ele)
                    rule3_ele = (x//3, y//3, ele)

                    if rule1_ele in rule1_set:
                        return False
                    else:
                        rule1_set.add(rule1_ele)

                    if rule2_ele in rule2_set:
                        return False
                    else:
                        rule2_set.add(rule2_ele)

                    if rule3_ele in rule3_set:
                        return False
                    else:
                        rule3_set.add(rule3_ele)

        return True

corner case 特殊情況處理

注意要處理 “.”，不然會以為已經出現過了。

Boundary conditions/ Edge conditions 邊際情況處理

討論區看到的一些酷解法 - 2

與上面酷解法差不多，這邊只是想強調比對時，可以用

if len(list) == len(set(list)):
    # 兩者相等，表示 set 未刪去東西 (無重複項)
else:
    # 兩者不相等，表示 set 有刪去東西 (有重複項)

可以參考：

範例程式碼

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:

        # Each row must contain the digits 1-9 without repetition.
        rule1_list = []
        # Each column must contain the digits 1-9 without repetition.
        rule2_list = []   
        # Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition.
        rule3_list = []

        for y, each_row in enumerate(board):
            for x, ele in enumerate(each_row):
                if ele != '.':
                    rule1_ele = (ele, y)
                    rule2_ele = (x, ele)
                    rule3_ele = (x//3, y//3, ele)

                    rule1_list.append(rule1_ele)
                    rule2_list.append(rule2_ele)
                    rule3_list.append(rule3_ele)


        return len(set(rule1_list)) == len(rule1_list) and \
                len(set(rule2_list)) == len(rule2_list) and \
                len(set(rule3_list)) == len(rule3_list) # if no duplicate in list, will return True

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】C++ - [1] Two Sum 個人解法筆記 (內含 C++ map find 方法補充 (dict find)) #easy #Array #HashTable

Thu, 24 Feb 2022 23:03:30 +0800

題目出處

https://leetcode.com/problems/two-sum/

難度

easy

題目分類

Array, Hash Table

2022-02-24 二刷

個人範例解法 - 二刷 (2022/02/24)

第二次要順便複習一下如何找 map 的 keys 的方法
(python 寫太多都忘了)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int, int> mymap;
        vector<int> ans;
        for(int i=0; i < nums.size(); i++){
            if(mymap.find(nums[i]) != mymap.end()){ // found
                ans.push_back(mymap[nums[i]]);
                ans.push_back(i);
                return ans;
            }
            else{
                mymap[target - nums[i]] = i;
            }
        }
        return ans;      
    }
};

解法重點

這題主要考的是 DP，
需要先建立一張表
(此處利用 map<int,int>，建立 int -> int 對應的 dict)，
利用「key->value」的特性保存「值->index」
因此就能快速反查表得到 index

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

map find 的方法

被 python 寵壞的我，整個 dict find 了起來 Orz
來我們回到一下 C++ map 的世界。

根據 iterator 找到元素

既然是特殊的資料型態，我們自然要靠 iterator 來幫助我們遍歷一下，
思考的方式很簡單，iterator 會幫助我們一直看資料，

map<int, int> mymap;
if(mymap.find(nums[i]) != mymap.end()){ 
    // found
}
else{
    // not found
}

或不喜歡逆邏輯 (使用’不等於’符號) 的人，我們也可以正向的來

map<int, int> mymap;
if(mymap.find(nums[i]) == mymap.end()){ 
    // not found
}
else{
    // found
}

2021-10-18 一刷

個人範例解法 - 一刷 (2021/10/18)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {

        map<int,int> dict;
        map<int,int>::iterator iter;
        vector<int> ans;

        for (int i=0; i<nums.size();i++){

            iter = dict.find(target-nums[i]);
            // cout<<iter;
            // printf("(%d,%d)",iter->first,iter->second);
            if (iter != dict.end()){ // num found
                ans.push_back(iter->second); //nums find in dict (smaller)
                ans.push_back(i); // current index (bigger)                
                return ans;     
            }
            else{ //iter == dict.end(), not found
                dict[nums[i]]=i;    
            }
        }
        return ans;
    }
};

Reference

How to find if a given key exists in a C++ std::map

【Leetcode】C++ - [217] Contains Duplicate 個人解法筆記 — set / unordered_set 用法整理

Thu, 24 Feb 2022 03:37:54 +0800

題目出處

217. Contains Duplicate

難度

Easy

題目分類

Array, Hash Table, Sorting

2022-02-24 一刷

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

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        // unordered_set set
        // Hash table | RB-tree
        // (unordered) | (ordered)
        // insert and search fast O(1) | search fast only when data less
        // memory use more | memory use less
        //
        // set: ordered, print as ascend, need know n-1...
        // unordered: no-sort needed, single lookup, only insert, delete, search
        set<int> s(nums.begin(), nums.end());
        // for(auto it = s.begin(); it != s.end(); it++)
        //     cout << *it << endl;
        return nums.size() != s.size();
    }
};

說明

這題考的東西很簡單，就是找有沒有重複的東西，
「找重複」非常適合使用 set 來做，我們只需要比較 set 之後的大小是否等於原長度即可。

C++ set 用法整理

set, unordered_set 的差別

說到 C++ 的 set，我們可以先來比較 set, unordered_set 的差別，

	set	unordered_set
實現方式	RB-tree	Hash table
順序	ordered	unordered
速度	search fast only when data less	insert and search fast O(1)
空間使用	memory use less	memory use more
使用場合	ordered/ print as ascend(descend)/ need know realtion of n-1, n-2...	no-sort needed/ single lookup/ only insert, delete, search

vector 轉 set, vector to set

剛好此題目有需要 vector 轉 set，
我們這邊示範一下如何轉換這樣的資料結構。

而轉換的過程中，重複的部分會因為 set 的特性自然地消失，
因此在這題目中我們能夠自然地知道有沒有重複的內容。

vector<int> v;
set<int> s(v.begin(), v.end());
for(auto it = s.begin(); it != s.end(); it++)
    cout << *it << endl;

如何印 set, how to print set

如果我們使用一般的 for 迴圈，因為 set 不具有「順序性」
(這裡指的不是有沒有 unordered 的問題，而是資料結構本身)
我們沒有辦法用 index 的方式去呼叫，類似 set[0], set[1]…

因此我們會需要宣告一個 iterator 幫助我們遍歷這個資料結構!
以下示範剛好結合 vector 轉換 set 的內容：

vector<int> v;
set<int> s(v.begin(), v.end());
for(auto it = s.begin(); it != s.end(); it++)
    cout << *it << endl;

補充一個類似的 map, unordered_map

map 就類似 python 中的 dict (抱歉作者比較熟 python XDD)，
總之就是有「key-value」 pair 的資料結構

	map	unordered_map
實現方式	RB-tree	Hash table
順序	ordered	unordered
速度	慢 (但效率穩定)	快
空間使用	節省 memory	使用較多 memory
使用場合	元素自動排序	元素不需要排序/ only insert, delete, search/ 不需要擔心 memory 使用

717 - LeetCode Hash Table on 嗡嗡的隨手筆記

【Leetcode】python - [238] Product of Array Except Self 個人解法筆記

題目出處

難度

題目分類

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

算法說明

Time Complexity

Space Complexity

Boundary conditions

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

算法說明

input handling

Boundary conditions

Reference

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

題目出處

難度

題目分類

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

算法說明

Time Complexity

Space Complexity

Boundary conditions

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

算法說明

input handling

Boundary conditions

Reference

【Leetcode】python - [1] Two Sum 個人解法筆記 | 內有 list comprehesion / dict comprehesion 整理

題目出處

難度

題目分類

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

算法說明

Time Complexity

Space Complexity

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

算法說明 - two pointers

input handling

Boundary conditions

補充：list comprehesion

補充：dict comprehesion

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

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

解法 - HashTable

示意圖

Reference

【演算法筆記 #5】Hash 筆記，為什麼要使用 bash，與常見的密碼查詢驗證

前言

推薦文章

hash 的介紹與特性

hash 最重要的特性 「不可逆」

collision

hash 在密碼上的應用

比較：加/解密 與 hash 的不同

Reference

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

題目出處

難度

題目分類

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

算法說明

input handling

Boundary conditions

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

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

算法說明

input handling

Boundary conditions

Reference

【Leetcode】python - [846] Hand of Straights 個人解法筆記

題目出處

難度

題目分類

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

算法說明

input handling

Boundary conditions

Reference

hash 最重要的特性「不可逆」

比較：加/解密與 hash 的不同