726 - LeetCode Two Pointers 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 有機會變得更大。

window 大小只會變大，「當發現不符合規則時，我們只會繼續移動 window，不會縮小 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]
*/

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

個人是從 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 - [239] Sliding Window Maximum 個人解法筆記

Tue, 21 Jun 2022 18:51:23 +0800

題目出處

239. Sliding Window Maximum

難度

hard

題目分類

Array, Queue, Sliding Window, Heap (Priority Queue), Monotonic Queue

2022-06-21 一刷

個人範例程式碼

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if len(nums) < k:
            return []

        queue_idx = []
        ans = []

        # 1. if i-k == queue_idx[0] (3-3 = 0) oversize, pop oldest (0)
        # 2. if +1 nums[queue_idx[-1]] < num, remove smaller
        # 3. append new element
        # 4. nums[queue_idx[0]] will be max

        for i, num in enumerate(nums):
            # 1. if i-k == queue_idx[0] (3-3 = 0) oversize, pop oldest (0)
            if queue_idx and i - k == queue_idx[0]:
                queue_idx.pop(0)

            # 2. if +1 nums[queue_idx[-1]] < num, remove smaller
            while queue_idx and nums[queue_idx[-1]] < num:
                queue_idx.pop(-1)

            # 3. append new element
            queue_idx.append(i)

            # 4. nums[queue_idx[0]] will be max
            if i+1 >= k: # 2+1 >= 3
                ans.append(nums[queue_idx[0]])    

        return ans

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

算法說明

暴力解的版本，會在每次的 find max 花太多時間，
而我們會發現，sliding window 的特性，我們應該可以達成最小化的重複性更改。

基本上我們可以拆成四大步驟：

queue_idx[0] (3-3 = 0) oversize, pop oldest (0)

input handling

如果 len(nums) < k，則不可能組出 window。

Boundary conditions

用 for 控制範圍

個人範例程式碼 - 暴力解，會 TLE

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if len(nums) < k:
            return []

        ans = []
        slow, fast = 0, k    
        counter = defaultdict(int)
        # init counter
        for i in range(k):
            counter[nums[i]] += 1
        ans.append(self.get_counter_max(counter))

        # sliding window
        while fast < len(nums):
            counter[nums[slow]] -= 1 
            counter[nums[fast]] += 1
            ans.append(self.get_counter_max(counter))
            slow += 1 
            fast += 1

        return ans

    # O(n), if sorting O(nlogn)        
    def get_counter_max(self, counter):
        get_max = float("-inf")
        for key in counter.keys():
            if counter[key] > 0:
                get_max = max(get_max, key)

        return get_max

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

算法說明

暴力解的版本，最主要花時間的地方在於找最大，
如果使用 sorting 會是 O(nlogn)，單一次遍歷找最大會是 O(n)，
結合最外層的 sliding window 移動則會是 O(n^2)，
也還是會 TLE，需要另外想更快的辦法了。

input handling

如果 len(nums) < k，則不可能組出 window。

Boundary conditions

用 for 控制範圍

Reference

滑动窗口的最大值 · Sliding Window Maximum

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

看懂題目後，這題就很簡單了，我們可以簡單地用一個 hashset 來記錄我們已經計算過的數字。

input handling

如果沒有 n，return False

Boundary conditions

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

Reference

快乐数 · Happy Number

【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 - [19] Remove Nth Node From End of List 個人解法筆記

Sun, 29 May 2022 01:45:09 +0800

題目出處

19. Remove Nth Node From End of List

難度

Medium

題目分類

Linked List, Two Pointers

2022-05-29 二刷

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

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        if not head:
            return head

        dummy = ListNode(0)
        dummy.next = head
        slow = fast = dummy

        for i in range(n):
            fast = fast.next

        while(fast.next):
            fast = fast.next
            slow = slow.next
        else:
            slow.next = slow.next.next

        return dummy.next

算法說明

使用快慢指針，快慢的間距始終保持 n，
最後當找不到 fast.next (為 None，即最後一個數字時)

做一次「slow.next = slow.next.next」，即可刪除該數字，得到我們要的結果。

input handling

這題 input 有 cornet case 要處理，例如 [1], n = 1 的情況。

因此我們使用 dummy = ListNode(0)，並以 dummy.next 作為我們最終的解答。

使用 dummy 的目的，會使得 head 本身是可以刪除的。

Boundary conditions

使用 fast 來控制我們搜尋的範圍。

2021-06-19 一刷

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

大概念 - TwoPointers

我們可以想像成有兩個指標，一個跑比較快，一個跑比較慢

跑比較快的幫我們去找 head
跑比較慢的幫我們定位要刪除的 node

所以跑比較快的與跑比較慢的會固定間距「n」

正常 case

遍歷停止條件

我們留意最後一個 front 停下來的地方，因為要固定間距 n，
所以當最後搜尋到 front.next 沒有東西時就應該要停下

刪除方法

而刪除的方法，則是靠 back 所在位置的 next 替換成 next.next

你可能會想問為什麼不能在 4 ? ，因為「只有 3 的 next 才能連接到 5」

特殊 case

只有一個值時，front 會跑到空值，所以我們判斷 front 為空，
則回傳 head.next

