791 - LeetCode 待分類 on 嗡嗡的隨手筆記

【Lintcode】python - [799] Backpack VIII 個人解法筆記

Thu, 02 Jun 2022 16:58:22 +0800

題目出處

難度

medium

2022-06-02 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param n: the value from 1 - n
    @param value: the value of coins
    @param amount: the number of coins
    @return: how many different value
    """
    def back_pack_v_i_i_i(self, n: int, value: List[int], amount: List[int]) -> int:
        # write your code here
        m = len(value)
        dp = [False for _ in range(n+1)]

        dp[0]= True
        current_max_value = 0
        ans = 0

        for i in range(1, m+1):
            cnt = [0 for _ in range(n+1)]
            current_max_value += amount[i-1] * value[i-1]
            for current_value in range(min(n, current_max_value)+1): 
                last_value = current_value - value[i-1]
                if last_value >= 0 and dp[last_value] and (not dp[current_value]) and cnt[last_value] < amount[i-1]: # only found dp[last_value] True, dp[current_value] False
                    ans += 1
                    cnt[current_value] = cnt[last_value] + 1
                    dp[current_value] = dp[current_value] or dp[last_value]
            #     print(cnt)
            # print(dp)

        return ans

算法說明

本題是背包系列問題的第 7 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

第八題，這題我們要處理的是有重複、但有限制使用上限數量的問題。
不同於只能使用一個，也不同於可以使用無線數量，
我們在搜尋時需要多加一個計數器，來幫助我們避免超過使用上限。

一種思維是 [2,4]*[3,1] 直接看做 [2,2,2,4] 來處理，也許會更容易 (就能夠比照單一數量的題目辦理)。

不過處理上這題會有時間要求，如果直接無腦三層 for 迴圈，會發生 TLE。
因此我們會需要做一些修改。

我們可以把同個元素視為一組，再一次 O(n) 運算中就全部算完。
三層 for 我們會要花 O(n^2) 的時間才算得完，使花的時間增加不少。

同時優化空間與時間的版本：

我們只有一個 dp，配上一個我們新宣告的 cnt 作為我們的計數器，
而我們只在 dp[last] = T 且 dp[current] = F 進行操作，理由是：

dp[last] = T，理由是我們本來就應該要確認，先前的數值是組的出來的。
dp[current] = F，理由是我們要排除 1+1, 2 這樣計數器會被增加的情況，實際上我們不需要用 2 就組得出來

三層 for 迴圈的解法 - 會 TLE

這題如果無腦三層 for 迴圈的寫法，會觸發 TLE，導致不能通過。

運算邏輯比較簡單，我們可以參考下圖：

或者以下列的方式理解：

以下就是三層 for 迴圈的程式碼 - 會 TLE

from typing import (
    List,
)

class Solution:
    """
    @param n: the value from 1 - n
    @param value: the value of coins
    @param amount: the number of coins
    @return: how many different value
    """
    def back_pack_v_i_i_i(self, n: int, value: List[int], amount: List[int]) -> int:
        # write your code here
        m = len(value)
        dp = [[False] *(n+1) for _ in range(2)]

        num_of_selected_items = 0
        dp[num_of_selected_items][0]= True
        current_max_value = 0

        for i in range(m):
            for get_i_amount in range(1, amount[i]+1): # get j amount
                num_of_selected_items += 1
                dp[num_of_selected_items%2][0]= True # init
                current_max_value += value[i]
                for current_value in range(min(n, current_max_value)+1): # need update: from 0 to min(n, current_max_value)+1, current_max_value = we take all thing's value
                    dp[num_of_selected_items%2][current_value] = dp[(num_of_selected_items-1)%2][current_value]
                    last_value = current_value - value[i]
                    if last_value >= 0:
                        dp[num_of_selected_items%2][current_value] = dp[num_of_selected_items%2][current_value] or dp[(num_of_selected_items-1)%2][last_value]

                # print(num_of_selected_items, dp)
                # print(dp[num_of_selected_items%2])

        cnt = 0
        for value in range(1, n+1):
            if dp[num_of_selected_items%2][value]:
                cnt += 1

        return cnt

input handling

一同在 dp 內處理

Boundary conditions

用三層 for 來控制搜尋範圍，
外層 for 控制選擇種類，
內層 for 控制上限數量，
最內層 for 使用的金錢上限 (表示我們目前花了多少錢)

Reference

背包问题VIII · Backpack VIII

【Lintcode】python - [798] Backpack VII 個人解法筆記

Thu, 02 Jun 2022 16:34:20 +0800

題目出處

798 · Backpack VII

難度

medium

2022-06-02 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param n: the money of you
    @param prices: the price of rice[i]
    @param weight: the weight of rice[i]
    @param amounts: the amount of rice[i]
    @return: the maximum weight
    """
    def back_pack_v_i_i(self, n: int, prices: List[int], weight: List[int], amounts: List[int]) -> int:
        # write your code here
        m = len(prices)
        dp = [[0]*(n+1) for _ in range(2)] # rotated array
        num_of_selected_items = 0

        for i in range(m): # take one kind of price
            for get_j_amount in range(1, amounts[i]+1): # get j amount 
                num_of_selected_items += 1
                for current_price in range(prices[i], n+1): 
                    dp[num_of_selected_items%2][current_price] = dp[(num_of_selected_items-1)%2][current_price]
                    last_price = current_price - prices[i]
                    if last_price >= 0:
                        dp[num_of_selected_items%2][current_price] = max(dp[num_of_selected_items%2][current_price], dp[(num_of_selected_items-1)%2][last_price] + weight[i]) 
                # print(i, get_j_amount, dp)

        return dp[num_of_selected_items%2][-1]

算法說明

本題是背包系列問題的第 7 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

第七題，這題我們要處理的是有重複、但有限制使用上限數量的問題。
不同於只能使用一個，也不同於可以使用無線數量，
我們在搜尋時需要多加一個計數器，來幫助我們避免超過使用上限。

一種思維是 [2,4]*[3,1] 直接看做 [2,2,2,4] 來處理，也許會更容易 (就能夠比照單一數量的題目辦理)。

input handling

一同在 dp 內處理

Boundary conditions

用三層 for 來控制搜尋範圍，
外層 for 控制選擇種類，
內層 for 控制上限數量，
最內層 for 使用的金錢上限 (表示我們目前花了多少錢)

Reference

背包问题VII · Backpack VII

【Lintcode】python - [801] Backpack X 個人解法筆記

Wed, 01 Jun 2022 19:04:51 +0800

題目出處

801 · Backpack X

難度

medium

2022-06-01 一刷

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

class Solution:
    """
    @param n: the money you have
    @return: the minimum money you have to give
    """
    def back_pack_x(self, n: int) -> int:
        # write your code here
        # 150, 250, 350 = 3, 5, 7 (//50)

        prices = [3, 5, 7]
        target = n // 50
        dp = [price for price in range(target+1)] # 0,1,2,3...

        for current_target in range(1, target+1):
            for price in prices:
                last_price = current_target - price
                if last_price >= 0:
                    dp[current_target] = min(dp[current_target], dp[last_price])

        rest = n % 50
        return dp[-1]*50 + rest

算法說明

本題是背包系列問題的第 10 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

第 10 題，也是背包問題的變化題型，這題我們是變成單位比較大值，
我們替換成鈔票，面額直接是 150, 250, 350 去組合。

