729 - LeetCode Math on 嗡嗡的隨手筆記

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

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

題目出處

70. Climbing Stairs

難度

easy

題目分類

Math, Dynamic Programming, Memoization

2026-07-21 二刷

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

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

        return curr

算法說明

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

Time Complexity

O(n)

Space Complexity

O(1)

2022-05-04 一刷

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

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

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

        return dp[-1]

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

算法說明

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

input handling

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

Boundary conditions

控制 for-loop 的範圍

Reference

【Leetcode】python - [137] Single Number II 個人解法筆記

Fri, 17 Jun 2022 18:18:33 +0800

題目出處

137. Single Number II

難度

medium

題目分類

Array, Bit Manipulation

2022-06-17 一刷

個人範例程式碼 - （非題目要求空間）解

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        counter = Counter(nums)
        for key, value in counter.items():
            if value == 1:
                return key

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

算法說明

先來簡介一下題目的要求，
題目要求這題，希望能夠「在線性時間 O(n) 完成」且「使用常數空間 O(1)」，

使用常數空間的方法，我們直覺會想到用 sort()
線性時間的方法，我們直覺會想到用 hashtable()

但如果要同時滿足兩者，我們需要使用特別的方法，
在這題會需要使用到 bit 的運算，但由於面試準備中這比較少見，
因此這邊只點出思路，不是示範對應做法。

而上方我們示範的是利用 hash 做出 counter 的做法，
統計並找出 counter 中數量為 1 的結果。

input handling

Boundary conditions

Reference

落单的数 II · Single Number II

【Leetcode】python - [867] Transpose Matrix 個人解法筆記

Thu, 16 Jun 2022 19:12:22 +0800

題目出處

867. Transpose Matrix

難度

easy

題目分類

Array, Matrix, Simulation

2022-06-16 一刷

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

class Solution:
    def transpose(self, matrix: List[List[int]]) -> List[List[int]]:
        m, n = len(matrix), len(matrix[0])
        ans = [[0]*m for _ in range(n)]

        for i in range(m):
            for j in range(n):
                ans[j][i] = matrix[i][j]

        return ans

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

算法說明

單純做矩陣轉置，沒什麼特別的

input handling

Boundary conditions

用 for 控制範圍

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

以系統思維來講，我們還可以加速：
可以把 i, j 視為獨立任務，進行 multiprocessing 運算
可以想像成把 n^2 的任務全部分出去算。

Reference

【Leetcode】python - [13] Roman to Integer 個人解法筆記

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

題目出處

13. Roman to Integer

難度

easy

題目分類

Hash Table, Math, String

2022-06-12 一刷

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

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

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

        return ans

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

算法說明

照 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

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

算法說明

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

input handling

Boundary conditions

用 while 控制範圍

Reference

罗马数字转整数 · Roman to Integer

【Leetcode】python - [9] Palindrome Number 個人解法筆記

Fri, 10 Jun 2022 03:34:11 +0800

題目出處

9. Palindrome Number

難度

easy

題目分類

Math

2022-06-10 一刷

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

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x < 0:
            return False
        if x == 0:
            return True

        return self.is_palindrome(str(x))

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

        return True

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

算法說明

先設計好一個判斷 palindrome 的 function，然後再處理特殊狀況

input handling

如果 = 0，回傳 True
如果 < 0，回傳 False

Boundary conditions

用 start, end 來判斷 palindrome

Reference

【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 - [191] Number of 1 Bits 個人解法筆記

Mon, 06 Jun 2022 16:23:17 +0800

題目出處

191. Number of 1 Bits

難度

easy

題目分類

Divide and Conquer, Bit Manipulation

2022-06-06 一刷

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

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

        # 7 (10) = 111 (2)
        # 4 (10) = 100 (2)
        # 3 (10) = 011 (2)

        cnt = 0
        while(n != 0):
            cnt += (n & 1) # and first bit
            n = n >> 1 # (// 2)
        return cnt

算法說明

簡單的位元運算題目，
我們可以先觀察「 10進位 (10) 與 2進位 (2) 」的變化，

7 (10) = 111 (2)