示意圖

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

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        back = front = head
        for _ in range(n):
            front = front.next

        if not front:
            return head.next

        while(front.next):
            front, back = front.next, back.next

        # print(back.val)
        back.next = back.next.next
        return head

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

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

算法說明

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

例如：ABC 找 ABC 用 set() 很容易，
但要比較 AABC 與 AABC 沒辦法用 set() 的方法，因此我們需要另外寫一個方法 is_sub_counter()

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

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

算法說明

上面的作法其實沒什麼問題，速度慢的原因「最主要是在調用 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

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

算法說明

首先我們先找出是否有 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: # 當不成立時，出現在這
    # 當條件不成立時，開始作這邊的事情

這個寫法，可能很多人覺得好像有沒有 else 似乎不會有太大的影響?
畢竟當 while 條件不成立後，後續的程式碼「本來就會執行」

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

例如說當我們有無關 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)

答案不是 1 2 !!! 而是只有 2 !!!

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

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

Reference

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

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

題目出處

42. Trapping Rain Water

難度

hard

題目分類

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

2022-05-12 一刷

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

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

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

        return water_contains

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

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

算法說明

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

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

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

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

注意，處理時請注意負值

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

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

max(0, min(left_max, right_max))

input handling

Boundary conditions

透過 while(left < right): 處理

Reference

接雨水 · Trapping Rain Water

【Leetcode】python - [11] Container With Most Water 個人解法筆記

Thu, 12 May 2022 03:54:28 +0800

題目出處

https://leetcode.com/problems/container-with-most-water/

難度

Medium

題目分類

Array, Two Pointers, Greedy

2022-05-12 二刷

題外話

這題與 [42] Trapping Rain Water 類似，但 42 題比較難，
或是我有想過如果水缸換成「中柱隔開不計算」，搞不好都是另外一種更難的題目。

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

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

        start, end = 0, len(height)-1
        # [1,8,6,2,5,4,8,3,7] = 7(8-1)*7(min([8],[1]))
        max_water = 0
        while(start < end):
            max_water = max(max_water, (end - start) * min(height[start], height[end]))
            if height[start] < height[end]: # try to find two highest side
                start += 1
            else:
                end -= 1
        else:
            max_water = max(max_water, (end - start) * min(height[start], height[end]))

        return max_water

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

算法說明

策略是，想辦法找到左右都是最高的，只去移動(更新)邊比較小的那側。
利用 two pointer 去找，過程中不斷更新。

input handling

如果 not height or len(height) < 2，return 0 (錯誤的狀況)

Boundary conditions

用 while(start < end) 控制搜尋的範圍。

2021-03-31 一刷

個人手繪解法筆記 (解法重點) - 2021/3/31 一刷

也因為「即使中柱隔開，照樣計算」，所以我們只要找到「兩側最高」乘上「寬度」綜合起來最大就是答案。

TwoPointers

我們用兩個指標 r, l 分別一個從左邊掃，一個從右邊掃，
從 height[r], height[l] 選比較矮的，往前走尋找更高的
(往前走也就是：r-1, l+1)

注意：我們定義的 r, l 是「index」
而 height[r], height[l] 才是真正的「高」
(第一個自己 debug 就是發現這個錯誤XDD)

每算一次更新一次最大面積 (還好這題不用考慮中間有卡柱子的問題，簡單很多)，
掃到中止目標 (寬 = 0 或 r 小於等於 l)

說「小於等於」是考慮所有「不可能」的情況，所以不只說等於

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

class Solution:
    def maxArea(self, height: List[int]) -> int:
        max_area = 0
        l = 0 # index
        r = len(height)-1 # index
        width = len(height)-1
        while(width > 0 and l < r): # normal case
            area = width * min(height[r], height[l])
            # print(f"area = {area}, r = {r}, l = {l}") # debug
            max_area = max(max_area, area)


            # update
            if height[r] > height[l]: # l smaller
                l += 1
                width -= 1
            else:
                r -= 1
                width -= 1

        return max_area

Reference

【Leetcode】python - [349] Intersection of Two Arrays 個人解法筆記

Thu, 12 May 2022 03:49:37 +0800

題目出處

349. Intersection of Two Arrays

難度

Easy

題目分類

Array, Hash Table, Two Pointers, Binary Search, Sorting

2022-05-12 一刷

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

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

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

算法說明

一個 set and 就結束了…
好舒服的 easy 題目…

input handling

set and 的過程會幫我們處理掉

Boundary conditions

Reference

【Leetcode】python - [350] Intersection of Two Arrays II 個人解法筆記

Thu, 12 May 2022 02:55:05 +0800

題目出處

350. Intersection of Two Arrays II

難度

Easy

題目分類

Array, Hash Table, Two Pointers, Binary Search, Sorting

2022-05-12 三刷

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

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        intersect_counter = (Counter(nums1) & Counter(nums2))

        ans = []
        for key, value in intersect_counter.items():
            for _ in range(value):
                ans.append(key)

        return ans

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

算法說明

此題目的前一題為不需要進行重複值處理，這題需要處理重複，可參考：

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

Counter & Counter：可以找到所有重複的數值 & 數量

這裡特別注意：很幸運的，他有幫我們處理掉「“3個重複數” & “2個重複數” = “2個重複數”」的情況，
不然我們預期可能直接因為數量不同就 False，這樣我們就不能使用這個方法了。

input handling

dict and 的過程中會處理掉

