DFS on 跟著 Desolve 學程式

Learn Algorithms from LeetCode-121 (0802. Find Eventual Safe States)

Wed, 01 May 2024 00:00:00 +0800

Categories: Graph/DFS

Level: Medium

Introduction: (Basic + Advanced + Interview Edition)
Learning Algorithms from LeetCode + Interview Success Guide
(Regular price: 3591 NTD, Discounted price until 2024/05/16 23:59)
https://hiskio.com/bundles/egb397?s=tc

(Regular price: 3990 NTD, Valid for a long term)
https://bit.ly/lc2022all

Please help me click on the “SHOW EMBED” below and give it 5 likes~ If you like it, you can also give me a round of applause~
(Liking doesn’t cost anything, thank you for supporting my writing~)

Question

There is a directed graph of n nodes with each node labeled from 0 to n - 1. The graph is represented by a 0-indexed 2D integer array graph where graph[i] is an integer array of nodes adjacent to node i, meaning there is an edge from node i to each node in graph[i].

A node is a terminal node if there are no outgoing edges. A node is a ** safe node** if every possible path starting from that node leads to a ** terminal node** (or another safe node).

Return an array containing all the *safe nodes * of the graph. The answer should be sorted in ascending order.

Example 1

1
2
3
4
5


Input: graph = [[1,2],[2,3],[5],[0],[5],[],[]]
Output: [2,4,5,6]
Explanation: The given graph is shown above.
Nodes 5 and 6 are terminal nodes as there are no outgoing edges from either of them.
Every path starting at nodes 2, 4, 5, and 6 all lead to either node 5 or 6.

Example 2

1
2
3


Input: graph = [[1,2,3,4],[1,2],[3,4],[0,4],[]]
Output: [4]
Explanation:

Constraints

n == graph.length
1 <= n <= 104
0 <= graph[i].length <= n
0 <= graph[i][j] <= n - 1
graph[i] is sorted in a strictly increasing order.
The graph may contain self-loops.
The number of edges in the graph will be in the range [1, 4 * 104].

Analysis/Approach:

There is a directed graph with n nodes, each labeled from 0 to n-1. The graph is represented using a 2D array called “graph,” where graph[i] represents the nodes connected to node i with an edge. The direction of the edge is from node i to each node in graph[i]. If a node has no outgoing edges , it is considered a terminal node . If all possible paths from a node ** lead to terminal nodes**, the node is considered a ** safe node**.

The task is to find all the safe nodes in the graph and return them in ascending order as an array (or list). To determine if a node is a safe node, we need to check if there are any cycles in the paths starting from that node. ** If there is a cycle, the node itself and all the nodes in the cycle will not be safe nodes.** Additionally, since we need to check that all paths are cycle-free to determine a safe node, ** the results from earlier checks for nodes can be applied to later checks.**

To solve this problem, we can use a depth-first search (DFS ) approach to traverse each node and its paths until the end (or until we can determine if there is a cycle). The steps for solving the problem are as follows:

Initialize two arrays/lists, vis and ** path**, to keep track of whether a node has been visited and whether it is part of a cycle. Both arrays/lists should have a length equal to the number of nodes in the graph, n, and initialized with 0 (or False).
Initialize an empty result list called res .
Declare a DFS function that takes the current node, graph , vis , and path as parameters and returns ** True if a cycle is found** and ** False if no cycle is found**.
In the DFS function, perform the following steps:
4.1. Set vis[curr] and ** path[curr]** to ** 1** (indicating that the node has been visited and is temporarily part of a cycle).
4.2. Iterate over the nodes u in graph[curr] :
4.2.1. If vis[u] is 0 (indicating that the node hasn’t been visited), recursively call DFS with u as the current node and check if it returns True. ** If True, return True (indicating a cycle is found).
4.2.2. Otherwise, if path[u] == 1 (indicating that u is already part of a cycle), return ** True.
4.3. After the loop ends without returning True , it means there is no cycle found when going down from the current node. ** Reset path[curr] to 0 and return False. (Since we set all the path[curr] alone with 1, we need to set it back)**
In the main function, use a loop to iterate over i from 0 to n-1 . If vis[i] is 0, call DFS with i as the current node.
After all iterations, use another loop to iterate over i from 0 to n-1 and add the nodes i with path[i] == 0 to the res list.
Return the res list.

Here is the code implementation in both Java and Python:

Java

In the Java implementation, an ArrayList is used for the res variable. If we want to reduce the number of parameters passed to the dfs function, we can make vis and path class variables. However, since their lengths are tied to the number of nodes in the graph, they still need to be initialized within the eventualSafeNodes method.

Python

As mentioned before, in the Python implementation, using nested functions can slightly reduce the number of variables that need to be passed as arguments. In fact, if we move the vis and path arrays/lists to the outermost scope, they don’t need to be passed as arguments at all because the nested function can access variables from the outer scope.

You may try rewriting the code and experimenting with this approach.

Potential Interview Questions:
“What are the time and space complexities?”
(O(V+E)/O(V) , where V is the number of nodes in the graph and E is the number of edges in the graph)

“Can we use a single array/list to handle visited nodes and cycles?” (Hint: State can have more than 1 or 0;
you can use 3 different states to handle this)

Similar and Extended Topics:
Special thanks to suggestions/corrections from viewers:
(Welcome to provide feedback to help with corrections~)

Learn Algorithms from LeetCode — See you next time!

Want to see more problems?
Feel free to check out Article 0 for the topic you want!

Also, follow our Facebook page for notifications on new articles:
Learn with Desolve

從LeetCode學演算法-121 (0802. Find Eventual Safe States)

Wed, 01 May 2024 00:00:00 +0800

Categories: Graph/DFS

Level: Medium

寫在前面

(基礎+進階+面試篇)從 LeetCode 學演算法 + 面試成功指南**

(3591元有效期限至 2024/05/16 23:59)
https://hiskio.com/bundles/egb397?s=tc

(3990元長期有效) https://bit.ly/lc2022all

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

Question

A node is a terminal node if there are no outgoing edges. A node is a ** safe node** if every possible path starting from that node leads to a ** terminal node** (or another safe node).

Return an array containing all the *safe nodes * of the graph. The answer should be sorted in ascending order.

Example 1

1
2
3
4
5


Input: graph = [[1,2],[2,3],[5],[0],[5],[],[]]
Output: [2,4,5,6]
Explanation: The given graph is shown above.
Nodes 5 and 6 are terminal nodes as there are no outgoing edges from either of them.
Every path starting at nodes 2, 4, 5, and 6 all lead to either node 5 or 6.

Example 2

1
2
3
4


Input: graph = [[1,2,3,4],[1,2],[3,4],[0,4],[]]
Output: [4]
Explanation:
Only node 4 is a terminal node, and every path starting at node 4 leads to node 4.

Constraints

n == graph.length
1 <= n <= 104
0 <= graph[i].length <= n
0 <= graph[i][j] <= n - 1
graph[i] is sorted in a strictly increasing order.
The graph may contain self-loops.
The number of edges in the graph will be in the range [1, 4 * 104].

分析/解題

有一個有向圖，當中包含了n個節點，每個節點分別被標記為0~n-1。
這個圖使用2D的array graph來表示，
當中graph[i]代表所有從節點i有邊(edge)相連的節點，
且方向是從節點i到每個graph[i]中的節點。

如果一個節點沒有任何向外的邊 的話，則該節點是terminal node ；
如果從一個節點出去的所有可能的路徑 都導向到terminal node 的話，
則該節點是safe node 。

試找出所有圖中的safe nodes，並且以陣列(串列)型態回傳，
當中答案必須要以升冪排序 (由小到大排列)。

首先我們要思考的是，怎麼樣的狀況下會沒辦法terminal呢？
按照定義，一旦導到terminal node ，則由於沒有向外的邊，
於是路徑就會停在terminal node了(因為無路可走 )。
換句話說，如果要不停下來的話，就要一直有路可走。
但節點和邊都是有限的 ，那麼就只有當存在環 的狀況下，
才能夠一直有路可以走囉！

因此，要判斷一個點是否為safe node，
端看從該點出發的路徑是否存在有環 ；
如果有環的話，則包含該點，以及環上的所有節點都不會是safe node 。

同時，由於我們判斷safe node必須要所有路徑 都沒有環存在，
因此前面檢查過的節點結果，會同樣適用於後面的檢查 。
例如：從點A出發，如果其中一條路徑我們走過點B跟點C，
那麼下次當檢查從點B出發的時候，
我們可以直接採納前面點A出發經過點B時對點B判斷的結果，
如此一來就不用重新再走一遍了！

那麼這題應該要做的就是遍歷每一個節點及路徑，
並且每條路徑都走到底(或者走到可以判定是否有環)為止，
這顯然適用於DFS的做法。

讓我們來試著列看看解題步驟：

