Dynamic Programming on 跟著 Desolve 學程式

從LeetCode學演算法 - 100 Dynamic Programming (14)

Mon, 20 Jul 2020 00:00:00 +0800

1510. Stone Game IV (Hard)

寫在前面

扣掉第0篇外，這篇是100篇啦！！！**從開始寫以來，一路到現在其實也不容易，
雖然頻率因為工作和開課的關係降低很多，
但希望大家仍然從文章中能有所收穫。

100篇好像應該要來個感恩回饋(?)
那這樣好了，如果有任何問題，
歡迎在本篇底下發問(Python Taiwan也可以)，
同時請在Python Taiwan的連結本篇文的文章 底下，
公開分享到你的臉書、按讚該篇文章、並留言告訴我說，
「你最喜歡這一整個系列的哪一篇？為什麼？」或
「除了從LeetCode學演算法系列以外，
你還想要看到關於什麼方向的文章？」
超過20則留言的話 (有完成以上步驟的才算)，我們就抽一組
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」
課程的免費兌換券進行贈送！

截止時間為7/31 23:59:59，這之後的留言問題我有看到還是會回答，
但就不會納入抽獎資格歐！

如果留言人數不足的話，
那我可能就以一篇文章的形式來回應大家的問題，
就不會進行抽獎囉XD

感謝大家的支持與肯定，期待我們都能從這當中(我寫文章，你們讀文章XD)
不斷成長，進而提升自己的程式能力！

容筆者工商一下，
「從Leetcode學演算法｜進階篇」 開放預購啦！
這次選了40道難度加深的LeetCode題目，
同樣也會細部解說對應的技巧及須要掌握的演算法！
同時這次購買進階篇的話，
額外還加贈**「從Leetcode學演算法｜面試篇」** ！面試篇已經全數上傳啦~
當中包含了面試準備須知分享 ，及訪談國內外不同經驗的工程師 ，
讓你不論是想走前端/後端/一般軟工 或者是想找國外的工作 ，
是初學想轉職 還是正在工作 ，都能夠從中得到收穫呦！
有興趣的朋友可以使用下面的早鳥優惠～
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」 ：
https://bit.ly/advleetcode

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

Question

Alice and Bob take turns playing a game, with Alice starting first.

Initially, there are n stones in a pile. On each player’s turn, that player makes a move consisting of removing any non-zero ** square number** of stones in the pile.

Also, if a player cannot make a move, he/she loses the game.

Given a positive integer n. Return True if and only if Alice wins the game otherwise return False, assuming both players play optimally.

Example 1

1
2
3


Input: n = 1
Output: true
Explanation: Alice can remove 1 stone winning the game because Bob doesn't have any moves.

Example 2

1
2
3


Input: n = 2
Output: false
Explanation: Alice can only remove 1 stone, after that Bob removes the last one winning the game (2 -> 1 -> 0).

Example 3

1
2
3


Input: n = 4
Output: true
Explanation: n is already a perfect square, Alice can win with one move, removing 4 stones (4 -> 0).

Example 4

1
2
3
4
5


Input: n = 7
Output: false
Explanation: Alice can't win the game if Bob plays optimally.
If Alice starts removing 4 stones, Bob will remove 1 stone then Alice should remove only 1 stone and finally Bob removes the last one (7 -> 3 -> 2 -> 1 -> 0).
If Alice starts removing 1 stone, Bob will remove 4 stones then Alice only can remove 1 stone and finally Bob removes the last one (7 -> 6 -> 2 -> 1 -> 0).

Example 5

1
2
3


Input: n = 17
Output: false
Explanation: Alice can't win the game if Bob plays optimally.

分析/解題

Alice和Bob玩不膩的撿石頭遊戲又來啦！
這次一樣是Alice先開始，一堆石頭裡面有n個石頭，每次玩家行動時，
可以選擇拿走某個非0的平方數的石頭數量，稱為一次行動。
(也就是1的平方、2的平方、3的平方…等)
當有人無法作任何行動的時候(也就是沒有任何石頭能拿)，就輸惹QQ
給定正整數n代表石頭的個數，如果Alice確定可以贏遊戲的話，
就回傳True，反之則回傳False。(假定雙方都採最佳的策略來進行)

由於每次要拿非0的平方數，所以不能pass，
這就保證了遊戲一定會結束，
因為最後一定會拿到空掉，下一個人會輸掉。

我們來考慮一下前面幾個狀況，來觀察一下有沒有什麼規律：
n = 0: False -> 顯然就是輸了嘛XD
n = 1: True -> Alice拿走1顆(1²)，由於拿光了，所以Alice贏。
n = 2: False -> Alice只能選擇拿1顆，Bob再拿1顆就沒了，Alice輸掉。
n = 3: True -> 只有1, 1, 1的選擇，所以Alice贏
n = 4: True -> Alice拿走4顆(2²)，直接獲勝

看起來好像沒有很明顯對吧？
但這邊可以從題目中思考到一個關鍵，由於雙方都是以最好的策略，
也就是Bob不會該贏卻沒贏 ，所以以下兩點是我們可以確定的：
1. 當n直接是完全平方數時，Alice可以贏
2. 當n=x會讓Bob贏(Alice輸)的時候，n在以下狀況時Alice會贏：
x+1, x+4, x+9, x+16…
因為這時候Alice只要拿掉對應的石頭，讓Bob碰到x的狀況，
這時候就反而變成Bob會輸了！
(Alice先拿會輸的狀況，換成Bob先拿也會輸)

由於這個狀況只限定於我們發現前一個False，
所以我們必須從已經確定的值去推論，
假設今天我們想要知道n = i的值是否為True ，
我們需要先知道n=0~i-1的值 ，
接著檢查是否有任何一個n=i-j² 的結果是False (留意j²要小於等於i )
只要有一個符合，那n=i的值就是True，
如果全部檢查完都沒有的話，n=i的值即為False。
由於n=i的值會跟前面n=i-j²的結果有關係，
這是一個很明顯的動態規劃的題目。

因此，我們的程式流程應該像這樣：

先初始化dp的陣列 ，其長度為n+1，並先全初始化成False。
執行一個迴圈，讓i從1~n (0已經是False了直接跳過) ：
2-1. 在裡面再開一個迴圈，讓j從1遞增到最大j² == i 為止
2-2. 若dp[i - j²]為False，將dp[i]設為True 並且break 離開這層迴圈
(已經確定True就不用往下找了)
整個雙層迴圈完成後，我們應該處理完成了整個dp的陣列，
只要回傳dp[n] 即可。

依此，寫成程式碼如下：

Java

Java的部分，由於boolean陣列初始化的預設值就是False，
就不用額外作初始化了。(C++的話還是記得要初始化啊！)
要使用ArrayList也可以，但長度確定固定的話，其實直接開陣列比較快。

Python

Python的部分，我們當然也可以一路append，
但直接初始化串列比較乾脆，內層的迴圈則使用while來檢查條件，
不要忘記每次將j遞增。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(n^(3/2))/O(n) 外層迴圈要跑n次，內層最大是根號n；
空間上使用dp的陣列/串列外，沒有額外的需求了)

相似及延伸

1140. Stone Game II (Medium)

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

別忘了，要抽獎的讀者記得去Python Taiwan按讚留言分享歐！

另外，「從Leetcode學演算法｜基礎篇」 已經回原價囉，
先前的優惠碼會失效，但這邊仍然為讀者保留了300塊的折抵，
雖然整捆一起買總體比較划算 (差290而已就有整組了阿XD)，
如果你還是想先試試基礎課的話，
300元折抵的連結 在這邊：
https://bit.ly/1desolve

從LeetCode學演算法 - 97 Dynamic Programming (13)

Wed, 17 Jun 2020 00:00:00 +0800