Boundary conditions

2022-03-04 二刷

個人範例程式碼 - 2022/3/4 二刷 (set & counter 流)

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        ans = []
        for ele in (set(nums1) & set(nums2)):
            for i in range(min(Counter(nums1)[ele], Counter(nums2)[ele])):
                ans.append(ele)
        return ans

說明

這題看到求「重複」的，第一個直覺反應是不是會想到用 set 呢?
可是一用 set 之後，就會發現這題目設計的難度之處，
不過沒關係，遇到重複了，我們還有 Counter!

先用 set 快速找出有重複的，
再用確定有重複的，計算數量後，取較少的即可得到答案。

corner case 特殊情況處理

記得要找的是兩個集合的 min，而不是「只找單邊」

Boundary conditions/ Edge conditions 邊際情況處理

2022-02-25 一刷

個人範例程式碼 - 2022/2/25 一刷 (two pointer 流)

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        # print(set(nums1) & set(nums2))
        nums1, nums2 = sorted(nums1), sorted(nums2)
        res = []
        pt1, pt2 = 0, 0
        while(pt1 < len(nums1) and pt2 < len(nums2)):
            if nums1[pt1] > nums2[pt2]:
                pt2 += 1
            elif nums1[pt1] < nums2[pt2]:
                pt1 += 1
            else: # nums1[pt1] == nums2[pt2]
                res.append(nums1[pt1])
                pt1 += 1
                pt2 += 1
        return res

說明

這題看到求「重複」的，第一個直覺反應是不是會想到用 set 呢?
可是一用 set 之後，就會發現這題目設計的難度之處，
因為它是允許有 [1,1,2,2] 去交集 [2,2] 的
所以如果我門直接用 set，會把重複的 2 給用掉。
因此這題不能用 set 的作法。

我們採用的是 sort 後並使用兩個 pointer，一個個對照，
只要發現比較小的那側，就往下一個數字前進，
而如果兩者是一樣的，我們就同時一起前進。

邊際情況處理

這題目需要處理的邊際情況為 pointer 什麼時候結束，
我們需要知道，當其中一個 pointer 已經「指完了全部的內容」，
就沒有繼續往下看的必要了。因為另外一個再往下看，也一定找不到一樣的值。

所以我們使用 while 設定範圍在 pt1 < len(nums1) 的範圍內，
就可以處理這個問題。

Reference

【Leetcode】python - [88] Merge Sorted Array 個人解法筆記 | 內含 python while-else 用法說明

Wed, 11 May 2022 02:52:15 +0800

題目出處

88. Merge Sorted Array

難度

Easy

題目分類

Array, Two Pointers, Sorting

2022-05-11 二刷

個人範例程式碼 - 2022/5/11

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        m, n = m-1, n-1 # get last idx
        for idx in range(len(nums1)-1, -1, -1):
            if(m >= 0 and n >= 0):
                if nums1[m] < nums2[n]:
                    nums1[idx] = nums2[n] 
                    n -= 1
                else:
                    nums1[idx] = nums1[m] 
                    m -= 1
            elif m >= 0:
                nums1[idx] = nums1[m] 
                m -= 1   
            elif n >= 0:
                nums1[idx] = nums2[n] 
                n -= 1

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

算法說明

從尾巴開始往前填，注意一下順序即可

input handling

在 for 迴圈中一起處理

Boundary conditions

for 迴圈控制範圍

2022-02-25 一刷

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

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        while (m > 0 and n > 0): 
            if(nums1[m-1] >= nums2[n-1]):
                nums1[m+n-1] = nums1[m-1] # put nums1[m] in to the last place of nums1
                m -= 1
            else:
                nums1[m+n-1] = nums2[n-1]
                n -= 1
        else:
            while n > 0: # m = 0
                nums1[m+n-1] = nums2[n-1]
                n -= 1
            # else m > 0, already in nums1

說明

這題我們可以先注意題目的敘述：
最需要思考的部分在於「題目希望最後的結果直接儲存在 nums1 裡面」

雖然這樣的限制會使我們解題更加的「受到限制」，但反過來說，
其實這也是題目給我們「最大的提示」。

題目的 nums1 給的空間為 m+n，所以最後我們都會將所有的值擺入 nums1 中，
而因為我們可以無憂慮去更改的值為最後的 0,0,0… 部分
(因為這個值就算被改消失了，也不影響我們想計算的結果)

所以這邊可以推斷出一定要「從後面開始解」，「從最無痛的 0 開始取代」，

再來我們就可以來思考，什麼時候擺入 nums1的值? 什麼時候擺入 nums2 的值?
我們可以靠著題目所給的 m, n 來進行這樣的操作，透過值不斷擺入，
我們去移動 m, n 作為 index 的座標，即可順利完成此題目。

邊際情況處理

這題要注意的邊際情況為 m=0, n=0 的時候我們要怎麼處理，
而照題目的敘述，

n=0 基本上對我們來說沒差，因為 m 控制的 nums1 即代表我們要的答案

m=0 才是重點，如果還有剩餘的 n，都需要擺入 nums1 中，而位置索幸很好取得，依然可以透過 m+n-1 算出

注意 index 細節，才是這題要考細心的部分

這題有很多 index 細節考驗著作答者的細心度，
包含：