初始化兩個陣列(串列) vis, path ，分別代表該節點是否已造訪過，
以及該節點是否為某個環的一部分，兩者的長度均為graph的節點數量n，
預設值均為0(或False也可以)。
初始化一個空的res串列備用。
宣告一個dfs函式，代入curr, graph, vis, path (curr為要檢查的node)，
其回傳True則代表存在環，False則代表不存在環 。
在dfs函式中，進行以下處理：
4–1. 將vis[curr]和path[curr]均設為1 (也就是已造訪，且暫定環存在 )
4–2. 迴圈從graph[curr] 中取出節點u：
4–2–1. 若vis[u]為0 (表示這個節點還沒被造訪) ->
代入到dfs往下檢查，如得到回傳True的話則也回傳True(代表確定有環)
4–2–2. 否則，若path[u] == 1 (表示** u在環上**)，回傳True。
4–3. 經過迴圈結束後尚未回傳，代表其實從curr往下走並不存在環，
這時候重新將path[curr]設為0 ，並且回傳False 。
(前面直接回傳True的時候，因為我們預先將沿路的path[curr]設為1，
因此離開的時候整條路徑上的節點都被標記成環了 ；
反過來說，當發現不存在環的時候，該還原的就要還原回來 。)
在主函式中，使用迴圈令i依次從0~n-1 ，
如果vis[i] == 0 的話，就代入進行dfs。
都做完的狀況下，再次使用迴圈令i從0~n-1 ，
將path[i] == 0 的i 加入到res。
回傳res。

依此，寫成程式碼如下：

Java

Java的部分使用了ArrayList給res使用，
如果想要讓dfs不要帶入那麼多東西的話，
也可以將vis跟path設定為class variables，
不過因為長度跟graph的節點數掛勾，
所以還是要在eventualSafeNodes裡才能初始化。

Python

Python的部分如同以前提到過的，
使用子函式也可以稍微減少需要代入的變數量，
甚至將vis和path放最前面的話也可以連它們都不需要代入，
因為子函式可以去取得到上面這層的變數。
(讀者可以自行嘗試再改寫看看)

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

「時間／空間複雜度？」
(O(V+E)/O(V)，V為graph的節點數，E為graph的邊數)

「能不能只用一個陣列／串列來處理經過的節點和環？」
(提示：State可以不只有1或0，可以設定3種state來處理)

相似及延伸

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

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

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

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

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

Learn Algorithms from LeetCode - 119 (0797. All Paths From Source to Target(Medium))

Sun, 04 Jun 2023 00:00:00 +0800

Categories: Graph/DFS

Level: Medium

Introduction: (Basic + Advanced + Interview Edition)
Learning Algorithms from LeetCode + Interview Success Guide
(Regular price: 3591 NTD, Discounted price until 2023/06/30 23:59)
https://hiskio.com/bundles/eCP23B397?s=tc

(Regular price: 3990 NTD, Valid for a long term)
https://bit.ly/lc2022all

Question

Given a directed acyclic graph (DAG ) of n nodes labeled from 0 to n - 1, find all possible paths from node 0 to node n - 1 and return them in any order .

The graph is given as follows: graph[i] is a list of all nodes you can visit from node i (i.e., there is a directed edge from node i to node graph[i][j]).

Example 1

1
2
3


Input: graph = [[1,2],[3],[3],[]]
Output: [[0,1,3],[0,2,3]]
Explanation: There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.

Example 2

1
2