首先我們如果直接一個一個處理，時間會太浪費，
因此我們先取最大公因數 [150, 250, 350] = [3, 5, 7]

dp 儲存我們「剩餘的最小價格」。

外圈 for 我們選擇新的幣種，
內圈 for 我們想計算的總額，記得也要先取 //50，並保留 rest = %50。

最後務必記得回傳「rest + dp[-1]*50」，一定要記得還有 rest 的部分！！

input handling

一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for 我們選擇新的幣種 (表示我們擁有新幣種後，可能有的組合。)
內層 for 使用的金錢 (表示我們目前用多少錢去換)

Reference

背包问题X · Backpack X

【Lintcode】python - [800] Backpack IX 個人解法筆記

Wed, 01 Jun 2022 18:45:19 +0800

題目出處

800 · Backpack IX

難度

medium

2022-06-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param n: Your money
    @param prices: Cost of each university application
    @param probability: Probability of getting the University's offer
    @return: the  highest probability
    """
    def backpack_i_x(self, n: int, prices: List[int], probability: List[float]) -> float:
        # write your code here
        # probability of receiving at least one offer = 1 - "(not get offer * not get offer * ...)" <- we record minimum of this 

        dp = [[1] * (n+1) for _ in range(2)] # record no offer probability

        for i in range(1, len(prices)+1):
            for j in range(1, n+1):
                dp[i%2][j] = dp[(i-1)%2][j]
                last_cost = j - prices[i-1]
                if last_cost >= 0:
                    no_offer_prob = dp[(i-1)%2][last_cost] * (1 - probability[i-1])
                    dp[i%2][j] = min(dp[i%2][j], no_offer_prob)

        # print(dp)

        ans = 0
        for each_price_no_offer_prob in dp[len(prices)%2]:
            ans = max(ans, 1 - each_price_no_offer_prob)

        return ans

算法說明

本題是背包系列問題的第 9 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

第九題，我們一間公司最多可以選一次，屬於變化題型的一種，大概念與之前相同。
這題我們要算的是「只少拿到一間公司 offer 的成功機率」，
我們先嘗試推導公式 = 「1 - (沒拿到公司 offer 的機率) * (沒拿到公司 offer 的機率) * (沒拿到公司 offer 的機率) …」
其中，「(沒拿到公司 offer 的機率)」= 「1 - 「(拿到公司 offer 的機率)」」

為了我們處理方便，我們在 dp 中記錄下「min((沒拿到公司 offer 的機率) * (沒拿到公司 offer 的機率) * (沒拿到公司 offer 的機率))…」的這一段。

外圈 for 我們新發現的公司
內圈 for 控制我們目前使用的金錢

優化空間 - 滾動數組

這裡我們先放上優化前的 code (會有「空間超過的問題」)

from typing import (
    List,
)

class Solution:
    """
    @param n: Your money
    @param prices: Cost of each university application
    @param probability: Probability of getting the University's offer
    @return: the  highest probability
    """
    def backpack_i_x(self, n: int, prices: List[int], probability: List[float]) -> float:
        # write your code here
        # probability of receiving at least one offer = 1 - "(not get offer * not get offer * ...)" <- we record minimum of this 

        dp = [[1] * (n+1) for _ in range(len(prices)+1)] # record no offer probability

        for i in range(1, len(prices)+1):
            for j in range(1, n+1):
                dp[i][j] = dp[i-1][j]
                last_cost = j - prices[i-1]
                if last_cost >= 0:
                    no_offer_prob = dp[i-1][last_cost] * (1 - probability[i-1])
                    dp[i][j] = min(dp[i][j], no_offer_prob)

        # print(dp)

        ans = 0
        for each_price_no_offer_prob in dp[-1]:
            ans = max(ans, 1 - each_price_no_offer_prob)

        return ans

我們仔細觀察我們 dp 的運算過程，基本上每一層新的 dp[i][]，
我們都只會參考 dp[i-1][] 的資料而已，(也就說，我們只參考前一層)，

因此我們可以利用這個特性節省空間，宣告空間 i = 2 即可，
而取 i 的變化時，我們取 mod 2，

最後的答案就位於 dp[n%2][volume] 中。

input handling

如果沒有 nums，回傳 0，
其他一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for 發現一間新的公司 (表示這間新的公司，我們決定去或不去有可能有哪些組合。)
內層 for 使用的金錢 (表示我們目前花了多少錢)

Reference

背包问题 IX · Backpack IX

【Lintcode】python - [563] Backpack V 個人解法筆記

Wed, 01 Jun 2022 18:34:58 +0800

題目出處

563 · Backpack V

難度

medium

2022-06-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param nums: an integer array and all positive numbers
    @param target: An integer
    @return: An integer
    """
    def back_pack_v(self, nums: List[int], target: int) -> int:
        # write your code here
        if not nums:
            return 0

        # [1,1,1,1] has 4 ans, remove 1 has 4 choice

        n = len(nums)
        dp = [[0] * (target +1) for _ in range(2)]
        dp[0][0] = 1
        prefix_sum = 0

        for i in range(1, n+1): # take next category of coin
            dp[i%2][0] = 1
            prefix_sum += nums[i-1] 
            for j in range(1, min(target, prefix_sum)+1): # find current max
                dp[i%2][j] = dp[(i-1)%2][j]
                last_volume = j - nums[i-1]
                if last_volume >= 0: # add take new one coin method
                    dp[i%2][j] += dp[(i-1)%2][last_volume]

        return dp[n%2][target]

算法說明

本題是背包系列問題的第 5 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

第五題，我們變成只有有限數量的物品可以拿，求可能的方法總數。
因為拿的順序會影響結果，例如：「(2,2,3) 與 (3,2,2) 是同一個結果」，
我們一開始就先 nums.sort()

但這邊要注意陷阱「同 size 的不同物品，是為不同組合」，例如： [1,1,1,1], target = 3，要算 4 個結果 (可以想像我們是在決定拿掉哪一個)。

外圈 for 我們去控制目前新拿的物品種類
內圈 for 控制目前背包最大的容量

dp 的運作

dp[i][j]，j 代表目前的大小，i 反映我們目前選擇的物件。

優化空間 - 滾動數組

這裡我們先放上優化前的 code (會有「空間超過的問題」)

from typing import (
    List,
)

class Solution:
    """
    @param nums: an integer array and all positive numbers
    @param target: An integer
    @return: An integer
    """
    def back_pack_v(self, nums: List[int], target: int) -> int:
        # write your code here
        if not nums:
            return 0

        # [1,1,1,1] has 4 ans, remove 1 has 4 choice

        n = len(nums)
        dp = [[0] * (target +1) for _ in range(n+1)]
        dp[0][0] = 1

        for i in range(1, n+1): # take next category of coin
            dp[i][0] = 1
            for j in range(1, target+1):
                dp[i][j] = dp[i-1][j]
                last_volume = j - nums[i-1]
                if last_volume >= 0: # add take new one coin method
                    dp[i][j] += dp[i-1][last_volume]

        return dp[-1][-1]

我們仔細觀察我們 dp 的運算過程，基本上每一層新的 dp[i][]，
我們都只會參考 dp[i-1][] 的資料而已，(也就說，我們只參考前一層)，

因此我們可以利用這個特性節省空間，宣告空間 i = 2 即可，
而取 i 的變化時，我們取 mod 2，

最後的答案就位於 dp[n%2][volume] 中。

小優化時間