迴圈的範圍僅限於 m, n > 0 時，其他需要進例外處理
m-1, n-1 才是當下座標
要擺入的位置為 m+n-1
處理到 n > 0 就應該停下，而非 n >= 0

python while-else 用法說明

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

邏輯如下：

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

這個寫法，可能很多人覺得好像有沒有 else 似乎不會有太大的影響?
畢竟當 while 條件不成立後，後續的程式碼「本來就會執行」

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

範例

假設我們要把一個 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!')

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

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

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

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

答案不是 1 2 !!! 而是只有 2 !!!

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

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

使用方式可以看我下面這題的示範：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/linked-list/leetcode-python-142/

Reference

Python easy to understand in-place solution

【Leetcode】python - [61] Rotate List 個人解法筆記

Thu, 05 May 2022 19:22:36 +0800

題目出處

61. Rotate List

難度

medium

題目分類

Linked List, Two Pointers

2022-05-05 一刷

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

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        if not head or k == 0:
            return head

        cur = head
        length = 0
        while(cur):
            length += 1
            prev = cur
            cur = cur.next
        else:
            prev.next = head # circular

        k = length - (k % length) # counterclockwise -> clockwise
        while(k > 0): # move k times (clockwise)
            k -= 1
            prev = head
            head = head.next
        else:
            prev.next = None  # tail
            return head # head

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

算法說明

網路上看到覺得最漂亮的算法，
既然都要 rotate 了，不如直接先串成一個環吧!

注意 rotate 逆時針

從題目敘述我們會發現 rotate 方向為「逆時針」，
這樣我們就有必要先計算總共有幾個元素，
再來透過 k = k - (k % length)，我們就可以得到「順時針要走多少 k 」

input handling

如果沒有 input head，return head

Boundary conditions

while loop 控制 k 的搜尋範圍，
先弄成環之後，處理環的前後。

Reference

旋转链表 · Rotate List

【Leetcode】python - [234] Palindrome Linked List 個人解法筆記 (內含 reverse LinkedList 方法)

Wed, 04 May 2022 03:42:30 +0800

題目出處

234. Palindrome Linked List

難度

easy

題目分類

Linked List, Two Pointers, Stack, Recursion

2022-05-04 一刷

個人範例程式碼 - Deque (比較進階)，空間 O(N)

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if not head:
            return False

        dq = deque([])
        while(head):
            dq.append(head.val)
            head = head.next

        return self.is_palindrome(dq)

    def is_palindrome(self, dq):
        while(len(dq)>=2):
            if dq.popleft() == dq.pop():
                continue
            else:
                return False
        else:  # if len(dq) <mark> 1, True or len(dq) </mark> 0, True                         
            return True

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

算法說明

Deque 解 palindrome 的題目真的是無敵，但因為是比較進階的資料結構，也許不一定是面試想要看到的解

input handling

處理沒有 head 的情況，return False

Boundary conditions

控制 pointer 搜尋至 None

個人範例程式碼 - 同向 two pointer, 使用空間 O(N/2) stack

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if not head:
            return False

        slow = head
        fast = head.next

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        else:
            if not fast:
                return self.odd_case(head, slow, fast)
            else: # not fast
                return self.even_case(head, slow, fast)


    def odd_case(self, head, slow, fast):
        mid = slow
        stack = deque([])

        slow = slow.next
        while(slow):
            stack.append(slow.val)
            slow = slow.next

        # print(stack)
        while(stack):
            if head.val == stack.pop():
                head = head.next
            else:
                return False
        else:
            return True

    def even_case(self, head, slow, fast):
        mid = slow
        stack = deque([])

        slow = slow.next
        while(slow):
            stack.append(slow.val)
            slow = slow.next

        # print(stack)
        while(stack):
            if head.val == stack.pop():
                head = head.next
            else:
                return False
        else:
            return True

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

算法說明

我猜此題目最多會要求到把使用空間壓縮至 O(1)，
這樣上面 Deque 的做法會因為空間 O(n) 而不能用。

如果要實現 O(1) 空間的話，
這題就可以考到 LinkedList 的反轉，同向 two pointer。

不過這邊求速度，就先不寫 LinkedList 的反轉，
使用 O(N/2) 空間的 stack 完成同樣的任務

input handling

處理沒有 head 的情況，return False

Boundary conditions

控制 slow, fast pointer 搜尋至 None，
注意結束條件的 fast and fast.next

個人範例程式碼 - 同向 two pointer，使用 reverse LinkedList 空間 O(1)

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if not head:
            return False

        slow = head
        fast = head.next

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        else:
            if not fast:
                return self.odd_case(head, slow, fast)
            else: # not fast
                return self.even_case(head, slow, fast)

    def odd_case(self, head, slow, fast):
        dummy = self.reverse(slow)
        while dummy:
            # print(dummy.val, head.val)
            if dummy.val == head.val:
                head, dummy = head.next, dummy.next
            else:
                return False
        return True

    def even_case(self, head, slow, fast):
        dummy = self.reverse(slow.next)
        while dummy:
            # print(dummy.val, head.val)
            if dummy.val == head.val:
                head, dummy = head.next, dummy.next
            else:
                return False
        return True

    def reverse(self, node):
        prev = None
        while node:
            tmp = node.next
            node.next = prev
            prev = node
            node = tmp

        return prev # prev <- node(None)

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