0368. Largest Divisible Subset (Medium)

寫在前面

容筆者工商一下，
「從Leetcode學演算法｜進階篇」 開放預購啦！
這次選了40道難度加深的LeetCode題目，
同樣也會細部解說對應的技巧及須要掌握的演算法！
同時這次購買進階篇的話，
額外還加贈**「從Leetcode學演算法｜面試篇」** ！
當中包含了面試準備須知分享 ，及訪談國內外不同經驗的工程師 ，
讓你不論是想走前端/後端/一般軟工 或者是想找國外的工作 ，
是初學想轉職 還是正在工作 ，都能夠從中得到收穫呦！
有興趣的朋友可以使用下面的早鳥優惠～
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」 ：
https://bit.ly/2desolve

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/adesolve

Question

Given a set of distinct positive integers, find the largest subset such that every pair (Si, Sj) of elements in this subset satisfies:

Si % Sj = 0 or Sj % Si = 0.

If there are multiple solutions, return any subset is fine.

Example 1

1
2


Input: [1,2,3]
Output: [1,2] (of course, [1,3] will also be ok)

Example 2

1
2


Input: [1,2,4,8]
Output: [1,2,4,8]

分析/解題

給定一個內含不同正整數的集合，找出最大的子集合，使得當中任取一對元素(Si, Sj)出來均能符合Si整除Sj或Sj整除Si。
如果有多個不同的解，回傳當中任何一個都可以。

首先我們可以先想到，在這個題目當中顯然nums是沒有被排序的，
如果以最笨的辦法來說的話，一個集合會擁有2^N個子集合
(因為每個元素都可以選擇要在這個子集合或不在這個子集合內)，
而每個組合當中如果又要兩兩檢查的話，又要各自花上n(n-1)/2的時間。
(n為該子集合的元素數量)
顯然直接考慮是非常不符合的，所以只好嘗試先排序過後，
看看能得到什麼可以用的特性。

那在排序過後，我們會想到一個點是，如果我們由小到大看的話，
假設前面選取了a跟b，那下一個選取的數c只需要確定能被b整除即可。
為什麼？因為按順序由小到大排，所以當我們選b的時候，
一定是要b能被a整除才行，於是後面接續的選擇，
只要確保能被最後一個數整除，就會符合能被前面的其他數整除了！

接著下來，假設我們觀察一下數列的規律：
假設有一個數列是1, 2, 3, 4, 6, 8, 12, 18，
我們可以稍微列出幾串能成立Divisible Subset的內容
(先不考慮有沒有最大個數)：
1, 2, 4 , 8
1, 3, 6, 12
1, 3, 6, 18
1, 2 , 6, 12
1, 2, 6, 18

有沒有發現，當中間選的不一樣，後面能接的數字也就不一樣，
從最大的數字往回推的時候，上一個index就有可能因而改變。

由於我們在考慮的是如何去找前面已經選取的子集合，
和下面要選取的數的關係，所以這基本上就是動態規劃的題目跑不了XD!

那麼，該怎麼樣定這中間的關係呢？
首先選取我們的dp，這個值要能夠拿來比較哪個子集合是擁有最多元素的，
那我們不妨這麼定義：
dp[i]就是從已經排序好的nums中，從index 0~i的數字中，
選取出來最大可整除的子集合其元素的個數，且這個子集合當中必須包含nums[i]。為什麼要定義必須包含nums[i]呢？因為不管怎麼樣，
最起碼可以選取index i，這樣子我們就可以將所有dp[i]先初始化為1 ，
因為這是它的保底。

接下來，我們要怎麼去紀錄當確立一個子集合的時候，
整個子集合的長相呢？
可以利用每個比較大的數只需要看前面一個數是否能將其整除的特性，
定義一組陣列或串列，當中存放符合前面dp定義的時候，
nums[i]的對應到前面一個數的index在哪裡 ，
將其稱呼為lidx(last index)。我們在找到最大的解的時候，
後續可以利用lidx來列出整個解。因此，將lidx全部初始化為-1 ，
當我們最後迴圈找尋遇到-1的時候，就表示整個解都被我們列出來了。

那接下來就簡單了，定義一個全局最大解所在的索引值max_idx，
以及最大解的元素總數max_dp，分別初始化成0跟1。
接下來我們需要一個雙層的迴圈，第一層迴圈是i從0開始到nums尾端 ，
以nums[i]做為當下這個子集合的最大值。
而第二層迴圈則是j從i-1開始到0 ，
目的是要一路往回找nums[i]是否整除nums[j]。
如果整除的話，代表有一個子集合的排列方式是：
…… , nums[j], nums[i]
這個子集合是不是對i來說是最好的狀況呢？
那就要看dp[j]+1是不是比dp[i]還要大 ，
如果比較大，才表示i的排列要換成走j這條線對吧XD？
所以比較大 的話，我們就應該要把dp[i]的值改成dp[j] + 1 ，
並且lidx[i]要改成j (因為改成走nums[j]這條路了)。
每次將j走完以後，dp[i]有可能被改變，
自然全局最大的解也有可能被改變，所以我們要檢查看看，
如果需要更動，就進行更動。

如此完成了雙層迴圈後，
最後就從max_idx開始以一個單層迴圈將解列出來 ，
記得迴圈的結束條件是index碰到-1 (代表已經到頭了)。

依此，寫成程式碼如下：

Java

Java的部分，可以用Arrays.fill來進行填充初始值的動作，
其他則是使用ArrayList來將res一個一個加入(要用LinkedList也可以)。
最後一個for迴圈的部分，如果使用者不想留max_idx，
也可以直接使用while來操作，
每次的下一步則是max_idx = lidx[max_idx] 。

Python

Python的部分則是用[x] * n的方式來初始化，其他的部分跟Java並無不同。
請留意將串列原地排要用nums.sort() ，
如果用sorted(nums) 的話則是會回傳一個新的排序好的串列 。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N²)/O(N)，因為時間用到雙層迴圈，每層都是O(N)要相乘，
而O(N²)會大於排序用的O(NlogN)，所以就取O(N²)；
空間上則用到dp跟lidx，均為O(N))

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 95 Dynamic Programming (12)

Sat, 06 Jun 2020 00:00:00 +0800

1143. Longest Common Subsequence (Medium)

寫在前面

容筆者工商一下，
接下來**「從Leetcode學演算法｜進階篇」** 即將於6/9 開放預購啦！
這次選了40道難度加深的LeetCode題目，
同樣也會細部解說對應的技巧及須要掌握的演算法！
同時這次購買進階篇的話，
額外還加贈**「從Leetcode學演算法｜面試篇」** ！
當中包含了面試準備須知分享，及訪談國內外不同經驗的工程師 ，
讓你不論是想走前端/後端/一般軟工 或者是想找國外的工作 ，
是初學想轉職 還是正在工作 ，都能夠從中得到收穫呦！
有興趣的朋友請留意下一篇貼文的早鳥優惠～

另外，

Question

Given two strings text1 and text2, return the length of their longest common subsequence.

A subsequence of a string is a new string generated from the original string with some characters(can be none) deleted without changing the relative order of the remaining characters. (eg, “ace” is a subsequence of “abcde” while “aec” is not). A common subsequence of two strings is a subsequence that is common to both strings.

If there is no common subsequence, return 0.

Example 1

1
2
3


Input: text1 = "abcde", text2 = "ace"
Output: 3
Explanation: The longest common subsequence is "ace" and its length is 3.

Example 2

1
2
3


Input: text1 = "abc", text2 = "abc"
Output: 3
Explanation: The longest common subsequence is "abc" and its length is 3.

Example 3

1
2
3


Input: text1 = "abc", text2 = "def"
Output: 0
Explanation: There is no such common subsequence, so the result is 0.