在內層的 for 迴圈，我們其實每次不一定有必要都算到 target 那麼大，
我們可以知道，多一個新的物品，最大可能的 size 就是前面全選的合。

因此，在內層的 for 迴圈中，
我們可以多取一個「min(target, prefix_sum) + 1」，

可以節省大量的明明算不到 target，卻總是算到 target 位置的時間。

input handling

如果沒有 nums，回傳 0，
其他一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for size (表示這個新的物品，我們決定拿與不拿有可能有哪些組合。)
內層 for volume (表示我們目前背包的大小)

Reference

背包问题 V · Backpack V

【Lintcode】python - [562] Backpack IV 個人解法筆記

Wed, 01 Jun 2022 17:28:05 +0800

題目出處

562 · Backpack IV

難度

medium

2022-06-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param nums: an integer array and all positive numbers, no duplicates
    @param target: An integer
    @return: An integer
    """
    def back_pack_i_v(self, nums: List[int], target: int) -> int:
        # write your code here
        if not nums:
            return 0

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

        nums.sort()
        for num in nums: # take new category by ascending
            for current_target in range(target+1):
                last_target_before_take_this_coin = current_target - num
                if last_target_before_take_this_coin >= 0:
                    dp[current_target] += dp[last_target_before_take_this_coin]

        return dp[-1]

算法說明

本題是背包系列問題的第 4 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

第四題，我們一樣有無限的物品可以拿，只是這題我們要改求可能的方法總數。
因為拿的順序會影響結果，例如：「(2,2,3) 與 (3,2,2) 是同一個結果」，

我們一開始就先 nums.sort()

外圈 for 一樣的是我們控制目前最大的容量
內圈 for 我們去控制目前新拿的物品種類

dp 的運作

初始化一樣 dp[0] = 1
last_volume = current_volume - size
如果 last_volume >= 0， dp[current_volume] += dp[last_volume] # 表示新增的可能性 (因為順序有先 sort 過，剛好會是直接排好的結果)

例如：

dp[3] += dp[2] (dp[2] 的所有可能性 + 1 size)
dp[3] += dp[1] (dp[1] 的所有可能性 + 2 size)

input handling

如果沒有 nums，回傳 0，
其他一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for volume (表示我們目前背包的大小，最大可能的價值)
內層 for value (表示新增「一個」新的種類後，保留目前容量可能的所有可能組合)

Reference

【Lintcode】python - [440] Backpack III 個人解法筆記

Wed, 01 Jun 2022 17:08:25 +0800

題目出處

440 · Backpack III

難度

medium

2022-06-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param a: an integer array
    @param v: an integer array
    @param m: An integer
    @return: an array
    """
    def back_pack_i_i_i(self, a: List[int], v: List[int], m: int) -> int:
        # write your code here
        n = len(a) 
        dp = [0 for _ in range(m+1)] # save max value
        for current_volume in range(m+1):
            for i, size in enumerate(a):
                if current_volume - size >= 0:
                    dp[current_volume] = max(dp[current_volume], dp[current_volume - size] + v[i])

        return max(dp)

算法說明

本題是背包系列問題的第 3 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

這題是給我們無限數量的物品可以拿，我們只提供物品的種類。

因為物品變成可以無限使用，首先我們可想像的第一個問題是，
我們的 i 比照之前方法辦理的話，會有無限個，
這時我們該怎麼辦法？

無限物品數量的思路

最簡單的方法，我們可以把 for 的內外圈對調，就可以輕鬆解決了。
我們的想法變為「背包目前最大的大小」在外圈，
「我們看到不同種類的硬幣」在內圈，因為我們可以無限取用。

拿新物品的前一個體積大小 last_volume = current_volume - size]
我們比較每次 dp[current_volume] = max(dp[current_volume], dp[last_volume] + value[此物品])，
只保留當前背包的最大價值。

input handling

一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for volume (表示我們目前背包的大小，最大可能的價值)
內層 for value (表示新增價值後，保留目前容量可能的最大價值)

Reference

【Lintcode】python - [125] Backpack II 個人解法筆記

Wed, 01 Jun 2022 16:57:21 +0800

題目出處

125 · Backpack II

難度

medium

2022-06-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param m: An integer m denotes the size of a backpack
    @param a: Given n items with size A[i]
    @param v: Given n items with value V[i]
    @return: The maximum value
    """
    def back_pack_i_i(self, m: int, a: List[int], v: List[int]) -> int:
        # write your code here
        # dp[i][j] = max price (i this round take, j volume)
        n = len(a)
        dp = [[0] * (m+1) for _ in range(n+1)]

        for i in range(1, n+1):
            for j in range(1, m+1):
                dp[i][j] = dp[i-1][j]
                last_volume = j - a[i-1]
                if last_volume >= 0:
                    dp[i][j] = max(dp[i][j], dp[i-1][last_volume] + v[i-1])

        print(dp[-1])
        return max(dp[-1])

算法說明

本題是背包系列問題的第 2 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

這題比起第一題，我們多考慮物品的價值，第一題只需要考慮 size 即可。
我們用 dp 保存當下背包的 max value

input handling

一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for size (表示我們選擇新的項目)
內層 for volume (表示紀錄目前已有的選擇下，可否達到裝滿的目標，並記錄最大價值)

Reference

【Lintcode】python - [92] Backpack 個人解法筆記 | 內含背包問題模板 #重要題型

Wed, 01 Jun 2022 16:50:25 +0800

題目出處

92 · Backpack

難度

medium

2022-06-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param m: An integer m denotes the size of a backpack
    @param a: Given n items with size A[i]
    @return: The maximum size
    """
    def back_pack(self, m: int, a: List[int]) -> int:
        # write your code here
        # define: dp[i][j], i = this round take, j = volume
        # dp[i][j] = dp[i-1][j] # last round take
        #          = dp[i-1][j - A[i-1]] # inherit last take, we take new can succeed (only when j - A[i-1] >= 0)

        # ans: last True dp[i][volume?]

        # init: dp[all][0] = True, other False
        dp = [[False]*(m+1) for _ in range(len(a)+1)] # i = m, j = count nums
        dp[0][0] = True

        for i in range(1, len(a)+1):
            dp[i][0] = True
            for j in range(1, m + 1):
                dp[i][j] = dp[i-1][j]
                if j - a[i-1] >= 0: # can take this
                    dp[i][j] = dp[i][j] or dp[i-1][j - a[i-1]]

        # print(dp)
        for i in range(m+1):
            if dp[-1][m-i]: # check max volume
                return m-i

        return -1 # not found

算法說明

本題是背包系列問題的第 1 題，建議初學者可以從第一題開始去學：
第 1 題：最基本的背包問題，不重複 size，物品只有一個，計算組合可能性
第 2 題：最基本的背包問題，不重複 size，物品只有一個，計算最大價值
第 3 題：完全背包問題，有重複 size，物品無限數量，計算最大價值
第 4 題：有重複 size，物品無限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 5 題：有重複 size，物品有限數量，計算可能組合，「(1,2,3) 與 (2,3,1) 視為相同答案」
第 6 題：有重複 size，物品無限數量，計算可能「排列」，也就是說「(1,2,3) 與 (2,3,1) 視為不同答案」
第 7 題：有重複物品，有限制物品數數量上限，問可能組合
第 8 題：有重複物品，有限制物品數數量上限，問最大價值
第 9 題：變化問題，有重複 size，計算機率
第 10 題：變化問題，只是把 size 面額提高