4 (10) = 100(2)

3 (10) = 11(2)

我們提取第一個位元 (最右側位元) 的方式是 (原數字 & 1)，
並一路往右 » 1，直到原值只剩下 0。

input handling

Boundary conditions

用 while 至 0 來控制範圍。

Reference

判断一个整数中有多少个1 · Number of 1 Bits

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

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

題目出處

338. Counting Bits

難度

easy

題目分類

Dynamic Programming, Bit Manipulation

2022-06-02 一刷

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

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

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

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

        return dp

算法說明

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

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

推理 dp 相關性

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

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

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

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

input handling

一同在 dp 內處理

Boundary conditions

用 for 迴圈控制範圍

Reference

数 1 · Counting Bits

【Leetcode】python - [48] Rotate Image 個人解法筆記

Sun, 29 May 2022 15:59:50 +0800

題目出處

48. Rotate Image

難度

Medium (但我覺得其實很難想XDD)

題目分類

Array, Math, Matrix

2022-05-29 二刷

特別注意題目說的「inplace」

特別注意題目說的「inplace」，基本上就是希望不要用到額外儲存空間，
可以當作不能「製造出新的矩陣」，只能單純的「矩陣內位置互換」

換成程式碼的意思就是：「一個個index去換值」，不要對整個矩陣操作

先講點題外話(喂

這題基本上就是真正實作「圖片的旋轉」了！
(不能靠 OpenCV 或 Numpy 幫助的那種XDD)

學起來這題後，我有體會到 OpenCV 中旋轉圖片的函數實作有多偉大與困難XDD
真心更尊敬 OpenCV 的開發者惹 (人家本來就超強XDD)

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

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        m, n = len(matrix), len(matrix[0])

        if m != n:
            return 

        # transpose
        for i in range(m):
            for j in range(i+1, n):
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j] 

        # reverse
        for i in range(m):
            matrix[i].reverse()

算法說明

利用「旋轉 90 度 = 先轉置，再單行反轉的概念」，我們可以推得

分析範圍，我們只能做成三角，尋找三角的方式

我們可以透過 i+1 來控制三角形的範圍 (也就是 m 的範圍)。

input handling

題目預設是沒有，這裡我多處理了一個 m != n 的特殊情況 (題目也不預期會發生)

Boundary conditions

用兩層 for loop 來控制範圍

2021-04-03 一刷