Constraints

1 <= text1.length <= 1000
1 <= text2.length <= 1000
The input strings consist of lowercase English characters only.

分析/解題

給定兩個字串text1及text2，
回傳他們的最長共同子序列(Logest Common Subsequence, LCS)。
一個字串的子序列是指一個字串從字串中原始的一些字母得來，
當中刪去原字串的一些字元(也可以都不刪)，
但保持相對於在原字串中的排列順序。
舉例來說 ，”ace ”是**”a** bc de” 的子序列，但”ae c”不是。
(排列相對順序已經不一樣了)
兩個字串的共同子序列是指這個字串分別都是兩個字串的子序列。

如果沒有共同子序列，則回傳0。

當我們看到題目乍看之下沒有明顯的簡單解法時，
就要考慮一下先找出前後之間的關聯 。
也就是說，
我們要先考慮從某一步推往下一步的算式。

由於我們要求的是LCS，這個要求對應順序的特性，
會導致一點：
前面經過的字母，後面就不能用了。 比方說"abec drr"跟”ac e”，假設我們已經找到了 a 跟 c ，
接下來我們只會從”drr”跟”e”之間作找尋，
因為"abec"中的 e 沒辦法跟第二個字串對應(順序會亂掉)。
這也表示，分別對兩個字串取出兩個子字串的LCS，
只會跟它們更前面的部分有關聯 ，而和後面的字元沒有關係。
思考到這裡，顯然這極有可能是Dynamic Programming了XD

那麼，我們不妨將t1和t2兩個子字串的記法用 i 和 j 表示，
當中0代表完全空字串，最大則分別到l1, l2。
(也就是i, j就代表現在在t1, t2的第幾個字元，從1開始 )
我們假設每個值互相關聯，那麼可以寫成一個二維陣列或串列dp。
所以我們知道dp[0][0] == dp[i][0] == dp[0][j] == 0。
(因為至少有一邊是空字串)
下一步呢？
如果我們在分別取 i, j 的字元數，那麼會分兩種狀況：
1. t1[i-1] == t2[j-1] (i, j 的位置上的字元一模一樣)
=> dp[i][j] = dp[i-1][j-1] + 1 因為對應的位置上得到相同字元，所以可以納入子序列中，
所以假設我們知道dp[i-1][j-1]，那麼dp[i][j]應該就恰好多1。

*這邊很容易搞混，請留意因為計算 index 的時候是從0 開始，
所以我們的dp[i][j] 指的是比較 t1 的 0 到 i-1 及 ** t2** 的 ** 0 到 j-1兩個子字串。**

2. i, j位置上的字元不同 => 往回推一個字元
由於i, j上的字元不同，所以dp[i][j]要嘛和dp[i][j-1]相同，
要嘛和dp[i-1][j]相同。也就是說，兩個子字串其中一個 往回退一格所得到的結果，
當中取比較大 的就可以了。(因為我們在找最大的解嘛XD)

為什麼不能同時退？
因為可能一邊對到的是前一個阿！
比方說：
“a bce ffz”跟”ac rrre”，假設我們現在正在比較”abcef”跟”acrrre”，
由於f和e不一樣，所以我們要改成比較"abce “-”acrrre ”和”abcef ”-”acrrr ”。
如果我們直接各退一格，去比較”abce”跟"acrrr”，
那e的對應不就被我們去掉了嗎？所以顯然要去除掉沒有對應到的字元，
一次只能從其中一邊倒退一格才行。

按照這個方式，我們可以使用雙層的迴圈，
就可以將整個dp陣列或串列算完，最終dp[l1][l2]就會是我們想要的答案。

回顧一下，我們利用了順序必須不變 的特性，
確定了某個位置的值只跟前面的結果 有關；
接著，判定當下對到的字元是否相同 ，
相同的話 可以計入並用各自的前一格 的結果表示，
不同的話 則要看誰退一格比較好 。
因此所有的值彼此環環相扣，某個位置的值可以用前面的位置的值來表達，
所以這的確是動態規劃 的問題無誤。

依此，寫成程式碼如下：

Java

Java的部分除了要留意index的計算不要搞錯以外，
整個程式碼相當簡單。

Python

Python的部分不要忘記二維串列不要連續用 * 的方式，
(記憶體使用會重疊而不是開新的串列，這個之前有提到過)
其他基本一模一樣。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(l1 * l2), O(l1 * l2))

相似及延伸

這題依照不同的起始方式，解也有不同的寫法，
讀者可以嘗試看看有沒有別的寫法。
同時，讀者可能會發現只要前一層的數據，
就可以拿來算下一層了，那麼，儲存的空間可以再進行精簡，
請想想看，這樣子空間複雜度會變成多少呢？

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經快回原價啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！

想要一次全包的話，請等待下一篇貼文提供的同捆包 XD

如果不太確定這是不是你想要的，
底下是最後一波優惠連結(下次就回原價囉)： ** https://hiskio.com/courses/319?promo_code=VE9Q5VE**

從LeetCode學演算法 - 90 Dynamic Programming (11) / DFS (9)

Sun, 22 Mar 2020 00:00:00 +0800

0576. Out of Boundary Paths (Medium)

Question

There is an m by ** n** grid with a ball. Given the start coordinate ** (i,j)** of the ball, you can move the ball to an ** adjacent** cell or cross the grid boundary in four directions (up, down, left, right). However, you can ** at most** move ** N** times. Find out the number of paths to move the ball out of the grid boundary. The answer may be very large, return it after mod 10⁹ + 7.

Example 1

1
2
3


Input: m = 2, n = 2, N = 2, i = 0, j = 0
Output: 6
Explanation:

Example 2

1
2
3


Input: m = 1, n = 3, N = 3, i = 0, j = 1
Output: 12
Explanation:

Note:

Once you move the ball out of the boundary, you cannot move it back.
The length and height of the grid are in the range [1,50].
N is in range [0,50].

分析/解題

題目描述有一組 m * n 的方格，格子上有一個球，其起始座標為 (i, j)，
你可以將球移到四個方向內沒超過邊界的格子，但最多只能移動N次。
試算出所有會將球移超過邊界的路徑數目。
限制：

一旦移出邊界就不能再回來(也就是直接遊戲結束了)
格子的寬高均在1~50的範圍
總次數N在0~50的範圍
另由於答案可能非常大，回傳結果要先除以10的9次方+7。

我們先思考關於路徑超過邊界的狀態。
要被算做是其中一種的話，首先最後一步一定要是從格子內移到格子外 ，
也就是要在邊界才可以，只差一格index就小於0 或**>m-1** (或n-1 )。
畢竟不在懸崖邊怎麼可能會有掉下懸崖的可能對吧XD！
並且，因為掉下去就回不來了 ，所以路徑就會到此為止。
(當然不管剩下的步數，你總不會飛簷走壁吧@@)

接著，當 N=0 時，
由於根本沒辦法動，自然不會有符合的路徑 ，答案為0。
N = 1 時，則要** 看你四邊有幾個懸崖對吧！
那N = 2呢？
是不是就要先看這一步有幾種可能會掉下去，加總起來以後** ，
接下來先走到不會掉下去的地方，再看那幾個有幾種情況會掉下去。
由於每走一步路，可用的步數就會少1，
我們終究會要嘛掉下去 ，要嘛走到沒有步數可用；
將所有加總起來，就得到答案了。