最經典的背包問題，我們用 dp 去解，
要理解背包問題，建議自己畫過一次表，會比較容易理解 DP 邏輯運作的奧妙。

用圖解析 DP 的分析過程

在這題目裡面，因為我們只有單純拿，因此我們不需要注意順序，不用花 O(nlogn) 的時間先 sort()

state

分析概念：我們建立一張表 dp[i][j]， i 位置表示我們這回合要處理的新增物品，j 表示背包目前已經有的大小。

init

初始化時：dp[i][0], dp[0][j] 都為 True，其他 init 為 False

define

dp[i][j] = dp[i-1][j] # default 情況，我們複製上個階段的所有結果。

特殊情況： last_volume = j - nums[i-1] # 表示如果本次我們選擇拿新東西，是否有可能有這個組合的大小。
dp[i][j] = dp[i][j] or dp[i-1][last_volume] # 任意 True 即可

ans

dp[-1][j] # 從最大直到找到第一個 True，就是結果。

input handling

一同在 dp 內處理

Boundary conditions

用兩層 for 來控制搜尋範圍，
外層 for size (表示我們選擇新的項目)
內層 for volume (表示紀錄目前已有的選擇下，可否達到裝滿的目標)

Reference

背包问题 · Backpack

【Leetcode】python - [674] Longest Continuous Increasing Subsequence 個人解法筆記

Sun, 22 May 2022 23:29:58 +0800

題目出處

674. Longest Continuous Increasing Subsequence

難度

easy

題目分類

Array

2022-05-22 一刷

個人範例程式碼 - 單純走過

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

        ans = 0
        cnt = 1
        for i in range(len(nums)):
            if i > 0 and nums[i] > nums[i-1]:
                cnt += 1
            else:
                ans = max(ans, cnt)
                cnt = 1

        ans = max(ans, cnt)
        return ans

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

算法說明

單純走過去，邊走邊看內容，並更新最大。

input handling

如果沒有 nums，回傳 0 (沒數字也不能數)

Boundary conditions

用 for 控制範圍

個人範例程式碼 - stack

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        ans = 0
        stack = []
        for i, num in enumerate(nums):
            if stack:
                if num > stack[-1]:
                    stack.append(num)
                else:
                    ans = max(len(stack), ans)
                    stack = [num]
            else:
                stack = [num]

        ans = max(len(stack), ans)
        return ans

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

算法說明

這題如果用 stack ，其實還能像上面的方法一樣再更簡化，
不過其實 stack 的運用空間已經很小了，其實以結果來講算還可以。

input handling

如果沒有 nums，回傳 0 (沒數字也不能數)

Boundary conditions

用 for 控制範圍

Reference

最长上升连续子序列 · Longest Continuous Increasing Subsequence

【Lintcode】python - [793] Intersection of Arrays 個人解法筆記

Thu, 12 May 2022 03:55:45 +0800

題目出處

793 · Intersection of Arrays

難度

medium

2022-05-12 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param arrs: the arrays
    @return: the number of the intersection of the arrays
    """
    def intersection_of_arrays(self, arrs: List[List[int]]) -> int:
        # write your code here
        ans = set(arrs[0])
        for arr in arrs:
            ans &= set(arr)

        return len(ans)

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

算法說明

題目說不需要重複，那就是瘋狂的 set and 取交集。

input handling

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

Boundary conditions

Reference

【Leetcode】python - [57] Insert Interval 個人解法筆記

Thu, 05 May 2022 20:43:00 +0800

題目出處

57. Insert Interval

難度

medium

題目分類

Array

2022-05-05 一刷

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

class Solution:
    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
        if not intervals:
            return [newInterval]

        ans = []
        for interval in intervals:
            if newInterval[0] > interval[1]: # head
                ans.append(interval)
            elif newInterval[1] < interval[0]: #tail
                ans.append(newInterval)
                newInterval = interval
            else: # merge
                newInterval = [min(interval[0], newInterval[0]), max(interval[1], newInterval[1])]

        ans.append(newInterval) # last
        return ans

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

算法說明

merge 類型變化，
排序時我們處理 min(start), max(end)

input handling

如果沒有 input intervals，return [newInterval]

Boundary conditions

for 到底，處理最後一組 interval，
有個滿漂亮的解法是 merge 之後的我們都使用 newInterval 幫助我們完成任務。

Reference

插入区间 · Insert Interval

【Lintcode】python - [680] Split String 個人解法筆記

Sat, 23 Apr 2022 18:44:55 +0800

題目出處

680 · Split String

難度

medium

2022-04-23 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param s: a string to be split
    @return: all possible split string array
    """
    def split_string(self, s: str) -> List[List[str]]:
        # write your code here
        if not s:
            return [[]]

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


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

        if start == len(s):
            self.ans.append(list(combinations))
            return

        # define and split
        combinations.append(f"{s[start]}")
        self.dfs(s, start+1, combinations)
        combinations.pop() # backtracking

        if start + 1 < len(s):
            combinations.append(f"{s[start:start+2]}")
            self.dfs(s, start+2, combinations)
            combinations.pop() # backtracking

算法說明

簡單來說就是一個求，「拿一個字母」或「拿兩個字母」的組合題目。

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

input handling

注意：如果沒有 s，要回傳的是 [[]]，而不是 []

Boundary conditions

注意邊界條件的設定

會有兩種情況

start 超過 len(s)，錯誤情況，預期不會發生 (也有被下面判斷式限制住)
start 剛好等於 len(s)，剛好的情況，就是我們要的答案

另外，判斷此層的 dfs 時，也有分兩種狀況

s[start]：判斷一個字母的情況
s[start:start+2]：判斷兩個字母的情況的，記得要先判斷「if start+1 < len(s)」，不然直接取座標會出錯

Reference

【Lintcode】python - [90] k Sum II 個人解法筆記

Fri, 22 Apr 2022 22:52:32 +0800

題目出處

90 · k Sum II

難度

medium

2022-04-22 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param a: an integer array
    @param k: a postive integer <= length(A)
    @param target: an integer
    @return: A list of lists of integer
             we will sort your return value in output
    """
    def k_sum_i_i(self, a: List[int], k: int, target: int) -> List[List[int]]:
        # write your code here
        if not a:
            return []

        self.ans = []
        self.dfs(a, k, target, [], 0)
        return self.ans

    def dfs(self, a, k, target, path, start_idx):

        # end of recursion
        if k <= 0:
            if sum(path) == target:
                self.ans.append(list(path)) # deepcopy
            return

        # define and split
        for idx in range(start_idx, len(a)):
            path.append(a[idx])
            self.dfs(a, k-1, target, path, idx+1)
            path.pop() # backtracking

算法說明

此題有類似問題，差別是在這題是「限制可用數字的數量」，可參考：

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

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

組合類的問題，使用 dfs 搜尋出全部的組合，在判斷可行的方案。

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

input handling

如果沒有 a，直接 return []

Boundary conditions

見上述說明

Reference

【Leetcode】python - [228] Summary Ranges 個人解法筆記

Fri, 22 Apr 2022 13:57:58 +0800

題目出處

228. Summary Ranges

難度

easy

題目分類

Array

2022-04-22 一刷

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

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

        ans = []
        tmp_ans = []
        idx = 0
        while(idx < len(nums)):
            tmp_ans.append(nums[idx])
            while idx+1 < len(nums) and nums[idx+1] == nums[idx] + 1:
                idx += 1
                tmp_ans.append(nums[idx])
            else:
                if len(tmp_ans) > 1:
                    s = f"{tmp_ans[0]}->{tmp_ans[-1]}"
                else:
                    s = f"{tmp_ans[0]}"
            ans.append(s)
            idx += 1
            tmp_ans = []
        return ans

算法說明

這題難度不高，麻煩的點在於邊界處理，必須要細心，不然很容易犯錯。

採取的策略是 while-loop 「idx+1 < len(nums) and nums[idx+1] nums[idx] + 1」
要注意的點在於邊界控制「idx+1 < len(nums)」。

另外有嘗試過「nums[idx] nums[idx-1] + 1」，也是可行，不過更要注意邊界控制，
這例子要特別注意「0, 1, 2」這種狀況，有可能 0 被單獨處理掉了。

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

input handling

沒有 input 時，return nums

Boundary conditions

見上述說明

Reference

C++ | 12 lines | put dummy

【Lintcode】python - [578] Lowest Common Ancestor III 個人解法筆記

Thu, 21 Apr 2022 14:46:50 +0800

題目出處

578 · Lowest Common Ancestor III

難度

medium

2022-04-21 一刷

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

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        this.val = val
        this.left, this.right = None, None
"""