Input: graph = [[4,3,1],[3,2,4],[3],[4],[]]
Output: [[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]

Constraints

n == graph.length
2 <= n <= 15
0 <= graph[i][j] < n
graph[i][j] != i (i.e., there will be no self-loops).
All the elements of graph[i] are unique .
The input graph is guaranteed to be a ** DAG**.

Analysis/Approach:
Given a directed acyclic graph (DAG) with n nodes labeled from 0 to n — 1, we need to find all possible paths from node 0 to node n — 1 and return them in any order.

The graph is represented in the following way: graph[i] represents a list of nodes that can be visited from node i. (Directly visiting means there is a directed edge from node i to graph[i][j].)

Let’s talk about graphs in this article. As mentioned in Article 115 , in a graph with directionality (a -> b and b -> a are considered different edges), it is called a directed graph . If a directed graph does not have cycles (a cycle means there is a path starting from a point a and ending at a, forming a loop), it is called a ** directed acyclic graph**, abbreviated as ** DAG**.

Since the problem guarantees that the graph is a DAG, it is impossible to return to the same node from any starting node, and it is also impossible to backtrack, meaning there are no duplicates in the paths.

Let’s try to outline the steps to find the paths:

Start from i = 0 and examine the connections in graph[i] . For example, in Example 1, node 0 connects to nodes 1 and 2, so there are two paths: 0->1 and 0->2.
For the path 0->1, we need to check the connections from node 1. It is connected only to node 3, which happens to be the last node in this graph. Therefore, we have found one valid path: 0->1->3.
Similarly, for the path 0->2, it only has one connection: 0->2->3.

Therefore, for this problem, we can use DFS starting from node 0 and recursively explore the graph. Along the way, we need to keep track of the current path at each step. Whenever we reach the destination node, we add that path to the result list. Finally, we return the entire result.

The steps for solving this problem are as follows:

Initialize a list called res to store the resulting paths.
Define a function dfs with parameters (i, path), where i is the current node and path is the path taken to reach node i (including i).
Inside the function, first check if i is equal to the length of the graph minus 1. If true, it means we have reached node n-1, and this path is one of the answers. Add it to res.
If the previous check fails, it means we need to continue exploring. Iterate through the next node nxt in graph[i] and recursively call dfs with nxt and the updated path (path + nxt).
Start the recursion by calling dfs with (0, [0]).
After Step 5 is completed, return res.

Based on this, the code can be written as follows:

Java

In Java, the res list is obviously two-dimensional, so we can use an ArrayList to store the paths. In the helper (or dfs) function, since we cannot use nested functions like in Python, we need to include graph, i, path, and res as parameters. Since the path is reused in each recursion, we use backtracking to keep track of the path. In each call to the helper function, we add the current node i to the path (path.add(i)), and remember to remove it (path.remove(path.size() — 1)) before exiting.

One important thing to note is that when adding paths to res, ArrayList is a reference-based structure, meaning it doesn’t create a copy of the path. Therefore, when adding to res, we need to use new ArrayList(path) to create a copy. Otherwise, when we backtrack, it will affect the results in res.

Python

In Python, we can use nested functions, so we don’t need to include res and graph as parameters, which makes the code cleaner. When performing dfs, we can directly create a new list using path + [nxt] . This way, we don’t need to deal with backtracking, and we can directly append path to res without making a separate copy. (Since path + [nxt] creates a new list already.)

Potential Interview Questions:
“What are the time and space complexities?” (O(V * 2^V), as each path has a maximum complexity of O(V), and there can be up to O(2^V) paths.)

Similar and Extended Topics:
Special thanks to suggestions/corrections from viewers:
(Welcome to provide feedback to help with corrections~)

Learn Algorithms from LeetCode — See you next time!

Want to see more problems?
Feel free to check out Article 0 for the topic you want!

Also, follow our Facebook page for notifications on new articles:
Learn with Desolve

從LeetCode學演算法 - 119 Graph (2) / DFS (21)

Sun, 04 Jun 2023 00:00:00 +0800

0797. All Paths From Source to Target (Medium)

寫在前面

(基礎+進階+面試篇)從 LeetCode 學演算法 + 面試成功指南**

(3591元特價中: 2023/06/30 23:59後截止)
https://hiskio.com/bundles/eCP23B397?s=tc

(3990元長期有效) https://bit.ly/lc2022all

Question

Given a directed acyclic graph (DAG ) of n nodes labeled from 0 to n - 1, find all possible paths from node 0 to node n - 1 and return them in any order .

The graph is given as follows: graph[i] is a list of all nodes you can visit from node i (i.e., there is a directed edge from node i to node graph[i][j]).

Example 1

1
2
3


Input: graph = [[1,2],[3],[3],[]]
Output: [[0,1,3],[0,2,3]]
Explanation: There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.

Example 2

1
2


Input: graph = [[4,3,1],[3,2,4],[3],[4],[]]
Output: [[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]

Constraints

n == graph.length
2 <= n <= 15
0 <= graph[i][j] < n
graph[i][j] != i (i.e., there will be no self-loops).
All the elements of graph[i] are unique .
The input graph is guaranteed to be a ** DAG**.

分析/解題

給定一個有向無環圖(directed acyclic graph, DAG)，
當中有n個nodes，分別被標記為0到n - 1，
找出所有可以從node 0走到node n - 1的路徑，
並且以任意排序的方式回傳。

graph的給定方式如以下敘述：
graph[i] 代表所有從node i可以造訪的nodes的串列。
(直接造訪，也就是指node i到graph[i][j]之間會有一個有方向的edge(邊))

我們這篇再來談談graph。
之前我們在第115篇 提到過，
在graph當中，有方向性的(a -> b和 b -> a被視為不一樣的邊)圖，
被稱為有向圖(directed graph) ；而如果有向圖中，
不存在環(cycle，也就是圖上存在一個點a，從點a出發，
有一條路徑可以再走回點a)的話，
則稱為有向無環圖，簡寫為DAG。

既然題目保證圖是DAG，那麼我們從任何一個點出發，
都保證不可能會再回到同一個點，同時也不可能走回頭路，
也就不存在重複的可能。

讓我們嘗試列出找尋路徑的步驟：

首先從i = 0開始，觀察graph[i] 的連接，
例如像Example 1中0就連到1跟2，
也就是說會有 0->1 跟0->2 這兩條路徑
對於0->1而言，接下來我們要看1的連接，
發現它只連接到3，而3剛好是這個graph的最後一個節點，
因此得到其中一個有效的路徑是0->1->3。
同理，對於0->2而言也剛好只有0->2->3。

因此對於這題，我們可以使用DFS從node 0做遞迴往下，
中途要記住每一步當下走過的路徑，只要有走到終點的路徑，
就將其放到答案的列表裡，最後再將整個結果回傳即可。

列出解題步驟如下：

初始化一個串列res，用以存放結果的路徑
定義一個dfs的函式，輸入為**(i, path)** ，
當中i為當前走到的node，path為走到node i時經過的路徑(包含i )。
在函式中，首先檢查i是否和graph的長度-1相等，
如是，代表走到node n-1 的位置了，
該路徑是答案之一，將其加到res上 。
若3的檢查解果為否，代表要繼續往下走，
迴圈遍歷graph[i] 中的下一個node nxt，
並呼叫dfs，將node nxt 和新的path(path加上nxt )代入遞迴。
將**(0, [0])** 代入dfs中開始遞迴。
完成5後，將res回傳即可。

依此，寫成程式碼如下：

Java

在Java的部分，我們的res顯然是二維的，
因此我們可以使用ArrayList來放入其中。
在helper(或dfs)中，因為不能像Python使用子函式，
這邊參數就需要graph、i、path、res；
又因為path是反覆遞迴下去利用的，
我們在記錄時使用backtracking的方式，
選擇在每次進入helper函式時，將path給加上當前走到的node i，
在離開時，則要記得將其收回，因此分別會在頭尾做path.add(i) ，
以及path.remove(path.size()-1) 。

其他要留意的部分是，由於在放到res的時候，
對於ArrayList來說是一個指向性質的放置，並不會直接複製一份path，
所以在res.add的時候，必須要使用new ArrayList(path) 的手法，
將path複製一份出來才行；不然後面我們在backtracking的時候，
就會同步影響到res的結果喲！

Python

在Python的部分由於可以使用子函式，
我們可以不需要再將res跟graph加到參數，
就會簡潔一點；
同時，在進行dfs的時候，我們這邊改成用
path + [nxt] 的方式，就會直接形成一個新的list。
這樣一來，path的部分就不需要再回頭處理backtracking的問題，
同時res也可以直接進行append(path)，不需要另行複製。
(因為前面path + [nxt]時已經複製完path並形成一個新的list了)

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

「時間/空間複雜度？」
(O(V * 2^V)，因為單一條最多是O(V)，最多可能有O(2^V)條)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 118 DFS (20) /BFS (5) / Queue (6)

Sun, 28 May 2023 00:00:00 +0800

0934. Shortest Bridge (Medium)

寫在前面

(基礎+進階+面試篇)從 LeetCode 學演算法 + 面試成功指南**

(3591元特價中: 2023/06/30 23:59後截止)
https://hiskio.com/bundles/eCP23B397?s=tc

(3990元長期有效) https://bit.ly/lc2022all

Question

You are given an n x n binary matrix grid where 1 represents land and 0 represents water.

An island is a 4-directionally connected group of 1’s not connected to any other 1’s. There are ** exactly two islands** in grid.

You may change 0’s to 1’s to connect the two islands to form one island .

Return the smallest number of 0’s you must flip to connect the two islands.

Example 1

1
2


Input: grid = [[0,1],[1,0]]
Output: 1

Example 2

1
2


Input: grid = [[0,1,0],[0,0,0],[0,0,1]]
Output: 2

Example 3

1
2


Input: grid = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
Output: 1

Constraints

n == grid.length == grid[i].length
2 <= n <= 100
grid[i][j] is either 0 or 1.
There are exactly two islands in grid.

分析/解題

給定一個 n x n 的 binary 矩陣 grid，當中 1 代表陸地，0 代表水。
一個 island (島嶼) 的定義是指一組在四個方向和其他的1相連的群組，
且沒有再和其他1相連(也就是中間經過1的都算是同一塊島嶼)。
在 grid 中恰好兩塊島嶼。
你可以將0變成1用來連接兩塊島嶼，以形成一塊島嶼，
試回傳要翻轉0到1使得兩塊島嶼連接的最少所需的數目。

好久不見了！

這題算是比較特別的題目，因為比較好的解法會是DFS和BFS都用上，
一個用來找到第一整塊島嶼，另一個用來連接。

就題目而言，從0翻到1，其實就是一個搭橋的概念，
單就grid上考慮，那麼我們肯定是從兩個島距離最近的點來搭會最好，
但怎麼知道哪兩個點距離最近呢？

如果兩塊島嶼都是完整矩形的話，
或許我們還可以從邊與邊的垂直距離來做文章，
也還有一些比較簡單的計算方法(比如下圖取兩點的垂直+水平距離)
(如果水平或垂直方向有重合的話則只計di或dj)

取最近的兩點垂直距離+水平距離(也有可能其中一個方向不用計)

但.…..它們並不一定是矩形XD"
所以有可能出現像這樣子的狀況，然後旁邊可能全是不規則形狀，
無法用矩形算完：

看圖會知道算哪個點，但究竟要娶幾個點才能算呢？

所以既然無法知道兩塊島嶼長什麼樣子，也不知道規不規則，
那只能回到笨方法了：
先找到其中一塊島嶼，再從這塊島嶼的邊界往外找(搭橋)。

我們嘗試來列出解題步驟：

取得grid的長寬r, c (沒錯，這題其實就算不是正方形的grid應該也可以做)
先遍歷找到grid上任意一個值為1的點(i, j)，
這個點肯定是其中一塊島上的陸地
從(i, j)開始進行DFS往四方探索陸地，同時將所有途經的陸地標為2
(標成2的意義是為了可以和另一塊島嶼的陸地區分開來)；
在步驟3的探索中，如果碰到0時，
把和0相接的陸地座標記到一個queue 裡面
(代表這是第一塊陸地的臨水的邊界)
完成3, 4後，我們會得到一個queue，當中全是第一個島嶼的臨水的邊界 ，
作為我們搭橋的出發點，這裡設定我們要求的答案step為0
當queue中有值的時候，持續操作以下步驟：
取得當前queue的長度L，進行一個L次的迴圈：
從queue中取出一組座標(i, j)
從(i, j)往四個方向看，如果沒有超出grid的話，檢查以下可能：
9-1. 如果值是1，則代表成功接通，這時候直接回傳step作為答案即可
9-2. 如果值是0，則代表繼續搭橋，將新座標放到queue當中，
並且將這個位置的值標為-1(代表已經走過了)
步驟7的迴圈結束後，將step遞增1，接下來回到6檢查是否要繼續
雖然題目設定上一直都是找得到解答的，但如果找不到解答的話，
離開步驟6的迴圈後，則應該要回傳-1，表示找不到能搭建的橋
(也就是grid可能被給成只有一塊土地)

在上面的解題步驟中，步驟34是DFS ，
目的在於要找到第一塊島嶼，記錄邊界，
並將其值改動成2，用來跟第二塊島嶼區別；
而步驟610則是BFS ，
用來從邊界開始往外嘗試搭橋，
因此我們可以在找到連接到第二塊島嶼的時候，
因為一次是每種可能都走一步的特性，確定最小所需的步數，
也就是我們所要求的答案。

依此，寫成程式碼如下。

Python

為求簡單，這邊我們直接將grid改名為A，避免寫太多次。
我們可以利用簡單的dirs串列來標定四個方向，
從而縮減每次寫+1和-1的部分，
這個小技巧應該常碰到類似題目的同學大多看過。
另外，我們使用了一個set start，用來幫我們自動化簡加入的座標，
因為我們有可能加同樣的座標到queue裡面，
使用set可以有效避免這一點。

同時請留意到當A[x][y] == 0的時候，要加入的是(i, j)歐!
因為我們加入的是陸地的邊界(1)，而不是水(0)，
同理，後面起始的時候因為是從陸地開始起算，
所以step是從0而非從1開始。

Java

Java的部分則會稍微麻煩一點，
這邊將大多數的東西放在class variable的位置，
可以有效避免需要大量的傳遞參數；
Queue的部份我們使用ArrayDeque來處理，
那麼對應的取出和放入就會變成poll()和offer()。
(注意每次放入的時候都要產生一個新的int[]來放入)

另一方面，由於HashSet在Java當中用起來比較沒有像Python這麼彈性，
這邊採用visited的方式來處理，
我們將已經放入過q的(i, j)在visited中設定為true，
再每次檢查，即可得到相同效果。
此外，由於Java不接受回傳一個沒有回傳值的function，
因此27和28行會分成兩行來寫，先進行dfs完，再呼叫return。

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

「時間/空間複雜度？」
(O(n²)/O(n²)，在長和寬均為n的狀況下，最多也就是掃完整個grid)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 116 Tree (21) / DFS (19)

Tue, 21 Sep 2021 00:00:00 +0800

0814. Binary Tree Pruning (Medium)

寫在前面

(基礎+進階+面試篇) 從 LeetCode 學演算法 + 面試成功指南**http://bit.ly/zeroclg

新書(第一本，不曉得會不會是最後一本XD)開始預購啦！
初學 Python 的第一本書 : 從基本語法到模組應用（iT邦幫忙鐵人賽系列書） https://www.tenlong.com.tw/products/9789864348503
這本書主要是針對初學Python的入門讀者，希望能夠提供一個得以從零開始上手，又不會太過冗長的入門學習書。有興趣的話請多多支持！

Question

Given the root of a binary tree, return the same tree where every subtree (of the given tree) not containing a 1 has been removed.

A subtree of a node node is node plus every node that is a descendant of node.

Example 1

1
2
3
4
5


Input: root = [1,null,0,0,1]
Output: [1,null,0,null,1]
Explanation:
Only the red nodes satisfy the property "every subtree not containing a 1".
The diagram on the right represents the answer.

Example 2

1
2


Input: root = [1,0,1,0,0,0,1]
Output: [1,null,1,null,1]

Example 3

1
2


Input: root = [1,1,0,1,1,0,1,0]
Output: [1,1,0,1,1,null,1]

Constraints

The number of nodes in the tree is in the range [1, 200].
Node.val is either 0 or 1.

分析/解題

給定一個二元樹的root，將同一棵樹中未含任何1的子樹均去除掉並回傳。
(限制條件：樹的節點數目在1~200之間，且Node的值只會是0或1)

如果我們看到範例的話，大致上可以理解要被去掉的部分就是包括自己以及其底下的所有節點值均為0的子樹，這樣才能保證剩下的符合題目要求的條件。

因此，我們總體要做的就是檢查一棵樹的左子樹及右子樹狀況，
然後分別決定左子樹/右子樹是否要被去掉，最後將當棵樹的總體狀況往上回傳，因此，設計一個子函數helper如下：

傳入要檢查的節點n
如果n是空節點，則直接回傳0(因為這代表往下左右沒有其它節點了，也不用繼續檢查)
遞迴檢查左子樹(將n.left代入helper)，取得左子樹含1的節點數量為l
遞迴檢查右子樹(將n.right代入helper)，取得右子樹含1的節點數量為r
若l為0，表示無左子樹或左子樹均無節點值為1的節點，將n.left設為NIL
同理，若r為0，將n.right設為NIL
回傳l+r+n.val

在將root代入helper遞迴結束後，所有root的子樹應該都被清乾淨了，
除了root自己以外，所以我們要檢查helper得到的最後的值，
若為0的話，則最終我們應回傳NIL，否則應回傳root。

依此，寫成程式碼如下：

Java

Java的部分使用三元運算子來處理最後的c，
其實我們也可以將整個helper的函式使用True/False來處理，
這樣中間的計算就要改成or來檢查是否至少存在一個節點值為1的節點。

Python

Python的部分使用子函數來簡單處理，其它的部分邏輯一樣。

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

「時間/空間複雜度？」
(O(N)/O(N)，N為節點總數，總體的遞迴深度則和樹的高度一致。)

相似及延伸

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

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

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

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

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

從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學演算法 - 108 Tree (20) / DFS (17)

Sun, 03 Jan 2021 00:00:00 +0800

1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree (Medium)

寫在前面

好久不見！筆者最近剛換了工作，
所以比較忙一點XD 之後1月中會有HiSKIO 技術年貨節的活動，
歡迎大家拿著折價券來修從LeetCode學演算法的課程喲！
如果預算不夠，相信這108篇也還是很夠讀者練習的啦XDD

在更之後還有規劃0元挑戰賽的部分，
只要修課後一定時間內成功錄取新工作 ，
課程就會全額退費喲！ 這部分再請留意官方那邊的公告，
如果有開始的話，文章中也會再提醒各位。

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

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

Question

Given two binary trees original and cloned and given a reference to a node target in the original tree.

The cloned tree is a copy of the original tree.

Return a reference to the same node in the cloned tree.

Note that you are ** not allowed** to change any of the two trees or the target node and the answer ** must be** a reference to a node in the cloned tree.

Follow up: Solve the problem if repeated values on the tree are allowed.

Example 1

1
2
3


Input: tree = [7,4,3,null,null,6,19], target = 3
Output: 3
Explanation: In all examples the original and cloned trees are shown. The target node is a green node from the original tree. The answer is the yellow node from the cloned tree.

Example 2

1
2


Input: tree = [7], target = 7
Output: 7

Example 3

1
2


Input: tree = [8,null,6,null,5,null,4,null,3,null,2,null,1], target = 4
Output: 4

Example 4

1
2


Input: tree = [1,2,3,4,5,6,7,8,9,10], target = 5
Output: 5

Example 5

1
2


Input: tree = [1,2,null,3], target = 2
Output: 2

Constraints

The number of nodes in the tree is in the range [1, 10^4].
The values of the nodes of the tree are unique.
target node is a node from the original tree and is not null.

分析/解題

給定兩個二元樹 original 跟 cloned ，
並給定一個 originl 樹上的參考節點 target，
當中，cloned是original的完全複製，
請找到 cloned 上和 target 相對應的相同節點回傳。
留意兩棵樹上的節點都不允許被改變，
且答案必須要是cloned這棵樹上的對應節點。
(而不是original上的或新作出來的節點)

條件限制：

樹上的總節點數量範圍在1到10⁴之間。
樹上的各節點值均為獨一無二 的。
target是original這棵樹上的節點，且不為null。

後續：如果重複值可被允許，嘗試在這個條件下解決問題。

這題雖然標為Medium，但說實在的不難XD
看完題目以後，已經經歷過前面各種難題的讀者，
應該會直覺想到使用DFS來解決。

那麼，由於題目一開始已經給定說值是全部獨一無二。
如果先不計較Follow up的部分，
其實我們可以直接比較值就可以了！
我們可以直接將target的值當作目標，
並且對於cloned這棵樹進行dfs，只要比較到相同的值，
就可以進行回傳啦！
由於1的關係，我們不用擔心使用遞迴會超過call stack限制，
使用一個helper函式，當遇到null/None時，
回傳null/None，接著檢查所在節點值是否和target的值相同 ；
接著分別dfs往左邊和往右邊的樹進行尋找 。

當左邊已經找到時，我們可以不用再檢查右邊的部分 ，
直接回傳得到的節點；否則當右邊有找到時，回傳右邊得到的節點 ；
當右邊也沒有找到時，則回傳null/None 。

那麼，如果節點值不一定獨一無二呢？
那麼我們就要同時也將original一起進行遞迴，
這時候檢查的就是original上歷經的節點是否是target節點，
在檢查到的時候同時去回傳cloned的對應節點。

這時候我們用來檢查相等的就是記憶體位址，而非節點值 。
因為唯有記憶體位址相同時，能保證這個節點是對應位置的那個節點。
(而非只有裡面的值相同)

依此，我們寫成程式碼如下：

Java

Java的部分我們額外提供了LeetCode上Follow Up的解法在註解，
使用相同的做法，應該也可以寫出Python的方法，
讀者可以自行嘗試看看。

Python

Python的部分，請讀者留意，
對Python而言，我們寫n: TreeNode, v: int這樣的格式，
是寫給人看的 XD，讀者也可以完全都不寫，一樣可以執行。
而且對於使用者來說，就算你將v代成不是int的東西，
也不會直接被Python視為錯誤，
並不像Java或其他程式語言那樣對這邊有型別檢查，
這點請務必留意喲！

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

「時間/空間複雜度？」
(O(N)/O(1)，基本上最差的狀況要遍歷整棵樹，
而空間上要計較Call Stack的話，則會跟樹的深度成正比，
除此以外沒有其他額外和N相關的部分)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 106 Tree (19) / DFS (16)

Mon, 09 Nov 2020 00:00:00 +0800

0563. Binary Tree Tilt (Easy)

寫在前面

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

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

Question

Given the root of a binary tree, return the sum of every tree node’s *tilt *.

The tilt of a tree node is the ** absolute difference** between the sum of all left subtree node ** values** and all right subtree node ** values**. If a node does not have a left child, then the sum of the left subtree node ** values** is treated as 0. The rule is similar if there the node does not have a right child.

Example 1

1
2
3
4
5
6
7


Input: root = [1,2,3]
Output: 1
Explanation:
Tilt of node 2 : |0-0| = 0 (no children)
Tilt of node 3 : |0-0| = 0 (no children)
Tile of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
Sum of every tilt : 0 + 0 + 1 = 1

Example 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Input: root = [4,2,9,3,5,null,7]
Output: 15
Explanation:
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 5 : |0-0| = 0 (no children)
Tilt of node 7 : |0-0| = 0 (no children)
Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5)
Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7)
Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16)
Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15

