Backtracking on 跟著 Desolve 學程式

從LeetCode學演算法 - 111 DFS (18) / Backtracking (8)

Wed, 20 Jan 2021 00:00:00 +0800

0784. Letter Case Permutation (Medium)

寫在前面

目前0元挑戰賽 的活動已經開始囉！
只要修課後三個月內完課且成功錄取新工作並撰寫心得，
課程就會全額退費喲！請使用下面連結看更詳細的規則說明：

零元求職挑戰賽 Python 組｜從 LeetCode 學演算法 + 面試成功指南 http://bit.ly/zeroclg

抽獎活動還在繼續累積人數(現在好像沒有人想抽XD)
在Python Taiwan的連結第100篇的文章 底下，
公開分享到你的臉書、按讚該篇文章、並留言告訴我說，
「你最喜歡這一整個系列的哪一篇？為什麼？」或
「除了從LeetCode學演算法系列以外，
你還想要看到關於什麼方向的文章？」
超過20則留言的話 (有完成以上步驟的才算)，我們就抽一組
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」
課程的免費兌換券進行贈送！

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

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

Question

Given a string S, we can transform every letter individually to be lowercase or uppercase to create another string.

Return a list of all possible strings we could create. You can return the output in any order .

Example 1

1
2


Input: S = "a1b2"
Output: ["a1b2","a1B2","A1b2","A1B2"]

Example 2

1
2


Input: S = "3z4"
Output: ["3z4","3Z4"]

Example 3

1
2


Input: S = "12345"
Output: ["12345"]

Example 4

1
2


Input: S = "0"
Output: ["0"]

Constraints

S will be a string with length between 1 and 12.
S will consist only of letters or digits.

分析/解題

給定一個字串S，
我們可以任意將其中的單一字母轉換成小寫或大寫，
以創造出另一個字串。
回傳一個列表，當中包含所有我們可以創造出來的字串。
(回傳的字串順序可以不同)
(限制：S的長度會在1~12之間，且S只會有字母或數字)

這個題目實際上並不是很難想，
從直觀上來說，就是找出所有字母的地方(因為只有字母可以變)，
讓它是小寫或大寫這兩種可能，會產生不一樣的字串，
因此如果當中存在L個字母的話，
其變化就會有2^L種。

那麼，我們怎麼樣處理這樣子的產生的過程呢？
這就要回頭複習一下回溯法的概念了！
以前我們提到過，回溯法就是當走到一段，無法再往下走時，
回到上一步並還原前面的痕跡，再往下一條路走的做法。
因此，我們來看待這題會變成這樣：

先將整個字串轉成小寫 (要都轉成大寫也可以)
從index 0 開始往下走(將現在的位置定為pos )，
當順著往下走都不改變 時，
最後應該會走到底部，此時pos == 整個字串長 ，
這會是其中一個字串變化，可記錄到結果(res)中 。
接著，回到上一步時，
我們可以檢查pos位置是否為字母 ，
是的話 ，我們可以改成將該位置的字母轉為大寫 ，
再重新往下走一次(因為這樣子變化又不一樣了)
走到底回到上一層時，再將字母轉回小寫(回溯法的復原)
最終，全數走完時，res 即會紀錄所有的答案。

所以在使用DFS和回溯法時，
讀者請切記兩個要點：
1. 走到死路(結束時該回頭)的條件要設定好
2. 被更改的東西，在這條路線結束後，記得復原

依此，寫成程式碼如下：

Java

Java的部分，使用toLowerCase()和toCharArray()，
將字串轉換成全小寫 的字元陣列，方便修改；
我們用helper函數來進行DFS+Backtracking。
在轉換上，使用new String(a)可以從一個字元陣列生成一個字串。
可能

Python

Python的部分，使用list() 來拆成串列，
同時組成字串是使用**’’.join()** 來處理的，
檢查字母是使用isalpha() 函式；
同時請留意**.upper()和.lower()並不直接對原來的東西做修改** ，
而是會回傳新的str ，所以請將其輸入回a[pos]裡，
才會真正修改到。

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

「時間/空間複雜度？」
(O(2^L)/O(len(S)), L為字串中字母的數量)

相似及延伸

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

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

想看看其他題目嗎？
歡迎從第零篇 找你想要的！