class Solution:
    """
    @param: root: The root of the binary tree.
    @param: A: A TreeNode
    @param: B: A TreeNode
    @return: Return the LCA of the two nodes.
    """
    def lowestCommonAncestor3(self, root, A, B):
        # write your code here
        self.found_A = False
        self.found_B = False

        ans = self.lca(root, A, B)
        return ans if (self.found_A and self.found_B) else None

    def lca(self, root, A, B):
        if not root:
            return None

        # divide
        found_left = self.lca(root.left, A, B) # keep traverse
        found_right = self.lca(root.right, A, B) # keep traverse

        if root == A: 
            self.found_A = True
        if root == B:
            self.found_B = True

        # conquer
        if found_left is not None and found_right is not None:
            return root
        elif root in (A, B): # found root in A or B
            return root
        elif found_left:
            return found_left
        elif found_right:
            return found_right
        else:
            return None

算法說明

這已經是系列題目的第四題了，前面可參考

此系列題目的第一題，由於設計上多了 parent node，相對來說比較沒有考到 LCA 的經常考點：

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

此系列題目的第二題，BST 與 BT 只多了比較好找數字，基本上有正確實作 LCA 其實也不用管數字排序：

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

此系列題目的第三題，與這題的差別在於，第四題會需要再多處理 A, B 可能不存在 Tree 中的情況：

https://wongwongnotes.com/posts/algorithm-practice/patterns/leetcode/leetcode-python-236/

修改部分，因為這題需要多處理「不存在樹中的情況」，
我們必須徹底的 traverse 完整棵樹。

這邊使用的策略是

另外建一個 class 中 global 找到的 A, B 的 bool
回傳時，判斷此 node 是否為 A or B (找到的當下回傳)

之所以這樣能找到正確答案是因為，最早回傳的 A or B 會一路往上傳，
而當 parent 如果發現也是 A or B，我們透過回傳「此 root」，就可以把結果洗掉。

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

Reference

578 · Lowest Common Ancestor III

【Lintcode】python - [474] Lowest Common Ancestor II 個人解法筆記

Thu, 21 Apr 2022 03:39:47 +0800

題目出處

474 · Lowest Common Ancestor II

難度

easy

2022-04-21 一刷

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

"""
Definition of ParentTreeNode:
class ParentTreeNode:
    def __init__(self, val):
        self.val = val
        self.parent, self.left, self.right = None, None, None
"""


class Solution:
    """
    @param: root: The root of the tree
    @param: A: node in the tree
    @param: B: node in the tree
    @return: The lowest common ancestor of A and B
    """
    def lowestCommonAncestorII(self, root, A, B):
        # use hashset
        path_of_A = set()
        while(A):
            path_of_A.add(A)
            A = A.parent

        while(B):
            if B in path_of_A:
                return B
            else:
                B = B.parent

        return None

算法說明

LCA 的基本題型，或是說更簡單的，這題中的 TreeNode 設計中多了 parent，使題目更簡單了。

我們可以快速使用 set() 幫我們記憶路徑，從底部往上找 parent，
兩者對比後即可快速得到答案。

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

Reference

474 · Lowest Common Ancestor II

【Lintcode】python - [596] Minimum Subtree 個人解法筆記

Wed, 20 Apr 2022 00:44:09 +0800

題目出處

596 · Minimum Subtree

難度

easy

2022-04-20 一刷

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

from lintcode import (
    TreeNode,
)

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: the root of binary tree
    @return: the root of the minimum subtree
    """    
    def __init__(self): # class variable (global in class)
        self.subtree = TreeNode(0)
        self.subtree_sum = float("inf")

    def find_subtree(self, root: TreeNode) -> TreeNode:
        self.dfs(root)
        return self.subtree

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

        thissum = self.dfs(root.left) + self.dfs(root.right) + root.val
        if thissum < self.subtree_sum:
            self.subtree_sum = thissum
            self.subtree = root

        return thissum

算法說明

基礎的 DFS 用來 traverse Tree 裡面的內容，這次是從底下算上來，慢慢地找最小總和。

這邊我們為了方便處理，我們多寫了一個「def init(self)」給他，
定義了在此 class function 裡面的 global 變數。

不過這樣的寫法不確定好不好，
畢竟題目說不定本來就有內建了 init(self) 在裡面，
而只希望我們調用題目所給的 template「def find_subtree(self, root: TreeNode) -> TreeNode:」並修改這之後的內容。

更新：其實這部分做點小修改就行，我們把具有 global 功能的 self.subtree、self.subtree_sum，
定義於「def find_subtree()」即可。

def __init__(self): # class variable (global in class)
    self.subtree = TreeNode(0)
    self.subtree_sum = float("inf")

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

input handling

Boundary conditions

end of recursion

dfs 直到最 None 的節點，回傳 0

define of recursion

每個 node 的和，等於「左子樹和 + 右子樹和 + 自己」

thissum = self.dfs(root.left) + self.dfs(root.right) + root.val

每次都與 global 的 self.subtree_sum 比較，
如果比較小，就更新 node 與新的最小 sum。

if thissum < self.subtree_sum:
    self.subtree_sum = thissum
    self.subtree = root

split of recursion

我們在上述一併做掉了，請見

thissum = self.dfs(root.left) + self.dfs(root.right) + root.val

Reference

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

Thu, 14 Apr 2022 20:15:54 +0800

題目出處

143 · Sort Colors II

難度

medium

2022-04-14 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param colors: A list of integer
    @param k: An integer
    @return: nothing
    """
    def sort_colors2(self, colors: List[int], k: int):
        # write your code here
        # sort 1~k
        self.partition(colors, 1, k, 0, len(colors)-1)
        return

    def partition(self, colors, color_from, color_to, start, end):
        # end
        if color_from <mark> color_to or start </mark> end:
            return 

        left, right = start, end
        pivot = (color_from + color_to) // 2

        # define
        while(left <= right):
            while(left <= right and colors[left] <= pivot): # if same, left part
                left += 1
            while(left <= right and colors[right] > pivot):
                right -= 1
            if(left <= right):
                colors[left], colors[right] = colors[right], colors[left] # careful infinite loop: left, right still can move

        else: # split
            # print(colors, start, right, left, end)
            self.partition(colors, color_from, pivot, start, right)
            self.partition(colors, pivot+1, color_to, left, end)