Example 3

1
2


Input: root = [21,7,14,1,1,2,2,3,3]
Output: 9

Constraints

The number of nodes in the tree is in the range [0, 104].
-1000 <= Node.val <= 1000

分析/解題

給定一個二元樹，試計算二元樹的每個節點的tilt(坡度)和。

什麼是tilt呢?
題目告訴我們，對於一個節點，
其左子樹的和以及右子樹的和相減的絕對值，
就稱為它的坡度(tilt)，當子樹不存在時，和則視為0。

另外由於整個樹的總節點數已經被限定在0~104之間了，
表示我們可以放心的用遞迴！

那麼，我們該怎麼對每個節點算坡度呢？
對於一個節點n，如果它不存在的話(NIL)，
其坡度自然為0，且總和同樣為0 ；
存在的話，我們必須先算出左子樹(n.left為根節點的子樹)和，
以及右子樹(n.right為根節點的子樹)和，將兩者相減取絕對值，
就是n的坡度。

因此，我們可以使用一個dfs的函式來同時處理算子樹和，
以及坡度的部分，整個dfs的概念應該會如下：

若n為NIL，回傳0
將n.left代入dfs中，取得n.left的子樹和l
將n.right代入dfs中，取得n.right子樹和r
將|l-r|加到物件變數的答案res中
回傳l+r+n.val