這個方式聽起來很DFS對吧？
所以按照上面的直覺，也許你會寫成像這樣子的內容：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# Will TLE
class Solution:
 def findPaths(self, m: int, n: int, N: int, i: int, j: int) -> int:
 def dfs(i, j, N):
 res = 0
 if N != 0:
 res += 1 if i - 1 < 0 else dfs(i-1, j, N-1)
 res += 1 if i + 1 == m else dfs(i+1, j, N-1)
 res += 1 if j - 1 < 0 else dfs(i, j-1, N-1)
 res += 1 if j + 1 == n else dfs(i, j+1, N-1)
 return res
 res = dfs(i, j, N)
 return res % (10 ** 9 + 7)

當方向會掉下去的時候，就代表方法數加1；
否則的話，就要往那個方向走1步去算可能的方法。
你會發現測試一般的結果可以算出正確答案，
但大一點的數字會算到超時，為什麼呢？

其實理由跟以前我們算Fibonacci數列時一樣，
這樣子的寫法會導致每一個數都是從單一個1累加起來的，
中間我們可能走到同樣的格子，剩下相同的步數，
卻沒有利用到這點，從而導致效率超級差。

那怎麼辦呢？
當我們同時考慮動態規劃的觀念時，
就容易想到，我們可以將先前算過的東西當成已知的內容儲存起來，
當再碰到時，就可以直接取用計算。
在本例當中，影響到結果的值有i, j, N，
所以我們可以選擇使用一個三維的陣列/串列 ，(也可以用兩個二維陣列)
或者Python內也可以用字典來做對應儲存。
扣除掉這點以外，跟前面的寫法並無不同，讀者可以自行參照看看。

那麼，有沒有別種思考的方式呢？
有的，像是lee215就提供了另一種思路：
我們最開始N=0時，整個盤面不論i, j為什麼，
(i, j, 0)的結果都會是0，而(i, j, N)的結果，
則取決於**(i, j)上下左右4格在N-1步的時候** 的結果。
如果該格超出邊界，則至少從(i, j)有1步可以走出邊界，
反之，(i, j)可以花1步走過去。
因此，我們可以一次一次更新整個盤面，
從而算得第N步的結果。(參見Python lee215解 )

或者，我們也可以從i, j為起點，
記錄從i, j到某一格的總路徑數量 ，
每當有機會超出邊界時，則將該部分加總到結果中，
兩個方法殊途同歸，最後都可以得到解答。(參見Java shawngao解)

依照上面的這些想法，我們可以寫成解答：

Java

在Java的部分，除了上面提過的遞進計算整個盤面，
(使用兩個二維陣列交替)
也可以用三維陣列去記錄結果，
留意為了要偵測是否有記錄結果，
我們要用Arrays.fill()，將初始化的陣列都填入-1，
這樣我們才知道這個值它是0還是未填入的狀態。

Python

Python的部分，除了lee215的解法外，
我們也可以如上面提到的採用一個字典來進行儲存先前已計算過的內容。
此外，由於在這個問題中，
鏡像對稱位置的點在相同的N值下應該會有相同的答案，
所以還可以透過對稱的方式來進一步化簡所需的計算數量。
(可以看註解底下最後一個解，65~69行的部分)

面試實際可能會遇到的問題

「時間/空間複雜度？」
(時間複雜度方面，原則上最壞的狀況就是每個步驟算完整個盤面，
所以會是O(m*n*N) 。
空間複雜度的話，使用三維陣列或字典 的話是O(m*n*N) ，
而使用兩個二維陣列交替記錄 的話則是O(m*n) )

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(最後一波早鳥優惠了，不確定調回原價是什麼時候)： ** https://hiskio.com/courses/319?promo_code=VE9Q5VE**

從LeetCode學演算法 - 83 Dynamic Programming (10)

Wed, 15 Jan 2020 00:00:00 +0800

0091. Decode Ways (Medium)

Question

A message containing letters from A-Z is being encoded to numbers using the following mapping:

1
2
3
4


'A' -> 1
'B' -> 2
...
'Z' -> 26

Given a non-empty string containing only digits, determine the total number of ways to decode it.

Example 1

1
2
3


Input: "12"
Output: 2
Explanation: It could be decoded as "AB" (1 2) or "L" (12).

Example 2

1
2
3


Input: "226"
Output: 3
Explanation: It could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).

分析/解題

給定一個訊息，當中A到Z以1至26的方式依序對應，
用數字的編碼方式寫成一個字串。
給定這樣子一個僅含數字1~9組成的字串，
試決定所有可以解碼的方法數。

這題在LeetCode上面比較有問題的點在於，
沒有硬性規定開頭或結尾多出來的0 的部分。
所以這邊我們會再加上一個條件，
一旦開頭有0或中間有碰到多餘的0 的部分，
就當作可以接續下去(不當作錯誤)，
這樣看起來會比較符合測資測出來的結果。

首先會考慮到就當下而言，如果是空字串的話，
應該要直接先回傳0**(雖然沒有字串嚴格來說也是1種方法，
但給題目來說就要代表沒有辦法解碼)。
如果是考慮每個字串起始檢查的狀況，
則應該會將起始條件設定為1種可能。**

接下來我們考慮往下走的時候，怎麼樣可以構成可能的字組呢？
我們假定從index 0開始的各種子字串，
均已知有幾種方法了，那麼，當我們在index i的位置時，
要如何決定到這邊的方法數呢？其實不難思考。

由於我們的英文字母可能性是從126，
所以如果**index i對應的值是19之間** 的話，
代表它獨立可以成為一種可能性，
也就是走到前面i-1的狀況，再加上i這邊單獨代表的字母 。
這麼考慮的話走到i的組合數就和走到i-1的組合數是相同的 。
(以index i位置的值單獨成立的狀況來說)

那麼還有另一種可能，
就是index i-1和index i所組成的二位數也能代表字母，
這個數字應該是10~26 之間，所以這種狀況成立的條件下，
走到i的組合數和走到i-2的組合數相同 。

所以歸納上述兩點，我們必須要分別檢查，
然後決定是否要將i-1的方法數及i-2的方法數加進來。

感覺是不是有點像之前的House Robber?
所以這也是一個典型的Dynamic Programming題目。
依此，我們可以定一個array或list，取名叫dp ，
長度為s的長度加1。

我們將可能的兩位數分別叫做prev跟curr，
那麼每次要作的事情，就如同上面所述一樣：

初始化dp[0] = 1 ,
dp[1] = 1 (如果第一個字不是'0’) or 0 (如果第一個字是'0’)
迴圈讓i從2l，
每次將curr的值遞移到prev，prev則取得s[i-1] 的值。
當curr非0 的時候(即19)，我們可以將dp[i-1]加到dp[i] 中；
當prev和curr 可以組成10~26之間 的值時，可以將dp[i-2]加到dp[i] 中。
迴圈結束後，回傳dp[l] 即可。

依此，寫成程式碼如下。

Java

Java的部分，也可以順便檢查s是否為null，
但本題的測資似乎也沒有刁難這個部分(題目有說均為數字)。
檢查10~26 的部分，
可以拆成(prev==’1’) 或(prev == ‘2’且curr ≤ ’6’) 檢驗。對Java而言，
char可以直接用數字的方式(ASCII Code)的狀態來比大小，
所以我們不用再轉成Integer來浪費時間XD

Python

Python的部分，也可以直接比大小 ，其實作是呼叫ord()函數，
來取得比大小所需的ASCII Code數字，
但就沒辦法像Java的char那樣很多花樣了。

提醒大家，在寫的時候請務必留意範圍，
以本題為例，由於dp[0] 是被佔用做為初始值的，
所以我們在寫的時候i是對應由1為準起算的。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(N)，N為字串長度)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

從LeetCode學演算法 - 61 Dynamic Programming (9)

Sun, 13 Oct 2019 00:00:00 +0800

1140. Stone Game II (Medium)

寫在前面

大家連假過的好嗎XD？筆者到新加坡玩了一趟，不好意思好幾天沒更新啦~

Question