算法說明

此題是考 partition 的綜合題。

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

遞迴判斷式

遞迴的定義

# define
while(left <= right):
    while(left <= right and colors[left] <= pivot): # if same, left part
        left += 1
    while(left <= right and colors[right] > pivot):
        right -= 1
    if(left <= right):
        colors[left], colors[right] = colors[right], colors[left] # careful infinite loop: left, right still can move

遞迴的拆解

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

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

start ~ right
left ~ end

self.partition(colors, color_from, pivot, start, right)
self.partition(colors, pivot+1, color_to, left, end)

遞迴的中止

如果「color_from color_to」 or 「start end」，return

「color_from color_to」：已經同顏色，不必再分
「start end」：同位置，不必再分

input handling

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

Boundary conditions

上方已經說明完囉

另解 - 更換中止條件

from typing import (
    List,
)

class Solution:
    """
    @param colors: A list of integer
    @param k: An integer
    @return: nothing
    """
    def sort_colors2(self, colors: List[int], k: int):
        # write your code here
        # sort 1~k
        self.partition(colors, 1, k, 0, len(colors)-1)
        return

    def partition(self, colors, color_from, color_to, start, end):
        # end
        if color_from == color_to:
            return 

        left, right = start, end
        pivot = (color_from + color_to) // 2

        # define
        while(left <= right):
            while(left <= right and colors[left] <= pivot): # if same, left part
                left += 1
            while(left <= right and colors[right] > pivot):
                right -= 1
            if(left <= right):
                colors[left], colors[right] = colors[right], colors[left] # careful infinite loop: left, right still can move

        else: # split
            # print(colors, start, right, left, end)
            if start < right: # still need sorting
                self.partition(colors, color_from, pivot, start, right)
            if left < end: # still need sorting
                self.partition(colors, pivot+1, color_to, left, end)

更換部分

當顏色一樣的時候，中止

# end
if color_from == color_to:
    return

限制範圍才持續往下做 partition (其實也等同於 start end)

if start < right: # still need sorting
    self.partition(colors, color_from, pivot, start, right)
if left < end: # still need sorting
    self.partition(colors, pivot+1, color_to, left, end)

Reference

颜色分类 II · Sort Colors II

【Lintcode】python - [5] Kth Largest Element 個人解法筆記 #重要題型 #常錯題型

Wed, 13 Apr 2022 23:45:45 +0800

題目出處

5 · Kth Largest Element

難度

medium

2022-04-13 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param k: An integer
    @param nums: An array
    @return: the Kth largest element
    """
    def kth_largest_element(self, k: int, nums: List[int]) -> int:
        # write your code here
        if not nums:
            return -1 # not found

        # 1, 2, 3,  first: idx = 2 = len(s)-k (k=1)
        return self.quickselect(k-1, nums, 0, len(nums)-1)

    def quickselect(self, k, nums, start, end):
        if not nums:
            return -1

        # recursion end
        if start == end:
            return nums[k]

        # recursion define
        left, right = start, end
        pivot = nums[(start + end) // 2]
        while(left <= right):
            while(left <= right and nums[left] > pivot): # bigger go to left, descending sorting
                left += 1
            while(left <= right and nums[right] < pivot):
                right -= 1
            if(left <= right):
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
                right -= 1
        else: # recursion split # start < right < left < end
            # print(nums)
            if start <= right and right >= k: # search left and still need sorting
                return self.quickselect(k, nums, start, right)
            elif left <= end and left <= k: # search right and still need sorting
                return self.quickselect(k, nums, left, end)
            else:
                return nums[k]

算法說明

此題有類似題，可參考：

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

最大的差別只在於 smallest 變 largest，簡單處理把 ascending 換成 descending 即可。

這題用到 QuickSelect 的概念，簡單來說就是藉由「每一次都切一半，減少一半的搜尋範圍」，
分出剩餘的另外一半後，再去嘗試切一半，進行 O(logN) 的快速尋找。

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

遞迴判斷式

遞迴的定義

這裡我自己錯好多次，總之不熟悉處理起來很麻煩，

導入 quickselect 的概念，我們把原本要搜尋的範圍切成兩半，
將比 pivot 小的往左擺，大的往右擺，一樣大的先不管

(管了會出事，會有無限迴圈：例 [3, 9, 4, 8]: 9 never moves.)

遞迴的拆解

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

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

start ~ right
left ~ end

可附加條件為「right >= k」、「left <= k」，我們可以提早結束 k 的搜尋。

start ~ right, right >= k：左側還比 k 多，需要再排序
left ~ end, left <= k：右側還比 k 少 (= 左側比 k 多)，需要再排序

遞迴的中止

如果 start end，return nums[k] ，

怎麼保證這一定會發生就是個大問題了，這也是最常出錯的地方，我錯好多次…
簡單來說我們可以想一些比較極端的 case，程式也都要能正常結束。

例如： [1,1]，k = 1 (index 0), k = 2(index 1)

這邊我暫時先這樣想，哪天有更好的想法再回來補吧。

input handling

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

Boundary conditions

上方已經說明完囉

Reference

无序数组K小元素 · Kth Smallest Numbers in Unsorted Array

【Lintcode】python - [461] Kth Smallest Numbers in Unsorted Array 個人解法筆記 #重要題型 #常錯題型

Wed, 13 Apr 2022 14:03:08 +0800

題目出處

461 · Kth Smallest Numbers in Unsorted Array

難度

medium

2022-04-13 一刷

個人範例程式碼 - 1 (相等時結束的討論)

from typing import (
    List,
)

class Solution:
    """
    @param k: An integer
    @param nums: An integer array
    @return: kth smallest element
    """
    def kth_smallest(self, k: int, nums: List[int]) -> int:
        # write your code here
        return self.quickselect(nums, k-1, 0, len(nums)-1)



    def quickselect(self, nums, k, start, end):
        # recusion end
        if start <mark> end: # (</mark>k)
            return nums[k] 

        # recursion define
        left, right = start, end
        pivot = nums[(start + end) // 2]
        # print(nums, pivot, start, end)

        while(left <= right):
            if nums[left] < pivot: # [3, 9, 4, 8]: 9 never moves.
                left += 1
            elif nums[right] > pivot:
                right -= 1
            else:
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
                right -= 1
        else:
            # two part start < right < left < end (<= , >)
            # recursion split
            if right >= k and start <= right:  # search left
                return self.quickselect(nums, k, start, right)
            elif left <= k and left <= end: # search right
                return self.quickselect(nums, k, left, end)
            else:
                return nums[k]

算法說明

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

遞迴判斷式

遞迴的定義

這裡我自己錯好多次，總之不熟悉處理起來很麻煩，

導入 quickselect 的概念，我們把原本要搜尋的範圍切成兩半，
將比 pivot 小的往左擺，大的往右擺，一樣大的先不管

(管了會出事，會有無限迴圈：例 [3, 9, 4, 8]: 9 never moves.)

遞迴的拆解

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

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

start ~ right
left ~ end

可附加條件為「right >= k」、「left <= k」，我們可以提早結束 k 的搜尋。

start ~ right, right >= k：左側還比 k 多，需要再排序
left ~ end, left <= k：右側還比 k 少 (= 左側比 k 多)，需要再排序

遞迴的中止

如果 start end，return nums[k] ，

怎麼保證這一定會發生就是個大問題了，這也是最常出錯的地方，我錯好多次…
簡單來說我們可以想一些比較極端的 case，程式也都要能正常結束。

例如： [1,1]，k = 1 (index 0), k = 2(index 1)

這邊我暫時先這樣想，哪天有更好的想法再回來補吧。

input handling

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

Boundary conditions

上方已經說明完囉

稍微修改一下解，修改一下定義式

這邊可以將上面的解答稍微修改一下，可能概念上會更漂亮一些。(因人而異)

主要修改的是迴圈的方式，上面的作法是「外圍跑完 N 輪，每一輪都會有決定要幹嘛」，
這邊的作法是「外圍只是限制，而每一次的 pointer 都直接迴圈到下一個要更改的點」。

概念大同小異，可以依個人決定哪個程式碼比較漂亮而決定採用哪一個。

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

Reference

无序数组K小元素 · Kth Smallest Numbers in Unsorted Array

【Lintcode】python - [31] Partition Array 個人解法筆記 #重要題型

Sat, 09 Apr 2022 20:54:57 +0800

題目出處

31 · Partition Array

難度

medium

2022-04-09 一刷

個人範例程式碼 - 1 (相等時結束的討論)

from typing import (
    List,
)

class Solution:
    """
    @param nums: The integer array you should partition
    @param k: An integer
    @return: The index after partition
    """
    def partition_array(self, nums: List[int], k: int) -> int:
        # write your code here
        if not nums:
            return 0

        start, end = 0, len(nums)-1

        while(start < end):
            if nums[start] < k:
                start += 1
            elif nums[end] >= k:
                end -= 1  
            else: 
                nums[start], nums[end] = nums[end], nums[start]
                start += 1
                end -= 1
        else:
            #  the first index i nums[i] >= k
            if nums[start] >= k:
                return start
            elif nums[end] >= k:
                return end
            else:
                return end+1 # special case, all < k

算法說明

基本的 partition 作法，#重要題型

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

input handling

處理 input 為 [] 的情況，輸出 0

Boundary conditions

注意結束條件，start < end ，表示當「start end」會結束。

特殊情況：全部 < k

這時候依照題目敘述，我們應該要回傳 end + 1，
但 end + 1，不會在我們的搜尋範圍，因此「我們需要特別做討論」。

個人範例程式碼 - 2 (start 超過 end 時才結束的討論)

from typing import (
    List,
)

class Solution:
    """
    @param nums: The integer array you should partition
    @param k: An integer
    @return: The index after partition
    """
    def partition_array(self, nums: List[int], k: int) -> int:
        # write your code here
        if not nums:
            return 0

        start, end = 0, len(nums)-1

        while(start <= end):
            if nums[start] < k:
                start += 1
            elif nums[end] >= k:
                end -= 1  
            else: 
                nums[start], nums[end] = nums[end], nums[start]
                start += 1
                end -= 1
        else:
            return start

算法說明

基本的 partition 作法，#重要題型
這裡展示另外一種作法，是為了處理 end + 1 搜尋

透過改變條件「start <= end」，因此只有當 start 與 end 交錯時才會終止。
當全部 < k 時，start 會走到 end + 1 並結束。

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

input handling

處理 input 為 [] 的情況，輸出 0

Boundary conditions

注意結束條件，start <= end ，表示當 start 與 end 相交會結束。

特殊情況：全部 < k

在這個 case 當中，我們改變了條件「start <= end」，
因此如果全部都 < k 的情況 start 會走到 end + 1，得到最終結果。

Reference

数组划分 · Partition Array

【Lintcode】python - [382] Triangle Count 個人解法筆記

Sat, 09 Apr 2022 20:14:41 +0800

題目出處

382 · Triangle Count

難度

medium

2022-04-09 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param s: A list of integers
    @return: An integer
    """
    def triangle_count(self, s: List[int]) -> int:
        # write your code here
        if not s:
            return 0

        ans = 0 
        s.sort()

        for idx, max_edge in enumerate(s):
            # ans = self.count_triange_fix_max_edge(max_edge, ans, s, start=idx+1, end=len(s)-1)
            ans = self.count_triange_fix_max_edge(max_edge, ans, s, start=0, end=idx-1) # notice this !!!!!
        return ans

    def count_triange_fix_max_edge(self, max_edge, ans, s, start, end):
        while(start < end):
            if s[start] + s[end] > max_edge:
                ans += (end -start)
                end -= 1 # too big
            else: # if s[start] + s[end] <= max_edge:
                start += 1 # too small
        else:
            return ans