同時追蹤粉專以獲得更多新文章的通知：
跟著Desolve學程式

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

從LeetCode學演算法 - 105 Tree (18) / DFS (15) / Backtracking (7)

Mon, 14 Sep 2020 00:00:00 +0800

0437. Path Sum III (Medium)

寫在前面

容筆者工商一下， 「從Leetcode學演算法｜進階篇」及 加贈的**「從Leetcode學演算法｜面試篇」已經全數上傳完囉！**

目前只剩下給讀者的進階篇+面試篇(3150) 和全套同捆優惠(3990) 了QQ
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」：
https://bit.ly/leetcodeadv
「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/leetcodeall

內容介紹：
這次選了40道難度加深的LeetCode題目，
同樣也會細部解說對應的技巧及須要掌握的演算法！
同時這次購買進階篇的話，
額外還加贈**「從Leetcode學演算法｜面試篇」** ！
當中包含了面試準備須知分享 ，及訪談國內外不同經驗的工程師 ，
讓你不論是想走前端/後端/一般軟工 或者是想找國外的工作 ，
是初學想轉職 還是正在工作 ，都能夠從中得到收穫呦！

Question

You are given a binary tree in which each node contains an integer value.

Find the number of paths that sum to a given value.

The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).

The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.

Example:

1

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

1

Return 3. The paths that sum to 8 are:

1
2
3


1. 5 -> 3
2. 5 -> 2 -> 1
3. -3 -> 11

分析/解題

給定一個二元樹，當中每個節點均含一個整數，
找出所有可以加總等於目標總和的路徑數量。
一個路徑不需要從根節點開始，也不必一定要到葉節點結束，
但是路徑只能往下走(也就是說只能從父節點往子節點走)；
另外，這棵樹最多只會有1000個節點，
且其值均在-1000000~1000000之間。

這一題是一整組Path Sum系列題的第三題。
由於題目提示節點數不會超過1000個，
所以基本是無法超過各程式的Call Stack限制，可以放心使用遞迴。

那麼，我們看看另一個重點：
路徑只能往下走，會有什麼特點呢？
舉例來說，以上面的二元樹，當我們走到某個節點2時，
所有終點是2的路徑有以下三種：
10 -> 5 -> 2
5 -> 2
2
再往下走到1的時候，路徑有以下四種：
10 -> 5 -> 2 -> 1
5 -> 2 -> 1
2 -> 1
1

我們可以發現，走到1的路徑和到底有沒有符合target的解這件事情，
可以透過兩點知道：

從root起算走到現在這個節點的總和是否和target相等
從root起算走到現在這個節點的總和-target是否在過往出現過

第2點比較抽象，我們稍微舉一下簡單的例子：
假設我們要找的目標是8的話，
那麼直接看我們當然知道是5->2->1，
但如果不能回頭重算的話，要怎麼辦呢？
我們可以得到5->2->1的路徑，
其實相當於從根節點10走到1的路徑和，減去節點10。

換句話說，如果我們每走到一個節點，都將路徑和記錄下來，
那麼我們就可以用前面過往的路徑和，
來表達出所有達到現在這個節點的路徑和。

例如：
1其實等於10 -> 5 -> 2 -> 1 去掉** 10 -> 5 -> 2
2** -> 1等於** 10 -> 5 -> 2** -> 1去掉** 10 -> 5
5 -> 2** -> 1等於** 10 -> 5 -> 2** -> 1去掉** 10**

這樣足夠清楚了嗎XD？
因此，我們要做的事情有：
0. 建一個dictionary或hashmap，
當中key/value分別代表路徑和/路徑和出現的次數。
同時，將(0, 1)置入字典當中。(這裡稱之為preSum)
(方便我們在剛好等於根節點到當前節點總長時計算)

呼叫遞迴DFS函式並回傳其結果。
在DFS函式中，遍歷整棵二元樹：
2.0. 檢查節點是否存在，不存在則回傳0
2.1. 將當前的節點值加上根節點的値，做為現在的總和(currSum)
2.2. 初始化res，其值為currSum-target在preSum中出現的次數
2.3. 分別向左右節點遞迴呼叫DFS函式，將得到的結果加到res
2.4. 由於這條路徑只能一路向下，
所以要回到上一層前，
需將剛剛加過的1次記錄從preSum中扣掉(backtracking)。
2.5. 回傳res