Alex and Lee continue their games with piles of stones. There are a number of piles arranged in a row , and each pile has a positive integer number of stones piles[i]. The objective of the game is to end with the most stones.

Alex and Lee take turns, with Alex starting first. Initially, M = 1.

On each player’s turn, that player can take all the stones in the ** first** X remaining piles, where 1 <= X <= 2M. Then, we set M = max(M, X).

The game continues until all the stones have been taken.

Assuming Alex and Lee play optimally, return the maximum number of stones Alex can get.

Example 1

1
2
3


Input: piles = [2,7,9,4,4]
Output: 10
Explanation: If Alex takes one pile at the beginning, Lee takes two piles, then Alex takes 2 piles again. Alex can get 2 + 4 + 4 = 10 piles in total. If Alex takes two piles at the beginning, then Lee can take all three piles left. In this case, Alex get 2 + 7 = 9 piles in total. So we return 10 since it's larger.

Constraints

1 <= piles.length <= 100
1 <= piles[i] <= 10 ^ 4

分析/解題

聽說之前有人一直嗆說怎麼都沒人能夠將1140這題講清楚？

這題其實題目不難理解：
Alex和Lee兩個人玩搶石頭的遊戲，石頭被分成數堆，
使用piles[i]來記錄，遊戲目的是在結尾時拿到最多的石頭。
Alex和Lee輪流拿石頭(Alex先 )，最開始的時候M設定為1 。
每次玩家要決定拿剩下的前X堆的所有石頭 (必須按順序不可以跳過 )，
X的範圍是1 ≤ X ≤ 2M；接下來就要依照X來更新M：M = max(M, X)

直到所有石頭都被拿光，遊戲就結束了。
假定Alex和Lee都以最佳化的狀況來玩這個遊戲(play optimally)，
回傳Alex在遊戲結束時最多能拿到的石頭。

在所謂"play optimally"的遊戲中，
我們會假設參與的玩家都清楚知道所有人的策略 ，
並且選擇對自己利益最大的選擇 。
依照這樣子的概念，我們其實可以感覺到前後會有所關聯，
因為對於雙方來說都是想要最大化自己拿到的石頭 ；
又，自己拿到最多，就意味著對方拿到最少 ，
所以這點同時還隱含了中間的可能會有一些判斷，
比如像是X這類型的變數對於同樣從第i堆開始來說，
要走哪個方向又會都有各自的分支，需要好好考慮才行。

我們先假定有一個函數dp，
這個函數可以計算當現在要從pile[i]開始拿的時候，
(也就是0~i-1堆都被拿光了)
輪到的玩家在這次及這輪以後所能拿到的石頭數的最大值。
顯然這還會有另一個變數M，
因為M能夠決定這輪最大可以拿到的堆數(2M)。
因此我們將這個函數表示成dp(i, M)。

先討論一個最簡單的狀況：
當i+2M ≥ n-1 的時候，(假設總石頭的堆數是n)
表示這個玩家可以直接選擇將剩下的石堆全取走 ，
就會是他所能拿到的石頭量的最大值。
(因為遊戲就結束了，另一個玩家什麼都拿不到)
所以這個就會是這個dp的確定值 的部分了。

接下來我們討論另一個狀況：(假設是A跟B玩家輪流拿石頭)
假設A玩家取了x堆 ，接下來會發生什麼事情呢？
輪到下一個玩家B了，對吧？
那麼玩家要從i+x堆 的位置開始拿取，
而此時的M按照遊戲規則是max(M,x) 。
由於B同樣也是play optimally ，
所以B也想最大限度的在這整場遊戲中獲得較多的石頭 ，
故對B而言在i+x堆開始拿取的數字按照定義就是dp(i+x, max(M,x)) 。

那麼關鍵來了：
對於dp(i,M) 而言，固定不變的會是從pile[i]到最後的石堆的石頭總量 ，
我們暫時先命名為Si, Si = pile[i]~ pile[N-1]的和 。
所以會變動的就只有B拿的部分而已。
所以我們可以得到dp(i, M) = Si - dp(i+x, max(M, x)) 。

又實際上我們一開始也不知道x應該取多少會最好，
所以x的範圍一樣是1~2M ，也就是我們要在x是這個範圍的所有狀況下，
找出dp(i+x, max(M, x))的最小值，從而得到dp(i, M) 。
(因為想要A拿的最多，就是要B拿的最少 ，故要取後者的最小值)

在實務上，我們可以拿前面的piles來計算Si，只要一路從尾到頭 ，
將piles的値往回加即可(因為Si = piles[i]piles[N-1]的和)。
我們需要一個二維陣列dp[][]，
第一個維度表示i (範圍是**0n-1** )
第二個維度表示M (範圍是1~(n-1)/2 + 1 ，但為了方便起見，
我們陣列只使用1開始的部分以避免位移，
所以再加一以後，我們第二維的長度會是**(n+1)/2 + 1** )

我們整理一下實際的演算流程。
主函式中:

從尾到頭 將piles[i+1] 加到piles[i] 上，
讓piles[i]現在代表從第i堆開始的所有石頭數 。
新增一個二維陣列dp[][] 以表示在**(i, M)** 條件下所能取得石頭的最大値。
呼叫helper函式來遞迴處理。
在helper函式中:
如果i已經走超過了則回傳0 (表遊戲結束)
如果2*M >= len(piles) - i則回傳piles[i] (一口氣取完剩下的石頭 )
當dp[i][M]尚未被計算出値的時候，
遞迴搜尋dp[i+x][max(M,x)]的最小值 ，(x範圍是1~2*M)
(已知値的話則直接代入)
dp[i][M]等於piles[i]減去前述的最小值
回傳dp[i][M]

依此，寫成程式碼：

Java

Python的部分，可將遞迴的部分搭配
for x in range(1, 2 * M + 1) 看起來會更簡潔。

Python

Python的部份根據大神lee215的解答，還可以做一些簡化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def stoneGameII(self, A: List[int]) -> int:
 N = len(A)
 for i in range(N - 2, -1, -1):
 A[i] += A[i + 1]
 from functools import lru_cache
 @lru_cache(None)
 def dp(i, m):
 if i + 2 * m >= N: return A[i]
 return A[i] - min(dp(i + x, max(m, x)) for x in range(1, 2 * m + 1))
 return dp(0, 1)

lru_cache 可以將函式已經計算過的結果直接快取放置在記憶體中，
當再次需要計算値的時候，不經過計算，直接將値回傳 。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N³)/O(N²)，因為記錄所有解要對應到二維陣列，
而對於每一個陣列解都需要往下搜尋O(N)的長度來比較得出最小值。)

「為什麼要記錄一個dp的陣列？不能直接靠遞迴記錄嗎 ？」
(遞迴記錄同樣要使用記憶體空間 ，且因為中間拆解時，
可能會有重複的(i, M)出現，不先記錄的話會造成有重複計算的狀況。 )