算法說明

3Sum 的延伸題，3Sum 可以視為 a + b = c 的問題，
此題為 a + b > c 的題型 (建議先解完 3Sum 再過來解此題。)

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

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

input handling

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

Boundary conditions

解這題要特別小心，很多細節要處理

1. 注意「最大邊」設定為哪一邊

我的策略是一開始就要決定好哪邊是最大邊，

2. 設定好「最大邊」後，討論結果的範圍

特別注意我們決定好「最大值」後，搜尋的範圍在 0 ~ 「idx-1」，

因此

# ans = self.count_triange_fix_max_edge(max_edge, ans, s, start=idx+1, end=len(s)-1) # wrong !!!
ans = self.count_triange_fix_max_edge(max_edge, ans, s, start=0, end=idx-1) # notice this !!!!!

3. 移動範圍

因為題目只要求「計數」，因此這邊我們相對不用處理到太細節，
而要使結果滿足 a + b > c 的情況有兩種可能，

我們先固定 c 後：「a 增加」或「b 減少」

這裡有個加速的做法，因為我們知道當 a + b > c 的 b 已經滿足時，剩下的「b -> c」範圍等式必定成立，
因此我們可以直接「ans += (c-b)」，再來移動「結束位置」 (end -= 1)

而一般情況是，start += 1，來去滿足「還不夠大」的部分。

Reference

三角形计数 · Triangle Count

【Leetcode】python - [Google | Onsite] Two Sum - Closest to Target 個人解法筆記 (Lintcode - 533)

Thu, 07 Apr 2022 18:16:33 +0800

題目出處

難度

medium

2022-04-07 一刷

個人範例程式碼 - two pointers

from typing import (
    List,
)

class Solution:
    """
    @param nums: an integer array
    @param target: An integer
    @return: the difference between the sum and the target
    """
    def two_sum_closest(self, nums: List[int], target: int) -> int:
        if not nums:
            return -1

        ans = float("inf") # biggest value

        nums.sort()
        start, end = 0, len(nums) - 1
        while(start < end):
            print(ans)
            if target - (nums[start] + nums[end]) == 0:
                return 0 # early return
            elif target > (nums[start] + nums[end]): # sum is smaller than target
                ans = min(ans, target - (nums[start] + nums[end]))
                start += 1
            else: # target < (nums[start] + nums[end]) # sum is bigger than target
                ans = min(ans, (nums[start] + nums[end]) - target)
                end -= 1
        else:
            return ans

算法說明

先 sort 後以 two pointers 處理，這邊容易有個思考上的盲點，
就是如果「減去負數」的處理不就「數值會變更大」了嗎?

這部分可以看下圖：

我們會發現其實 target 的移動與結果影響不大。
就算是"減去"“負的”，也只是「往離 target」更遠的方向前進。

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

input handling