留意到我們使用dfs的回傳一直都是回傳以n為根節點的子樹和，
這個和我們要計算的坡度不同，所以必須要用一個res變數來儲存。

在寫出dfs函式後，我們只需要初始化res，
並且在主函式中呼叫dfs後，回傳res即可。

依此，寫成程式碼如下：

Java 對於Java而言abs在java.lang.Math函式庫中，

如果不是在LeetCode的編輯器的話，不要忘記自行import。

Python

Python的部分和Java大同小異，
這邊採用將dfs寫成一個子函式，別忘記要宣告以後才能夠使用呦！
此外，__init__並非一定要這樣使用，在class Solution中直接定義也沒問題。

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

「時間/空間複雜度？」
(O(N)/O(樹的深度)，最差則為O(N))

相似及延伸

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

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

從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學演算法 - 103 Tree (16) / DFS (13) / BFS (3) / Queue (4)

Sat, 08 Aug 2020 00:00:00 +0800

0112. Path Sum (Easy)

寫在前面

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

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

Question

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

return true, as there exists a root-to-leaf path 5->4->11->2 which sum is 22.

分析/解題

給定一棵二元樹，試決定該二元樹是否有一個從根到葉的路徑，
使得路徑上的節點總和恰等於給定的目標和。

這一題是一整組Path Sum系列題的第一題，
除了接下來幾篇會陸續談到系列題外，這篇也想著重給讀者一個提醒：
很多時候能用DFS解的題目，通常也能用BFS解 (反之亦然)

所以當下遇到一個題目的時候，除非有限定要求，
否則只要能想到的解法就是好解法 ，
不要硬逼自己一定要用DFS或一定要用BFS。
(練習的時候，當然還是可以自我挑戰兩種都想出解來就是了XD)

首先我們要留意到一件事情：
由於是從根到葉，
所以我們只需要在走到左右均無節點時再檢查總和是否相符即可，
千萬不要沿途檢查呀XD！

再者，由於路途經過的都會算做計入的總和，
所以我們可以沿路將往下走所需的總和減去當前經過的節點。

依照這個概念，我們可以蠻直觀地寫出一個DFS的解：

先檢查root如果是NIL -> 直接回傳False
檢查root.left/root.right 是不是都為NIL -> 若均為NIL，
若root.val等於所需和 則回傳True ，否則回傳False
將往下走的剩下的和next定為sum — root.val(剩下需要湊的和)
回傳hasPathSum(root.left, next) || hasPathSum(root.right, next) (因為只要存在一條路徑即為True，所以兩者用或來連接)

由上可知，用來判定這個位置能不能成為我們要的路徑和，
只取決於兩點：

現在這個位置是否已經是葉(leaf)
現在這個位置的値是否是剩下需要的和

所以我們也可以用BFS的方式，搭配前面講過的Queue來處理：

同樣先檢查root及處理回傳
將**[(root, sum - root.val)]** 放入Queue當中
進行迴圈，每次從Queue中取出一組**(curr, val)** 並檢查：
3–1. 若curr.left/curr.right均為NIL -> ** 若val為0，回傳True**
3–2. 檢查curr.left，若存在 -> 將**(curr.left, val - curr.left.val)放入Queue** 中
3–3. 對curr.right做相同處理
若迴圈結束仍未回傳，則回傳Fals e(找不到適合的路徑)

依上面的方式，我們分別在Java/Python演示不同的方法：
(讀者也可以自行嘗試完整練完單一語言的DFS/BFS的方法)

Java

Java的部分，使用了DFS，所以整體而言看起來很簡單，
不過原則上有用遞迴的題目，就盡量要留意call stack的深度會不會超過。

Python

Python的部分則使用了BFS，搭配deque做為queue使用，
留意當val != 0的時候記得要繼續操作，因為你可能會有其他節點符和XD，
這點和DFS時不一樣，請特別留意不要直接在那邊回傳False呦！

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

「時間/空間複雜度？」
(O(N)/O(log N)或O(N)(平均)，
因為DFS的話記憶體計算call stack深度，
BFS的話則是要用最底部的橫向長度來看；
如果極端的狀況的話DFS也有可能到O(N)，因為樹可能不平衡)

相似及延伸

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

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

從LeetCode學演算法 - 102 Tree (15) / DFS (12)

Fri, 31 Jul 2020 00:00:00 +0800

1530. Number of Good Leaf Nodes Pairs (Medium)

寫在前面

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

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

Question

Given the root of a binary tree and an integer distance. A pair of two different leaf nodes of a binary tree is said to be good if the length of ** the shortest path** between them is less than or equal to distance.

Return the number of good leaf node pairs in the tree.

Example 1

1
2
3


Input: root = [1,2,3,null,4], distance = 3
Output: 1
Explanation: The leaf nodes of the tree are 3 and 4 and the length of the shortest path between them is 3. This is the only good pair.

Example 2

1
2
3


Input: root = [1,2,3,4,5,6,7], distance = 3
Output: 2
Explanation: The good pairs are [4,5] and [6,7] with shortest path = 2. The pair [4,6] is not good because the length of ther shortest path between them is 4.

Example 3

1
2
3


Input: root = [7,1,4,6,null,5,3,null,null,null,null,null,2], distance = 3
Output: 1
Explanation: The only good pair is [2,5].

Example 4

1
2


Input: root = [100], distance = 1
Output: 0

Example 5

1
2


Input: root = [1,1,1], distance = 2
Output: 1

Constraints

The number of nodes in the tree is in the range [1, 2^10].
Each node’s value is between [1, 100].
1 <= distance <= 10

分析/解題

這題是2020/07/26舉辦的199th LeetCode Weekly Contest的第3題。
給定一個二元樹的根節點root和一個整數距離distance，
如果兩個不同的葉節點配對，其最小距離小於等於distance，
我們就將其稱之為好(good)。
試回傳這棵樹好的葉節點配對的總數。

我們先前應該已經提到過葉節點就是指左右都沒有連接節點的節點 ，
那麼，這題要怎麼思考呢？

我們不妨先留意一下題目給定的條件：
節點數量是1~2¹⁰，由於2¹⁰=1024 ，所以最壞的狀況，
遞迴的數量也就1024而已，所以應該可以不會超過call stack的上限。
接著，1≤distance≤10決定了我們在遞迴時，
可以適度修剪我們要處理的節點。

那這題該怎麼思考呢？
由於我們在求的是最短距離，假定我們要看兩個節點x, y，
那麼最短路徑肯定是從x往上走到x, y的最低共同祖先，
再往下走到y的位置。

如果我們知道x, y的LCA(最低共同祖先)n，
又知道n的左子樹的所有葉節點各自的深度，
及右子樹的所有葉節點各自的深度，
那麼我們就可以知道以n為LCA時，正確的節點對有哪些。
怎麼知道？就迴圈加起來就好了嘛！

那我們又怎麼知道某個節點n的左右子樹的葉節點深度呢？
我們可以先用dfs往深處走，走到出現葉節點的時候，
將其記錄為距離1並往上傳(因為這時候左右也都沒得走了)；

那在某個非葉節點的n 時，我們應該可以從dfs的結果，
分別獲得左右子樹的各個葉節點離n的距離 。
我們將兩個距離的列表分別叫作llt跟rlt (left list, right list)，
從llt跟rlt分別成對取出來相加，
每發現一組葉節點距離相加小於等於10，全局的解就加1 。

做完檢查以後該做什麼呢？
裡面所有的葉節點應該可以往上通用，對吧？
可是我們左子樹和右子樹往上都導到當前的節點再往上，
再往上的深度應該都要加1 才對！
所以我們應該將llt和rlt裡面的所有值都分別+1以後，
放入一個新的list，這裡命名為merge，再將其往上傳。

因此，整個流程會大致如下：

定一個class變數cnt，用來記錄成功配對的葉節點對的總數
在主函式裡，先檢查root是否為NIL，是的話直接回傳0
將root和distance帶入遞迴函式dfs中
回傳cnt

而在dfs函式中，我們要做的事情是：

若n為NIL，回傳空的串列
若n的左右節點均為NIL ，則回傳一個裡面只含一個1的串列
呼叫dfs(n.left, distance) 及dfs(n.right, distance) 進行遞迴，
取得回傳的llt 跟rlt (記錄兩邊葉節點深度的串列)
初始化一個空的串列merge
雙重迴圈，每當遇到llt和rlt的値**，
兩兩相加會小於等於distance的狀況，就將 cnt遞增1**
分別將llt和rlt的値全數+1後，加到merge 裡
(這邊可以檢查值必須小於distance ，超過的話因為總路徑肯定超過， 所以不符的不用放到merge內)
回傳merge