依此，寫成程式碼如下：

Java

Java的部分preSum使用HashMap，留意先進行一次put，
再放入helper函式中做DFS；
helper函式中的部分，由於HashMap本身找不存在的值會出錯，
別忘了使用getOrDefault來給定預設值(當然，你要用containsKey也行)。
在遞迴取得左右兩邊節點的符合路徑數加總後，
別忘記回傳前要將加上去的刪掉，才符合回溯法的要件。

Python

Python的部分大同小異，
不同的是我們可以用defaultdict來將預設值當作0，
從Python的寫法中應該可以更清晰看見回溯法的樣貌。
(先加1後減1)
這邊的helper直接寫成子函式，
所以我們就不需使用self.xxx的形式來呼叫了。

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

「時間/空間複雜度？」
(O(N)/O(N*樹深)，每個節點均需要經過一次，
每個節點最多可以成立d個preSum值，
d為樹的深度，以平衡樹來說則是log(N))

相似及延伸

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

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

從LeetCode學演算法 - 104 Tree (17) / DFS (14) / Backtracking (6)

Tue, 18 Aug 2020 00:00:00 +0800

0113. Path Sum II (Medium)

寫在前面

容筆者工商一下， 「從Leetcode學演算法｜進階篇」及 加贈的**「從Leetcode學演算法｜面試篇」已經全數上傳完囉！**

Question

Given a binary tree and a sum, find all root-to-leaf paths where each path’s sum equals the given sum.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

Return:

1
2
3
4


[
 [5,4,11,2],
 [5,8,4,5]
]

分析/解題
給定一個二元樹以及目標的和(sum)，找出所有根節點到葉的路徑，這些路徑各自的和要等於給定的和。

這一題是一整組Path Sum系列題的第二題。
由於要找出路徑，所以我們需要一組記錄當前路徑current的位置的list。
同時，要能夠判定是否要確認這條路徑OK的狀態，
只取決於現在是否走到葉節點(因為題目要求)；
並且走到葉節點時，左右也都沒有節點了，就無法往下走。

我們可以用一個result的list記錄最終處理完的結果，
接著使用DFS 的方式往下找。

那麼自然我們每走過一個節點，
就要將sum減去現在root的値，同時記錄到current上。

接下來要往下走還是檢查呢？
當然就是看左右節點是否為NIL且sum和root的値是否相等啦！
如果是的話，可以將result加上走到現在的路徑；
如果不是的話，則以DFS往左和往右走(不要忘記去檢查NIL的狀況)。
這整段走完要回到上一層的時候，表示已經處理完了，
不要忘記我們先前將這層root的値放進了current裡面，
所以我們應該要將其移除。(** Backtracking**的部分)

依此，寫成程式碼如下：

Java

Java的部分我們可以使用同名但不同參數長度的函式，
直接利用開頭檢查root，
來順便處理後續帶入root.left/root.right所需要的檢查。
Backtracking的部分，
currentResult先加上root.val後，後續再進行remove即可；
而留意由於我們不斷地在變換currentResult，
不要忘記要將其複製一份以加到result裡面，而非直接用加的。
(使用new LinkedList(currentResult) )

Python

同理，Python的部分一樣需要複製，
我們可以寫成curr[:]以複製一份用來讓res進行附加。

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

「時間/空間複雜度？」
(O(N)/O(logN)，因為整棵樹要遍歷過一遍，
然後平均而言，樹的深度會到O(logN)，
所以空間複雜度所以空間複雜度，這個部分不包含result的占用空間)

相似及延伸

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

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

從LeetCode學演算法 - 81 Backtracking (5) / DFS (7)

Tue, 07 Jan 2020 00:00:00 +0800

0093. Restore IP Addresses (Medium)

Question

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

Example:

1
2


Input: "25525511135"
Output: ["255.255.11.135", "255.255.111.35"]

分析/解題

給定一個僅含數字0~9的字串，將其還原成所有合法的IP位址的可能組合。

對於IP而言，我們所需考慮的有以下幾個條件：
1. 共分4段(且必須恰好是4段)
2. 中間以小數點連接，每組的數字在0~255之間