「這題是否可以用迭代法解？」
(可以，請參閱yzstone的解法。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 37 Dynamic Programming (8)

Thu, 22 Aug 2019 00:00:00 +0800

0121. Best Time to Buy and Sell Stock (Easy)

Question

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Note that you cannot sell a stock before you buy one.

Example 1

1
2
3
4


Input: [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
 Not 7-1 = 6, as selling price needs to be larger than buying price.

Example 2

1
2
3


Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.

分析/解題

買股票啦XD~題目給定一個陣列，第i個元素代表day i的股價。
如果你只被允許完成一次交易(買一次然後賣一次)，
嘗試找到最大的利潤為何。

我們假定我們在某個時間點買了股票，
那獲得的利潤每隔一天，就會變動這兩天的差價值。
我們可以將當下的利潤定為cur，那麼cur不論從哪開始必定為0。
(當天買當天賣)

假定有一天股價低於我們買的時候的價格，就表示我們買貴了，
應該要從現在這個點開始一定會比前面那個點還好 ，(買進的價格較低)
我們可以將cur重設為0(從這個點重新出發) 。

反之如果價格比較高的話，我們可以計算現在的利潤，
並和全局最大值比較後再更新全局最大值。
所以每次依序計算現在的利潤決定是否重新選擇出發點，
再處理好全局最大值的紀錄即可解決此題。

這邊Java和Python的程式碼僅差別在設定條件的方式不同而已，
但本質一樣是在處理現有的值 及最大值 這兩項。
讀者可以自行選用處理的方式。

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(1)，掃過整個空間一次，除cur跟res外不需其他變數。)

相似及延伸

1.0053. Maximum Subarray 2. Best Time to Buy and Sell Stock系列題(XDDDDD)

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 29 Dynamic Programming (7)

Mon, 12 Aug 2019 00:00:00 +0800

0213. House Robber II (Medium)

Question

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have security system connected and ** it will automatically contact the police if two adjacent houses were broken into on the same night**.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police .

Example 1

1
2
3
4
5


Input: [2,3,2]
Output: 3
Explanation:
You cannot rob house 1 (money = 2) and then rob house 3 (money = 2),
because they are adjacent houses.

Example 2

1
2
3
4
5


Input: [1,2,3,1]
Output: 4
Explanation:
Rob house 1 (money = 1) and then rob house 3 (money = 3).
Total amount you can rob = 1 + 3 = 4.

分析/解題

繼上一次偷完一排房子 以後，我們決定挑戰更高難度的偷竊XD
(有完沒完啦！)

保全狀態依舊是相鄰房子連續被偷就會響警報，不同的是，
現在房子的分布是圓形！也就是第一間和最後一間是相鄰的，
這就會造成我們上一次使用的算法會出現問題。

那麼怎麼辦呢？
第一間和最後一間有關聯是不是？
那我們就來斷開魂結，斷開鎖鏈，斷開一切的牽連吧！(大誤)

這裡我們為求方便起見，使用0為index開頭來描述，
這樣等一下對照程式碼也比較方便。
我們令nums的總長度為l ，
並且使用dp[i] 來表示偷到index i的房子時當前所能得到的最大金額。

如何處理index 0跟l-1的關係呢？
針對index 0的話，只會分成偷或不偷。

古語有云：

To rob, or not to rob, that is a question.

莎士比亞沒有說過

所以我們可以分開來討論。
假設今天無論如何就是要偷index 0 的房子的話，
可以得到以下推論：

index l-1不能偷
dp[0] = nums[0], dp[1] = nums[0] (偷了0就不能偷1)
這狀況能得到的最大金額應為dp[l-2] (因l-1不能偷)
這個狀況，我們可以給定2的起始條件並計算到dp[l-2]即可得到最大金額。

假設今天就是不偷index 0的房子的話，
可以得到以下推論：

index l-1能不能偷只需要看index l-2 決定要不要偷
dp[0] = 0, dp[1] = nums[1] (因0不偷，dp[1]要選擇偷index 1)
這狀況能得到的最大金額應為dp[l-1]

所以依照這兩個狀況拆開來分別計算一次，
將兩個結果比較大小，取較大的即為答案。

同上一題描述的一樣，
我們可以利用兩個變數及一個暫存變數，來達到dp的效果。

Java

Python的部分則再額外提供了將迴圈部分包裝成函式的程式碼，
但實測上由於需要呼叫的原因，看起來平均會略慢於未包裝的狀況。
(附在底下註解處，使用者可再多執行幾次試試看)

Python

所以總體而言，這題的根本在於，當發現有些狀態是互相關聯時，
嘗試將其進行拆解，從而重新得到線性可計算動態規劃的狀態。 再次強調， DP的精髓在於找到初始狀態，
及找到從一個狀態推展到下一個狀態的方法。用骨牌來比喻的話，後者相當於 骨牌之間的關係，
前者則相當於那個第一個倒下來的骨牌 。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(1)
這次的範例程式碼已經不用dp陣列來記錄了，
即便需要掃過nums兩次，但時間複雜度還是O(N))

「如果保安增強，變成只要連續三棟房子內任二棟被偷即會有警報的話？」
(可以嘗試用類似的方式來推導)

相似及延伸

0337. House Robber III 2.0746. Min Cost Climbing Stairs

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 28 Dynamic Programming (6)

Sat, 10 Aug 2019 00:00:00 +0800

0198. House Robber (Easy)

Question

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night .

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police .

Example 1

1
2
3
4
5


Input: [1,2,3,1]
Output: 4
Explanation:
Rob house 1 (money = 1) and then rob house 3 (money = 3).
Total amount you can rob = 1 + 3 = 4.

Example 2

1
2
3
4
5


Input: [2,7,9,3,1]
Output: 12
Explanation:
Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
Total amount you can rob = 2 + 9 + 1 = 12.

分析/解題

題目描述你是一個專業的強盜，即將進行入室行竊的勾當。
每間房子都存有確定數量的金錢，但唯一的限制是，每間房都有安保設置，只要相鄰的二間房子在同一個晚上被闖入的話，系統就會自動報警。
給定一個用來表示每間房子存放金額的陣列，試求在不驚動警察狀況下，
最大可以獲得的金額。

看到這個問題的時候，首先就想OS: 一間就報警的話不是最乾脆XD

好吧，我們假設這個安保真的是有這種漏洞的話，
那麼怎麼偷最好呢？

由於題目條件的限制，我們先假設一路偷到第i間，
所能獲得的最大金額為rob[i]，rob[i]會受到什麼限制呢？
假設我們走到第i間，
選擇要偷第i間的話，意味著我們前面不能偷第i-1間 。
這種狀況下，我們可以將rob[i]的值拆開來算：
rob[i] = rob[i-2] + num[i]
(選擇不動第i-1間，並偷了第i間，
而在此之前i-2間所能偷到的最大值是rob[i-2])

那麼，選擇不偷第i間的話，意味著rob[i] = rob[i-1] (因為你沒偷嘛XD)

既然有這兩種可能，那麼我們就該選當中比較大的，
所以rob[i] = max(rob[i-1], rob[i-2] + nums[i]) 。

讓我們考慮一下最前面的狀況：
rob[0] = nums[0] (第一間不用考慮前面的影響)
rob[1] = max(nums[0], nums[1]) (兩間選一間偷)

所以接下來我們只需要一路用前面的式子，迴圈從i=2計算到i=n-1，
最後將rob[n-1]回傳即可。

所以一路下來，讀者會發現有關動態規劃的題目，
一直在做的事情其實就是嘗試尋找在第n項的解，
和前面的項次之間的關係，一旦能找到這個關係，
並能確認初始的條件，就能一路從頭開始計算將其解出。

在程式碼的部分，我們可以先行考慮nums為空跟長度為1的狀況，
直接回傳結果以節省空間。

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(N)，掃過一次nums陣列，
並且也用相同長度來儲存最大的偷取金額)

「空間複雜度可以降低嗎？」
(可以！可以觀察出每個rob的值之間的關聯只有和前2個值有關(i-2和i-1)
我們可以使用robprev, robnext搭配一個temp值，
在迴圈中使用類似下面的方式，可以反復更新值，如此一來，
就只需要O(1)的空間就可以解決此題。)

1
2
3


int tmp = robprev;
robprev = robnext;
robnext = Math.max(robprev, tmp + nums[i]);

相似及延伸

1.0213. House Robber II (Medium) (從線性變圓形) 2. 0337. House Robber III (Medium) (變成二元樹 )
(到底哪個鄉鎮會這樣子蓋房子啦XD)

Special Thanks suggestions/corrections from viewers:

From Medium:

Raiy Kuo - 更正Python程式碼尾端，應回傳rob[-1]或rob[l-1]即可。
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 26 Dynamic Programming (5)

Wed, 07 Aug 2019 00:00:00 +0800

0096. Unique Binary Search Trees (Medium)

Question

Given n, how many structurally unique BST’s (binary search trees) that store values 1 … n?

Example:

1
2
3
4


Input: 3
Output: 5
Explanation:
Given n = 3, there are a total of 5 unique BST's:

1
2
3
4
5


 1 3 3 2 1
 \ / / / \ \
 3 2 1 1 3 2
 / / \ \
 2 1 2 3

分析/解題

還記得什麼是二元搜尋樹嗎？
不知道的話，可以翻閱前面的第16篇的介紹歐！
簡言之，一個合法的BST除了左邊的節點要全小於根節點，右邊的節點要全大於根節點 外，
其左右子樹也要是BST 才行。
觀察n=3的狀況，我們可以將其歸納成3類：
以1為根節點/以2為根節點/以3為根節點。

首先是1為根節點的狀況：
左邊沒有比其小的節點，故只有一種可能；
右邊有2跟3的組合，相當於n=2的時候的狀況(2種)。
(2跟3等價於1跟2兩個節點會有的組合)

再來是2為根節點的狀況：
左邊只有1種可能(1這個節點)；
右邊也只有1種可能(3這個節點)。

最後是3為根節點的狀況：
左邊是1跟2的組合(2種)，
右邊只有1種可能。

如果我們將n的組合命名為函式f(n)，
那麼顯然f(0)=1(只有一種可能)，f(1)=1。

計算n=3的組合算法為：
f(0)*f(2) + f(1)*f(1) + f(2)*f(0)

掌握這個規律的狀態，我們可以得到f(n)的計算方式：
f(0)*f(n-1) + f(1)*f(n-2) + … + f(n-1)*f(0)
那麼，從f(1)開始起算的話，
我們可以一路疊加將f(1)到f(n-1)都算出來，
最後得到我們要的f(n)。
讓f(n)能夠化成f(n-1)或較小的項次的組合，一路化簡到能直接確認的值，
所以這個就是典型的動態規劃的範例。

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(n²), O(n)
由於計算時兩層迴圈最大都要經歷n，故時間上會和n的平方相關)

「可以改成遞迴的方式嗎？」
(可以，我們只要將dp改成字典或HashMap，開一個函式search，
令其在找不到值的時候呼叫自己如 sum += search(i-1) * search(n-i)，
最後也會如同迴圈的解法一樣一路拆解到最底下，
讀者可以自行嘗試看看，實測上兩者速度在實作正確的狀況下，
應該是感受不出太明顯的差異的。)

Special Thanks suggestions/corrections from viewers:
From Python Taiwan
曾淯銘: 更正BST的筆誤(連結是對的，本文打錯，是左<根<右，已更正)
ChenRay Hsieh: 本文的解其實等同於Catalan number，讀者可參考閱讀。

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 24 Dynamic Programming (4)

Mon, 05 Aug 2019 00:00:00 +0800

0063. Unique Paths II (Medium)

Question

A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below).

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as 1 and 0 respectively in the grid.

Note: m and n will be at most 100.

Example 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


Input:
[
 [0,0,0],
 [0,1,0],
 [0,0,0]
]
Output: 2
Explanation:
There is one obstacle in the middle of the 3x3 grid above.
There are two ways to reach the bottom-right corner:
1. Right -> Right -> Down -> Down
2. Down -> Down -> Right -> Right

分析/解題

這題基本上就是前面Unique Paths I的續集，在棋盤上存在障礙物。
如果我們考慮某個點是障礙物的話，其造成的影響會是什麼呢？
建議讀者可以自行畫幾條路徑試試看，這個狀況下，
會造成的結果為：

能到達該點的方法數為0(已經是障礙物了)
承1，因此對1個點來說，
加總的方式應該是先看這個點是否是障礙物 ，
不是的話，才需要考慮它左邊和上面是否有可以到達的方法數。

我們最開始先檢查輸入的方格是否正常，且第一個如果被擋的話，
代表完全走不出去，直接回傳0即可。扣除掉這個狀況的話，
接著從原點開始的方法數就是1 。接下來便可由此開始進行dp。

先定義好儲存path的二維陣列並將1放到原點，
依序對每個方格檢查，只要確定它不是障礙物，
就依照判斷將該加上去的部分加上去。
(加到左邊或上面是障礙物的點沒關係，因為它已經是0了)

全部遍歷過一次以後，回傳右下角的值即可。

Java

Python的部分要特別留意二維列表的生成，
請勿使用[[0]*n]*m，這樣在第二層會產生m個指向相同位址的列表 。
(第一層不會，因為0的部分還是基本型態而非物件)
(也就是動其中一個row會同步改到其他的row)
我們可以使用二層的List Comprehension來處理，或者第一層用*，
第二層用List Comprehension亦可，這裡示範後者。
(實測上兩者速度並無明顯差異 )

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(m*n), O(m*n)，因我們會遍歷整個二維列表，
且需要另一個二維列表來儲存中間的方法數)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 21 Dynamic Programming (3)

Mon, 29 Jul 2019 00:00:00 +0800

0062. Unique Paths (Medium)

Question

A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below).

How many possible unique paths are there?

Above is a 7 x 3 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

Example 1

1
2
3
4
5
6
7


Input: m = 3, n = 2
Output: 3
Explanation:
From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
1. Right -> Right -> Down
2. Right -> Down -> Right
3. Down -> Right -> Right

Example 2

1
2


Input: m = 7, n = 3
Output: 28

分析/解題

有一個m x n大小的格子，其左上處有一台機器人，每次機器人僅能選擇往右或往下走，目的是要達到右下角的Finish的位置，題目問說當給定m和n時，有多少種不同的方法可以從左上走到右下？

這題也是典型的動態規劃題目，只要稍稍思考一下，
我們就能發現一件事情：
走到任何一個點的方式，取決於走到其左的方法數 加上走到其上的方法數 。

那麼，再思考一下走到左邊跟走到上面會有重複的狀況嗎？顯然是不會的。
因為走到一個格子的左邊顯然和走到其上面會相差往下走一格及往右走一格的動作，而且因為機器人也只能往下或往右，所以沒辦法再回頭，故已經走過的部分不可能再繞得回來。

在這個狀況的特例有幾個：

機器人所站的原點 (按我們的定義一開始就在此，故可以將方法數定為1)
最左邊 的一排格子 (僅取決於走到其上面格子的方法數)
最上面 的一排格子 (僅取決於走到其左邊格子的方法數)

而實際上從第1點來推算的話，
我們可以知道最左邊一排跟最上面到達的方法數都會是1 。
所以我們可以先將這三點的部分先設定為1，接著從較小的index開始沿途把到達每個點的方法算出來，直到最後將整個grid算完。

在這個方法下，我們需要一個m x n的陣列用以儲存方法數，為了方便起見，我們就直接叫它dp，讀者亦可命名為grid，請留意這些命名都只是方便起見，只要你的命名能和面試官溝通即可，我們現在並不是在寫一個大的project，簡短命名並告知你的面試官你的目的是筆者推薦的做法。

最後僅需回傳dp[m-1][n-1]即可。
(註:由於這邊row跟column的交換並不影響結果，
故我們這邊不特別去在意m和n的前後順序。)

Java

Python這邊收尾的時候可以用dp[-1][-1]來表示尾端的元素，
宣告的時候則採用list comprehension(列表解析式/列表表達式)。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(均為O(m*n))