處理 input 為 [] 的情況，輸出 -1。 (題目沒說，但做為表示找不到結果)

Boundary conditions

結束條件

相向相交時，start < end

Reference

两数和的最接近值 · Two Sum - Closest to target

【Leetcode】python - [Amazon | OA 2019] Two Sum - Unique Pairs 個人解法筆記 (Lintcode - 587)

Thu, 07 Apr 2022 17:31:08 +0800

題目出處

難度

medium

2022-04-07 一刷

個人範例程式碼 - two pointers

from typing import (
    List,
)

class Solution:
    """
    @param nums: an array of integer
    @param target: An integer
    @return: An integer
    """
    def two_sum6(self, nums: List[int], target: int) -> int:
        if not nums:
            return 0

        nums.sort()
        ans = 0
        start, end = 0, len(nums)-1
        while(start < end):
            if(start > 0 and nums[start] == nums[start - 1]):
                start += 1
                continue
            if(end < len(nums)-1 and nums[end] == nums[end + 1]):
                end -= 1
                continue

            if nums[start] + nums[end] == target:
                ans += 1
                start += 1
                end -= 1
            elif nums[start] + nums[end] < target:
                start += 1
            else: # nums[start] + nums[end] > target:
                end -= 1
        else:
            return ans

算法說明

簡單的組合，先 sort 後以 two pointers 處理，
而注意重複，這邊以第一次就去做為準下去寫。

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

input handling

處理 input 為 [] 的情況，輸出 0。

Boundary conditions

結束條件

相向相交時，start < end

處理重複

這邊以第一次就去做為準下去寫。

因此有

if(start > 0 and nums[start]  nums[start - 1]):
    start += 1
    continue
if(end < len(nums)-1 and nums[end]  nums[end + 1]):
    end -= 1
    continue

特別注意「start > 0」、「end < len(nums)-1」這兩個部分。

Reference

两数之和 - 不同组成 · Two Sum - Unique pairs

【Lintcode】python - [140] Fast Power 個人解法筆記

Tue, 05 Apr 2022 20:48:27 +0800

題目出處

140 · Fast Power

難度

medium

2022-04-05 一刷

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

class Solution:
    """
    @param a: A 32bit integer
    @param b: A 32bit integer
    @param n: A 32bit integer
    @return: An integer
    """
    def fast_power(self, a: int, b: int, n: int) -> int:
        ans, tmp = 1, a 
        while(n > 0):
            if(n % 2 == 1):
                ans = (ans * tmp) % b

            tmp = (tmp * tmp) % b 
            n = n // 2
        else:
            return ans % b

算法說明

有非常類似的問題，詳細說明可參考：【Leetcode】python – [50] Pow(x, n) 個人解法筆記

核心概念為，將 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

快速幂 · Fast Power

【Lintcode】python - [447] Search in a Big Sorted Array 個人解法筆記

Tue, 05 Apr 2022 16:29:26 +0800

題目出處

447 · Search in a Big Sorted Array

難度

medium

2022-04-05 一刷

個人範例程式碼 - Binary Search

class Solution:
    """
    @param reader: An instance of ArrayReader.
    @param target: An integer
    @return: An integer which is the first index of target.
    """
    def searchBigSortedArray(self, reader, target):
        start, end = 0, 1
        while(reader.get(end) <= target):
            end *= 2

        while(start + 1 < end):
            mid = (start + end) // 2
            if(reader.get(mid) == target):
                end = mid
            elif(reader.get(mid) < target):
                start = mid
            else: # (reader.get(mid) > target):
                end = mid
        else:
            if(reader.get(start) == target):
                return start
            elif(reader.get(end) == target):
                return end
            else:
                return -1

算法說明 - Binary Search

先不斷的 *=2 放大 end，直到找到一個比較可靠的右邊界為止

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

input handling

應該要做但我沒做XD，不過題目有保證輸入正確就是

Boundary conditions

binary search 的邊界條件

這裡有兩個 Boundary conditions 要注意，一個是一開始的 binary search 的邊界條件

個人範例程式碼 - Exponential backoff (倍增)

class Solution:
    """
    @param reader: An instance of ArrayReader.
    @param target: An integer
    @return: An integer which is the first index of target.
    """
    def searchBigSortedArray(self, reader, target):
        # write your code here
        first_element = reader.get(0)
        if first_element == target:
            return 0
        if first_element > target:
            return -1

        idx, jump = 0, 1
        while(jump):
            while(jump and reader.get(idx + jump) >= target): # bigger or same
                jump = jump // 2 # >> 1 # until 0
                print(jump)
            else: # when smaller
                idx += jump
                jump = jump * 2 # << 1 
        else:
            if reader.get(idx+1) == target:
                return idx+1
            else: # reader.get(start) > target:
                return -1

        return -1

算法說明 - Exponential backoff (倍增)

倍增法的概念，先不斷放大，當超過時再縮小範圍搜尋。

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

畫個示意圖吧!

input handling

應該要做但我沒做XD，不過題目有保證輸入正確就是

Boundary conditions

當 >= target 時，縮小 jump
當 < target 時，利用 idx + jump，並 jump 不斷的增加

Reference

python 「>>， <<」用法，BitwiseOperators

BitwiseOperators

- [在大数组中查找 · Search in a Big Sorted Array](https://www.jiuzhang.com/solution/search-in-a-big-sorted-array/)

【Lintcode】python - [458] Last Position of Target 個人解法筆記

Fri, 01 Apr 2022 16:26:39 +0800

題目出處

458 · Last Position of Target

難度

easy

2022-04-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param nums: An integer array sorted in ascending order
    @param target: An integer
    @return: An integer
    """
    def last_position(self, nums: List[int], target: int) -> int:
        # write your code here
        if not nums:
            return -1

        start, end = 0, len(nums)-1
        while(start + 1 < end):
            mid = (start + end) // 2
            if (nums[mid] == target): # find last, move start
                start = mid
            elif (nums[mid] < target):
                start = mid
            else: # (nums[mid] > target):
                end = mid
        else: # when quit loop
            if nums[end] == target:
                return end
            elif nums[start] == target:
                return start
            else:
                return -1

        return -1

算法說明

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

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

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

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

input handling

注意 input nums 為 [] 的時候的處理，return 個 -1 給他

Boundary conditions

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

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

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

Reference

目标最后位置 · Last Position of Target

【Lintcode】python - [14] First Position of Target 個人解法筆記

Fri, 01 Apr 2022 16:24:41 +0800

題目出處

14 · First Position of Target

難度

easy

2022-04-01 一刷

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

from typing import (
    List,
)

class Solution:
    """
    @param nums: The integer array.
    @param target: Target to find.
    @return: The first position of target. Position starts from 0.
    """
    def binary_search(self, nums: List[int], target: int) -> int:
        # write your code here
        if not nums:
            return -1

        start, end = 0, len(nums)-1
        while(start + 1 < end):
            mid = (start + end) // 2
            if(nums[mid] == target): # find first, move end
                end = mid
            elif(nums[mid] < target):
                start = mid
            else: # (nums[mid] > target):
                end = mid
        else: # when quit loop
            if nums[start] == target:
                return start
            elif nums[end] == target:
                return end
            else: # not found
                return -1
        return -1

算法說明

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

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

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

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

input handling

注意 input nums 為 [] 的時候的處理，return 個 -1 給他

Boundary conditions

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

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

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

Reference

二分查找 · First Position of Target