如果定義再清楚一點的話，
可以補上前面寫0的部分除了0以外不能納入，會更好一點。
(比如113.002.22.3不會是合法的IP，但一個IP可以是0.0.0.0)

所以這題也是很典型的Backtracking+DFS 的題目：
每次從s上面按順序取一段長度，檢查它是否合法，
再遞迴取下一段。

那麼，我們需要考慮一些邊界的條件，
以便於我們考慮什麼時候該「回頭」：
最基本的條件，就是已經分到第4段 了，
我們應該要考慮這段剩下的部分是否合法。

當剩下的長度>3 => 根本就超過了，完全不用考慮XD
剩下的長度≤3且轉成數字≤255 ，即可將該段補齊並加到結果。
例外：連續的0會有問題，所以要優先檢查是否剛好為'0’ 的狀況，
除了剛好為"0"的狀況外，首字元為'0’就必須被排除掉 。

邊界條件考慮完後，我們來考慮一般的分段法。

在開始之前，可以先排除掉剩下的長度小於所需的分段數 的狀況，
用以避免取分段時超出邊界。
(例如剩下長度為2，但還需要取3段，那麼顯然不夠用)

假設現在我們接下來要取的位置在 i ，要取 j 個字元：
那麼 j可以是1~3，但 i+j 不能超過s的長度 。
我們會發現額外要考慮的就是上面的2的部分 ，
取完一段以後，呼叫相同的函式進行遞迴，
不要忘記除了上一次傳進來的前導字串cur 外，
要加上的是這次取的分段 ，以及分隔用的小數點"." 。

依此，寫成程式碼如下：

Java

Java的部分，我們使用LinkedList來記錄結果res，
傳入的參數有該字串s，res，當前要取的索引值i，
當前的分段cnt(從0起算)，以及到目前為止的IP的字串cur。
由於每次呼叫checkIP時帶進去的字串都是新生成 的，
所以回到上一層時就自然還原了cur的狀態，
不用像之前的棋盤搜尋字串問題中需要額外考慮要還原的問題。
每次開始前不要忘記檢查s.length()-i < 4 - cnt的邊界 ，
若已經不符則可直接return。
(註：理論上也可以額外檢查s.length()-i > (4-cnt)*4的邊界，
但實測上並不會因此變快，推估可能理由和檢查255的問題一樣)

另外請務必留意在比較字串是否相等時請使用equals()的函式 ，
不要使用"=="(會出錯) 。

Python

Python的部分也是一樣的概念，
只是substring的操作可以簡單用s[i:j] 的形式來處理，
且比較相等可以直接使用"=="。

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

「時間/空間複雜度？」
(O(len(s)) / O(len(s))，更廣義來說，其實長度必須在12 以內，
所以最大的佔用空間和時間是可以固定的 ，
要說O(1)也不太算有錯就是了。)

「為什麼不是當3位數才檢查小於等於255？」
(這樣必須要先分開3位數及其他，變成要先經過另一組判斷式，
整體而言不會比較節省時間。)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 63 Backtracking (4) / DFS (6)

Fri, 18 Oct 2019 00:00:00 +0800

0077. Combinations (Medium)

Question

Given two integers n and k, return all possible combinations of k numbers out of 1 … n.

Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Input: n = 4, k = 2
Output:
[
 [2,4],
 [3,4],
 [2,3],
 [1,2],
 [1,3],
 [1,4],
]

分析/解題

給定兩個整數n跟k，回傳所有1~n之間取k個數字的組合。

這題其實跟先前的0078. Subsets非常的接近，
差別在於我們必須改成取得固定k個 ，
所以現在考慮上必須要將**「目前將取到第幾個數字」** 這件事情納入考量。

那麼，我們可以同樣用backtracking(回溯法) 的方式來考慮。
我們考慮初始化一個組合combo ，從1 開始決定要不要加入組合中，
並記錄現在走到的index(以i表示) 。

那麼，我們需要傳入的參數值有：
combo (當前未完成的組合), res (記錄結果的所有已完成的組合),
n (1~n的數字), k(連同當前這輪，還有幾個數字要被納入組合 ),
i (當前走到的數字)