依此，寫成程式碼如下：

Java

由於需要一個一個取出，並且重複使用，
所以我們使用ArrayList 並使用get 來取得當中的值。
在雙重迴圈的時候，我們可以順便將外層的値處理一下放到merge內 ，
這樣後面就不用再重複一個新的迴圈處理。
(但內層的不能這麼做，因為會被重複執行)

Python

Python的部分，cnt的累計可以使用list comprehension，
處理符合的配對再來取len() ，這樣寫起來會比雙重迴圈方便許多。
llt和rlt則可以用類似的方式，最後將串列用加號組起來回傳。

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

「時間/空間複雜度？」
(O((log N)³)/O(log N)，因為只有葉節點需要被記錄，
空間應該跟最底層的節點數有關，而除了雙重迴圈外，
dfs的深度也跟這棵樹的深度有關，但這個部分會受到distance的制約，
所以實際應該比這個複雜度快不少)

相似及延伸

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

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

從LeetCode學演算法 - 99 Tree (14) / DFS (11)

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

0404. Sum of Left Leaves (Easy)

寫在前面

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

Question

Find the sum of all left leaves in a given binary tree.

Example:

1

There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.

分析/解題

給定一個二元樹，試求所有左葉子的總和。

我們很久以前有提過二元樹的定義，
忘記的話，請再複習一下XD
而葉子的定義，就是它左右都沒有連接節點(NIL)！

這時候，你可能會說：
我知道，那我只要一直往左邊看就好啦！

呃……同學，你忘記了你的右子樹也可能產生左葉子 嗎XD？
範例中的15，不就是先從3的右節點20，
再往左節點來到15所得到的嗎？

那怎麼辦呢？
所以我們在檢查所在節點是不是葉子的時候，
還需要看看這個節點是不是從它的根節點往左邊走下來 的。
因此，我們可以每次分支往左右走，給出一個參數from，
分別給往左子樹走的函式1，給右子樹走的函式-1 ，
用來代表下一層的時候拿來判定是不是左葉子的前置依據。

當我們看到from == 1且左右節點均為NIL時，
就可以將當前的節點值回傳，
否則的話，就繼續遞迴往下找底下子樹當中左葉的和。

依此，寫成程式碼如下：

Java

Java的部分，每次先檢查root是否為null，
接著我們的答案就用
sumOfLeftLeaves(root.left, 1) + sumOfLeftLeaves(root.right, -1)
來取得。
其他的寫法概念如前所述。

Python

Python的部分寫一個子函式，因為這邊沒有用self，
所以可以不用self.getSum來算。
(也可以把add設定預設値-1，
使用單個sumOfLeftLeaves來解此題，
這個化簡方式很簡單，就留給讀者來練習看看XD)

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

「時間/空間複雜度？」
(O(N)/O(1)，因為要經過每個節點，
而如果考慮call stack的話，
空間複雜度會是O(depth of Tree))

相似及延伸

0235. Lowest Common Ancestor of a Binary Search Tree (Easy)

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

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

從LeetCode學演算法 - 98 Tree (13) / DFS (10)

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

0129. Sum Root to Leaf Numbers (Medium)

寫在前面

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

Question

Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.

An example is the root-to-leaf path 1->2->3 which represents the number 123.

Find the total sum of all root-to-leaf numbers.

Note: A leaf is a node with no children.

Example:

1
2
3
4
5
6
7
8
9


Input: [1,2,3]
 1
 / \
 2 3
Output: 25
Explanation:
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.
Therefore, sum = 12 + 13 = 25.

Example 2

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


Input: [4,9,0,5,1]
 4
 / \
 9 0
 / \
5 1
Output: 1026
Explanation:
The root-to-leaf path 4->9->5 represents the number 495.
The root-to-leaf path 4->9->1 represents the number 491.
The root-to-leaf path 4->0 represents the number 40.
Therefore, sum = 495 + 491 + 40 = 1026.

分析/解題

給定一個二元樹，當中只有數字0~9，
每個根到葉子的路徑可以表達一個數。
舉例來說，1->2->3可以表達123。
找出所有的根到葉的數字的總和。
(葉的定義是沒有子節點的節點)

這題雖然標註為Medium，但其實並不那麼難思考，
只是定義要弄清楚而已。

首先，假設我們在某個節點n，它如果左節點和右節點都沒有的話，
意味著它是葉(leaf)，這時數字就要計入總和；
如果有其中一個成立的話，我們應該要往下走，
並記錄之前經過的節點値，這樣子在遇到葉的時候才能夠結算。

那麼自然，由於每棵樹只有0~9，
所以從一層樹到下一層的時候，原先經過的數字的作用會放大10倍。
也就是說，從上一層下來的時候，如果所在是葉的話，
我們應該要把這個數字乘以10以後，加上現在的節點値 。

因此，我們只要遍歷完整棵樹，將葉子加總 起來即可。
寫成流程應該如下：

檢查根節點是否為NIL，如果是，直接回傳0(此路不通)
計算上面下來的值(last)到當前根節點的值(now)的結果，
now = last * 10 + root.val
如果左右節點均為NIL，直接回傳now 即可(當前節點為葉)
將root.left, now及root.right, now 分別傳入做遞迴計算左右子樹的和 ，
最後加總起來並回傳 。
所以我們會先沿著最左邊一路到最底，然後依序將所有節點走過，
這樣子是先往深處走，所以是所謂的深度優先搜尋(DFS)的方法。

另外一方面，留意由於我們最開始已經檢查了root是否為NIL，
所以在傳入左右子節點時，可以讓前面這條檢查來確認NIL的狀況，
也就不用再先檢查節點是否為空了。

依此，寫成程式碼如下：

Java

Java可以使用相同的函式名稱，傳入不同長度的參數 來處理。

Python

Python的部分，我們直接設定預設值 ，這樣就可以通用了XD
當從根節點開始時，由於只傳入root, 自然last會是0。

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

「時間/空間複雜度？」
(O(N)/O(1), 如果算上call stack的部分的話，
平均空間複雜度是O(logN) (DFS的深度))

相似及延伸

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

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

從LeetCode學演算法 - 96 BST (5) / DFS (10)

Tue, 09 Jun 2020 00:00:00 +0800

1008. Construct Binary Search Tree from Preorder Traversal (Medium)

寫在前面

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

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

另外，

Question

Return the root node of a binary search tree that matches the given preorder traversal.

(Recall that a binary search tree is a binary tree where for every node, any descendant of node.left has a value <``node.val, and any descendant of node.right has a value >``node.val. Also recall that a preorder traversal displays the value of the node first, then traverses node.left, then traverses node.right.)

It’s guaranteed that for the given test cases there is always possible to find a binary search tree with the given requirements.

Example 1

1
2


Input: [8,5,1,7,10,12]
Output: [8,5,10,1,7,null,12]

Constraints

1 <= preorder.length <= 100
1 <= preorder[i] <= 10^8
The values of preorder are distinct.

分析/解題

從給定的前序走訪 一棵二元搜尋樹的結果，
重建一棵符合的二元搜尋樹，並回傳其根節點。
題目給出的測試資料均保證可以找到一個符合的二元搜尋樹。

我們很早以前已經解說過二元搜尋樹的特性 了，
前序走訪(preorder) 表示順序是根-左-右 ，
不像是中序走訪(inorder) 會剛好是左-根-右，順序會剛好由小到大排列 。
那麼，我們要怎麼樣才能架構一個合理的BST(二元搜尋樹)呢？
由於BST和preorder的特性，當我們一路往左走的時候，
我們會越走碰到的值越小 ，這表示我們是一路看到當下的根節點 ，
接著往左走看到左節點 才會發生這樣的狀況；

如果我們當下碰到了比根節點還要大的狀況呢？
代表這段往左已經走完了，現在看到的是右節點。
那麼怎麼知道是不是當下這個位置的右節點 呢？
我們必須要比較現在所在的位置的前面的根節點值 才行。
如果比根節點值小，代表它是被包含在當下這個子二元樹，
反之，則代表它應該在上一層或更上層 才對。
此外，我們可以設定一個class的變數i，
用來紀錄現在我們建立二元樹的過程走到哪個index。

那麼我們來整理一下流程：
0. 初始化一個class變數 i = 0 。

先檢查當前的陣列/串列是不是沒東西 ，沒東西的話就回傳null/None。
將int的最大值 作為邊界值 bound，
傳入用來建立二元樹的函式(這裡命名為build )
在build函式中，檢查如果i走完全長了 或者preorder[i] > bound，
前者表示整個樹重建完了，後者表示這個子樹底下對於preorder[i]來說不可能放在任何一個地方了，所以回傳null/None回到上一層。4. 在這層建立一個 根節點root，** 其值為preorder[i]，完成後 將i遞增**。
接下來要建立root.left，呼叫build函式，
將preorder及邊界值root.val 傳入。
(因為root的左子樹所有值都要小於root的值)
再來建立root.right，呼叫build函式，
將preorder及邊界值bound傳入。
(因為root的右子樹裡的所有值要介於root的值 和上一層限制的bound 之間)
這層等於建立完畢了，將root回傳 。