算法說明

同上 slow, fast 作法，但實現 O(1) 空間，利用 LinkedList 的反轉，同向 two pointer。

input handling

處理沒有 head 的情況，return False

Boundary conditions

控制 slow, fast pointer 搜尋至 None，
注意結束條件的 fast and fast.next

Reference

【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

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

算法說明

用同向的 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 - [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

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

算法說明

使用 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 - [31] Next Permutation 個人解法筆記

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

題目出處

31. Next Permutation

難度

medium

題目分類

Array, Two Pointers

2022-04-26 一刷

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

class Solution:
    def nextPermutation(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        if not nums:
            return nums

        last = len(nums)-1
        while(last > 0):
            if nums[last-1] < nums[last]: # ...last-2, last-1, last # 34 -> 43  
                self.change_inplace(nums, last-1) 
                return 
            last -= 1

        else: # all descend
            # nums.reverse() 
            self.inplace_reverse(nums, 0, len(nums)-1)
            return 

    def change_inplace(self, nums, idx):
        change_idx = self.find_next_same_or_bigger(nums, idx)
        nums[change_idx], nums[idx] = nums[idx], nums[change_idx] # inplace
        self.inplace_reverse(nums, idx+1, len(nums)-1) # inplace reverse after idx, nums[:idx]
        return 

    def find_next_same_or_bigger(self, nums, idx):
        last = len(nums)-1
        target = nums[idx]
        while nums[last] <= target:
            last -= 1
        else:
            return last

    def inplace_reverse(self, nums, start, end):
        while(start < end):
            nums[start], nums[end] = nums[end], nums[start]
            start += 1
            end -= 1
            print(nums)
        return

算法說明

排列問題的進階版，求「下一個排列」，
直接的做法可以簡單歸納為，

- 從結尾處開始找「第一個」往下的地方 - 如果找到了，交換「往下的那個」與「之前往上的過程中 <= 此數的數字 (注意等於)」，交換後把整個數列顛倒 - 如果找不到，下一個數字就是全部順序直接顛倒 (也就是第一個數字)

圖片說明

我們找第一個往下的地方，上面我們有標示箭頭，
將「在下的位置」與「之前上升時，>= 下降數的第一個數字」交換

注意這邊可以多留意 [1,1,5] -> [1.5.1] 這個 case，可以解釋為何要處理「>=」

交換後，我們會發現之前的上升順序還是會保持上升，我們直接顛倒方向，使後綴的部分呈現下降順序。

以文字說明 - 1 (邊看圖想會比較懂在做什麼)

- 1243 我們抓到下降的 4->2， - 2 與第一個 3 (>=2)交換，此時為 1342， - 把交換處之後的倒序，變成 1324，就是下一個數字

以文字說明 - 2 (邊看圖想會比較懂在做什麼)

- 1342 我們抓到下降的 4->3， - 3 與第一個 4 (>= 3)交換，此時為 1432， - 把交換處之後的倒序，變成 1423，就是下一個數字

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

這邊也可以參考 leetcode 上很讚的圖片說明版：

Easy python solution based on lexicographical permutation algorithm

input handling

如果沒有 nums，回傳 nums

Boundary conditions

做完上述的交換後，return 結果

Reference

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

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

input handling

Boundary conditions

見上述說明

Reference

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

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

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

題目出處

75. Sort Colors

難度

medium

題目分類

Array, Two Pointers, Sorting

2022-04-14 一刷

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

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


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

        left, right = start, end

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

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

算法說明

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

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

遞迴判斷式

遞迴的定義

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

遞迴的拆解

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

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

start ~ right
left ~ end

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

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

遞迴的中止

如果 pivot = 0，return

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

input handling

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

Boundary conditions

上方已經說明完囉

Reference

颜色分类 · Sort Colors

【Leetcode】python - [16] 3Sum Closest 個人解法筆記

Fri, 08 Apr 2022 17:35:24 +0800

題目出處

16. 3Sum Closest

難度

medium

題目分類

Array, Two Pointers, Sorting

2022-04-08 一刷

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

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        if not nums or len(nums) < 3:
            return -1

        nums.sort()
        ans = float("inf")

        for idx, first_num in enumerate(nums):
            ans = self.two_sum(nums, target, ans, first_num, idx+1, len(nums)-1)    

        return ans

    def two_sum(self, nums, target, ans, first_num, left, right):
        while(left < right):
            if first_num + nums[left] + nums[right] == target:
                return target
            elif first_num + nums[left] + nums[right] < target:
                ans = self.find_closest(ans, first_num + nums[left] + nums[right], target)
                left += 1
            else: # if first_num + nums[left] + nums[right] > target:
                ans = self.find_closest(ans, first_num + nums[left] + nums[right], target)
                right -= 1
        else:
            return ans      

    def find_closest(self, a, b, target):
        if abs(a - target) <= abs(b - target):
            return a
        else:
            return b

算法說明

這題有幾乎相同的類似題，可參考：

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

前者是 2Sum，這題更難改成 3Sum，但思路與 3Sum 大同小異

https://wongwongnotes.com/posts/algorithm-practice/pointers/two-pointers-start-end/leetcode-python-15/

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

input handling

處理 input 為 [] 或 len < 3 的情況，輸出 -1 。(題目沒說，但這邊先預留特殊狀況處理)

Boundary conditions

特別留意 3Sum 的搜尋條件，特別是 a <= b <= c 的處理部分 (可以看 3Sum 的文章)

Reference

【Leetcode】python - [876] Middle of the Linked List 個人解法筆記

Thu, 07 Apr 2022 18:55:28 +0800

題目出處

876. Middle of the Linked List

難度

easy

題目分類

Linked List, Two Pointers

2022-04-07 一刷

個人範例程式碼 - two pointers

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head is None:
            return None

        slow = head 
        fast = slow.next
        while(fast is not None and fast.next is not None):
            slow = slow.next
            fast = fast.next.next
        else:
            if(fast is None): # odd case
                return slow
            else: # fast is not None, fast.next is None: # even case
                return slow.next

算法說明

同向的快慢 pointers，這題目雖然簡單，但很考慮細節的處理。

這部分可以看下圖，說明請見 Boundary conditions ：

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

input handling

處理 input 為 None 的情況，輸出 None。

Boundary conditions

我們依照上面的圖片繼續說明：

基本上拆成兩種狀況討論：

odd case：奇數情況，特性為 fast 直接指到 None 上，return slow
even case：偶數情況，特性為 fast.next 才指到 None 上 (或 fast 有值卻進入了 else part)，return slow.next

結束條件

fast or fast.next is None 的時候，我們再來分析情況

(至少要自己本身能指到 None)

Reference

链表的中点 · Middle of Linked List

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

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

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

input handling

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

Boundary conditions

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

Reference

有效回文 II · Valid Palindrome II

【Leetcode】python - [167] Two Sum II - Input Array Is Sorted 個人解法筆記

Wed, 06 Apr 2022 19:34:18 +0800

題目出處

167. Two Sum II - Input Array Is Sorted

難度

medium

題目分類

Array, Two Pointers, Binary Search

2022-04-06 一刷

個人範例程式碼 - two pointers

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

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

算法說明

這題我們在之前的題目已經有詳細說明了，可參考：

【Leetcode】python - [1] Two Sum 個人解法筆記 (last update: 2022/04/06) | 內有 list comprehesion / dict comprehesion 整理

另外，這題因為有「已經排序」的特性，目的就是為了解決表格中的 sort，
加速 two pointers 做法的時間複雜度。

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

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

input handling

處理沒有 input 的狀況，return [-1, -1]

Boundary conditions

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

Reference

两数和 II-输入已排序的数组 · Two Sum II - Input array is sorted

【Leetcode】python - [283] Move Zeroes 個人解法筆記

Wed, 06 Apr 2022 18:36:09 +0800

題目出處

283. Move Zeroes

難度

easy

題目分類

Array, Two Pointers

2022-04-06 一刷

個人範例程式碼 - two pointers

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        start, end = 0, 0
        while(end < len(nums)):
            if(nums[end] != 0): # != 0
                nums[start], nums[end] = nums[end], nums[start] # change
                start +=1
            end += 1

        return nums

算法說明

同向 pointers，因為題目有說要保留「the relative order」(相對順序)

start 保留最後指向 0 位置 (在指到第一個 0 之前，都是指數字與 end 一起前進，讓自己互換)

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

input handling

處理沒有 input 的狀況，return []

Boundary conditions

當 end 先行達到 len(nums)，就結束迴圈

Reference

移动零 · Move Zeroes

【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 - [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 就是正確的了，

我們可以保證 fast 與 fast.next 必存在，
而 fast.next 可以指向 None，
當 fast = fast.next.next 時，我們會在下一個迴圈把 None 判出來。

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

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

Reference

【Leetcode】python - [189] Rotate Array 個人解法筆記

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

題目出處

189. Rotate Array

難度

Medium

題目分類

Array, Math, Two Pointers

2022-03-02 一刷

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

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        len_nums = must_visited = len(nums)
        start_idx = 0
        while(must_visited != 0):
            i = start_idx
            prev = nums[start_idx]
            while(True):
                next_i = (i+k)%len_nums
                save = nums[next_i] # save next
                nums[next_i] = prev # use prev to change next
                prev = save # next give to keep
                i = next_i # move to next index
                must_visited -= 1 # prevent for len_nums can divide k
                if i == start_idx: # return to start 
                    break
            start_idx += 1 # prevent for len_nums can divide k

Time Complexity

O(n)

Space Complexity

O(1) # 這題有特別要求希望是這個空間

算法說明

題目要求空間 O(1)，通常就表示這個題目「高機率」可以用 swap 的方式解出來 (想辦法只用交換的)

題目提到「in-place」，表示這題目可以用 swap 的方法解的「可能性很高」，不過這個提示沒有上方機率那麼高，有時候我們也是可以另外 assign 空間再去進行「in-place」的動作。

方法一 - circular array

直覺上，我們可以將此 array 當作一個環，不斷的交換一個循環，直到回到起點結束交換。

為了方便起見，以下的例子我們故意將 index 與裡面的元素值取相同。

我們可以觀察，k=2 時，我們下一個移動的目標 next_i = (i+k)%(array長度) <- 取餘數

我們再次觀察，k=3 時，我們下一個移動的目標 next_i = (i+k)%(array長度) <- 取餘數

注意!! 此方法有個陷阱!!

當「矩陣的長度可以被 k 整除時，會有快速循環的現象」，
例如「len(nums) = 4, k = 2」

[0,1,2,3]
如果只照上述循環後，我們就只會變更 [2,1,0,3] <- 注意只有 0, 2 交換。

為了避免此問題，我們需要另外設計一個 visited 的機制，確保每一個位置都有換過!!

範例程式碼

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        len_nums = must_visited = len(nums)
        start_idx = 0
        while(must_visited != 0):
            i = start_idx
            prev = nums[start_idx]
            while(True):
                next_i = (i+k)%len_nums
                save = nums[next_i] # save next
                nums[next_i] = prev # use prev to change next
                prev = save # next give to keep
                i = next_i # move to next index
                must_visited -= 1 # prevent for len_nums can divide k
                if i == start_idx: # return to start 
                    break
            start_idx += 1 # prevent for len_nums can divide k

corner case 特殊情況處理

處理當 len(nums) = 0 或 k 的情況，基本上都不用做事情，可以節省時間。

上述範例沒有做，但程式碼已經可以處理這個情況。

Boundary conditions/ Edge conditions 邊際情況處理

結束位置在，當 index 返回出發點時。

但要讓整個交換完成，需要注意是否有整除問題，所以真正結束是在 visited 剛好等於 array 長度時，期間我們需要去變換起始的 index 位置。

方法二 - recursive

這個方法我也是參考 discussion 看到的，非常酷的做法!
他運用的概念是「矩陣反轉兩次後，會回到原位置」。

因此如果在第二步驟，我們依照「目標 k 位置」進行「分別反轉」，
就可以得到答案。

舉例：k = 3，以下為了方便起見，直接讓 index 值等於元素值

[0,1,2,3,4,5,6] <- 原始位置
[6,5,4,3,2,1,0] <- 第一次全反轉
[4,5,6,0,1,2,3] <- 拆兩次反轉 0~~k-1, k~~len(nums)-1

範例程式碼

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        if len(nums) <= 1:
            return
        else:
            k = k % len(nums)
            self.reverse(nums, 0, len(nums)-1)
            self.reverse(nums, 0, k-1)
            self.reverse(nums, k, len(nums)-1)
            return

    def reverse(self, nums, start, end):
        while start < end:
            nums[start], nums[end] = nums[end], nums[start] 
            start += 1
            end -= 1

corner case 特殊情況處理

處理當 len(nums) = 0 或 k 的情況，基本上都不用做事情，可以節省時間。

上述範例沒有做，但程式碼已經可以處理這個情況。
當 0 or k 時，就是 list 進行全部反轉，再反轉一次回來的意思。

處理當 len(nums) = 1 的情況，會超出範圍

新增以下片段

if len(nums) <= 1:
    return

處理當 k > len(nums) 的情況，會超出範圍

這個就是考這題要細心的地方，因為題目沒說 k 必小於 len(nums)，
通常會沒考慮到這點，也是要看到測資才會想到…

新增以下片段

k = k % len(nums)

Boundary conditions/ Edge conditions 邊際情況處理

k=3 時，

前半段位置從 0 到 2 = (k-1)
後半段則是 k 開始至 len(nums)-1

Reference

【Leetcode】C++ - [88] Merge Sorted Array 個人解法筆記

Fri, 25 Feb 2022 04:20:01 +0800

題目出處

88. Merge Sorted Array

難度

Easy

題目分類

Array, Two Pointers, Sorting

2022-02-25 一刷

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

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        while(m > 0 && n > 0){
            if(nums1[m-1] >= nums2[n-1]){
                nums1[m+n-1] = nums1[m-1];
                m -= 1;
            }
            else{
                nums1[m+n-1] = nums2[n-1];
                n -= 1;
            }
        }
        while(n > 0){
            nums1[m+n-1] = nums2[n-1];
            n -= 1;
        }        
    }
};

說明

這題我們可以先注意題目的敘述：
最需要思考的部分在於「題目希望最後的結果直接儲存在 nums1 裡面」

雖然這樣的限制會使我們解題更加的「受到限制」，但反過來說，
其實這也是題目給我們「最大的提示」。

所以這邊可以推斷出一定要「從後面開始解」，「從最無痛的 0 開始取代」，

邊際情況處理

這題要注意的邊際情況為 m=0, n=0 的時候我們要怎麼處理，
而照題目的敘述，

n=0 基本上對我們來說沒差，因為 m 控制的 nums1 即代表我們要的答案

m=0 才是重點，如果還有剩餘的 n，都需要擺入 nums1 中，而位置索幸很好取得，依然可以透過 m+n-1 算出

注意 index 細節，才是這題要考細心的部分

這題有很多 index 細節考驗著作答者的細心度，
包含：

迴圈的範圍僅限於 m, n > 0 時，其他需要進例外處理
m-1, n-1 才是當下座標
要擺入的位置為 m+n-1
處理到 n > 0 就應該停下，而非 n >= 0

Reference

Python easy to understand in-place solution

【Leetcode】python - [15] 3Sum 個人解法筆記

Fri, 02 Apr 2021 00:27:36 +0800

題目出處

15. 3Sum

難度

Medium

題目分類

Array, Two Pointers, Sorting

2022-04-06 二刷

個人範例程式碼 - two pointers (第二次解：2022/4/6)

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        ans = []
        for idx, target in enumerate(nums):
            if idx > 0 and nums[idx] == nums[idx-1]: # prevent duplicate
                continue
            ans = self.two_sum(nums, ans, idx+1, len(nums)-1, -target)
        return ans


    def two_sum(self, nums, ans, start, end, target):
        last_ans = []
        while(start < end):
            if(nums[start] + nums[end] == target):
                if [-target, nums[start], nums[end]] != last_ans: # prevent duplicate
                    last_ans = [-target, nums[start], nums[end]]
                    ans.append(last_ans)
                start += 1
                end -= 1
            elif(nums[start] + nums[end] < target):
                start += 1
            else: # if(nums[start] + nums[end] > target):
                end -= 1
        else:
            return ans

算法說明

3Sum 可以當作是 2Sum 的進階版，
而變化的部分在於 target 的變化變成可以動態的，

可以視為：3Sum = 2Sum + 「動態 target」

因此我們可以沿用 2Sum 的作法，
並把 2Sum 中 target 改為動態的尋找。

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

input handling

處理 input 為 [] 的情況，應該要輸出 []。
處理 input 為 [0, 0, 0] 的情況，應該也要輸出 [[0, 0, 0]]。

Boundary conditions

有幾個重點：

防止重複 1 : 「a <= b」 <= c

防止重複的第一個部分，就是避免重複數值時，
a, b 都被重算，我們都統一取第一個去運算。

此外需要特別注意：因為判斷式為「nums[idx] nums[idx-1]」，需要再多判斷一個「idx > 0」。

if idx > 0 and nums[idx] == nums[idx-1]: # prevent duplicate
    continue

防止重複 2 : a <=「b <= c」

這邊基本上我們統一拿來結果來判斷，只要 b, c 組合不相同，就視為不同的解。

3. two pointers: start < end，交錯或等於就結束

two pointers 的基本結束條件。

2021-04-02 一刷

個人解法筆記 - (第一次解：2021/4/2)

這題是第 1 題的延伸題目，這次我們要處理 3數之和的問題。

大概念

我們將這個題目看成，「任兩數和」等於「負的第三數」
「負的第三數」我們稱之為我們要的 target
為了更乾淨我們處理的順序，我們會先進行「排序」

示意圖：

TwoPointers

在排序後，我們選定 target，我們使用 TwoPointers，
從左 ( l ) 開始小往大掃、從右 ( r ) 開始大往小掃，
當左( l ) 大於等於右( r ) ，也就是交錯甚至超過。
就是我們的終止條件。

示意圖：

重複處理 case1 : target 的重複

重複時的選擇：我們選擇第一個 target。

除了 target 重複會造成重複解答之外，
選擇第一個也能夠保證當解答中有與target重複的數值也能被我們考慮到。

示意圖：(處理 target 的重複)

可以觀察 i 與 target 的變化，仔細思考，可以得到一些心得：

重複處理 case2 : r, l 選到值的重複

重複時的選擇：我們選擇「l」的第一個值，r不同時處理。

因為，當我們得到答案並更新「l」之後，對應的 nums[r] 直接不成立。
思考時，只需要思考單邊重複如何處理即可。 (多思考會錯，可以見下面錯誤區)

選擇第一個值的原因是，我們預期「剩下的值」有可能存在答案。
而當找到答案時，我們再將「l」移至下一個值 (也就是說，反覆 l+1 直到值不同)

這樣才能處理極端狀況：[0, 0, 0]

示意圖：(處理 l, r 的重複)

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

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        ans = []

        # decide target
        for i in range(len(nums)):
            if(i > 0 and nums[i-1] == nums[i]): # when same target, only calculate first 
                continue # go to next loop
            target = -nums[i]
            # print(f"i = {i}, target = {target}") # debug

            l = i+1
            r = len(nums)-1

            while(l < r and l < len(nums) and r >= 0): # normal condition
                # print(f"l = {l}, r = {r}") # debug
                if nums[l] + nums[r] == target:
                    ans.append([nums[i], nums[l], nums[r]])
                    l += 1
                    while l < r and nums[l] == nums[l-1]: # when same value, only calculate first
                        l += 1 
                elif nums[l] + nums[r] > target: # need smaller, r - 1
                    r -= 1                  
                else: # nums[l] + nums[r] < target: need bigger, l + 1
                    l += 1        

        return ans

「錯誤紀錄」手繪筆記

重點：錯誤錯在兩邊同時尋找，無法解[0,0,0] 這個 case!

這題是第 1 題的延伸題目，這次我們要處理 3數之和的問題。

大概念

示意圖：

TwoPointers

示意圖：

重複處理 case1 : target 的重複

重複時的選擇：我們選擇第一個 target。

除了 target 重複會造成重複解答之外，
選擇第一個也能夠保證當解答中有與target重複的數值也能被我們考慮到。

示意圖：

重複處理 case2 : r, l 選到值的重複

重複時的選擇：我們選擇最後一個值。

選擇最後一個值的原因是，我們預期「剩下兩個值」的組合應該會不同。
所以我們只看最後一個。

~~而且，就算真的重複了。(例如極端狀況：[0, 0, 0])~~ (此方法並沒有辦法處理)
我們也會先進行 -target = nums[l] + nums[r] 的檢查後，
抓出這樣的極端情況。

示意圖：