那麼，我們可以使用遞迴(命名為findCombos)來處理這題，
當k等於0 時，表示已經完成這個組合，將其加入res中 ；
否則當i ≤ n 時，表示還有** 可以選擇的數字**(** 且組合還沒完成**)，
此時可以分成 a. ** 將i加入combo 或 b. 不加入combo** 中。
a. 將i加入combo中的話 -> ** 代入findCombos的遞迴中k要減1，i要加1。
且這輪下去遞迴完以後，記得將狀態復原(把combo的最後一個數字拿掉)
b. 不將i加入combo的話** -> 代入findCombos的遞迴僅需i要加1即可。
(因為只有當前選擇的數字增加)

除此以外，我們可以額外考慮一件事情：
由於剩下的可選數字應該大於我們還需要選擇的數字 ，
所以 i≤n 的條件應該可以進一步縮限成 ** i+k-1 ≤ n**。

依此，寫成如下的程式碼。

Java的部分，可以使用ArrayList/LinkedList皆可，
並且保險起見，可以先行檢查n和k。
(畢竟測資也有可能弄個不合法的負數或零)

Java

如之前的文章，Python請不要忘記append到combo上的必須是複製的list。
此外也可以使用itertools的combination來直接得到答案，
但請不要 在面試的時候這樣用XD
(因為這只證明了你知道工具，而不是你懂回溯法)

Python

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

「時間/空間複雜度？」
(O(C(n, k))/O(k*C(n,k))。
由於k的値會影響階乘連接的個數，所以不好化簡。)

相似及延伸

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

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

從LeetCode學演算法 - 60 Backtracking (3) / DFS (5)

Mon, 07 Oct 2019 00:00:00 +0800

0078. Subsets (Medium)

(當然，Medium的拍手也可以多拍幾下啦XD)

Question

Given a set of distinct integers, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:

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


Input: nums = [1,2,3]
Output:
[
 [3],
 [1],
 [2],
 [1,2,3],
 [1,3],
 [2,3],
 [1,2],
 []
]

分析/解題

給定一組內含相異的整數的集合nums，試回傳其power set。
(所有可能的子集合，包含空集合)

我們先考慮一下所謂的子集合。
所謂的子集合就是在指說，在nums所有的元素(element)中，
有哪些要被用，哪些不要被用的所有組合。
所以對於每個數都有加進去/不加進去的兩種可能，
如果nums有N個元素，所有的組合的可能是就會是2^N。

我們可以透過上述的思路來建構遞迴的函式。
首先，我們先產生一個subset，
用來存放走到當前的狀況 ，
而一個確定可以放進結果res的subset，
必須是將整個nums走完且決定誰要進，誰不要進才行。
要放進subset和不放都是可行的選擇，
那麼我們就必須要分岔成兩條路 ：

將當前遇到的數字置之不理，直接朝向下一個index走
先將當前遇到的數字加進subset中 ，再朝下一個index走
留意當回到上一層 的時候，這個index遇到的數字同樣應該要被取消掉 ，
所以我們應該要從subset中拔掉最後一個數字 。

那麼遞迴的尾端 ，自然就是當index走超過範圍的時候，
此時我們應該將這個subset作為其中一個結果放入到res中，
並回到上一層。

依此，我們可以寫成如下的程式碼。
在Java的部分，List使用LinkedList或ArrayList皆可，
ArrayList適用於需要取得某個點的値，
而LinkedList在儲存時會稍微快一點，
請留意我們在新增組合時是使用new ArrayList<>(subset) ，
用以加入subset的複本來放入res中。
如果單純放subset的話，由於大家都指向相同的位置，
後面修改subset的時候會導致res內的內容也同部被改到，
請務必留意XD

Java

這邊也提供了參考的其它解，包含了迭代解和另一種遞迴解，
概念都是**拿現在的所有組合和新的數字，決定要加或不要加，
用以衍生出兩倍的組合。**這種方法其實概念上類似我們之前提到的Gray Code的解法，
用原先的部分來組新的東西，有興趣可再參考。

Python的部分一樣需注意subset要使用copy來複製一份使用。

Python

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

「時間/空間複雜度？」
(O(2^N)/O(2^N)，因每種組合皆須經過一次，且都要存入結果。)

相似及延伸

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

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

從LeetCode學演算法 - 59 Backtracking (2) / DFS (4)