個人範例程式碼 - 2021/4/3 一刷 (方法一)

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        N = len(matrix) # one side

        for i in range(N//2 + N%2):
            for j in range(N//2):

                tmp = matrix[i][j] # save temporarily
                matrix[i][j] = matrix[-j+(N-1)][i]                  # 1
                matrix[-j+(N-1)][i] = matrix[-i+(N-1)][-j+(N-1)]    # 2
                matrix[-i+(N-1)][-j+(N-1)] = matrix[j][-i+(N-1)]    # 3
                matrix[j][-i+(N-1)]  = tmp                          # 4

真的別小看這只有八行的程式碼…，實際上寫出來花的時間根本遠遠超過這八行

解法說明

個人推薦可以先思考轉180度，再來考慮90度

我是認真的XD，
過來人的經驗，180度要先解出來，90度才是下一個階段的問題。

~~直接就硬爆 90度大魔王連怎麼死的都不知道~~

來先解 180度吧，直接看圖! (觀察只有兩個東西在互換)

重要觀念：i, j 是「變化量 (delta)」，不要用「座標」的概念下去想。
寫 for 迴圈的時候，就會知道這問題出在哪了! (可以見文章最下面錯誤的部分)

示意圖：(我們可以發現，這題只有兩個東西在互換)

觀察 x軸, y軸的變化

180度比較簡單，「x軸」上的變化只會影響在「x軸」，
等等 90度就沒有這麼簡單了!!!

整理一下變換公式：

先有這樣的觀念，我們再來推 90度的答案!

個人手繪解法筆記 - (方法一比較正常思考一點)

再強調一次重要觀念：i, j 是「變化量 (delta)」，不要用「座標」的概念下去想。
寫 for 迴圈的時候，就會知道這問題出在哪了! (可以見文章最下面錯誤的部分)

每次的互換，只同時牽扯到四個東西

示意圖：(看得出來每次互換只扯到四個東西吧?)

我們將每個座標對應的關係，都「仔細地」寫出來!

示意圖：(仔細觀察 i,j 變化量出現的位置，牽扯到 x軸, y軸值上面的移動。)

列成循環算式，並更正方向錯誤的座標。

如果一個「i,j 變化量」的方向錯誤，
我們可以視為「加上(N-1)後，減去變化量的值」，
(可以想想，N-1是最大邊界，不能再更多了，只能再扣掉變化量。)

示意圖：(整理一下就能夠得到我們最終的循環公式囉!)

另外一個大魔王? 什麼時候才是終止條件? (你以為能無腦全部掃過嗎XDD，那就是轉四次回原狀惹)

為什麼不能夠無腦全部掃過?

這就是另外一個大魔王惹，真的不能無腦全部掃過

因為全部掃過 = 轉四次 = 變回原狀，根本沒解到題目XDDD

那要怎麼找到只需要掃一次的東西呢?

什麼時候才是終止條件? (其實也沒那麼難啦XDD)

因為是四角轉換，我們從最簡單的 2*2 來看，是不是就很簡單了呢?
也就是說，放大來看後，我們一樣只需要去抓一個角即可。

示意圖：(四角互換)

先來處理比較容易的「N = 偶數」邊

偶數沒什麼問題，就是稍微算一下範圍確認 for 要到多少即可。
記得 range 的範圍，與實際範圍的不同。

注意: +1, -1 對答案都會有影響XDD 請小心。

再來處理比較難搞的「N = 奇數」邊

奇數就比較麻煩一點點，我們先上一下色，
我們發現 y軸上的分析，需要比 x軸少一格，
不然就會有重複運算的問題。

稍微注意這點也就沒什麼好怕的了。

我們奇偶數不分開處理，再更方便一點

我們仔細分析我們剛剛得到的範圍，(當然你要 N = 奇偶數分開處理一定可以的XD)
幾乎都出現了 in range (N/2)，只有在奇數的時候多出現一個 in range ((N/2)+1)

那這個「1」可以怎麼來呢? 就是只有「奇數」才會來嘛!
所以「N%2 = 1」 (就會得到我們的奇數囉!!)

我們將範圍公式都改寫成：「in range (N/2 + N%2)」，這樣就非常漂亮了!

注意：只有「x軸」需要這個範圍
不要太開心連「y軸」一起用下去了XDD，偶數就會錯惹!!!
(現在你知道這題 +1, -1 的問題真的有夠煩的吧!)

個人範例程式碼 - 2021/4/3 一刷 (方法二，炫炮解法)

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        N = len(matrix) # one side

        # transpose
        for i in range(N):
            for j in range(i+1, N):
                tmp = matrix[i][j]
                matrix[i][j] = matrix[j][i]
                matrix[j][i] = tmp
        # print(f"{matrix}") #dubug

        # right and left reverse
        for i in range(N):
            for j in range(N//2):
                tmp = matrix[i][j]
                matrix[i][j] = matrix[i][-j+(N-1)]
                matrix[i][-j+(N-1)] = tmp

解法說明

直接看圖吧! 這題我們利用「轉90度 = 轉置 + 左右翻轉」的概念
(嗯… 有夠快的…，~~我們剛剛在幹嘛~~)

仔細分析題目的能力還是很重要的!!! (不一定是解題，工作上更是常需要!)

示意圖: (轉90度 = 轉置 + 左右翻轉)

轉置細節：也是不能無聊全部掃過

即使是轉置矩陣，我們也沒辦法無腦掃過XDD，
我們只能掃「一個對角線內的全部值」，
我們可以運用「j = i + 1」來達到我們想要的效果!

左右反轉細節：思考座標點，跟想像的不太一樣

這邊我踩了一個雷，就是我想像中的座標概念，
與實際上的座標概念是不同的。
主要原因是：list[list] 會先讀取到第一個是「該行」矩陣，也就是「y軸」
請務必想清楚這一點，不然就會錯惹QQ (好複雜XDDD)

觀念錯誤筆記

觀念錯誤的部分：i, j 是「變化量 (delta)」，不要用「座標」的概念下去想。
寫 for 迴圈的時候，就會知道這問題出在哪了!

來先解 180度吧，直接看圖!

從圖中我們大概知道，「x軸上的移動，會影響的只會在x軸」
(也許聰明的你已經想到了，90度的影響會跑到y軸去！！！會更複雜!)

所以我們由上圖整理一下我們的x,y軸變化

我們將數值整理一下，
可以發現x軸上 i + offset(變化量)的時候，
對應的 180度 x軸上後的變化量為 i+(N-1)-offset(變化量)

也就是說

i + offset -> i+(N-1)-offset

同理可以推得

j + offset -> j+(N-1)-offset

先有這樣的觀念，我們再來推 90度的答案!

每次的互換，只同時牽扯到四個東西

示意圖：(看得出來每次互換只扯到四個東西吧?)

將它換成 offset

示意圖：(換成 k = offset 之後的圖)

慢慢來，我們把他慢慢的都寫出來

示意圖：(一個個把算式寫出來就對了! 就只有這四行關鍵算式!!!)

Reference

【Leetcode】python - [222] Count Complete Tree Nodes 個人解法筆記

Sat, 28 May 2022 20:50:20 +0800

題目出處

222. Count Complete Tree Nodes

難度

medium

題目分類

Binary Search, Bit Manipulation, Tree, Binary Tree

2022-05-28 一刷

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

# 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 countNodes(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0

        left_depth = self.get_depth(root.left)
        right_depth = self.get_depth(root.right)

        if left_depth == right_depth: # (left completed)
            return 1 + (2**left_depth - 1) + self.countNodes(root.right)
        else: # left_depth > right_depth (right completed)
            return 1 + (2**right_depth - 1) + self.countNodes(root.left)

    def get_depth(self, root):
        if not root:
            return 0

        return 1 + self.get_depth(root.left)

算法說明

拆成兩路進行，兩路我們都直接找「最左下」，比較兩者的深度，此時會有兩種情況

當左右，表示左邊一定是 completed binary tree
當左 > 右，表示右邊一定是 completed binary tree

你可能想問，那「左 < 右」?
不可能，你再想想 completed Tree 的定義XD

因此，我們簡略圖示一下，當「左右」，左邊一定是 completed

當「左 < 右」，右邊一定是 completed

我們可以搭配「2**depth -1」快速計算出 completed tree 的總 node 數。

input handling

處理沒有 root 的情況，return 0

Boundary conditions

用「not root」去控制 traverse tree 的結束。

Reference

统计完全树节点数 · Count Complete Tree Nodes

【Leetcode】python - [62] Unique Paths 個人解法筆記 #重要題型

Mon, 23 May 2022 13:56:05 +0800

題目出處

62. Unique Paths

難度

Medium

題目分類

Math, Dynamic Programming, Combinatorics

2022-05-23 一刷

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

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if not m or not n:
            return 0

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

        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i][j-1] + dp[i-1][j]

        return dp[-1][-1]

算法說明

也是經典的二維 DP 問題，
透過建立下方的圖片，就可以求得所有路徑的答案

(DP 記錄到達那一格的所有方法數)

input handling

如果沒有 m 或 n，return 0 (無方法)

Boundary conditions

用 for 來控制 DP 的範圍

Reference

【Leetcode】python - [78] Subsets 個人解法筆記 #重要題型

Mon, 23 May 2022 13:09:00 +0800

題目出處

78. Subsets

難度

Medium

題目分類

Array, Backtracking, Bit Manipulation

2022-05-23 一刷

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

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

        ans = []
        self.dfs(nums, 0, [], ans)

        # print(ans)        
        return ans

        # [] 
        # [1] [12] [123]
        #     [13]
        # [2] [23]
        # [3]

    def dfs(self, nums, start, combination, ans):

        ans.append(combination[:]) # deepcopy

        # end of recursion        
        # define and split (use or not use)
        for i in range(start, len(nums)):       
            combination.append(nums[i])
            self.dfs(nums, i+1, combination, ans)
            combination.pop() # backtracking

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

算法說明

經典 DFS 的組合問題，思考方式如下：

每一層我們都可以決定「取特定數字或不取」，但取或不取，順序都要一直往後。

input handling

如果沒有 nums，return [[]]

Boundary conditions

用 dfs 內的 for loop 控制搜尋範圍

Reference

子集 · Subsets

【Leetcode】python - [90] Subsets II 個人解法筆記 #重要題型

Mon, 23 May 2022 13:01:52 +0800

題目出處

90. Subsets II

難度

Medium

題目分類

Array, Backtracking, Bit Manipulation

2022-05-23 一刷

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

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

        nums.sort()

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

    def dfs(self, nums, start, combination, ans):

        ans.append(combination[:]) # deepcopy

        # end of recursion, define ans split
        for i in range(start, len(nums)):
            if i > start and nums[i] == nums[i-1]: # only take first duplicate
                continue
            combination.append(nums[i])
            self.dfs(nums, i+1, combination, ans)
            combination.pop()

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

算法說明

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

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

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

我們先 sort() 確保有一致的順序，
我們利用 i > start 來確保跟開始項目相同時，第一組重複有被計算到

注意：不是 i > 0，而是 i > start
start 位置就是代表重複字母的第一個字，除了第一次判斷會拿之外，後面都不會再拿。

if i > start and nums[i] == nums[i-1]: # only take first duplicate
    continue

input handling

如果沒有 nums，return [[]]

Boundary conditions

用 dfs 內的 for loop 控制搜尋範圍

Reference

子集 II · Subsets II

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

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

題目出處

509. Fibonacci Number

難度

Easy

題目分類

Math, Dynamic Programming, Recursion, Memoization

2022-05-22 一刷

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

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

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

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

        return dp[-1]

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

算法說明

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

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

初始化:

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

input handling

都在 for 裡面處理

Boundary conditions

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

例：要求 dp(2)，共需要 0, 1, 2，三個位置。

Reference

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

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

題目出處

2266. Count Number of Texts

難度

medium

題目分類

Hash Table, Math, String, Dynamic Programming

2022-05-10 一刷

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

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

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

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

        # print(dp)
        return dp[-1]

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

算法說明

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

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

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

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

我們可以知道:

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

改寫成程式碼變成：

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

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

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

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

… 以此類推

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

input handling

如果沒有 input ，return 0

Boundary conditions

for loop 控制範圍

Reference

Python | DP with diagrams for beginners

【Leetcode】python - [7] Reverse Integer 個人解法筆記

Fri, 06 May 2022 04:33:38 +0800

題目出處

7. Reverse Integer

難度

medium

題目分類

Math

2022-05-06 一刷

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

class Solution:
    def reverse(self, x: int) -> int:

        negative_flag = False
        if x < 0:
            x = -x
            negative_flag = True

        ans = int(str(x)[::-1])
        if ans >= (1 << 31) -1:
            return 0
        return -ans if negative_flag else ans

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

算法說明

先抽出負號，再直接以 string 的方式顛倒，
需要注意題目要求數值範圍介於 -2^31 ~ 2^31-1 之間，
2^31 = (1 « 31)

input handling

處理負號，拿出來後再丟回去。

Boundary conditions

處理好數字範圍

Reference

反转整数 · Reverse Integer

【Leetcode】python - [268] Missing Number 個人解法筆記

Wed, 04 May 2022 16:31:39 +0800

題目出處

268. Missing Number

難度

easy

題目分類

Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting

2022-05-04 一刷

個人範例程式碼

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

        num_set = set(nums)
        n = len(nums) + 1
        for i in range(n):
            if i not in num_set: # O(1)
                return i

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

算法說明

因為 list 搜尋是 O(N) 時間，
為了加速，先轉成 hashset，搜尋時間變成 O(1)

input handling

如果沒有 input，return 0

Boundary conditions

for loop 控制範圍

個人範例程式碼 - set

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

        num_set = set([x for x in range(len(nums)+1)])
        return (num_set - set(nums)).pop()

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

算法說明

set - set，找到缺少的內容

set.pop() 可以取得 set 裡面的內容，例如從 {2} 中取得 2

input handling

如果沒有 input，return 0

Boundary conditions

for loop 控制範圍

Reference

寻找缺失的数 · Missing Number

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

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

題目出處

264. Ugly Number II

難度

Medium

題目分類

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

2022-04-30 一刷

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

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

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

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

        return cur

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

算法說明

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

input handling

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

Boundary conditions

for 迴圈控制數量

Reference

丑数 II · Ugly Number II

【Leetcode】python - [54] Spiral Matrix 個人解法筆記

Wed, 27 Apr 2022 03:46:15 +0800

題目出處

54. Spiral Matrix

難度

medium

題目分類

Array, Matrix, Simulation

2022-04-27 一刷

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

MOVES = [
    (0, 1),
    (1, 0),
    (0, -1),
    (-1, 0)    
]
class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        if not matrix:
            return []

        x, y = 0, 0
        direction = 0
        visited = {(0, 0)}
        ans = [matrix[0][0]]
        total_num = len(matrix) * len(matrix[0])
        while(len(ans) < total_num):
            next_x, next_y = x + MOVES[direction][0], y + MOVES[direction][1]
            if self.isvalid(next_x, next_y, matrix, visited):
                ans.append(matrix[next_x][next_y])
                visited.add((next_x, next_y))
                x, y = next_x, next_y
            else:
                direction = (direction + 1)%4

        return ans


    def isvalid(self, x, y, matrix, visited):
        r = len(matrix)
        c = len(matrix[0])
        return 0 <= x < r and 0 <= y < c and (x, y) not in visited

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

算法說明

螺旋狀的 traverse 矩陣，
記得設定好邊界條件，就可以處理

input handling

當沒有 matrix 時，return []

Boundary conditions

要處理的條件有

- x, y 邊界 - 有沒有 visited

而結束的判斷條件為

while len(ans) < total_nums，
當得到全部的結果後，就會結束迴圈。

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，並找尋出現的點

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

速度優化

這邊我們可以進行一次數學加速，我們只需要分析 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 - [2243] Calculate Digit Sum of a String 個人解法筆記 | 289th LeetCode Weekly Contest

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

題目出處

2243. Calculate Digit Sum of a String

難度

easy

題目分類

String, Simulation

2022-04-17 一刷

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

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

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

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

        # split
        return self.digitSum(end_string, k)

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

        return str(string_sum)

算法說明

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

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

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

input handling

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

Boundary conditions

注意結束條件：

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

Reference

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

【Leetcode】python - [2] Add Two Numbers 個人解法筆記

Sat, 16 Apr 2022 22:37:42 +0800

題目出處

2. Add Two Numbers

難度

medium

題目分類

Linked List, Math, Recursion

2022-04-16 一刷

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

基本版本

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:

        dummy = head = ListNode(0)
        carry = 0

        while(l1 and l2):
            this_val = l1.val + l2.val + carry
            carry = this_val // 10            
            head.next = ListNode(this_val % 10)
            l1 = l1.next
            l2 = l2.next
            head = head.next
        else:
            while(l1):
                this_val = l1.val + carry
                carry = this_val // 10            
                head.next = ListNode(this_val % 10)
                l1 = l1.next
                head = head.next
            while(l2):
                this_val = l2.val + carry
                carry = this_val // 10            
                head.next = ListNode(this_val % 10)
                l2 = l2.next
                head = head.next
            if carry:
                head.next = ListNode(carry)

        return dummy.next

算法說明

- 當 l1, l2 還有值時，為第一階段 - 其中一個沒有值時，用 while 去將剩下的 l1 或 l2 掃完 - 最後判定有沒有剩餘的 carry

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

input handling

處理 input 為空的情況，這裡我是直接回傳 None。

Boundary conditions

注意 LinkList 的結束條件：

結束的 None 也算是一個節點。會被 if node 判為 False。

與之相對應的是使用 node.next 來判斷，
可是因為 node.next 依然可以走到 None 的 Node，因此容易因此而判錯。

優化版本

優化，將 l1, l2, carry 有無剩餘的內容一起看，一路處理到沒剩餘內容為止。

# Definition for singly-linked list.
# class ListNode
# def __init__(self, val=0, next=None)
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:

        dummy = head = ListNode(0)
        carry = 0
        while(l1 or l2 or carry): # something still exist
            if l1:
                carry += l1.val
                l1 = l1.next
            if l2:
                carry += l2.val
                l2 = l2.next

            head.next = ListNode(carry % 10)
            head = head.next
            carry = carry // 10
        else:
            return dummy.next

Reference

Is this Algorithm optimal or what?

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

Fri, 15 Apr 2022 19:59:02 +0800

題目出處

263. Ugly Number

難度

Easy

題目分類

Math

2022-04-15 一刷

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

class Solution:
    def isUgly(self, n: int) -> bool:
        if not n:
            return False
        if n <= 0:
            return False
        if n == 1:
            return True

        while(n%2 == 0):
            n = n // 2
        while(n%3 == 0):
            n = n // 3
        while(n%5 == 0):
            n = n // 5

        return (n == 1)

算法說明

沒什麼好說的

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

input handling

注意定義，小於等於 0 都不是，return False
等於 1 時，return True

Boundary conditions

當不能整除時，結束迴圈。

Reference

2-4 lines, every language

【Leetcode】python - [50] Pow(x, n) 個人解法筆記

Tue, 05 Apr 2022 20:43:38 +0800

題目出處

50. Pow(x, n)

難度

medium

題目分類

Math, Recursion

2022-04-05 一刷

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

class Solution:
    def myPow(self, x: float, n: int) -> float:
        # write your code here
        # 2 = 1 + 0
        # 7 = 1 + 1 + 1
        # 5 = 1 + 1 + 0
        # 13 = 1 + 1 + 0 + 1
        ans = 1
        minus_flag = False
        if n == 0:
            return 1
        if n < 0:
            minus_flag = True
            n = -n

        while(n > 0):
            if n % 2 == 0:
                pass # print(0)
            else:
                # print(1)
                ans *= x
            x = x * x
            n = n >> 1 # // 2
        else:
            if minus_flag:
                return 1/ans
            else:
                return ans

算法說明

核心概念為，將 n 次方拆成二進位的方式計算 (這樣就不用重複算)

例如 9 = 8 + 0 + 0 + 1，

我們只重複計算 1^2^2^2^2…. 可以減少一半的計算次數，複雜度為 O(n) -> O(logN)

另外處理負數要特別注意。

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

input handling

處理輸入 n = 0 ，return 1,
與輸入 n < 0 ，作負數處理。

Boundary conditions

循環直到當 n 0 時 ( 1//2 = 0 )

Reference

x的n次幂 · Pow(x, n)

【Leetcode】python - [278] First Bad Version 個人解法筆記

Tue, 05 Apr 2022 02:22:32 +0800

題目出處

278. First Bad Version

難度

easy

題目分類

Binary Search, Interactive

2022-04-05 一刷

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

# The isBadVersion API is already defined for you.
# def isBadVersion(version: int) -> bool

class Solution:
    def firstBadVersion(self, n: int) -> int:
        # isBadVersion = true 
        # OOO(X)XXX
        # FFF(T)TTT <- notice this!
        if not n: 
            return 0

        start, end = 1, n

        while(start + 1 < end):
            mid = (start + end) // 2
            if isBadVersion(mid): # [mid] = false (still good version.), move end to search after     
                end = mid
            else: # if isBadVersion(mid) == True: # [mid] = true, move start to search behind
                start = mid

        else:
            if isBadVersion(start):
                return start
            elif isBadVersion(end):
                return end
            else:
                return 0

        return 0

算法說明

變化版本的 binary search，採用的策略為先縮小範圍再得到答案。

也就是說 left, right 縮小至最小範圍的 left, right，再去判斷答案。

當然比較常見的方法是：left, right 找 mid，mid 直接找到答案會更為簡潔。

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

input handling

注意 input nums 為 0 的時候的處理，return 個 0 給他 (題目好像沒特別提到這個，我自己加的)

Boundary conditions

start 與 end 的處理一直都是 binary search 常出錯的地方，這邊要細心一些。

我採用網路上看到的 start + 1 < end 的方式，先縮小 left, right 範圍
並且不把目標放在直接找到 mid 做為答案。

再從最小範圍 left, right 中找到最終解答。

其他重點

注意 isBadVersion 是「錯的」回傳「True」，
這個雙重否定有弄到我XD，
概念要剛好相反。

Reference

第一个错误的代码版本 · First Bad Version

【Leetcode】python - [136] Single Number 個人解法筆記

Thu, 03 Mar 2022 21:38:20 +0800

題目出處

136. Single Number

難度

Easy

題目分類

Array, Bit Manipulation

2022-03-03 一刷

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

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        ans = 0
        for ele in nums:
            ans ^= ele
        return ans

Time Complexity

O(n)

算法說明

這題算是經典題目，因為經典做法太神奇了，
這題考的概念可以用 XOR 漂亮的解出來。

python 裡面，XOR 的符號表示做「^」，
我們運用以下特性，同一個東西重複 XOR 兩次則變回原樣，
就可以在最小時間與空間解決此問題。

0 ^ a = a
a ^ a = 0
b ^ a ^ a = b

corner case 特殊情況處理

Boundary conditions/ Edge conditions 邊際情況處理

注意初始值應該為「0」而不是「1」

Reference

C++ EASY SOLUTIONS - (SORTING , XOR , MAPS (OR FREQUENCY ARRAY))

【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】python - [566] Reshape the Matrix 個人解法筆記內含 array 初始化, index 操作與控制範例

Wed, 02 Mar 2022 16:06:37 +0800

題目出處

566. Reshape the Matrix

難度

Easy

題目分類

Array, Matrix, Simulation

2022-03-02 一刷

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

class Solution:
    def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
        m, n = len(mat), len(mat[0])
        total = m*n
        if total != r*c :
            return mat
        else:
            ans = [[0] * c for _ in range(r)] # count to c, then add one r
            for idx in range(total):
            # origin matrix = [idx//n][idx%n] # which y, and which x
            # notice: [idx//n][idx%n] not m,n
            # after matrix = [idx//n][idx%c] # which y, and which x
            # notice: [idx//c][idx%c] not r,c (r -> auto add axis)
                ans[idx//c][idx%c] = mat[idx//n][idx%n]
            return ans

Time Complexity

O(mn)

算法說明

先判斷是否元素數量相等，
再來去進行移動動作，用 index 去巧妙控制他。

corner case 特殊情況處理

元素數量不相等時，直接回傳原來的答案。

Boundary conditions/ Edge conditions 邊際情況處理

這題可以練習 array 初始化與位置操作相關的技巧，

array 初始化

二維陣列的初始化，
我們可以記憶：

從第一維的 [0] 開始複製，「複製 c 次」完成第一維，
這個動作要「重複做 r 次」，完成複製 r 維。

ans = [[0] * c for _ in range(r)] # count to c, then add one r

元素 index 操作與控制

這裡有個元素 index 操作的技巧，
當我們已經知道所有元素的內容皆會被使用，
而我們只是要單純控制輸出方式時，
像這題中，我們可以發現邏輯上，
我們都是「先完成第一維後，再新增一維」

以這題來說，有另外一個 index 操作技巧，
我們先有「完成一層後，才新增一層」的概念，
因此我們可以很容易用「%」、「//」取餘數、整除，
來獲得相對應的位置。

for idx in range(total):
            # origin matrix = [idx//n][idx%n] # which y, and which x
            # notice: [idx//n][idx%n] not m,n
            # after matrix = [idx//c][idx%c] # which y, and which x
            # notice: [idx//c][idx%c] not r,c (r -> auto add axis)
                ans[idx//c][idx%c] = mat[idx//n][idx%n]

特別注意：取的座標為「//n」、「%n」，而非 m, n，
因為我們真正「決定是否換行、與現在座標餘數」的，都只有 n 。

Reference

[Python] One pass - Clean & Concise