我們簡單拿Example 1為範例來嘗試推導看看：

(i, preorder[i], bound) = (0, 8, Integer.MAX_VALUE)
=> root節點建立，其值為8，i遞增，呼叫build(preorder, 8)以建立左節點。
(i, preorder[i], bound) = (1, 5, 8)
=> 建立根節點，其值為5，i遞增，呼叫build(preorder, 5)以建立左節點。
(i, preorder[i], bound) = (2, 1, 5)
=> 建立根節點，其值為1，i遞增，呼叫build(preorder, 1)以建立左節點。
(i, preorder[i], bound) = (3, 7, 1)
=> 7>1，所以表示這層沒辦法放了，回傳null到上一層。
(i, preorder[i], bound) = (3, 7, 5)
=> 走到root.right這行，呼叫build(preorder, 8)以建立右節點。
(i, preorder[i], bound) = (3, 7, 8)
=> 建立根節點，其值為7，i遞增，
呼叫root.left及root.right兩行都會回傳null，
所以回傳該節點到上一層。
(i, preorder[i], bound) = (4, 10, 8)
=> 在5的底下建立完7的右節點了，這邊也完成了，
回傳5的節點回到上一層。
(i, preorder[i], bound) = (4, 10, Integer.MAX_VALUE)
=> 走到root.right這行，呼叫build(preorder, Integer.MAX_VALUE)。
(i, preorder[i], bound) = (4, 10, Integer.MAX_VALUE)
=> 建立根節點，其值為10，i遞增，
root.left這行會回傳null，
root.right傳入build(preorder, Integer.MAX_VALUE)。
(i, preorder[i], bound) = (5, 12, Integer.MAX_VALUE)
=> 建立根節點，其值為12，i遞增。
後面的部分由於i已經到達6，所以會往上層回到8的這層，
最後回傳根節點(值為8)，結束。

請讀者嘗試在紙上畫出來推過一遍，有助於更了解整個程式運行。
由於我們是先一路往左深入並建立節點，碰到無法建立時，
才回到上一層並嘗試往右走，
所以這樣子的方式是DFS(深度優先搜尋) 的模式。

依此，寫成程式碼如下：

Java

Java的部分，
使用int時可以用Integer.MAX_VALUE作為初始邊界(即int能表示的最大值)。

Python

Python的部分，我們可以設定bound在未傳入值時預設值當作float(‘inf’) ，
即可使用同一個函式進行遞迴。
此外，還是不要忘記Python並沒有++或–，請自己換成用**”self.i += 1"** 。

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

「時間/空間複雜度？」
(O(length of array)/O(1), 如果計算call stack的話則是O(BST的深度))

相似及延伸

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

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

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

從LeetCode學演算法 - 93 Tree (12) / DFS (9)

Sun, 10 May 2020 00:00:00 +0800

0687. Longest Univalue Path (Easy)

Question

Given a binary tree, find the length of the longest path where each node in the path has the same value. This path may or may not pass through the root.

The length of the path between two nodes is represented by the number of edges between them.

Example 1

Input:

Output: 2

Example 2

Input:

Output: 2

Note: The given binary tree has not more than 10000 nodes. The height of the tree is not more than 1000.

分析/解題

給定一個二元樹，尋找其最長的路徑長，
當中的所有節點必須擁有相同的值。
這條路徑通過或沒有通過根節點均可。
(路徑長度的定義為兩個節點之間經過的邊(edge)的數量)

由於很早我們就介紹過樹的基本性質了，
(印象模糊的讀者請回頭參照0100. Same Tree)，
在此就不再贅述。這題嘗試要找相同值的路徑，
但又不限定要通過root，該怎麼思考呢？
我們可以先考慮怎樣可以算一條相同值的路徑 。
一條相同值的路徑有可能有以下兩種狀況：

從一個頂點下來，
每次選擇往左節點走或往右節點走，到一個位置停下。
例如：

當中的5-5-5就是一條相同值的路徑。

從一個頂點進行分岔，左右各自走到一個位置停下。
例如：

當中的粗斜體的4-4-4 就是一條從頂點往左右分岔所得到的路徑，
可以選擇從左下的4 -> 中間的4 -> 再到右邊的4 ，這樣連成一個路徑。
但從這邊來看可以發現，這條路徑就無法把root的4算在內，
因為不管怎麼連，我們都沒辦法一筆不重複將這4個4走完。

因此，我們可以得知：
對於某個節點來說，有經過它所能得到的最長路徑，
有可能是從它的上面連下來(分岔點在它的上面 )，
也可能是以它自己為分岔點 ，左右各自找完和它值相同的節點路徑。
在第一個情況來說，要求它的上一個節點值和它的值相同；
第二個情況來說，則要將左右和它的值相同的路徑長相加 。

所以我們可以定義一個count函式，
回傳以某個節點值來說，其下的最長所能得到的相同值的路徑長，
當中計算的時候一邊留意當下最長的路徑長並進行更新。

我們將整個題目的答案(相同值的最長路徑長)叫做mx(叫result也可以)，
流程順序應為：

一開始應該先檢查root是否為NIL ，
如是，回傳0 (因為沒有路徑)，否則呼叫count函式，
檢查它所能得到的相同值的最長路徑長 。
(傳入root節點，及當下的路徑節點值root.val )
在count當中，
同樣應先檢查傳入的節點值是否為null，
接下來為了要知道左右路徑的相同值的最長路徑長，
應該要分別帶入其left/right節點及當前節點的值 進去檢查，
假設得到的結果分別為l/r 。
依照2的定義，l + r的值代表了一條可能的相同值路徑，
所以要拿它和mx比較，將較長的路徑值更新。
如果當前的節點值 和**傳進來的路徑節點值兩者相同，
代表有機會可以考慮上面提到過的
「從一個頂點下來，每次選擇往左節點走或往右節點走，
到一個位置停下。」的狀況，
這時候要回傳的值會是左右路徑長較長的部分+1。
(因為要包含左節點/右節點到當前節點的這個路徑)
上面的判斷不成立的話，代表路徑從上面下來到這邊斷掉了。
(值不相同)，這時候應該回傳0，代表相同值路徑到這邊沒辦法繼續。**

上面的流程順序，請讀者務必自行畫圖推導，
會比較清楚整個思考過程。

依此，寫成程式碼如下：

Java

Java的部分mx直接宣告一個class變數即可，其它就是使用Math.max，
及檢查null的部分，並不複雜。

Python

Python的話，可以使用self.mx來宣告，
並且在__init__時進行處理，
其它就是一樣注意呼叫時不要忘記用self 即可。

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

「時間/空間複雜度？」
(O(N)/O(1)，如果空間要算上call stack的部分的話，
則是O(TreeNode的高度)。)

相似及延伸

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

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

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

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

Fri, 24 Jan 2020 00:00:00 +0800

0116. Populating Next Right Pointers in Each Node (Medium)

Question

You are given a perfect binary tree where all leaves are on the same level, and every parent has two children. The binary tree has the following definition:

1
2
3
4
5
6


struct Node {
 int val;
 Node *left;
 Node *right;
 Node *next;
}

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Follow up:

You may only use constant extra space.
Recursive approach is fine, you may assume implicit stack space does not count as extra space for this problem.

Example 1

1
2
3


Input: root = [1,2,3,4,5,6,7]
Output: [1,#,2,3,#,4,5,6,7,#]
Explanation: Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.

分析/解題

給定一個完美二元樹(perfect binary tree)，
也就是所有葉子都在相同level且所有父節點均有兩個子節點。
在Node的定義中增加一個next的定義，
如圖所示，每個節點的next為其右邊的節點，
如右邊已無節點，則為NULL。
(最開始的時候預設所有節點的next均為NULL)
請把整個next的定義完成。

由於這個題目已經有提到說只能用常數的額外記憶體空間了，
但同時將遞迴導致的stack(也就是call stack)當作不算，
所以使用簡單的遞迴可以簡單達到目的。

最直觀的方式，就是先檢查root是否是null，
接下來呼叫一個helper function，代入左節點和右節點來處理，
只要左節點不是NULL，則將左節點的next設為右節點；
接下來則要分別處理這三個連接：
1. 左節點的left -> 左節點的right
2. 左節點的right -> 右節點的left
3. 右節點的left -> 右節點的right

當然，也可以從root為中心出發，
這時候每次要關注的應該是root.left -> root.right，
及root.right -> root.next.left。

如果想要用迭代的方式呢？
我們留意到每次開始進行連接的都是當個階層的最左邊的節點，
從Figure B 上來看的話，即為1, 2, 4…等節點。
所以我們最開始應該要從一個階層的最左邊的節點
(這邊叫做level_first)開始進行迭代，將當前的節點稱為curr
分別將curr.left -> curr.right 及curr.right -> curr.next.left。
接著讓curr遞移到curr.next。
所以每次連接兩組next的關係，直到curr走到NULL為止。
這時候這層走完以後，進行到下一層，
level_first應該遞移到level_first.left。

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

Java

在Java中，上述三種方法均有列出，
順序剛好跟上面提到的相反，
請務必留意在接續前必須要留意要確定節點是否為null的狀況。
如果計入call stack的話，只有迭代的方式是O(1)才對。

Python

Python的部分大同小異，不要忘記使用self來呼叫，
這邊僅列出第二種和第三種。

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

「時間/空間複雜度？」
(O(N)/O(1)，如果不考慮Call Stack的話。
如果考慮的話上面只有直接使用迴圈迭代的是O(1))

相似及延伸

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學演算法 - 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學演算法 - 55 DFS (3)

Mon, 23 Sep 2019 00:00:00 +0800

0236. Lowest Common Ancestor of a Binary Tree (Medium)

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

Question

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself ).”