Fri, 04 Oct 2019 00:00:00 +0800

0079. Word Search (Medium)

(當然，Medium的拍手也可以多拍幾下啦XD)

Question

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of a sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

Example:

1
2
3
4
5
6


board =
[
 ['A','B','C','E'],
 ['S','F','C','S'],
 ['A','D','E','E']
]

1
2
3


Given word = "ABCCED", return true.
Given word = "SEE", return true.
Given word = "ABCB", return false.

分析/解題

給定一個2維棋盤和一個字(word)，檢查這個字是否存在這個棋盤裡。
構成字的方式是從棋盤的某一格開始，連續選取相鄰的格子。
同時，相同的格子不能使用兩次。

前面提到過Backtracking(回溯法)，
這題同樣也是典型的DFS+Backtracking方法可以處理的對象。

首先，要構成一個字，就要從棋盤上選擇一個位置開始往下 。
每次選一個相鄰的格子，拿來跟word比對，
都必須要和word對應的位置上的字元(char)相同才行，
所以這表示我們還要記錄現在比對到哪個index 了。
同時，由於用過的格子不能重複使用，每次在進入dfs的時候，
我們必須要記錄是否有造訪(visit)過這個格子 ，
才往更深處呼叫；同時，在該層的四個方向都判斷完以後 ，
回到上一層之前，必須將造訪的紀錄還原回去 。
(因為我們只有在這次走這條路的時候有造訪，
回到上一層的時候這個格子應該處於沒有造訪過的狀態)

所以最開始我們要做的事情是，
使用迴圈分別將每個cell作為起始點，開始進行搜尋。
(搜尋的遞迴函式如果其中一次是True的話就可以直接回傳True)

每次搜尋的時候，傳入的有：
board(棋盤), r, c(當前的cell位置),
index(比對到word的哪一個char), word

每一次我們要做的步驟：

檢查board[r][c]和word的index處的值是否不同 ，
不同則回傳False 表示這條路行不通。
檢查index 是否已經走到最後了(length of word - 1 )，
是的話代表這條路到這邊剛好就是答案，回傳True 。
將index遞增 (接下來要給下面遞迴使用)，並將board[r][c]標明已造訪 。
分別以往上下左右 方向的新的(r, c)值來代入函式進行遞迴搜尋 ，
如果結果是True的話，直接回傳True 。(也就是下面的部份都不用做了XD)
(這邊記得要檢查上下左右移動一格以後是否超出board範圍 )
前面四個都是False的狀況，代表這條路行不通了，
我們要回到上一步，這時候要先將board[r][c]標明未造訪 ，
才回傳False 。

如果跑完整個棋盤，都沒有能夠成立的路徑的話，
就應該回傳False 作為答案。(因為我們沒有找到可行的路徑)

在實作時為了方便起見，我們可以宣告class的變數來放一些常用的東西，
這邊用了wlen(word的長度), row, col(board的列/行數)。
需要注意的是，在實作造訪與否的紀錄時，
我們可以選擇使用像是visited[][]的二維陣列來寫，
但也可以採用別的方法，比如將裡面的值暫時設為"0"，
後面再還原，或者像Java這邊寫的將其和128進行XOR 。

為什麼和128進行XOR呢？
因為ASCII中的所有字元值均不超過128，
也就是說，它們在二進位上的第8位數(由右數到左)均為0 。
XOR後，第8位數會變成1，所以再度遞迴下去比對時，
就不可能等於任何字元，從而達到標示造訪過的目的。

還原回來的時候，因為：
a XOR 128 XOR 128 ＝ a XOR 0 = a
(先前的文章 有提到過的Bitwise Operation)

所以再重複用128進行一次XOR即可還原原先的值 了！

寫成程式碼如下：
(留意Java可以直接對char當作是數字來操作 )

Java

Python

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

「時間/空間複雜度？」
(如果row = m, col = n，word長度=l的話，從每個點出發一次，
並且每次都有4個方向的選擇(但只有三個方向能繼續延伸)，
時間複雜度會是O(m * n * 3^L)。
空間複雜度的部分，如果考慮call stack的話，最大會是O(L)，
不考慮的話，由於沒有使用visited[][]來處理，則會是O(1)。
如果用visited來存放的話則是O(m*n))