「空間複雜度是否可以降低？」
(理論上可以，因為實際每次處理的關連部分僅有兩行或兩列，
反覆利用應該可以讓空間需求降低到O(m)或O(n)，但時間複雜度一致)

「是否有更簡單的解？」
(DP的話，沒有，數學的話，有。
假設往下叫D，往右叫R，求不同走法的過程，
即相當於在求**(n-1)個D和(m-1)個R的不同排列方法** ，
故答案會是(m-1+n-1)!/(m-1)!(n-1)!，
此時空間複雜度為O(1)，時間複雜度為O(m+n) 。
但階乘的部分當值過大時有可能會有超過int的可能性。)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 9 Dynamic Programming (2)

Tue, 09 Jul 2019 00:00:00 +0800

0070. Climbing Stairs (Easy)

Question

You are climbing a staircase. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Note: Given n will be a positive integer.

Example 1

1
2
3
4
5


Input: 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Example 2

1
2
3
4
5
6


Input: 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

分析/解題

題目描述有一個要爬n階才能到頂端的階梯，每次只能爬1階或2階，
試求有多少種不同的方法可以走到頂端。
如果以窮舉的話我們可能需要列很久，
所以這時候又回到了看看是否能找出相互關係的時候了。

我們考慮要爬n階的話，首先要先爬到n-1 階或n-2 階，因為只有一次走1階或一次走2階的選擇。也就是說，走到n階的方法，就相當於走到n-1階的方法和走到n-2階的方法和 。因為最後的步伐已經固定了，我們同時還可以保證這兩個方法的組合之間不會互相重複 (一個最後走1步，一個最後走2步)。

同樣的，走到n-1階的方法=走到(n-2)階的方法+走到(n-3)階的方法，
以此類推拆解，最終我們來到走到第1階的方法跟走到第2階的方法，
分別是1跟2。

我們可以選擇開一個res的陣列，初始化前2階以後，
一路加上去最終得到到第n階的方法數，下面Java的版本因為陣列由0開始，
有刻意將數字不先行化簡，讀者應該可以很簡單地對照。

Java

Python的部分，則採用兩個數s1, s2來輪替使用，可以節省記憶體。
每次應該要做的，是將s1+s2的值擺到s2，而將s2的值擺到s1的位置。
(等於把兩個數代表的位置遞移了一層)
(Java也可以用類似的作法，但需要多宣告一個暫存值進行儲存)

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
（O(N), 依方法而定，
上面Java的寫法需要O(N)，Python的寫法則只需O(1)）

「哪個寫法比較好？」
(以空間節省的角度來說是Python版本的寫法較佳，
但如果我們不止需要算一次的話，執行一次n階，
其實可以將n階以下的走法數量全部記起來，
這樣被讀取的時候可以先查是否可以直接拿結果回傳，
所以反覆執行的效率會變比較好，不過這個就需要再修改一下程式就是了)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 7 Dynamic Programming (1)

Thu, 04 Jul 2019 00:00:00 +0800

0053. Maximum Subarray (Easy)

Question

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

Example:

1
2
3


Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

Follow up:

If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.

分析/解題

題目給定一個整數陣列，要求找到其中一個連續的子陣列，這個子陣列的和是所有子陣列中最大的，並且回傳該總和值。

這題如果以暴力法來解決的話，我們可以拿到的總連續子陣列數是
N+(N-1)+(N-2)+…+1，每個子陣列中的計算下一組和(如[-2] -> [-2,1])，
都只需一個加法，故時間複雜度會是O(N²)。

但……感覺很浪費(?)
我們先思考一個問題：
「假設我知道nums中1到i-1的最大子陣列和，
有沒有辦法知道1到i的最大子陣列和呢？」
我們討論1到i的最大子陣列和，應該分兩種情況：
a. 這個子陣列包括index i
b. 這個子陣列不包括index i
如果是b 的話，那答案其實就是1到i-1的最大子陣列和 ；
但如果是a 的話，我們好像還需要一些條件？
什麼條件呢？就是1到i-1中，包含i-1元素的最大子陣列和 。
因為如果是前面所提到的a狀況的話，
那麼1到i的最大連續子陣列，就必須從i->i-1連回去才行(或乾脆是只有i)。

所以這麼一來，條件就比較清楚了，我們會需要的有：

到現在為止包含當前這個元素的最大子陣列和 ，我們命名為curr(current)
到目前為止的最大子陣列和 ，我們命名為res(result)

那麼我們就以範例的[-2,1,-3,4,-1,2,1,-5,4]來操作看看。
該怎麼決定curr跟res的初始值呢？因為一開始只有一個值，
所以curr和res應該都等於nums[0]=-2才對。
所以一開始我們將curr和res都設為-2，接下來由i=1開始，
一路往下到最後一個結束。

i=1: [-2,1 *,-3,4,-1,2,1,-5,4]
按我們的定義，curr應該是-2+1和1中較大的值，
我們可以先將curr加上nums[1]，
接下來檢查curr小於0* ，或者curr<nums[1] ，
就表示其實我們只要取nums[1] 就好。
(註1: 表示兩者的正負號為**(-, -), (-, +)** ，不論如何前面那部分貢獻均是負的 )
(註2: 也可以拆成別的形式或調換順序，但先判斷<0的計算速度會比較快)
(註3: 後面程式碼Java和Python的判斷方式就不同，可自行依喜好決定使用)
所以新的curr為1, 接著再比較得知curr<res，故res也要改為1。
接下來的流程，讀者可以嘗試自己操作一遍再對照一下。

1
2
3
4


i=2: [-2,1,-3,4,-1,2,1,-5,4]
-> curr = 1 + -3 = -2 < 0
-> curr = -3
-> res = 1

1
2
3
4


i=3: [-2,1,-3,4,-1,2,1,-5,4]
-> curr = -3 + 4 = 1 < 4
-> curr = 4
-> res = 4

1
2


i=4: [-2,1,-3,4,-1,2,1,-5,4]
-> curr = 4 + -1 = 3 > -1

1
2
3


i=5: [-2,1,-3,4,-1,2,1,-5,4]
-> curr = 3 + 2 = 5 > 2
-> res = 5

1
2
3


i=6: [-2,1,-3,4,-1,2,1,-5,4]
-> curr = 5 + 1 = 6 > 1
-> res = 6

1
2


i=7: [-2,1,-3,4,-1,2,1,-5,4]
-> curr = 6 + -5 = 1 > -5

1
2


i=8: [-2,1,-3,4,-1,2,1,-5,4]
-> curr = 1 + 4 = 5 > 4

所以最後我們得到res = 6，再回傳即可。

這個解法第一次並不是很容易上手，而且並非相當直觀的方式，
但它常常可以在特別的地方有效地解決問題。
適用於這類型的解法的問題會有一個特性：
「N=i+1時的解，通常和N=i時的解以及第i+1的值有關連性」
(也有可能跟更前面幾個值同時有關連性)
而我們通常很難直觀地直接用簡單的方式去算出N=i+1的解，
所以會依靠其本身和前面的連動關係，
讓答案像堆積木一樣，從i=0開始堆到最後面得到最終的答案。

有些問題可能未必是一層一層疊上去，
也有可能是把一個大問題拆成數個小問題，
最後將其組合起來得到大問題的答案。
但通常我們最常見的形式還是如上面那樣子按順序堆疊的。

上面這樣子形式的解題方法，
被稱之為動態規劃(Dynamic Programming) ，或者也常簡稱為DP。
每個動態規劃的問題都會有些不一樣，
但只要抓到其中的連動性，找到從i -> i+1 中間的關聯，
就可以順利解開題目。

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N), O(1))

「如果不使用DP是否有O(N)解？」
(可以使用分治法，請參見 *LeetCode這篇討論 *底下的回應)

從LeetCode學演算法，我們下次見囉，掰~