Given the following binary tree: root = [3,5,1,6,2,0,8,null,null,7,4]

Example 1

1
2
3


Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
Output: 3
Explanation: The LCA of nodes 5 and 1 is 3.

Example 2

1
2
3


Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
Output: 5
Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.

Note:

All of the nodes’ values will be unique.
p and q are different and both values will exist in the binary tree.

分析/解題

給定一棵二元樹，試找出樹中兩個給定的節點的最低共同祖先(LCA)。
整棵樹的節點值均不同，且兩個節點p, q是不同的節點，
且會存在於此樹上。

由於不同於之前的0235題，這題是二元樹而非二元搜尋樹，
所以我們於此喪失了可以透過比大小來決定要往哪個方向走的可能。
那麼怎麼辦呢？

對於兩個節點的最低共同祖先來說，有一個特性是絕對肯定的，
就是以下3點必然會恰好成立2點 ：
1. 節點自己是p或q
2. 節點的左子樹有p或q
3. 節點的右子樹有p或q

1, 2和1, 3應該很直觀，就不多作解釋了，
這邊有一點很重要的是，當共同祖先不是p或q 的時候，
如果p和q都分布在同一邊的子樹，那它就不會是最低共同祖先 ，
因為我們還可以再往下找更低的共同祖先。
所以1不成立的時候，2, 3都必須要成立才行 ，
這樣才能符合最低的特性。

我們可以運用DFS 的方式來確認一個節點的左子樹/右子樹是否符合特性，
並且同時判斷該節點是否是p或q之一 ，
這樣一來，只要三者成立兩點 的時候，就表示我們找到目標了，
可以將答案記錄下來。

所以只要將整棵樹遍歷過一次，最後回傳記錄下來的答案即可。
實作上，我們將1當作成立，0當作不成立，
那麼整個DFS的過程就是在找三個結果相加等於2。

Java

Python部分基本一致，只是三元運算是由if else來寫的。

Python

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

「時間/空間複雜度？」
(O(N)/O(N)，因為要考慮到最糟的情況，同時遞迴會產生call stack )

「能否給出迭代解？」
(原題的Solution處有給出來，請參照看看XD，簡單來說，
就是分別使用stack記錄p跟q的祖先節點，最後回頭找最底層的那個祖先。)
(但因為使用stack的關係，空間複雜度依舊會是O(N) )

相似及延伸

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

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

從LeetCode學演算法 - 54 DFS (2)

Sun, 22 Sep 2019 00:00:00 +0800

0114. Flatten Binary Tree to Linked List (Medium)

Question

Given a binary tree, flatten it to a linked list in-place.

For example, given the following tree:

The flattened tree should look like:

分析/解題

給定一個二元樹，請將其攤平成linkedlist形式且以in-place的條件進行。
依照題目要求攤平後，整棵樹應該會變成每一個節點只會有右邊的節點。

仔細觀察題目我們會發現其走訪的順序其實是pre-order。(中左右)
那麼，該怎麼做到攤平呢？

我們可以先考慮某個子樹的情況，
根節點自己在攤平後應該還是不會動，
而所有左子樹的節點在攤平後應該都排在右子樹節點的前面 。
所以當我們假定先完成了一個樹的左右子樹的攤平的話，
樹應該長得像這樣：

1
2
3
4
5
6
7


　 a
 / \
b e
 \ \
 c f
 \ \
 d g

那麼，我們要做的應該是將d跟e接起來(a-e斷開) ，
並且將b的位置從a的左邊挪到右邊 。

所以整個流程會像這樣：

檢查根節點 ，是NIL則回傳(代表這條路走到底了)。
先記錄左右節點備用(l, r)，
並分別呼叫自己的左右節點進入flatten遞迴 。
經過2以後左右子樹應該分別攤平了，
現在將左節點設為null，右節點設為l 。
使用迴圈找到root.right的最右邊的節點 (也就是原先左子樹的最後一個節點)，
將其和r接起來。(也就是在做上圖的d跟e 的銜接)

Java

Python

讀者可能會注意到上面也提供了迭代解，
這個版本的解法源自於Morris Traversal ，
有興趣的讀者可以了解一下。

簡單來說呢，它做的事情跟遞迴是一致的，
不過它不需要使用到call stack，
只需要用到輔助的TreeNode 來記錄先前的root.right。
每次我們會檢查左節點是否為NIL ，
是的話我們可以直接往右邊走 (因為左邊不用處理了)；
接著做的事情相同，先用tmp暫時存下右子樹 ，
對左子樹進行接到右邊的動作。 (也就是每一次會處理掉每個左子樹的右邊的分枝 )
這整個流程並不是很好理解，
讀者只需留意到其時間複雜度一樣是O(N) 即可，
在實際面對類似題目時，如果沒有把握，可以以前面的遞迴解為主。

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

「時間/空間複雜度？」
(O(N)/O(1)，但遞迴解的空間複雜度要另行考慮call stack，
若平衡的話是O(logN))

相似及延伸

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

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

從LeetCode學演算法 - 45 DFS (1)

Wed, 04 Sep 2019 00:00:00 +0800

0200 Number of Islands (Medium)

Question

Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1

1

Output: 1

Example 2

1

Output: 3

分析/解題

給定一個二維的地圖當中陸地用'1’表示，水則用'0’表示 ，
試計數這整張圖有多少島嶼(island)。可假定地圖的外圍均為水域。
(島嶼的定義就是其周圍都圍繞著水，
且可以通過連接相鄰的垂直/水平陸地所構成。)

如對於題目描述依舊沒搞懂的話，就把它當成小畫家填色的色塊吧！
視為相同區域的用油漆桶可以全部填滿XD
而題目所問的，就相當於要填幾次才能將所有陸地區域填滿 。

對於要確認島嶼這點，只有一種方法：
每次從一個點開始向外延伸相鄰的格子，
直到周圍沒有可以延伸的區域為止。
這時候這整塊區域就是我們所謂的島嶼，於是計數可以加1 。
那麼問題來了，在延伸的過程中一共有四個方向 可以選擇，
如果不加限制的話，無疑會有重複的部分；
所以除了檢查是否遇到水(‘0’，也就是可以不用繼續往下搜尋)外 ，
我們還需要知道這個格子是否已經走過了。
所以我們會再新增一個visited陣列用來標明已經走過的區域 。
(這樣子只要已經走過的就直接跳過即可。)

由於每次會需要走到底才會回頭，
所以這種方式是很典型的DFS(Depth-First Search，深度優先搜尋) 方法。

所以流程會變成：

初始化一個visited 二維陣列，預設當中每個值均為false
對grid中的每個點(i, j)檢查其是否為陸地(‘1’) ，且未曾走訪過的話:
2-a. 遞增島嶼計數值，並從每個點(i, j)呼叫函式dfs 來開始走訪
在dfs中，先檢查(i, j)點是否符合規範(因會+1或-1，須不超出範圍 )，
且尚未走訪過(visited[i][j] == false) 的狀況，進行3-a的流程
3-a. 將visited[i][j]設定為true
3-b. 往(i, j)的上下左右 走，並傳入下一階段的dfs。

這麼一來，當整張圖掃過去以後，
我們就能知道到底有幾個島嶼了！

Java和Python的寫法基本一致，這邊不再贅述，
讀者只要注意到應該被檢查的邊界條件 即可。

Java

Python

在這個範例中我們使用了一個額外的陣列來儲存，
有沒有辦法能夠不用額外的陣列呢？
其實是有的，辦法就是將每次走過的陸地(‘1’)，
都直接設定成水(‘0’)，自然就相當於都走過了，
從而可以替代掉用visited來處理。
優點是速度會較為快速，
但很嚴重的缺點是這麼做完以後，
grid本身就會變成全部都是’0’的陣列了 。
除非已經確定這個grid可以被任意操作，
否則筆者認為要這麼做的話記得要先問清楚要求才下手才行XD~

此外，這題在返回時仍舊要保留走過哪些格子的資訊 ，
所以和之前的Backtracking的題目作法是不一樣的。

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

「時間/空間複雜度？」
(若m, n為長寬，O(m*n) for best case，理論上全部走訪一遍即可, O(m*n))
(如果可以清空grid則記錄用的空間複雜度是O(1))
(若考慮call stack的部份的話，總空間複雜度worst case是O(N) )

相似及延伸

1.0130. Surrounded Regions 2.0695. Max Area of Island

Special Thanks suggestions/corrections from viewers:
Raiy Kuo: DFS時recusive占用的stack應一併考慮進去。

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

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