「在Python中是否可以使用類似Java對char的解法來處理呢？」
(可以，請使用ord()將單個字元進行轉換成數字再進行xor，
不能直接用str型態的値來處理。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
Raiy Kuo: 細算的話選擇方向這部份的時間複雜度是3^L，
詳情請見response中的討論。

(歡迎提供意見協助更正歐~)

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

從LeetCode學演算法 - 42 Backtracking (1) / Tree (8)

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

0257. Binary Tree Paths (Easy)

Question

Given a binary tree, return all root-to-leaf paths.

Note: A leaf is a node with no children.

Example:

1

Input:

1

Output: ["1->2->5", "1->3"]

1

Explanation: All root-to-leaf paths are: 1->2->5, 1->3

分析/解題

給定一個二元樹，回傳其所有根到葉的路徑。
這題是Easy難度的題目，剛好藉由它來講一下回溯法(Backtracking) 。
這個題目看起來挺簡單的，如果沒有特別要求的話，寫起來也不難，
依照遞回的模式就可以順利解決，
思路大致上是每走一步就將root的值串上path字串 ，
直到左右均無節點，表示已走到葉節點了，即可將其放到結果res中。

所以一般可能會寫成這樣：

可以通過但不盡理想的遞回解

這麼做其實不盡理想，
因為我們會發現裡面的每一個tmp其實都是使用一個新的變數 ，
顯然這件事情會讓我們花費更多的空間(因為產生新的變數)。
怎麼辦呢？這時候就到了回溯法上場的時候了。

我們之前有介紹過DFS/BFS ，
分別代表著深度優先搜尋 和廣度優先搜尋 ，
如這題前面的解法其實也可以當作DFS來看待，

而回溯法的概念又更廣泛一些 ：
在每個階段將所有可能性列出 ，
經過檢查排除掉不可能的解後，往下一個階段 進行搜尋；
如果這個階段的所有分支均不成立 ，
則回復到上一個階段 的搜尋，並取消掉這個階段所造成的影響。
(過程中視要求，可在找到所有答案後才回傳，或者找到第一個答案就回傳)

簡單來說，就是一個一個試，
走錯了就回頭，而且記得先前** 試的痕跡要處理掉**就對了XD
聽起來可能還是有點抽象，我們講這題的實作方式好了。

要進行回溯法，首先要確立要處理的對象 。

例如這題裡面最重要的是節點經過的路徑 ，
那麼我們應該可以將當前的路徑當作主要處理的對象：
每次在遞迴函式中應該要做的事情有：

將當前的根節點 加到路徑的ArrayList中
如果左節點 存在，遞迴進行左子樹 的部分
如果右節點 存在，遞迴進行右子樹 的部分
如果左右節點均不存在 ，表示該路徑是答案要求的其中一條 ，
將整個路徑內的節點值按照要求的格式輸出到結果res中
走完前4步，這個階段的可能性均搜索完畢 ，
所以要回到上一個階段，這時在1.的時候加入的根節點應該要被移除 ，
因為上一個階段並沒有它。

可以看到在回溯法中，路徑的部分是所有函式共用 的，
所以只要妥善處理用完後復原，即可使用一個List來處理整個樹的狀況，
這個List最大的占用空間就是這棵樹的深度 。

依此，我們可以寫出其程式碼。

Java的部分，這邊用DFS來命名遞迴的函式名，
也可以叫getPath，可依讀者喜號命名。
使用StringBuilder來進行字串的整理(加上”->”)，
以及使用ArrayList/LinkedList來處理path相關的部分。
(應該是用哪個都可以啦XD 題目只限定List)
最後不要忘記每次該階段做完要將最後一個進行移除(remove)。

Java

Python的部份我們可以直接使用List來處理，
並且利用join 的特性可以很方便地串接所有的path。
最後一樣不要忘記移除當階段的痕跡(pop )。

Python

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

「時間/空間複雜度？」
(時間複雜度為O(N)(因為要掃過整棵樹)；
空間複雜度的部分，使用的path在平衡的狀態下複雜度是O(logN)
而最後的res部分如果用個數來看的話，完美的二元樹深度是O(logN)，
路徑數是O(N)，所以總占用空間是O(N * logN) )

相似及延伸

1.0113. Path Sum II

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

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