從LeetCode學演算法 on 跟著 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

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
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

從LeetCode學演算法-120 (0547. Number of Provinces)

Tue, 06 Jun 2023 00:00:00 +0800

Categories: Graph/Union Find

Level: Medium

寫在前面

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

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

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

Question

There are n cities. Some of them are connected, while some are not. If city a is connected directly with city b, and city b is connected directly with city c, then city a is connected indirectly with city c.

A province is a group of directly or indirectly connected cities and no other cities outside of the group.

You are given an n x n matrix isConnected where isConnected[i][j] = 1 if the ith city and the jth city are directly connected, and isConnected[i][j] = 0 otherwise.

Return the total number of *provinces *.

Example 1

1
2


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

Example 2

1
2


Input: isConnected = [[1,0,0],[0,1,0],[0,0,1]]
Output: 3

Constraints

1 <= n <= 200
n == isConnected.length
n == isConnected[i].length
isConnected[i][j] is 1 or 0.
isConnected[i][i] == 1
isConnected[i][j] == isConnected[j][i]

分析/解題

有n個城市，其中一些城市彼此相連，而另一些則沒有。
如果城市a與城市b直接相連，並且城市b與城市c直接相連，
那麼城市a與城市c之間間接相連。(OS: 好廢話XD)

一個省(province)是一組直接或間接相連的城市，
且該群組中沒有其他的城市。
(也就是直要可以從x走到y，它們就視為相同省)

給定一個n x n的矩陣isConnected，
其中isConnected[i][j] = 1表示第i個城市和第j個城市直接相連，isConnected[i][j] = 0則表示它們不直接相連，回傳省的總數量。

我們已經在第115篇 以及上一篇中提到了很多Graph的概念，
今天再來仔細一點探討Union Find的用法。

由於isConnected太長了，我們底下還是直接使用edges來稱呼比較簡便。
首先看到了要找provinces的組數，
顯然又是一個很典型能使用Union Find的場合；
但先前我們提到過，如果只是一路沿著edge往回trace老大的話，
對於單一點的find有可能達到O(n)，
因此我們需要做一些簡化：在union 的合併時，
就盡可能地先行收斂 。那麼我們應該怎麼做呢？

我們這邊定義一個串列叫做rank，
用以表達每個節點往上對到的root所含有的節點總數。
那麼在合併的時候，有別於先前的任意指定，
我們這次可以選擇先檢查誰的rank大，
接著人多欺負人少 ……不對，是rank大的合併掉rank小 的群組；
rank小的群組的root要設定為rank大的群組的root。
這麼一來，在合併的過程中，由於一直是大的合併小的，
相對而言會較不容易將union的連接拉太多層，
這個手法我們稱之為路徑壓縮(path compression) 。

因此，我們的find的寫法和union的寫法會像這樣：
find(root, i):

先取到r = root[i]
如果r和root[r]不相等(代表還沒走到自己是root(老大)的節點)進行迴圈:
將root[root[r]]的值塞給root[r]
令r = root[r] (來到上面一層，繼續準備判斷)
在2~4的迴圈結束後，直接令root[i] = r，
標明節點i的最上面的老大是r。

union(root, rank, x, y):

對x, y分別使用find，取得各自的root rx, ry
如果rx和ry相同 ，代表已經是同一組了，直接回傳false
如果不同，則看rank[rx]和rank[ry]的關係，
rank[rx] ≥ rank[ry] 的話，就將rank[rx]遞增rank[ry] ，
並且令root[ry] = rx ；
反之，若rank[rx] < rank[ry] ，則將rank[ry]遞增rank[rx] ，
並且令root[rx] = ry 。

那麼，剩下來我們只需要做完對root和rank的初始化(1~n-1 跟1 )
剩下就是雙層迴圈 對有edge 的兩點呼叫union ，
最後對於每個節點確認它們不重複的root有哪些 即可。

依此，寫成程式碼如下：

Java

Java的部分一樣可以用Arrays.fill() 來設定定值，
同時因為我們union其實沒特別用到true/false的需求，
可以設定為void，直接將對應該改的東西改一改，
並直接return即可。

同時，在記錄答案時，我們可以使用HashSet，
在最後對i做遍歷並逐個進行find()，並加到當中，
最後檢查res.size()即可得到我們要的答案。

另外可以留意的是，雙重迴圈的union(i, j)因為沒有方向性的關係，
第二層的j可以從i+1開始 就好，不需要從0開始。

Python

Python的部分除了改成用子函式以外，
其餘則大同小異。

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

「時間/空間複雜度？」
( O(n²)/O(n)，因為即便有經過path的壓縮，遍歷所有edge仍然要O(n²)，
空間的部分則是只需要考慮記錄root和rank的空間)

相似及延伸

Redundant Connection (Medium)

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

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

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

同時追蹤粉專以獲得更多新文章的通知：
跟著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學演算法 — 格式變更

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

該來個改版了!

話說筆者心血來潮搜尋了一下自己的文章，
發現Medium上按照現有的格式，
其實subtitle(副標題)的部分根本不會進入到搜尋的Title中，
這點感覺對於讀者搜尋很不方便XD

(雖然第0篇都有放連結，老讀者懂得都懂)

考量過後，將格式調整如下：
Titlte: 從LeetCode學演算法-120 (0547. Number of Provinces)
Subtitle: Categories: Graph/Union Find, Level: Medium

調整過後，讀者可以清晰看見該篇的題號，
而subtitle會列出題目的種類和難度(就不列是種類的第幾篇了，因為在Medium中沒辦法直接連結搜尋相同個作者的特定tag)。

另外，因應這個國際化的社會(?)，
接下來的每一篇文章都會提供英文版本，
英文版本只會往英語系的Python或Coding相關的FB社團發文 ，
同時不會列到第0篇文章。

以上調整，不溯及既往，並且從本篇文章起即刻生效，
感謝大家的理解與支持XD!

從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學演算法 - 優惠資訊

Sat, 04 Jun 2022 00:00:00 +0800

下周二(6/7)開始有從LeetCode學演算法全套組合的優惠~

https://hiskio.com/bundles/eMF22B397?s=tc

全套組合特惠價3591元！有興趣的朋友可以參考XD

從LeetCode學演算法 - 117 Array (17)

Sun, 30 Jan 2022 00:00:00 +0800

0941. Valid Mountain Array (Easy)

寫在前面

2022/03/09: 配合官方修改格式，各項優惠連結3/14之後會失效，
這邊更新新版的連結給大家~**

從 LeetCode 學演算法｜完整解題技巧 + 面試成功指南： https://bit.ly/lc2022all

Question

Given an array of integers arr, return true if and only if it is a valid mountain array.

Recall that arr is a mountain array if and only if:

arr.length >= 3
There exists some i with 0 < i < arr.length - 1 such that:
arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
arr[i] > arr[i + 1] > ... > arr[arr.length - 1]

Example 1

1
2


Input: arr = [2,1]
Output: false

Example 2

1
2


Input: arr = [3,5,5]
Output: false

Example 3

1
2


Input: arr = [0,3,2,1]
Output: true

Constraints

1 <= arr.length <= 104
0 <= arr[i] <= 104

分析/解題

給定一個整數陣列arr，若且唯若它是一個合格的mountain array時，
回傳true(否則回傳false)。
mountain array的條件要符合以下幾點:

arr長≥3
存在i，0<i<arr.length-1使得:
arr[0] < arr[1] < … < arr[i-1] < arr[i] 且
arr[i] > arr[i + 1] > … > arr[arr.length-1]

為了避免大家隔太久沒有練習(我也是)，而且快過年了不要讓大家太燒腦，
今天我們就介紹簡單一點的題目就好XD！

在LeetCode的題型中，有一些簡單的題目的規格，
會呈現為只要題目讀得懂，按要求做完就會答對的形式，
本題就是相當明確的例子之一。

我們來看看要求：mountain array
前面必須要嚴格遞增 ，後面必須要嚴格遞減 ，
中間的arr[i]值為整個陣列的最高點。
同時限制了長度必須大於等於3，也就是上下坡都必然存在。

那麼解題方式就很明確了：

先檢查長度是否≥3，且arr[0]是否小於arr[1]
(一定要檢查，因為我們希望上下坡都存在 )
從陣列的開頭開始以i計數，往後沿途比較arr[i]跟arr[i+1]，
一路遞增到遞減轉折出現為止(也就是第一個arr[i] >arr[i+1])
在2當中如果出現前後相等 的狀況可直接回傳False，
同時，如果還沒下坡就已經走到底(i + 1 == arr.length) 的話，
也要回傳False 。
沿路下坡，一路走到尾端
如果沿途均符合的話(會走到i + 1 == arr.length )，則回傳true；
如果沿途變平或上坡的話，需在4的位置提早停下，
這樣子就可以藉由是否走到尾端這點來判斷要回傳true或false。

依此，寫成程式碼如下。

Java

可以看到我們在上坡的時候使用迴圈，
每次檢查就做兩件事來確認是否離開迴圈：

是不是走到底了 -> 走到底的話就不對了，因為還沒下坡
是不是有在走上坡 -> 變平的話不對，只有變下坡可以接受

而下坡時只有一路下坡走到底可以被接受。

Python

Python寫法基本上一致，所以說這題不難，對吧XD！
關鍵還是在於是否能確切釐清題目要求，
例如如果沒有寫A[0] ≥ A[1]的檢查的話，
就有可能碰到只有下坡的陣列，從而讓檢查結果出問題喲！

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

「時間/空間複雜度？」
(O(N)/O(1)，這題最多需要掃完整個陣列，
且我們只有多使用一個i的變數。)

相似及延伸

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

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

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

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

從LeetCode學演算法 — 雜談及促銷活動XD！

Wed, 08 Dec 2021 00:00:00 +0800

還在等折價嗎？這不就來了嗎XD

即日起開始有配合HiSKIO官方的折價活動，
整包課程活動價只要3591元，
新的一年，投資自己練功，為自己加值戰力！
有興趣的朋友可以參考看看~
https://hiskio.com/packages/1AyXD1oyQ

由於事情比較多的關係，一直打不起精神寫新的文章，真是不好意思QQ
雜談一下，這段時間以來，大體上就是在了解加密貨幣相關的基本知識(真的很基本的那種)，以及換工作(大誤)，還有做之前鐵人賽得名的從零開始學Python，在博碩文化出版為初學 Python 的第一本書 : 從基本語法到模組應用 ，在天瓏書局或博客來都有販售，當然也有電子書版本，打完折應該都算打到骨折啦，同時也邀請到了葉丙成老師(對，是各位想的那位葉丙成) 做封面推薦，以及HiSKIO的創辦人Adam 來寫序。

這邊要說一點實話，其實完書後我是覺得還存在一些不足的，儘管我某種程度上很嚴苛地對待第一本出版的著作，但有限的時間內，其實只允許我盡可能將錯字和排版錯誤等問題排除，以及程式碼不要有錯漏的問題，還有增加一些基本的習題，希望能協助新手每個環節都能練習到基本Python使用的方法和觀念。沒記錯的話，跟線上的文章差異應該僅有幾個小節的新增，而沒有大幅度的變化。

所以如果你問我說：「我想支持你，買一本你的書怎麼樣？」的時候，我會很感激，然後拜託你買課我會賺比較多XD
當然，畢竟是第一本書，所以真的願意花錢購買支持的讀者，我也是真的相當感謝，希望額外的修改以及適當的排版能幫助你/妳能更好的吸收。

扣掉這些時間以外，其實說真的我就沒做些什麼事情了，前陣子家裡的貓突然心臟病發作併發肺炎，送醫院進氧氣倉，還沒等到我們轉診送去更專門救治毛小孩心臟病的專科就沒撐過來過世了。哭了一陣然後故作堅強好像是入了社會的人的基本技能，本來還想好結婚的時候一定要讓牠走紅毯當我們的花童的，沒想到牠等不到那天了。世事無常，變化太快，只能且行且珍惜。也請大家要保重身體，以及珍惜和身邊的人相處的時光，不要到最後才後悔。

扯遠了，拉回來一下。
總之，如果還沒有購買課的讀者，可以把握這次的優惠，
相關的介紹會放在下面。之後會盡量找時間繼續寫文章，就再請大家多多支持囉。

相關介紹：

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

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

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

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

從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學演算法 - 115 Graph(1) / Union Find (1)

Sun, 04 Jul 2021 00:00:00 +0800

0684. Redundant Connection (Medium)

寫在前面

從 LeetCode 學演算法 + 面試成功指南**http://bit.ly/zeroclg

Question

In this problem, a tree is an undirected graph that is connected and has no cycles.

You are given a graph that started as a tree with n nodes labeled from 1 to n, with one additional edge added. The added edge has two different vertices chosen from 1 to n, and was not an edge that already existed. The graph is represented as an array edges of length n where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the graph.

Return an edge that can be removed so that the resulting graph is a tree of n nodes. If there are multiple answers, return the answer that occurs last in the input.

Example 1

1
2


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

Example 2

1
2


Input: edges = [[1,2],[2,3],[3,4],[1,4],[1,5]]
Output: [1,4]

Constraints

n == edges.length
3 <= n <= 1000
edges[i].length == 2
1 <= ai < bi <= edges.length
ai != bi
There are no repeated edges.
The given graph is connected.

分析/解題

在這個問題中，一棵樹是一個無向圖(undirected graph)，且當中沒有環(cycle)。給定一個圖，當中有n個node，標記為從1到n，其中有多一個邊(edge)；多出來的邊是由1到n選出兩個不同的節點(vertices, vertex的複數)所構成的，且並非已經存在的邊。這個圖是由一個長度為n的陣列edges來表示的，其每個元素edges[i]=[ai, bi]表示在圖中，ai和bi兩個節點中間有一個邊連結。

請回傳一個可以在移除後令這個圖可以形成一棵含有n個節點的樹的邊，如果有多個答案的話，請回傳讓其發生在最後的輸入。

好的，光翻譯題目就是一個很麻煩的事情，這也是為什麼從之前到現在始終不太想作圖(graph)相關的文章：因為實在太麻煩了，且不好解釋XD

那我們今天就來挑戰看看吧！希望在看完本篇文章以後，大家還醒著(笑)XD

在解這題之前，我們應該要先對圖作一點基本介紹：
圖(graph)是一種描述資料與資料之間的連結(不是人與人之間的)的結構，
當中最主要會分為兩個主要的元素：vertex(節點)及edge(邊/線段)。
節點可能擁有自己的一些屬性或值，這個可以依照定義而改變，而節點和節點之間，則是透過邊來連接，因此在同一張圖內，如果有超過一個節點，那它們至少要有能夠相連的邊連結彼此(不然就不會是同一張圖了！)。

接下來另一個很重要的點是，圖可以分為有向圖(directed graph) 和無向圖(undirected graph) ，什麼意思呢？

舉例來說，筆者對台北還不夠熟悉的時候，騎著機車在台北附近總是容易繞一大圈才走到自己的目的地，而且回程的時候還容易繞錯路，其中一個原因就是單行道 。單行道表示了今天從A走到B可能可以走XX路，但從B到A可能要走OO路接RR路才行，因為XX路是單向的；換句話說，當從A到B和從B到A無法等價看待的時候，我們會稱這樣的圖為有向圖，因為其關連性不能夠直接反過來也成立。這種圖在繪製上的體現就是節點到節點之間會有箭頭以表示方向 ，對於本題來說，由於給定是無方向的，所以讀者會看到圖形上的連接僅有線條，沒有箭頭。

接著是環(cycle) ，如果一個圖可以從某個節點出發，經過不重複 的節點(起點除外)，最終又能回到起始的節點，我們稱這個圖具有一個循環。

圖的表示方式一般有兩種：

Adjacency Matrix(相鄰矩陣)，也就是如果有N個節點，就開一個NxN的矩陣Mat，當中如果A點跟B點有edge的話，Mat[A][B]=1，否則為0；可以想見，如果某個圖是無向圖的話，這個矩陣應該會沿對角線相對稱(因為Mat[A][B]會和Mat[B][A]等價)。
Adjacency List(相鄰串列)，也就是對每個節點，都用一個串列來列出跟這個節點有相連的邊的所有節點。

一般而言，如果總體的edge數量較多的話會使用相鄰矩陣，比較少的話則會使用相鄰串列。

其它跟圖有關的基礎其實還很多，我們容後有機會再慢慢講。

回到我們的題目，其實它是一個相對簡單的圖，
因為要連接n個節點總體只需要n-1個邊，而這個圖有n個邊，
要讓這個圖不成環，只能將其中一個會構成環的邊給去除掉。

那麼，我們怎麼知道哪邊會有環成立呢？
這邊我們可以使用union find的概念來處理。
union find其實是在探究併查集( Disjoint-set data structure**)** 的問題。
用最白話的方式，就是「我們有沒有同一國」的概念。
什麼意思呢？

假設一個班級有幾個小團體，這些小團體跟幫派一樣很講17且不能重覆加入，我們現在想知道究竟哪些同學屬於哪個小團體，要怎麼找呢？
其實很簡單，就是把每個同學叫過來問：「你的老大是誰？」

舉例來說，如果有一個班級有兩個小團體，它們之間的層級分部是這樣的：

A
|
B C
| |
DE- F

G
|
H
|
I

D會告訴你他的老大是B；
E會告訴你他的老大是C；
然後B、C會告訴你他們的老大是A；
最後問到A他會說：「我就是老大！」
於是我們就會發現B、C、D、E這四位其實都是隸屬於A的，
也就是他們都是同一團體的。而G、H、I則屬於另一個團體。
因此，我們可以對某個節點找到它最上層的節點，
用這個節點來定義它所屬的團體，同時在過程中依照新增的邊來合併彼此的老大，這個過程叫作find 。

那麼，我們換個角度來思考：
依照上面的概念，每個節點之間的邊，其實就可以代表它們是同一國的，
那麼，如果在看到這個邊之前，它們就已經有相同的老大了呢？
比如上面的圖而言，對於E和F來說，由於有A-C-E跟A-C-F，
因此E跟F都知道自己的老大是A。
接著我們看到E-F的這條邊連結起來，就意味著這邊構成了一個環 ！
因為前面E已經可以連到A，F也可以連到A表示EAF之間可以連接起來，
因此E-F的連接就給這之間構成了一個環。

因此，我們可以利用這點，來找出構成環的邊，就是我們要的答案了！
因為節點和邊的總數量我們知道是n，所有節點也只有1~n，
所以我們可以使用一個陣列或串列來簡單表示某個節點的老大是哪個節點。
如果它自己就是最大的老大的話，那麼我們就用-1來代表它沒有更上層了。

因此，我們的解題步驟應該像這樣：

產生一個root的陣列/串列，其長度為n+1 (比較方便對應1~n)，
其初始值均為**-1** 。
對於edges中的每個邊edge，使用find 函式找到它們的老大x跟y，
檢查x和y是否相同；若相同，表示這個邊構成了一個環 ，回傳edge 即可；
若不同，則須統一老大，將root[x]設定為y (將x這系列的上層往y這邊合併)。
如果檢查完均檢查不到，則在外層回傳空的陣列/串列表示沒找到(但題目表示應該都會存在答案，所以理論上不會走到這邊)。

在find函式 的定義中，輸入應該是root這個陣列跟要被確認的節點i：

使用迴圈，當root[i]不是-1時，令i = root[i] ，往上找尋更上層的老大。
直到迴圈結束，這時候的i應該是最上層了，就回傳i 即可。

依此，寫成程式碼如下：

Java

Java的部份可以使用Arrays.fill來給定一整組的陣列初始值。

Python

Python的部分則直接用*號來初始化即可，同時使用子函式，
略去self相關的麻煩寫法。

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

「時間/空間複雜度？」
(如果找尋root的時間沒有到最糟糕狀況的話為O(N)/O(N)，但我們在這個版本的只實作了find，最差狀況下find會一條線接上去，導致find的複雜度達到O(N)，這時候總體時間複雜度就會是O(N^2)。)

「如果要實作化簡的部份的話？」
(化簡的概念在於將中間尋找的部分也一併處理，也就是告訴沿路上的所有節點它們最大的老大是誰，要怎麼作才能讓整個路徑更短，可以參見https://en.wikipedia.org/wiki/Disjoint-set_data_structure，或者參考LeetCode的Solution也有提供，原則上是看兩個小團之間的節點數量來進行誰併到誰的決定。)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 114 Stack (3)

Sat, 27 Feb 2021 00:00:00 +0800

0946. Validate Stack Sequences (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 two sequences pushed and popped with distinct values , return true if and only if this could have been the result of a sequence of push and pop operations on an initially empty stack.

Example 1

1
2
3
4
5


Input: pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
Output: true
Explanation: We might do the following sequence:
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

Example 2

1
2
3


Input: pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
Output: false
Explanation: 1 cannot be popped before 2.

Constraints

0 <= pushed.length == popped.length <= 1000
0 <= pushed[i], popped[i] < 1000
pushed is a permutation of popped.
pushed and popped have distinct values.

分析/解題

給定兩個序列pushed跟poped，
序列當中的每個值都是獨特的(也就是每個值會不同)，
如果對於一個空的stack進行push和pop的操作，
能夠完全符合pushed和poped列出來的順序的話，
就回傳true，否則回傳false。

這個問題乍看之下或許有點不夠清楚，
簡單來說呢，就是不管如何，推入的順序一定是pushed，
也就是放入的時候的順序是固定的，只是選擇在什麼時候poped而已，
例如[1, 2, 3, 4, 5]，
如果我們push兩次，pop一次，再push三次，pop四次 ，
那麼我們所得到的結果會是:

1
2
3
4
5


stack poped
1, 2 　
1 2
1, 3, 4, 5 2
 2, 5, 4, 3, 1

再多做一些嘗試，就會知道pop的時間點會影響到poped最終的順序結果。
因此，我們可以試想一下幾個情況：

當stack裡面沒有東西 ->
沒辦法pop東西出來，必須要先push進去才行。
當stack裡面有東西 ->
要pop出來嗎？由於每個值都相異，所以這邊出現過的數字，後面就不能出現了！因此我們應該看現在poped的順序走到哪裡 ，去檢查現在stack最上面 是否和poped對應的數字一樣 ，這樣才代表需要做pop的操作。

依照上面的想法，我們做的順序應該像這樣：

開一個新的Stack，這邊稱為st。
宣告一個變數i並初始化為0，用來記錄下一個poped所在的index 。
使用迴圈，依序每次從pushed取出一個num：
3–1. 將num推入st中
3–2. 當st還有值在內，且最上層剛好和poped[i]相同 時，進行迴圈，
對st進行一次pop，並遞增i (代表往下一個值來看)
(不相同的話，就代表這個值不該在這邊被pop出來)
大迴圈結束後，若st剛好清空，代表這個順序是OK的，
因此st是空的時候回傳true，否則回傳false 。

依此，寫成程式碼如下：

Java

Java的部分，檢查stack是否為空要用isEmpty函式，
看stack最上層可以使用peek ，也就是先偷看一下，
避免使用pop，因為我們還沒有篤定要將其移出stack外。

Python

Python的部分，我們可以直接使用list做為stack來使用 ，
可以使用append/pop，看最上層就直接利用st[-1] 即可。

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

「時間/空間複雜度？」
(O(N)/O(N)，N為pushed/popped的長度)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 113 BFS (4) / Queue (5)

Tue, 16 Feb 2021 00:00:00 +0800

1091. Shortest Path in Binary Matrix (Medium)

寫在前面

(新年優惠套組已截止囉！）

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

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

Question

In an N by N square grid, each cell is either empty (0) or blocked (1).

A clear path from top-left to bottom-right has length k if and only if it is composed of cells C_1, C_2, ..., C_k such that:

Adjacent cells C_i and C_{i+1} are connected 8-directionally (ie., they are different and share an edge or corner)
C_1 is at location (0, 0) (ie. has value grid[0][0])
C_k is at location (N-1, N-1) (ie. has value grid[N-1][N-1])
If C_i is located at (r, c), then grid[r][c] is empty (ie. grid[r][c] == 0).

Return the length of the shortest such clear path from top-left to bottom-right. If such a path does not exist, return -1.

Example 1

1

Input: [[0,1],[1,0]]

1

Output: 2

Example 2

1

Input: [[0,0,0],[1,1,0],[1,1,0]]

1

Output: 4

Note:

1 <= grid.length == grid[0].length <= 100
grid[r][c] is 0 or 1

分析/解題

在一個N x N的平方格子裡，每個格子可能是空的(0)，
不然就是阻塞住的(1)。

一個乾淨的路徑從左上到右下的長度為k，如果路徑上的格子都是8方向(也就是九宮格的對應)相連，且開頭是(0, 0)，結尾是(N-1, N-1)，且每一格都是空的(0)。請回傳從左上到右下最短的乾淨路徑長，若不存在則回傳-1。

這個題目其實可以有很多種不同的解決方式，
不過我們好久沒有使用到BFS了，就來試試看BFS的解法吧！
根據題目的定義，我們要找的是最短路徑，
所以可以從(0, 0)開始嘗試每次往8個方向各走一步，
並且將計數+1及標記已經走過，當在某步碰到了(N-1, N-1)時，
即表示我們找到了最短路徑(因為所有路線都是每次同時走一步)。
因此，我們需要一個Queue來記錄當前所有走到的點，
然後每次再將Queue的點取出，
找到8個方向的新的一步的點，加入到Queue中。
(不能超出邊界，不能已經走過，也不能被阻擋住)

那麼我們怎麼知道同一層的要做到哪裡呢？
很簡單，在這層開始之前，我們先記錄下當前Queue的長度，
這樣子同一層只要做完這麼多個點就可以啦！

依此，寫成程式碼如下：
(下面的程式碼中，我們直接把走過的路徑給標成block了，
這點相對較節省空間也較方便，但其實不是很正規，
如果面試時沒有說你可以動grid，請開出一個N x N的visited格子，
用來記錄有經過的點會比較好呦！)

Java

Java的部分，首先我們先檢查grid的狀況，
以及左上右下是否有阻擋住的狀況，有的話就直接回傳-1。
接著使用LinkedList作為我們的Queue，
可以使用add或者offer來加入新的元素。
當queue不為空時，每次取出一個點，往對應的8個方向取點並檢查：

走到右下角的話代表走完，直接回傳cnt。
如果點是合法的點的話，就將那格標記為1並加入queue中。
每輪做完別忘記將cnt遞增。

全部做完還沒有碰到右下角，代表沒有解，回傳-1。

Python

Python的部分則使用deque來操作，
留意到這個題目其實也可以擴展成矩形，
這邊示範使用r, c的方式來記錄，但其實區別不大。
但對deque來說，取出記得是使用popleft，請不要誤用成pop了！

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

「時間/空間複雜度？」
(O(N²)/O(N²)，最糟糕的狀況是擴散的很開的時候，
queue所需要的空間會很大，這個問題其實可以使用bi-directional的BFS來降低擴散的程度，可以再參考leetcode上別人的解法。)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 112 Binary Search (6) / Newton’s Method

Mon, 01 Feb 2021 00:00:00 +0800

0367. Valid Perfect Square (Easy)

寫在前面

同時，還有限時更便宜的套組3490 (再便宜500呦！限額10名！)
新年限量組合🎁 零元求職挑戰賽 Python 組｜從 LeetCode 學演算法https://hiskio.com/packages/ZXwe2p9yv

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

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

Question

Given a positive integer num, write a function which returns True if num is a perfect square else False.

Follow up: ** Do not** use any built-in library function such as sqrt.

Example 1

1
2


Input: num = 16
Output: true

Example 2

1
2


Input: num = 14
Output: false

Constraints

1 <= num <= 2^31 - 1

分析/解題

給定一個正整數num，試檢驗num是否為完全平方數(也就是可以分解成兩個完全相等的數相乘)。
請不要使用內建的sqrt或類似的函式。

雖然被封印了平方根函數，但已經看到標題的讀者應該不難猜想到，
我們可以運用一般的二分逼近法，
去將目標(我們先稱之為x)的範圍縮小。
當找到 x² 和num相等時，就表示num是完全平方數(回傳True)，
否則一路找到兩個邊界交叉時，表示num不存在整數平方根，
我們就可以回傳False。

那麼，有沒有再更厲害一點的方法呢？
這邊來介紹一下一個著名的方法，名為牛頓法(Newton’s Method)。
我們在求x² = num當中的x，(下面方便起見，將num寫成n)
其實相當於求 y = f(x) = x² - n在y = 0時的正根。
假定r是這個根，我們先取一個任意一個比較大的值x0，
那麼它對應到的座標應該是(x0, f(x0))。
對於這個點做曲線的切線的話，應該可以得到切線方程式：
y = f(x0) + f’(x0) (x-x0)
也就是y = ax +b嘛! a就是在x0上的切線斜率，
而x代入x0的話可以驗證y = f(x0)，
所以這個方程式可以表達該切線沒錯。

我們將這個切線叫做L，
那麼L和x軸的交點的x座標，應該就和r更近囉！
(想像一下拋物線的斜度會越來越平，所以切線和x軸的交點，
比起拋物線和x軸的交點來說應該會大一點)
我們將後面和x軸的交點位置叫做x1 ，
那麼就可以計算其斜率為 f(x0) / (x0-x1) = (x0²-n)/(x0-x1) ，
同時也等於f(x)的導數(就是對其微分)f’(x) = 2x 。
因此，2x0 = (x0²-n)/(x0-x1) -> 2x0(x0-x1) = x0²-n
繼續化簡：
-> 2x0²-2x0x1=x0²-n
-> x0²+n = 2x0x1
-> x1 = (x0 + n/x0) / 2

每次取得一個更接近的x來逼近r的位置

我們可以再用這個x1再取得在f(x)上的點，接下來再畫切線，
重復上面的動作。
當我們每次用前面這個算式迭代，就可以取得一個新的x，
理論上它會更接近於r。(x1, x2, x3, …)
由於要取的是整數，所以我們在計算的時候，
就將所有的算式中的除法都取整數，
這樣算出來的狀況，就會變得有機會更小。
所以在運用到實際的計算時，
我們可以設定一個迴圈，將x直接先定為num，
當x² > num時，就持續迴圈，
那麼在x持續縮小的狀況下，
最終要嘛縮小到剛好得到一個正整數的平方根，
要嘛就是x²已經小於num了，我們就不用繼續往下做啦！

依此，寫成程式碼如下：

Java Java的部分，請留意到大小問題，我們應該要使用long來宣告變數。

Python

Python部分則請不要忘記整數除法是”//”。

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

「時間/空間複雜度？」
(時間複雜度難以界定，最差應該是O(num)，(但二分法也是)
平均應該優於O(log(num))，這可能也取決於初始值的取法；
空間複雜度則為O(1))

相似及延伸：
本題還有其他的解法可以參考以下連結https://leetcode.com/problems/valid-perfect-square/discuss/130010/Python-4-Methods-with-time-testing

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

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

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

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

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

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

0784. Letter Case Permutation (Medium)

寫在前面

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

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

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學演算法 - 110 Array (16) / Greedy Algorithm (1)

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

0881. Boats to Save People (Medium)

寫在前面

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

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

Question

The i-th person has weight people[i], and each boat can carry a maximum weight of limit.

Each boat carries at most 2 people at the same time, provided the sum of the weight of those people is at most limit.

Return the minimum number of boats to carry every given person. (It is guaranteed each person can be carried by a boat.)

Example 1

1
2
3


Input: people = [1,2], limit = 3
Output: 1
Explanation: 1 boat (1, 2)

Example 2

1
2
3


Input: people = [3,2,2,1], limit = 3
Output: 3
Explanation: 3 boats (1, 2), (2) and (3)

Example 3

1
2
3


Input: people = [3,5,3,4], limit = 5
Output: 4
Explanation: 4 boats (3), (3), (4), (5)

Note :

1 <= people.length <= 50000
1 <= people[i] <= limit <= 30000

分析/解題

有一群人people，當中第i個人的重量是people[i]，
且每艘船最重可以載重limit，同時最多只能乘載2個人，
乘載的重量最多為limit(剛好的話也可以)
試計算並回傳最少所需裝載所有人的船的數量。

乍看之下，這題是不是有點像以前的Two Sum?
但再仔細想想，就會發現，
由於我們並不一定要每艘船都裝載到limit的重量，
所以並不能夠形成相加等於特定和的關係。

那麼該怎麼處理呢？
如果這群人是由小到大排列的話，
不管如何最重的那些人都還是要上船，
所以我們先挑最右邊的(最重的人)上船。
接下來這艘船還能不能帶人呢？
我們就再幫忙找最左邊的(最輕的人)看能不能湊一組，
可以湊就沒問題，不能湊也無法強求，就只好讓這個人自己一條船囉！
這樣搭配下，我們就可以盡可能先幫較重的人找看看能不能組起來，
因此會是所需求的船隻數量會是最小的。

上面這樣子的概念，被稱為貪婪演算法(Greedy Algorithm) 。
貪婪演算法的核心精神，在於先找到一個方法，
使得每次盡可能都處理所有可以操作的單位，
再依序往下做處理，這樣的方法是對總體來說也是最佳 的時候，
就符合貪婪演算法的特性。
請讀者務必留意，
如果像是動態規劃(Dynamic Programming) 這類型的問題，
就顯然不會符合 貪婪演算法的作法，
因為局部的最佳解，不見得會是全局的最佳解 。

所以對這題來說，當我們排序完這群人以後，
從最重的開始盡可能幫其安排組合，對總體來說就會是最好的。

因此，我們的大體解法應該如下：

先將people由小到大排序
令l = 0, r = people.length - 1, res = 0 (用來記錄需要幾艘船)
使用一個迴圈，當 l ≤ r 時，進行以下操作：
3–1. 如果 people[l]+people[r]<= limit 時，
代表可以捎上index l 的人，此時將** l遞增。
3–2. 由於所有人的重量都一定小於limit** ，(題目說的)
所以people[r]一定可以占一艘船 (不管people[l]有沒有上船)，
所以我們將r遞減 ，並且將res遞增 ，這艘船我們就處理完囉！
回傳res 即為答案。

讀者可能會問：咦？那l和r重疊 的話怎麼辦？
問得好！重疊的話，由於不論怎麼樣r都會遞減，
所以重疊的時候，事實上就是相當於3–1沒有任何作用 ，
但並沒有影響到我們要計算的res，對吧XD？

依此，寫成程式碼如下：

Java

Java的話使用Arrays.sort()，
其他部分應該相當直觀。
這裡提供LeetCode的另一種解法，
由於有limit的限制，所以我們可以利用長度為limit+1的陣列，
來達到排序的效果(這相當於O(limit)的空間去換取時間複雜度降低)

Python

Python的排序則直接對串列進行.sort()即可，
讀者請記得sorted()函式是產生一個新的排序的串列，別搞混喲！

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

「時間/空間複雜度？」
(O(NlogN)/O(1)，N為people的長度。
如果是使用Java附上的參考解的話則是O(limit)/O(limit))

相似及延伸

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

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

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

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

從LeetCode學演算法 - 109 Array (15) / Hash Table (11)

Fri, 08 Jan 2021 00:00:00 +0800

1640. Check Array Formation Through Concatenation (Easy)

寫在前面

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

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

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

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

Question

You are given an array of distinct integers arr and an array of integer arrays pieces, where the integers in pieces are ** distinct**. Your goal is to form arr by concatenating the arrays in pieces ** in any order**. However, you are ** not** allowed to reorder the integers in each array pieces[i].

Return true if it is possible to form the array arr from pieces. Otherwise, return false.

Example 1

1
2


Input: arr = [85], pieces = [[85]]
Output: true

Example 2

1
2
3


Input: arr = [15,88], pieces = [[88],[15]]
Output: true
Explanation: Concatenate [15] then [88]

Example 3

1
2
3


Input: arr = [49,18,16], pieces = [[16,18,49]]
Output: false
Explanation: Even though the numbers match, we cannot reorder pieces[0].

Example 4

1
2
3


Input: arr = [91,4,64,78], pieces = [[78],[4,64],[91]]
Output: true
Explanation: Concatenate [91] then [4,64] then [78]

Example 5

1
2


Input: arr = [1,3,5,7], pieces = [[2,4,6,8]]
Output: false

Constraints

1 <= pieces.length <= arr.length <= 100
sum(pieces[i].length) == arr.length
1 <= pieces[i].length <= arr.length
1 <= arr[i], pieces[i][j] <= 100
The integers in arr are distinct .
The integers in pieces are distinct (i.e., If we flatten pieces in a 1D array, all the integers in this array are distinct).

分析/解題

給定一個陣列arr，當中有不同的整數們，
以及另一個整數陣列的陣列pieces(好饒口XD)，
當中所有的pieces中的整數也都是相異的，
我們的目標就是要將pieces拼接成arr，
但pieces中要怎麼接順序都沒關係，
但每一個pieces中的子陣列中的順序不可以被調換 。
(例如arr = [15,88], pieces = [[88],[15]]，
可以先拚[15]再拚[88]從而組出arr，可回傳true；
但arr = [49,18,16], pieces = [[16,18,49]]的話，
因為[16,18,49]內不能夠調換順序，所以只能回傳false)

如果拚得起來就回傳true，否則回傳false。

條件限制：

arr的長度和pieces的長度均為1~100之間(後者小於前者)。
pieces的所有子陣列長度總和，和arr陣列長度相等。
arr和pieces的所有子陣列中的元素值均在1~100之間。
arr中的所有整數均為相異。
pieces中的所有整數均為相異。

根據條件限制的部分，我們可以簡單得到，
反正要能對上的話，因為總個數剛好相等，
所以不存在第二種對應方式 ！
既然不存在第二種對應的方式，
那麼我們在arr中看到一個開頭時，
我們應該只要在pieces中找那個值 ，
就知道該對上pieces中的那一個子陣列囉！

那麼，我們該怎麼樣去找對應呢？
每次都掃過一輪去找，時間複雜度感覺會很糟糕，
那麼，想要迅速的找到對應的位置，
我們就會想到利用HashTable的概念。
因此，在Java使用HashMap，Python中則使用dictionary，
就可以讓我們使用O(1)的複雜度進行存取(不過前面要先花O(N)來存喲！)

這邊我們可以選擇將每個(pieces[i][0], i)的對應存入，
這樣在搜尋時，我們就知道接下來要拚入哪一組子陣列囉！

接著我們需要遍歷整個arr，
每次先拿第一個值去搜尋到對應的pieces，
接著依序一個一個去對照兩邊的值是否相等。
如果找不到對應或者是值不相等，就表示無法對應成功囉！
(可以直接回傳false)
如果全數拚完都沒問題，自然就可以回傳true。

依此，寫成程式碼如下：

Java Java的部分，我們使用HashMap來記錄，

記得使用put(key, value) 的形式！
(因為沒有重複的問題，所以也不需要檢查)

接著我們利用cnt來進行遍歷的紀錄，
這邊不要忘記先檢查 能不能找到arr[cnt]啊！
(因為有可能找不到，直接用get會有exception的！)
另外，由於get出來是Integer，
這邊我們使用(int)來將其轉型回一般的int 。
其他就依序處理即可。

Python

Python的部分，字典和list的操作方式差不多，
不過還是不要忘記先檢查喲！
另外對初學的讀者提醒一下，
Python中沒有++或–這種方便的遞增/遞減方式 ，
所以請乖乖使用cnt += 1或cnt = cnt + 1 。

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

「時間/空間複雜度？」
(O(N)/O(pieces的子陣列個數，最大為N))

相似及延伸

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)

寫在前面

期限嘛…就延長到滿人數吧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學演算法 - 107 String (7) / Stack (2)

Sat, 12 Dec 2020 00:00:00 +0800

1544. Make The String Great (Easy)

好久不見啦！最近筆者比較忙碌，還請多多見諒XD

寫在前面

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

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

Question

Given a string s of lower and upper case English letters.

A good string is a string which doesn’t have two adjacent characters s[i] and s[i + 1] where:

0 <= i <= s.length - 2
s[i] is a lower-case letter and s[i + 1] is the same letter but in upper-case or vice-versa .

To make the string good, you can choose two adjacent characters that make the string bad and remove them. You can keep doing this until the string becomes good.

Return the string after making it good. The answer is guaranteed to be unique under the given constraints.

Notice that an empty string is also good.

Example 1

1
2
3


Input: s = "leEeetcode"
Output: "leetcode"
Explanation: In the first step, either you choose i = 1 or i = 2, both will result "leEeetcode" to be reduced to "leetcode".

Example 2

1
2
3
4
5


Input: s = "abBAcC"
Output: ""
Explanation: We have many possible scenarios, and all lead to the same answer. For example:
"abBAcC" --> "aAcC" --> "cC" --> ""
"abBAcC" --> "abBA" --> "aA" --> ""

Example 3

1
2


Input: s = "s"
Output: "s"

Constraints

1 <= s.length <= 100
s contains only lower and upper case English letters.

分析/解題

給定一個字串s，當中含有大小寫的英文字母，
一個好的字串被定義為對於 0 ≤ i ≤ s.length - 2 來說，
兩個相鄰的字元s[i]和s[i+1]不會含有相同字母但大小寫相反的狀況，
例如aA, Cc這種型式。

要讓字串變好，可以透過每次拿掉兩個相鄰且讓字串變壞的字元達到，
最終得到一個好的字串。

題目表示給定的題目一定有答案且必然是唯一的。
(空字串也是好的字串)

說起來這題的標題不禁讓人想到美國總統大選，
不過到現在恐怕已經大勢底定了就是，
這句話恐怕就要成為絕響了吧XD

扯遠了，我們來看看這題。

由於它已經保證會有唯一解，
那麼相鄰字元的移除順序理論上並不會影響結果，
所以直觀上好像可以每次掃過一遍字串，
將大小寫相鄰的相同字母移掉就解決了……嗎？

但這麼做的話，我們會不知道要掃過幾次字串才能夠將所有問題移除完，
因為比如碰到abBA 這樣子的字串，我們要將**’bB’** 移除掉，
才會在下一次發現**’aA’** 可以移除。

所以為求簡單起見，
我們可以使用一個Stack 來存放已經檢查過的部分，
每次放一個字元到Stack中，存放前將Stack最上面的那個字元，
跟準備要放的字元做比較：
兩者是相同字母且大小寫相反->將Stack中最上面的字元pop掉
兩者不需相消->放入Stack

這麼一來，我們就只會放沒有讓字串變壞的字元進到Stack，
同時每次都會拿新的字元跟前面的比對，以排除掉應該移除的部分。

那麼，怎麼算大小寫相反呢？
除了用upper/lower case相關的函式外，
在 ASCII Code 中，相同大小寫的字母的對應碼會恰巧差32。

為什麼不是26? 因為中間還有帶一些標點符號。 Python中我們可以使用ord()來對一個字元取其ASCII Code值，
而在Java中，我們可以視char為一個數字來進行加減運算，
所以直接相加減就可以了。

可能有讀者會問：
「那我記不住32這個數字怎麼辦？」

在寫的過程中，我們也可以用’a’和’A’的位置差算出來，
注意**’a’對應的值是比較大** 的呦！
所以可以將其寫成：‘a’ - ‘A’ (Java)或 ord(‘a’)- ord(‘A’) (Python)

你再問：
「那我記不住哪個在前面怎麼辦？」
呃……那你只好再加個絕對值 了！
使用Math.abs() (Java) 或 abs() (Python)就可以囉！

因此，流程大體如下：

建立一個stack名為st
從字串s當中依序取出字元c，進行迴圈：
2-1. 當st不為空，且最上面的值和c的值相差32 時，就對st進行pop
2-2. 否則表示不需消除，將c推入st中(push)
完成迴圈後，將st的所有字元連起來得到的字串即為答案

依此，寫成程式碼如下：

Java

Java的部分，由於Java的Stack固定從尾端取出，
最終使用StringBuilder進行組合完以後，toString之前記得要reverse，
不然答案就會反掉囉XD！
當然，也可以採用ArrayDeque來做，
這樣就可以從頭排列到尾而不需要反轉。
使用peek()可以幫助我們確認stack的最上面一個值是什麼，
而不會將其取出，同時因不確定大小寫誰在前面，
所以檢查時要記得取絕對值！

Python

Python這邊多加了一條判斷，但其實不影響，
只是s的長度是1或0時都可以直接回傳就是了XD

我們可以看到對於Python來說好處就是可以直接拿list當stack來使用，
同時，使用join函式可以簡單地將list組成字串。

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

「時間/空間複雜度？」
(O(N)/O(N)，N為字串長度。Java也可以使用CharAt(i)的型式來處理取出字元的部分，但不影響空間複雜度，因為後面還有其他要組的部分XD)

相似及延伸

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學演算法 - 101 String (6)

Sun, 26 Jul 2020 00:00:00 +0800

1529. Bulb Switcher IV (Medium)

寫在前面

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

當前面試篇以上傳完畢，進階篇則會在8/31前陸續上傳完成呦！

有興趣的朋友可以使用下面的早鳥優惠～
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」 ：
https://bit.ly/advleetcode

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

Question

There is a room with n bulbs, numbered from 0 to n-1, arranged in a row from left to right. Initially all the bulbs are turned off .

Your task is to obtain the configuration represented by target where target[i] is ‘1’ if the i-th bulb is turned on and is ‘0’ if it is turned off.

You have a switch to flip the state of the bulb, a flip operation is defined as follows:

Choose any bulb (index i) of your current configuration.
Flip each bulb from index i to n-1.

When any bulb is flipped it means that if it is 0 it changes to 1 and if it is 1 it changes to 0.

Return the minimum number of flips required to form target.

Example 1

1
2
3
4
5
6
7


Input: target = "10111"
Output: 3
Explanation: Initial configuration "00000".
flip from the third bulb: "00000" -> "00111"
flip from the first bulb: "00111" -> "11000"
flip from the second bulb: "11000" -> "10111"
We need at least 3 flip operations to form target.

Example 2

1
2
3


Input: target = "101"
Output: 3
Explanation: "000" -> "111" -> "100" -> "101".

Example 3

1
2


Input: target = "00000"
Output: 0

Example 4

1
2


Input: target = "001011101"
Output: 5

Constraints

1 <= target.length <= 10^5
target[i] == '0' or target[i] == '1'

分析/解題

這題是今天(2020/07/26)舉辦的199th LeetCode Weekly Contest的第2題。
房間裡有n個燈泡**(0~n-1)** ，從左至右排列，初始全數是關的 。
我們的目標是將燈開關成target 的狀態，在index i的位置上，
target[i]如果是'1’的話就表示開，target[i]如果是'0’的話就表示關。

所能夠做的操作只有一種叫flip 的方法。
flip方法的操作是選取一個index i，
接著會將i~n-1的所有燈泡狀態反轉，1變成0，0變成1 。

我們要作的事情是找出最少完成target的flip次數。

是說每次碰到稍微生活化一點的題目，就會覺得有點87：
像這題亮燈就亮燈，搞那麼麻煩的開關方式幹嘛啦！！！
不怕燈泡壞掉逆？？？

這題乍看之下好像不容易，
但仔細一看，flip的操作只影響該點及其右側的燈泡，
所以我們由左往右看的話，只需要考慮當前該燈泡需不需要翻轉 即可，
因為某個點右側的燈泡flip不會影響該點。

由於右邊的會一起反轉 ，所以我們可以定位一個flag=1 ，
一開始大家都是0，所以第一次我們要翻轉的狀況，
就是碰到target[i]和flag相等時。 把右側翻過來以後，我們可以將flag從'1’變成'0’，
因為我們只要考慮翻或不翻 ，所以使用flag的變化 ，
和target[i]碰到的値來作對照 會相當方便：
只要碰到和flag相同的就代表要加翻一次 ，
不同的就代表不用翻 ，這樣沿路走到尾端，就可以得到計數的答案。

依此，寫成程式碼如下：

Java

Java的部分使用charAt可以按char來取出每個字元，
請留意要比較的時候要取成int，這邊直接減去’0’即可。

Python

Python的部分直接用int進行轉換字元成整數即可。

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

「時間/空間複雜度？」
(O(len(target))/O(1)，除了flag跟cnt以外並未額外再多用到其他空間)

相似及延伸

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

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

從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學演算法 - 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學演算法 - 面試篇宣傳

Sun, 12 Jul 2020 00:00:00 +0800

透過聆聽不同的工程師訪談，培養能力並抓住面試的機會

由於剛好上架完了面試篇的所有內容，所以想來跟大家介紹一下。
在面試篇當中，我們整理了一些各種面試常出現的題型，
以及幫助你初步推測解題方向的方法；
同時，我們訪問了四位工程師：

LiuLiu , HiSKIO的後端工程師，主要使用PHP+Laravel
Andy , Aimazing的前端工程師，主要使用Javascript+Vue.js
Mike , 資深前端工程師，
也是擁有7門線上課程 和YouTube頻道 的前端講師
Kenji , 資深軟體工程師，目前在矽谷的Square工作
(一家FinTech電子支付公司)
(同時他也有一個Podcast: Just Kidding Tech 輕鬆談科技)

由於涵蓋了不同資歷和定位的工程師的視角，
你可以從不同的受訪者身上，看到他們的觀點的差異，
以及不同時期的工程師所需要的技能有什麼。

這門面試課是和進階課綁定，不另行收費 ，個人覺得相當之划算。
當初原本只是一個附帶的構想，但為了想要給出足夠完整的東西，
最後就變得反而讓我做到很崩潰XD

當然，成果也是可喜的，我從訪談的交流過程中，
除了得到有用的資訊外，也常常被逗樂。

比方說Mike就告訴我們：

我就是Code我就會忘阿，我就是靠編輯器來幫我提示阿，
我就是哪有辦法這樣寫得出來，我就覺得莫名其妙耶你知道嗎？
工程師考試那沒有提供電腦，那叫我拿紙筆寫，又不是在寫作文。

Kenji則說：

你看太看重那個失敗本身，你太看重你被拒絕這件事情的話，
你反而會很難再繼續面試，因為你這個東西就是一個拒絕的過程。

人總會有被打槍的時候嘛XD

面試如是，人生如是，總會有種種的挫折，
但我由衷希望，我的文章和課程，
能帶給所有正準備挑戰工程師的面試的人幫助。

所以，有興趣的話，就考慮一下吧！
如果有希望我開什麼樣的內容或寫什麼方向的文章的話，
也可以留言告訴我～

「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」 ：
https://bit.ly/advleetcode

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

從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學演算法 - 97 Dynamic Programming (13)

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

0368. Largest Divisible Subset (Medium)

寫在前面

「從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學演算法 - 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學演算法 - 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學演算法 - 94 Hash Table (10)

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

0438. Find All Anagrams in a String (Easy)

Question

Given a string s and a ** non-empty** string ** p**, find all the start indices of ** p**’s anagrams in ** s**.

Strings consist of lowercase English letters only and the length of both strings s and ** p** will not be larger than 20,100.

The order of output does not matter.

Example 1

1
2


Input:
s: "cbaebabacd" p: "abc"

1
2


Output:
[0, 6]

1
2
3


Explanation:
The substring with start index = 0 is "cba", which is an anagram of "abc".
The substring with start index = 6 is "bac", which is an anagram of "abc".

Example 2

1
2


Input:
s: "abab" p: "ab"

1
2


Output:
[0, 1, 2]

1
2
3
4


Explanation:
The substring with start index = 0 is "ab", which is an anagram of "ab".
The substring with start index = 1 is "ba", which is an anagram of "ab".
The substring with start index = 2 is "ab", which is an anagram of "ab".

分析/解題

給定一個字串s及一個非空的字串p，
試找出所有在p在s內的所有異位構詞(anagram)的起始的索引值。
本題當中的字串僅含小寫英文字母，且s和p的長度分別不會大於20, 100.
(但不用在意輸出的順序)

我們先前已經提過anagram的定義了，詳情可見0242. Valid Anagram (Easy) 。簡單來說，anagram是指說兩個字串是由相同的字元組成的，
只有順序可能不同而已。

我們先假設我們拿到兩個字串，要檢查它們是不是互為anagram，
端看它們的’a’出現的次數，’b’出現的次數，’c’出現的次數…,
‘z’出現的次數是否相同即可。
這個儲存兩者出現的次數，可以使用HashTable來計算，
而且由於我們要分的內容很簡單，所以只需要小寫字母個數26個即可，
也就是Java可以使用一個長度為26的一維陣列，
Python可以使用串列，要使用字典也行(相當於HashMap)。

回到我們的問題，我們想要在s當中找到一個子字串，
使得這個子字串和p互為anagram，
這時候應該可以先將p的各字母出現次數先行記錄下來。
接下來從s的index 0開始往右 ，一路計算走到可以取p的長度為止，
如果這段能和p的組成內容相同，那就可以記做其中一個解。

為了要比對是否組成內容相同，
我們可以將每次看到的字母從p的hash table中扣除掉 ，
當所有整個hash table都歸零的時候，我們就知道當前的組成相同了。
但為了不需要每次都檢查整個hash table，
我們可以先行設定一個cnt變數，其值等於p的長度。
每次碰到可以扣除的組成就將cnt遞減，
這樣當cnt為0且當前長度為和p長度相等時，就知道取得一個解了。

接下來，我們需要一個left和一個right的索引值來記錄。
由於長度固定就這麼長，當我們已經來到左右距離p的長度時，
我們可以將left和right各自往右移動一格 。
同時left移出

舉例來說假設：
s: “ecba ebabac d” p: “abc”
(這邊將Example 1前面多加一個字元比較容易看出不同)

(left, right, cnt) : (0, 0, 3) -> (0, 1, 3) -> (0, 2, 2) -> (0, 3, 1)
沿路會檢查’e’, ‘c’, ‘b’，每次碰到的字母會從p的hash table中扣掉，
不過cnt這樣只會降到1，表示沒有成立anagram 。
(left, right, cnt) : (0, 3, 1) -> (1, 4, 0)
將left往右移一格，’e’就出範圍外了(hash table要加回來)，
接著right往右移一格，’a’進入範圍內，且符合p的hash table擁有的子母，
所以cnt會從1降為0，同時範圍長度相符，
表示這是其中一個解，將1加入到我們的答案範圍中。
(left, right, cnt) : (1, 4, 0) -> (2, 5, 1) -> (3, 6, 2) -> (4, 7, 3)
依序移出範圍，如果發現加上去前hash table該值有≥0的話，
表示有移出p原有的字母，所以我們要將cnt進行遞增。
(left, right, cnt) : (4, 7, 3) -> (5, 8, 2) -> (6, 9, 1) -> (7, 10, 0)
同樣經歷了一個cnt等於0且長度等於p的範圍，
將7 加入答案當中。
(left, right, cnt) : (8, 11, 1) -> right超過，停止檢查。

所以按上面這個範例的output就會是[1, 7]。

這個題目由於我們中途開始的left和right呈現一個固定距離的狀態，
只是隨著遞增滑動，所以這種固定窗口大小並且移動的方式，
一般稱為Sliding Window 。
(也可以視為Two Pointer在某種狀態的條件限定)

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

Java

Java的部分，參考了一位leetcode上的解法，
我們使用一個ArrayList來儲存我們的答案，
並且前期的檢查可以分別檢查s, p是否為null或空，
以及s的長度不能小於p的長度才行(不然要怎麼組對吧XD)

接著，我們使用一個長度26的一維陣列，
也可以使用ASCII長度256直接存，我們使用26的長度時，
index使用c-’a’即可對應。

初始化left, right, count後，迴圈條件設定為right還沒有超出去範圍。
迴圈內的判斷式則利用++和–的特性，
(放後面時會先進行完整個操作才遞增/遞減)，
其他的重點做法跟前面的描述是一樣的，
讀者可以再自己嘗試在紙上推導一次，會更加清楚。

Python

Python的部分我們示範使用字典來處理，
由於我們不想要每次在取值時都先檢查值有沒有存在的問題，
(不論是get或者是用[]取值，字典都不會有預設值)
所以這邊先行將26個字母的對應都置入0，後續就不需要再檢查了。 其它的部分跟Java的寫法基本相同，只是沒有++跟- -能用而已XD!

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

「時間/空間複雜度？」
(O(N)/O(1)，
空間複雜度如果要算上答案的部分的話則為O(N)，N為s的長度)

相似及延伸

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

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

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

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

從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學演算法 - 92 String (5)

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

0680. Valid Palindrome II (Easy)

Question

Given a non-empty string s, you may delete at most one character. Judge whether you can make it a palindrome.

Example 1

1
2


Input: "aba"
Output: True

Example 2

1
2
3


Input: "abca"
Output: True
Explanation: You could delete the character 'c'.

Note:

The string will only contain lowercase characters a-z. The maximum length of the string is 50000.

分析/解題

給定一個非空白的字串s，最多可以從當中刪除掉一個字元，
試判斷你能否讓這個字串變成一個回文。

回文(Palindrome)先前已經介紹過了 ，
就是符合「從尾到頭和從頭到尾看起來相同」即可，
所以它可以是像是abcba 的形式(中間有一個單獨的字元)，
或者是abba (成對兩兩相對)，這個概念在很多回文的題目都有用到，
讀者可以多加留意。

假設今天不能刪除任何字元的話，
問題就會直接變成檢查字串是否是回文，
那麼我們就可以直接設定兩個index i, j，
當中i從0開始遞增，j從s.length()-1(或len(s)-1)開始遞減 ，
依序對照對稱的位置檢查字元是否相等 即可。
(檢查到i, j交會都還兩兩對稱相等，則為回文)

好，那麼問題來了：
如果原先不是回文，需要刪掉一個字元才能變成回文呢？
該刪哪個？
有一句話說得好：
「解決不了問題，就解決產生問題的人」(大誤)，
既然我們只有一個可以刪的空間，
那麼就只能等到有無法對應到的狀況才處理。
舉例來說：
abcce ba -> a-a, b-b, 在c-e這個地方沒有對應到，
那麼有可能是c有問題，也有可能是e有問題，
所以我們可以分成刪掉c或刪掉e的狀況來檢查。
(因為實際上我們不會預先知道是誰有問題，也有可能都有問題)
也就是說，
當i, j沒辦法對應到時，我們可以選擇略過i 的位置上的字元，
或者略過j 的位置上的字元。(因為只是要檢查，所以不用真的作刪除)
略過i 的話，我們就要嘗試拿i+1來和j做對應 ；
略過j 的話，則是拿i和j-1做對應 。
剩下的狀況，就是按照前面一般檢查回文的流程依序檢查，
只要這兩條路其中一種 可以讓s變為回文，答案就會是true 。
那麼，如果又碰到沒對應到的呢？

那我們就只能說抱歉了XD~
我們已經用掉了一次刪除的機會，
後面再碰到對應不上的，當然就是不能成為回文囉！
所以這題看似會產生分支，其實只會產生一次而已，
因為我們只能刪一次而已，所以這題的時間複雜度並不高。

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

Java

Java的部分求方便起見，使用了toCharArray()，
我們將後續略過1個字元檢查的函式稱為isp(isPalindrome)，
當validPalindrome內的迴圈檢查到不符合的時候，
便呼叫isp來分支檢查；進入isp時，則只有所有剩下的字元兩兩對應，
才會回傳true，否則一定會回傳false。

Python

Python的部分，一樣不要忘記被用到的子函式要先宣告在前面，
其它和Java的解大同小異。

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

「時間/空間複雜度？」
(O(len(s))/O(1)，
由於最多分支就只有一次，
所以總體的複雜度還是跟字串長有關；
Java的部分因為偷懶使用toCharArray()，
所以空間複雜度也是O(len(s))，願意節省一點的話，
也可以用CharAt()來取得某個位置的字元。)

相似及延伸

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

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

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

從LeetCode學演算法 - 91 String (4)

Sun, 19 Apr 2020 00:00:00 +0800

0678. Valid Parenthesis String (Medium)

Question

Given a string containing only three types of characters: ‘(‘, ‘)’ and ‘*’, write a function to check whether this string is valid. We define the validity of a string by these rules:

Any left parenthesis '(' must have a corresponding right parenthesis ')'.
Any right parenthesis ')' must have a corresponding left parenthesis '('.
Left parenthesis '(' must go before the corresponding right parenthesis ')'.
'*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string.
An empty string is also valid.

Example 1

1
2


Input: "()"
Output: True

Example 2

1
2


Input: "(*)"
Output: True

Example 3

1
2


Input: "(*))"
Output: True

Note: The string size will be in the range [1, 100].

分析/解題

給定一個字串，當中僅含三種字元：’(’, ‘)’, ‘*’ (左括號，右括號及米字號)，試寫一個函式以檢查這個字串是否有效。
一個字串要符合以下的規則才算是有效的：

任一個左括號都要有一個對應的右括號
任一個右括號都要有一個對應的左括號
左括號必須出現在其對應的右括號之前
米字號(*)可以被視為單一個右括號、左括號、或空字串
空字串也是有效的

綜合上面的描述，我們可以知道像是：
‘)(’ -> 右括號還沒對應就出現在左括號前所以是False；
但像是‘(()()*)’ 就會是True，
仔細觀察可以發現，如果我們先不考慮米字號的部分，
從左到右，左括號出現的次數必然 >= 右括號出現的次數。
(因為要兩兩相對應，且右括號不能還沒對應到就出現在左括號之前)

所以，如果是沒有米字號的話，這題會相當簡單：
定義一個cnt(初始值為0)，由左至右，
每次碰到左括號則+1，右括號則-1 ，中間如果cnt變為負數，
則代表有右括號還沒對應到就出現了 ，則有效性是False ；
而遍歷整個字串到結尾時，
如果cnt變為0 的話則有效性是True (剛好所有括號兩兩對應)，
否則則為False (還有未對應到的括號)。

那麼，加上米字號的話該怎麼辦呢？
我們可以先將所有的米字號當成左括號來用 ，
由左至右檢查是否左括號足夠配對右括號完還有剩。
假設中途左括號不夠的話 ，肯定是False (因為加上米字號都不夠用)；
配對完剛好用完 -> ** True**(因為所有的米字號全拿來當左括號剛好OK)
配對完左括號還有剩 呢？
這時候我們應該從右至左， 換成將所有的米字號當成右括號來用，
換成檢查右括號足不足夠配對。
中途右括號不夠 -> False；
最後如果右括號數量足夠的話，則為True。

最後一段我們需要更仔細的考慮原因：
有沒有可能在由左至右留下來多出來的部分是左括號呢？
答案是否定的，因為如果是這樣的話，這些多出來的部分，
在反方向的時候會因為它們不是米字號，使得右括號的數量不夠用 ，
從而讓中途不足以配對 的狀況發生。
所以要嘛就是剛好完全配對 ，不然的話，就是剩下的全都是米字號 ，
這樣反向時才有辦法處理。

所以，當雙向都能夠順利滿足的時候，
只要將多出來的米字號視作空字串，就能使整個字串得以滿足有效性了！

依照上面的邏輯，我們可以進行 two pass 經過整個字串，
完成整個檢查工作，其空間複雜度為O(1)，時間複雜度為O(n)。
(n為字串的長度)

寫成程式碼如下。

Java

Java的部分，使用charAt()來取得特定index的字元，
並分別設定l跟r變數來計算。(要設成同一個cnt變數也行，自己歸零即可)

Python

Python的部分，這邊使用三元運算子處理。
此外，如果不想用index一個一個數的話，
用for c in s以及for c in reversed(s)也可以。

讀者可能會留意到註解裡有附註了lee215的one pass解法 ，
有興趣的可以再深入了解。具體的思路是記錄從左至右途中，
我們現在需要等待多少右括號來將一組括號完整；
cmax 是將所有碰到的*都當作是左括號 處理，
(也就是最大可能會產生尚未配對的左括號數量)
而cmin 是中間能消去配對的狀況就消去 。
(也就是最少一定要被配對完成的左括號數量)
按這個條件的話，cmax必然要一直>=0，
且cmin再結尾時要剛好是0才可以。

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

「時間/空間複雜度？」
(O(n)/O(1)，n為字串長度，空間不論是哪種方式都只需常數大小)

「如果不管空間複雜度，你能使用stack來解這題嗎？」
(可以做配對然後將成對的括號吐掉，
具體可以參考以下幾個discussion的解法。
Java: https://leetcode.com/problems/valid-parenthesis-string/discuss/107572/Java-using-2-stacks.-O(n)-space-and-time-complexity.

Python: https://leetcode.com/problems/valid-parenthesis-string/discuss/145228/python-using-stack-20ms-beats-100-probably-the-easiest-solution)

相似及延伸

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

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

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

從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學演算法 - 89 Hash Table (9)

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

1346. Check If N and Its Double Exist (Easy)

Question

Given an array arr of integers, check if there exist two integers N and M such that N is the double of M ( i.e. N = 2 * M).

More formally check if there exist two indices i and j such that :

i != j
0 <= i, j < arr.length
arr[i] == 2 * arr[j]

Example 1

1
2
3


Input: arr = [10,2,5,3]
Output: true
Explanation: N = 10 is the double of M = 5,that is, 10 = 2 * 5.

Example 2

1
2
3


Input: arr = [7,1,14,11]
Output: true
Explanation: N = 14 is the double of M = 7,that is, 14 = 2 * 7.

Example 3

1
2
3


Input: arr = [3,1,7,11]
Output: false
Explanation: In this case does not exist N and M, such that N = 2 * M.

Constraints

2 <= arr.length <= 500
-10^3 <= arr[i] <= 10^3

分析/解題

給定一組整數陣列，檢查當中是否存在兩個數N, M使得N = 2 * M。
(留意不可使用重複的index)

乍看之下有沒有覺得一陣熟悉？
沒錯，LeetCode最開始的第一題0001.Two Sum 的套路，
跟這個非常的相似，只不過從兩數相加等於固定數，
變成一個是另一個的兩倍。另一方面，我們只要將存在與否輸出，
所以不用記錄是什麼配對 。

那麼，按照先前的做法，我們需要做的事情是：

檢查現在的值有沒有符合之前的配對 ，若有，就直接回傳True即可。
(先前使用HashMap/Dictionary，這次可以使用HashSet/Set)
將當前的值對應到的配對 擺進Set當中，
由於當前的值x對應到之後的y有可能是 x = 2 * y 或 y = 2 * x，
所以我們要一次將兩種可能都放進去。
這樣子整個Set的總大小會變成2N，但不會影響檢查速度。
(因為HashSet/Set同樣是使用hash function的機制)
全部檢查完，仍然沒有符合的狀況，則回傳False。

依此，寫成程式碼如下：

Java

Java的部分，由於限制資料型態，
要留意處理除以2的部分，不能讓它自動做整數除法，
所以先檢查能否被2整除，可以的狀況才將其加入Set中 。
(使用HashSet ，檢查是否存在值使用contains() ，add() 來加入元素)

Python

Python的部分，由於/2直接會變成float，沒有特別被限制，
我們可以直接選擇加入而略過檢查的部分。
(反正小數點也不會被對到嘛XD)
(使用set() 開一個Set，in / not in 來檢查，並用update 來加入多個元素)
(先處理存在或先處理不存在的狀況都可以，看自己的喜好)

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

「時間/空間複雜度？」
(O(N)/O(N)，記得乘以2倍空間上是常數，不要講O(2N)歐XD)

相似及延伸

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

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

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

從LeetCode學演算法 - 88 Hash Table (8)

Fri, 21 Feb 2020 00:00:00 +0800

0575. Distribute Candies (Easy)

Question

Given an integer array with ** even** length, where different numbers in this array represent different ** kinds** of candies. Each number means one candy of the corresponding kind. You need to distribute these candies ** equally** in number to brother and sister. Return the maximum number of ** kinds** of candies the sister could gain.

Example 1

1
2
3
4
5
6


Input: candies = [1,1,2,2,3,3]
Output: 3
Explanation:
There are three different kinds of candies (1, 2 and 3), and two candies for each kind.
Optimal distribution: The sister has candies [1,2,3] and the brother has candies [1,2,3], too.
The sister has three different kinds of candies.

Example 2

1
2
3
4


Input: candies = [1,1,2,3]
Output: 2
Explanation: For example, the sister has candies [2,3] and the brother has candies [1,1].
The sister has two different kinds of candies, the brother has only one kind of candies.

Note:

The length of the given array is in the range [2, 10,000], and will be even.
The number in given array is in range [-100,000, 100,000].

分析/解題

給定一個偶數長度的整數陣列，當中不同的數字代表不同種類的糖果。
你要將糖果平分給一對兄妹(姐弟)，試算出當中姐姐/妹妹最多能拿到幾種不同種類的糖果。

什麼？題目也偏女生嗎(大誤)

題目內文基本上已經講得相當清楚了，
接下來問題就來到究竟我們要怎麼知道種類有多少種不同呢？
首先，如果每顆糖果都不同種類，女生最多能拿的也只有一半，
所以能拿到的種類上限會受限於candies的總數除以2 。
這個是大前提，我們先將它放在一邊。

那麼，如果種類總數比candies總數的一半小 呢？
簡單的想法就是發糖果的時候，每次遇到沒看過的種類，
就先記起來，藉此將整個種類數計數過一遍。
(或者你也可以想成每次看到沒看過的種類 要優先給女生，
給到女生拿滿或沒有新的種類 為止，兩個思考的模式和條件其實差不多。)

要記錄某種糖果的出現數量，
自然會想到HashTable/HashSet/Dictionary這類的東西，
但由於題目有提到種類是從-100000~100000，
所以其實我們可以開出一個長度為200001的陣列/串列，
直接當成Hash Table來使用，只要位移個100000即可。
(陣列/串列要從0開始)

因此，我們每次就可以從candies中依序取出一個數字，
將Hash Table內的對應位置進行遞增，再看看加完後是否剛好是1，
是1就代表這是新種類的糖果，所以要將種類的變數加1。

最後再回頭比較種類的數量，跟糖果的總數的一半，
選擇較小的進行回傳即可。

依此，寫成程式碼：

Java

Python的部分，我們也可以用set的方式取得不重複的種類，
再取其len()即可得到不重複的種類數量。

Python

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

「時間/空間複雜度？」
(O(N)/O(N)，如果將空間固定成題目給定的限制的話，
會固定要開出一個200001的空間，這個可以再直接用說的。)

相似及延伸

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

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

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

從LeetCode學演算法 - 87 Bitwise Operation (6)

Tue, 11 Feb 2020 00:00:00 +0800

1342. Number of Steps to Reduce a Number to Zero (Easy)

Question

Given a non-negative integer num, return the number of steps to reduce it to zero. If the current number is even, you have to divide it by 2, otherwise, you have to subtract 1 from it.

Example 1

1
2
3
4
5
6
7
8
9


Input: num = 14
Output: 6
Explanation:
Step 1) 14 is even; divide by 2 and obtain 7.
Step 2) 7 is odd; subtract 1 and obtain 6.
Step 3) 6 is even; divide by 2 and obtain 3.
Step 4) 3 is odd; subtract 1 and obtain 2.
Step 5) 2 is even; divide by 2 and obtain 1.
Step 6) 1 is odd; subtract 1 and obtain 0.

Example 2

1
2
3
4
5
6
7


Input: num = 8
Output: 4
Explanation:
Step 1) 8 is even; divide by 2 and obtain 4.
Step 2) 4 is even; divide by 2 and obtain 2.
Step 3) 2 is even; divide by 2 and obtain 1.
Step 4) 1 is odd; subtract 1 and obtain 0.

Example 3

1
2


Input: num = 123
Output: 12

Constraints

0 <= num <= 10^6

分析/解題

給定一個數字num，回傳其化簡至0所用的步驟數。
化簡的方法為：
若num此刻為偶數，將其除以2；若num此刻為奇數，將其減去1。

這題如果按照題目的條件一步一步走的話，
以二進位制來看，
我們會發現當尾端的bit是1時，就必須減去1並除以2 ，
也就是向右位移一個bit(這整件事情耗費了2步 )；
若bit是0時，則只需要除以2即可。

所以一個很簡單且直觀的寫法，就是利用迴圈，
當num還大於0時，檢查尾數的bit(可以用num & 1取得尾數是0或1)，
你可以用三元運算子 ，或者直接**(num & 1) + 1** 亦可，
請注意由於**&運算子的優先序較低** ，務必將num和1用括號包起來！
一路做到最後一個1，最後num等於0時就完成了。
(因為最後一個1不用再位移了，所以我們加總起來的步數最後要減去1)

這裡提供另一個想法：
當我們沒有限制計算bitCount的函式及轉換二進位/字串時，
可以推想到：

所有1都必須被消成0 (每個bit ‘1’會耗費1步)
要除以幾次2，端看最高位的1離個位數有多遠
(轉成二進位的總長減去1等於總共要除以2的次數)

所以我們得到： 答案 = num的bit ‘1’數量 + num的長度 - 1

依此，寫成程式碼如下：

Java

Java的部分，我們可以利用bitCount和toBinaryString來達到要求。
(一步一步算的也有列出參考解，讀者可以自己試看看)

Python

Python的部分，由於bin()轉二進位時，前面會多出**’0b’** ，
所以計算長度時會多出2，後面的減1就會變成需要改成減3 ，
請再留意。其他跟Java大同小異。

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

「時間/空間複雜度？」
(O(logN)/O(1)，但因為num最高就是10^6而已，如果你要宣稱num是constant，因此時間複雜度當成O(1)，個人覺得也是合理的。)

相似及延伸

Special Thanks suggestions/corrections from viewers:

From Cheng Rui Xie :
位元運算有很多有趣的 function 可以呼叫：
回傳以二為底的次方項：__lg(num)
回傳數字二進位後1的個數：__builtin_popcount(num)
只要取兩個的和即可且運算的時間＝O(1)
(這個想法的O(1)也是將num當限定大小看待。)

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

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

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

從LeetCode學演算法 - 86 Hash Table (7)

Wed, 05 Feb 2020 00:00:00 +0800

1331. Rank Transform of an Array (Easy)

Question

Given an array of integers arr, replace each element with its rank.

The rank represents how large the element is. The rank has the following rules:

Rank is an integer starting from 1.
The larger the element, the larger the rank. If two elements are equal, their rank must be the same.
Rank should be as small as possible.

Example 1

1
2
3


Input: arr = [40,10,20,30]
Output: [4,1,2,3]
Explanation: 40 is the largest element. 10 is the smallest. 20 is the second smallest. 30 is the third smallest.

Example 2

1
2
3


Input: arr = [100,100,100]
Output: [1,1,1]
Explanation: Same elements share the same rank.

Example 3

1
2


Input: arr = [37,12,28,9,100,56,80,5,12]
Output: [5,3,4,2,8,6,7,1,3]

Constraints

0 <= arr.length <= 10^9
-10^9 <= arr[i] <= 10^9

分析/解題

給定一個陣列，將其依照大小順序排出rank。
(由1開始，大小相同則相同rank，數字越大，其rank則越大)

由於我們需要按照大小相同來排定rank，所以顯然我們需要將其排序後，
才能知道誰應該在第幾個。對於這樣子的題目，
一般而言我們不需要自己實作排序的過程，除非面試官要求，
否則說明清楚你使用了排序即可；
不要忘記對於沒有特別安排的資料結構，
一般程式語言所使用的排序法基本上都是O(N log N) 的時間複雜度，
所以最後在問複雜度時記得納入考量。

既然我們需要取代原先的陣列，所以我們必須另外增加一組記憶體空間，
用來存放排序的狀態。存放好以後，應該要怎麼去記錄呢？
由於相同的數字要擁有相同的rank，對於存取和讀出擁有最快的複雜度的，
就是Hash Table了！我們可以先檢查當下該數字是否已經放入對應 ，
若還沒有放入對應，則需要寫入(number, rank)的對應。
這時候rank是多少呢？應該要將已經置入的配對數量+1 來計算。
(因為代表現在已經給到多少數量的rank了)
都放完以後，再依序將陣列中的每個值作為key，
來從Hash Table得到其對應的rank(value)，再覆蓋掉即可。

依此，寫成程式碼：

Java

Java在增加新的記憶體儲存一份陣列時，可以使用Arrays.copyOf() 。
(後面加length可以指定複製的總長度)
使用HashMap來進行存放，並且用putIfAbsent(key, value) ，
僅在不存在對應時才進行寫入。
最後再利用HashMap.get()來一一取得對應rank並寫入。

Python

Python的部分，我們可以直接使用sorted(arr)取得一份新的串列。
也可以使用list.copy() 或者arr[:] 的方式來取得複製的串列。
請注意 “sArr = arr” 和 “sArr = arr[:]“意義上是不同的，
後者才是完整複製一份arr的串列 ，前者是新增了一個變數名稱，
但其記憶體位址依舊是指向到arr的！(也就是後者並沒有進行複製)

Java中使用HashMap，在Python中則用Dictionary達到，
而對應到putIfAbsent的函式則是setdefault 。
(也可以用if ** a not in rk: rk[a] = len(rk) + 1**)

最後，使用map函式來一一得到arr對應到rk.get的內容。
(即每次從arr依序取出元素再代入到rk.get內)

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

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

相似及延伸

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

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

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

從LeetCode學演算法 - 85 String (3)

Thu, 30 Jan 2020 00:00:00 +0800

1332. Remove Palindromic Subsequences (Easy)

寫在前面

Question

Given a string s consisting only of letters 'a' and 'b'. In a single step you can remove one palindromic subsequence from s.

Return the minimum number of steps to make the given string empty.

A string is a subsequence of a given string, if it is generated by deleting some characters of a given string without changing its order.

A string is called palindrome if is one that reads the same backward as well as forward.

Example 1

1
2
3


Input: s = "ababa"
Output: 1
Explanation: String is already palindrome

Example 2

1
2
3
4


Input: s = "abb"
Output: 2
Explanation: "abb" -> "bb" -> "".
Remove palindromic subsequence "a" then "bb".

Example 3

1
2
3
4


Input: s = "baabb"
Output: 2
Explanation: "baabb" -> "b" -> "".
Remove palindromic subsequence "baab" then "b".

Example 4

1
2


Input: s = ""
Output: 0

Constraints

0 <= s.length <= 1000
s only consists of letters ‘a’ and ‘b’

分析/解題

給定一個字串，當中僅由’a’或’b’的字母所構成，每次你可以從中移除一個palindrome subsequence. 試回傳將該字串刪成空字串所需的最小步數。

我們先前有講過subsequence的定義，可以參照之前的題目。
所以每次要移除掉一個subsequence且必須符合palindrome的條件，
乍看之下似乎不容易。
但選這題的目的就是要告訴大家，有時候事情並沒有想像中那麼複雜，
靜下心來好好推敲，可能可以找到適合的規律，
不要急著找通解，先試著去用上所有已知的條件 看看才對！

我們知道subsequence就是按照排列的先後順序取就可以了，
但palindrome(回文) 則必須取出來從頭到尾和從尾到頭一致才行。

我們先考慮最簡單的部分，再慢慢往下推。
1. 當字串是空白的時候：
不需操作 即可達到條件，所以總step為0。
2. 當字串本身就是palindrome：
把整個字串做為subsequence移除，所以總step為1。

接下來是最重要的部分，
如果字串本身不是palindrome的話，
要怎麼樣才會移除一個palindrome sequence後，
可以用最小步數化簡呢？
由於s僅僅由’a’和’b’所組成 ，
所以我們可以考慮直接移去全部的’a’或全部的’b’，
由於全部都是’a’或全部都是’b’也是一種palindrome，
所以符合前面移除的規則；
而剩下來的就全部都是另外一種字元，
同樣也構成palindrome。
因此，最多只要2個step，就能全數移完。

(想一下，如果今天是有N種不同的字元構成s，
最多就會需要N個step，但這只是上限而已，而不是minimum steps。)

有興趣寫更細的話，可以用two pointer來寫這題的檢查palindrome的部分，
這裡就直接用簡單的操作處理。

Java

Java的部分，操作reverse 要使用StringBuilder 來處理，
處理完以後，再轉回String。

Python

Python的部分更精簡，使用**[::-1]** 即可表達從尾到頭 的部分。

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

「時間/空間複雜度？」
(O(N)/O(N)，若願意一個一個字元比較的話，
空間複雜度也可以降到O(1)，也就是用簡單的two pointer處理即可)

相似及延伸

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學演算法 - 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學演算法 - 82 Linked List (10)

Thu, 09 Jan 2020 00:00:00 +0800

0086. Partition List (Medium)

寫在前面

再過兩天就是投票日了，懇請各位讀者們，
不論支持誰，都要好好地去了解候選人們及政黨的政見，
在1/11投下您寶貴的一票。**

筆者在這裡提醒大家去思考一下：
程式的世界很單純，很多東西不是True就是False，
而一個按照正常邏輯運行的程式，最終該呈現怎樣的結果，
大抵都是可以預期的。

想像一下，如果一個同事常常遲到早退，罔顧專案進度，
讓大家必須要幫忙收拾爛攤子；
話說的很滿，遇到事情卻推拖閃躲，
顧左右而言他的話，相信這樣的人，
我們不會希望其成為自己的頂頭上司。

既然如此，我們會希望這種人成為自己的大老闆嗎？

運用簡單的邏輯思考，相信聰明的各位都能得到正確答案。
儘管這種人的餅畫得再大再漂亮，我們知道，
那都不是真的，因為我們難以相信一個沒有誠信的人能夠說到做到。

Question

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

Example:

1
2


Input: head = 1->4->3->2->5->2, x = 3
Output: 1->2->2->4->3->5

分析/解題

給定一個Linked List和一個值x，使用x來將所有節點進行分段，
令較x小的節點排在≥x的分段位置的前面。
注意在分段時，同時也要保有原先兩段的節點順序。

這題其實有點像是之前我們在講Merge Two Sorted Lists的感覺，
為了要能夠讓兩個段落分開且照順序，
我們應該要有兩個做為頭的dummy節點 ，稱為d1/d2。
所有小於x的部分都接到d1，反之則接到d2。
那麼實際上來說，我們只要將整個List遍歷過一遍，
就可以依照實際和x之間的比較，來決定要將這次看到的節點 ，
必須要接到d1還是d2上面。

由於最後我們需要將兩段接起來，
所以d1/d2保持不動的狀況下，
我們需要另一個變數來儲存現在遍歷的部份走到的節點，
先稱其為ite1/ite2，所以ite1/ite2起始分別是d1/d2。

那麼，按照邏輯來說，我們可以能會想到下面的寫法：

1
2
3
4


if (head.val < x) {
 　ite1.next = head;
 　ite1 = ite1.next;
}

但這麼考慮欠缺了一個條件：
當我們選定ite1.next = head時，head裡面還藏有它的next的資訊 ，
造成你以為是只有納入head，殊不知head.next也被隱含進去了 ！
要解決這個問題，我們可以將ite1.next重新設為null 。
問題來了，這一設為null，反而變成head的資訊就消失了 ，
同時head.next的資訊也消失了 。

所以，我們要一開始用一個nxt的ListNode來記錄head.next，
接下來兩種狀況下的next相關操作做完以後，
最後再讓head接上先前儲存的nxt。

依此，寫成程式碼。

Java

Java的部分，我們先用直觀的方式來處理，
所以包含前面的處理都完整的話，
我們應該能得到d1及其後面的一組(直到ite1)、
d2及其後面的另一組(直到ite2)，
若其中一個沒有接上任何節點的話，
可以直接吐出d1.next/d2.next 的狀況。
若兩者皆有，則先將第一排的結尾接給第二排的開頭 ，
最後回傳d1.next即可。

同時，運用陣列可以更輕鬆地化簡邏輯，
這裡將改善過後的版本放在註解欄中。

Python

就Python的部分而言，只要使用跟前述相近的處理方式，
最後再回傳d1.next 即可。

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

「時間/空間複雜度？」
(O(N)/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學演算法 - 80 Linked List (9)

Sat, 04 Jan 2020 00:00:00 +0800

0082. Remove Duplicates from Sorted List II (Medium)

Question

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

Example 1

1
2


Input: 1->2->3->3->4->4->5
Output: 1->2->5

Example 2

1
2


Input: 1->1->1->2->3
Output: 2->3

分析/解題

給定一個排序好的鏈結串列，將擁有重複的數字的節點全數刪去，
只保留原先在串列上相異的數字。

我們之前就嘗試過從鏈結串列刪去節點 的題目了，
只是今天這組更激進一點XD
原本是刪到剩一個即可，現在變成要將重複的全都刪掉，
那麼，該怎麼辦呢？

由於有可能刪到第一個，一般來說這種狀況，
習慣上會開出一個dummy node做為不會變動的節點參照，
我們先將其叫做dum，簡單將dum的next連接至head即可。

接下來要處理的是：我們要記得數值一致的節點群前面的那一個節點 ，
這樣刪去的時候才能將前後重新連接上。
因此，我們需要一個節點記錄，這裡將它叫做pre ；
另一個節點則做為迭代用，記錄現在所在的位置，將其稱做cur ，且就位置關係來說，pre的next應該會是cur 。
開始時pre的起始點 應該是dum ，這樣cur 會從head 開始，
當cur還沒走到底的時候要進行迴圈遍歷 。
另外在內部每次要迴圈檢查 ：
1. cur是否有下一個節點
且
2. cur的下一個節點和自己的值是否相等
(和先前一樣，這個迴圈用來略過所有重複值的節點 )

當走完以後有可能是

cur還沒到底(有值) =>
pre的next就是cur ，所以再往下找的話要將pre設為pre.next
cur已經碰到底了 (cur.next == null) =>
將pre.next指向null (pre.next = cur.next)

最後，別忘了將cur往下走(cur = cur.next) 。
最終做完的時候，由於先前我們將dum.next設定成head ，
中間連接有變動的話，會被pre的操作給連接過去，
所以新的head的位置不管有無更動，
應該還是位於dum.next上。
(因為pre一開始等於dum，pre.next一開始會連動到dum.next )

依此，寫成程式碼。

Java

Java的部分不要忘記該new的dum，
剩下就只有判斷null的時候不像Python可以直接用if not，
其他大多大同小異；Python的邏輯是一致的，就不再贅述說明了。

Python

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

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

相似及延伸

這題理論上也可以用遞迴的方法解，有興趣的讀者可以嘗試看看。

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

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

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

從LeetCode學演算法 - 79 Hash Table (6)

Tue, 31 Dec 2019 00:00:00 +0800

0383. Ransom Note (Easy)

Question

Given an arbitrary ransom note string and another string containing letters from all the magazines, write a function that will return true if the ransom note can be constructed from the magazines; otherwise, it will return false.

Each letter in the magazine string can only be used once in your ransom note.

Note:
You may assume that both strings contain only lowercase letters.

1
2
3


canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true

分析/解題

繼時空旅人買賣股票( 0121 ) 及闖空門教學( 0198 , ** 0213**** )後，
我們這次要來寫勒索信** 啦！
有沒有覺得這一系列很實用？(大誤)

勒索信的構成很簡單，就是每個從雜誌上的字，
剪下來以後只能用一次 ，要用這些字去組出勒索信的內容。

所以這個就很簡單就可以處理啦！
我們可以先將所有雜誌上的字分門別類，
這邊還很貼心告訴我們全部只有小寫字母 ，
所以分成a-z即可，計算總共有的素材數量。

接下來用勒索信上的每個字來去檢驗，
每次都扣除掉對應的字母的計數，中間一旦有素材不夠，
表示已經沒辦法完成信件，即可回傳false，
否則整個迴圈完成的話表示可構成勒索信，則回傳true。

依此可以寫成程式碼。

Java

Java的部分，其實如要扣掉一些條件，
可以先檢查兩者的長度，magazine長度比較小時肯定無法完成勒索信。
由於題目的給定，我們可以不用HashMap，
僅用一個長度26的陣列來處理，index則用c - ‘a’ 來計算，
留意使用–table[c-‘a’]時由於先進行遞減 ，所以檢查條件是小於0。

Python

Python的部分，可以用dictionary作到類似的事情。
(list也可以，不過要自行用ord來轉換，和Java不同)
當然，我們也可以使用Counter或count來做更迅速的計算。
(註解提供了另外兩種leetcode上別人的解法)

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

「時間/空間複雜度？」
(O(len(ransomNote) + len(magazine))/O(1))
(空間複雜度因為依題目提示，key值固定最多26，
所以不因字串長而改變。)

「如果要求含大小寫/大小寫可混用/含標點符號等狀況呢？」
(依照所需使用HashMap或Dictionary，
並將共用的部分利用他們相減的距離歸到同類)
(在ASCII Code上，‘a’-’A’ == 32 )

相似及延伸

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

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

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

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

從LeetCode學演算法 - 78 Two Pointer (4) / Binary Search (5)

Sat, 28 Dec 2019 00:00:00 +0800

0392. Is Subsequence (Easy)

Question

Given a string s and a string ** t**, check if ** s** is a subsequence of ** t**.

You may assume that there are only lower case English letters in both s and ** t**. ** t** is potentially a very long (length ~= 500,000) string, and ** s** is a short string (<=100).

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ace" is a subsequence of "abcde" while "aec" is not).

Example 1

s = "abc", ** t** = "ahbgdc"

Return true.

Example 2

s = "axc", ** t** = "ahbgdc"

Return false.

Follow up:
If there are lots of incoming S, say S1, S2, … , Sk where k >= 1B, and you want to check one by one to see if T has its subsequence. In this scenario, how would you change your code?

分析/解題

給定一個字串s跟一個字串t，
檢查s是否是t的subsequence(子序列)。可以假設s是一個短字串(長度≤100)且t是一個長字串(長度約500000)。

從原字串t刪除字母(也可以完全不刪)，
並保有原字串的相對位置，所構成的新字串，即為t的子序列。
後面有一個Follow up問的是，
假設這個函式會拿來檢查很多次(k次)不同的S的話(例如會處理1billion次)，
要怎麼實作這個函式比較好？

首先我們先來看看比較直觀的解法。
我們先舉個例子，如果有一個s是”abcde”的話，
s要是t的子序列的條件，就是我們要能在t當中，
依序得到 a~e這五個字母。
那麼第一個我們一定要先找a，假設從t中找到一個a以後，
按照順序的話，這個a以前的bcde就都不能用了 ！
(因為順序就不對啦XD)
同樣的，找到b以後b以前的cde也不能用，以此類推。
因此，我們要保持能確定找到可能性的方式，
就是每一次在t中都取這個順序最前面出現的字母 。

在s當中使用一個記錄index用的i ，
從頭開始找t中的s[i] 在哪，記錄為pre 。
每次找到以後，將i遞增 ，
接下來從t的pre+1處 開始尋找下一個s[i]的位置。
如果找不到的話呢？就表示沒辦法成立，應該回傳false，
否則當全部的s的字母都能找到對應的位置的話，
則代表s可以作為t的子序列。

上面描述這樣的方法，我們使用了兩個索引值，
來記錄s和t當前查找到的位置，
所以這個解法可以視為two pointer手段的一種操作。

同時，我們前面在解的時候，
每次都盡可能 去找最前面出現 的第一個s[i]，
這種概念的想法，僅在特定的題目適用。
當符合在每一個當前狀況都取當前最佳的狀況 ，
全局就會是最佳 的時候，我們就在局部的區段盡可能貪婪。
這樣子的策略被稱為貪婪演算法 (Greedy Algorithm)

請留意到，這種方式往往在很多情況下會失效，
所以在使用前請詳閱公開說明書(X)。
(開玩笑的XD，應該是使用前請確認局部最佳能推導至全局最佳 。)

這麼做基本上要掃過s跟t的字串，所以時間會是O(len(s)+len(t))，
或者說當t遠大於s的時候可以視為O(len(t))。

那麼如果搭配Follow up的條件呢？
如果有k次不同的s的檢查，
就上面的解法而言，每次仍然要各掃過一遍s跟t，
時間複雜度是O(k*(len(s)+len(t))) ，顯然當t很大的時候，
掃過k次是很不理想的，我們會希望能夠化簡一點這個部分。

那要怎麼作呢？這邊引用shuoshankou 在leetcode上的解，
我們可以先針對t建立一個HashMap ，當中的key是t上的字母 ，
而value是這個字母出現在t上面的indices (使用ArrayList來儲存)。
這個儲存過程會是O(len(t)) 。

接著要查找的過程就會變成針對s[i]來搜尋HashMap上的index，
且限定這個index要剛好是在i之後的第一個出現的位置。有沒有覺得很眼熟？沒錯， 這不就是Binary Search嗎？
我們在處理的，就跟對於某個陣列，
搜尋一個值在哪裡(或應插入在哪裡)的問題一樣！

所以就一般來說，搜尋需求是log(N)，
如果前後拆成常數的單位可以忽略不記，
所以對於k個s搜尋所需會是O(k*len(s) * log(len(t))) ，
當k大到一定程度的時候，顯然只作一次O(len(t))先建立對應表，
讓後面的搜尋相關的t的複雜度都變成對數量級 是相當划算的。

注意，以這題的測試資料而言，Binary Search速度並不會跑起來比較漂亮，
原因是測試資料的總數可能相對有限，並不像Follow up假想那樣，
所以前面吃下一整個建立HashMap的時間就會顯得拖累。

Java

Java的部分可以先檢查s和t的長度來避免一些根本不需要跑的狀況，
同時使用indexOf 來搜尋每次的si第一個出現的位置。
(搜尋不到的話indexOf會回傳-1 )

Binary Search的寫法則如註解處，
先建立起HashMap並掃過整個t並依序塞入，
後面再使用getNextIndex來寫Binary Search。
其實如果要能像Follow up那樣反覆利用的話，
應該要能將t的輸入抽離開來，題目的要求和預設寫法並沒有考慮這點，
會導致每次都需要對t建立一個HashMap。

如果要重複利用的話，應該要給定成class Solution的變數，
且建立時能先給入t才對。

Python

Python的部分則使用index 來進行查找，
請留意查找不到的話會產生exception，
所以這邊是使用try/except 來處理的。

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

「時間/空間複雜度？」
(請見上面詳述。)

相似及延伸

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

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

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

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(接下來快要漲成下個價格啦XD)： https://hiskio.com/courses/319?promo_code=VEQZV7E

從LeetCode學演算法 - 77 String (2)

Tue, 24 Dec 2019 00:00:00 +0800

1071. Greatest Common Divisor of Strings (Easy)

Question

For strings S and T, we say “T divides S” if and only if S = T + ... + T (T concatenated with itself 1 or more times)

Return the largest string X such that X divides str1 and X divides str2.

Example 1

1
2


Input: str1 = "ABCABC", str2 = "ABC"
Output: "ABC"

Example 2

1
2


Input: str1 = "ABABAB", str2 = "ABAB"
Output: "AB"

Example 3

1
2


Input: str1 = "LEET", str2 = "CODE"
Output: ""

Note:

1 <= str1.length <= 1000
1 <= str2.length <= 1000
str1[i] and str2[i] are English uppercase letters.

分析/解題

給定兩字串，找出能「除盡」這兩個字串的最長字串X。
題目已經給定的非常明顯了就是在求gcd(最大公因數)，
因此，拿出小學就教過的輾轉相除法即可。
(要看起來厲害一點的話，也可以叫歐幾里得算法Euclidean algorithm)

輾轉相除法告訴我們說，兩個數的最大公因數，
就是不斷將大的除以小的，取出餘數替代之，直到能夠整除為止。
於是這邊變成字串時，我們的除就會比較麻煩一點。
為求簡單起見，我們可以固定將第一個字串選擇放比較長的 ，
如果發現相反 的話，則將兩者進行對調 。

所以就可以分成以下的步驟：

取兩字串長l1, l2，若l1 < l2 則呼叫遞迴將str1, str2交換
若str1和str2完全一樣，則回傳str1
若str1的前面的部分 和str2 一樣，則將str1扣除掉該部份 以後，
呼叫遞迴傳入繼續計算。
(因為我們操作字串的除只能一組一組扣掉 )
否則就回傳空字串 (因為不一樣的話代表完全沒有共同的字串，
跟數字的最大公因數是1概念一樣)

Java

Java的部分，字串相等請使用equals來比較，
而前面的部分一樣可以用startsWith函式，
並留意空字串要用雙引號，不能用單引號(因為單引號是char)。

Python

Python的部分，使用==和串列取值的方式，
可以簡單達成我們所需要的操作。

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

「時間/空間複雜度？」
(O(l1+l2)/O(l1+l2)，由於每階段會固定消去最小單位的長度，
所以最差的狀況就是全部都消去，也就做了兩字串長度的消去的動作，
但中間未考慮比較是否相等的狀況。
空間複雜度的部分，
Java的substring和Python的切list的方式都會產生新的單位，
理論上仍然最少會佔用到完整的l1+l2單位空間)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 76 Hash Table (5)

Sat, 21 Dec 2019 00:00:00 +0800

0290. Word Pattern (Easy)

Question

Given a pattern and a string str, find if str follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a ** non-empty** word in str.

Example 1

1
2


Input: pattern = "abba", str = "dog cat cat dog"
Output: true

Example 2

1
2


Input:pattern = "abba", str = "dog cat cat fish"
Output: false

Example 3

1
2


Input: pattern = "aaaa", str = "dog cat cat dog"
Output: false

Example 4

1
2


Input: pattern = "abba", str = "dog dog dog dog"
Output: false

Notes:
You may assume pattern contains only lowercase letters, and str contains lowercase letters that may be separated by a single space.

分析/解題

給定一個pattern和一個字串str，檢查str是否遵循pattern的模式。
簡單來說，就是str的每一段字的重複或不重複模式，
都要能被pattern裡的"abba"這樣的每個字母去對應 的方式來表達出來。
看到這邊，有沒有覺得很像LeetCode最開始的那個Two Sum?
我們每次想要將一個pattern內的字母去對應到str的一段字串，
而重複的狀況應該要有相同的對應。

那不就是key-value的對應方式嗎?

所以想法就很簡單了：

建立一個Hash Table名為map(Java的HashMap或Python的Dictionary)
先檢查pattern的段數和str的段數是否相同 ，若否則直接回傳false
依序按段取出 pattern和對應的str的分段，檢查以下性質：
(下面pattern均作為key，str的分段均作為value)
若key不存在且value不存在->將**(key, value)** 放入map
若key不存在且value存在->回傳false (** 表示別人先對應到它了**)
若key存在且value不對->回傳false (** 表示該key已經被占用掉**)

請留意後面的兩個false的狀況，
我們可以對照Example 2 跟Example 3 ，
因為有些可能是前面某個key或某個value已經達成對應關係了，
後續如果出現對不上的狀況，就表示整個對應關係無法成立囉！

依此，寫成程式碼如下：

Java

Java的部分，
可以使用HashMap的containsKey/containsValue/get，
以及字串的split/equals函式，來協助判斷的工作。

Python

Python方面，同樣有split可以使用，
其他使用dict的in/not in及values()等簡單的存取方式即可。

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

「時間/空間複雜度？」
(O(N)/O(N)，準確來說應該是看len(str)來決定N)

「如果限制使用split呢？」
(進行依字元掃瞄過整個陣列，碰到空白再輸出成字串(list或arraylist)即可)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 75 Array (14)

Thu, 19 Dec 2019 00:00:00 +0800

0289. Game of Life (Medium)

Question

According to the Wikipedia’s article: “The Game of Life , also known simply as Life , is a cellular automaton devised by the British mathematician John Horton Conway in 1970.”

Given a board with m by n cells, each cell has an initial state live (1) or dead (0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):

Any live cell with fewer than two live neighbors dies, as if caused by under-population.
Any live cell with two or three live neighbors lives on to the next generation.
Any live cell with more than three live neighbors dies, as if by over-population..
Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.

Write a function to compute the next state (after one update) of the board given its current state. The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously.

Example:

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


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

Follow up :

Could you solve it in-place? Remember that the board needs to be updated at the same time: You cannot update some cells first and then use their updated values to update other cells.
In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches the border of the array. How would you address these problems?

分析/解題

這題是典型的生命遊戲 題目。生命遊戲一般是透過2D的棋盤式的格子，
上面以1代表活著的細胞，0代表死去的細胞，
透過設定好的規則來觀察其演化的狀況。
設定這些東西的目的最初應該是為了要產生模擬圖靈機，
後來發現一些有趣的現象，比如能穩定周期性的圖案像是滑翔機、
機關槍等等，也有的看似是有周期的但最後會消滅的狀況，
總之某種層面上有點像是可以拿來模擬族群聚落的演進等狀態就是了，
有興趣的讀者可以再看看相關的資料。

回到題目，基本上生命遊戲裡面的每個單位，
在下一個時間點要嘛是1(活著)，不然就是0(死去)。
典型的規則是看其九宮格的周圍：

如果原本自己是1(活著) 的話，只有周圍有2~3個 鄰居(活著的細胞)，
下一刻自己才會繼續存活，否則就會死去。
(只有1個鄰居以下會因人口過少而死，
而超過3個鄰居會因人口過多而死)
如果原本自己是0(死去) 的話，只有周圍恰好有3個鄰居 ，
下一刻自己會變成1(活著) (視作被繁衍出來的後代)

Follow up有兩點，1是詢問是否能in-place解題，
2是棋盤是無窮大的話該怎麼描述問題。

這個題目其實看懂定義的話並不困難，只是繁瑣而已。
首先有一個重點是：更新的時候必須要一口氣一起更新，
因為每個細胞的變化都需要看周圍的細胞，不同時改變的話，
結果就有可能會出錯。這邊有兩種考慮方式：

開一個跟board一樣大的二維陣列(串列)，
記錄下一刻的狀態，最後再進行替換。
想辦法用原有的board 來進行記錄。
我們這邊因為希望達成in-place，所以自然選擇2。
還記得之前我們提過的word search嗎？
我們利用了沒有被用到的位元做為遮罩進行XOR，
使得visited的資訊用原先的棋盤就可以做記錄了；
這邊比之前還要簡單，我們只要拿2的1次方位 來記錄即可，
因為board一開始只用到1和0而已 ，所以判斷完以後，
如果它會變成存活的狀態，則將該值加上2，
死去的話則不用額外動作。
這樣一來，最後我們只要將整個board除以2取整數 ，
就可以得到新的棋盤狀態了！
中間在進行周圍八格的判斷時，不要忘記要除以2取餘數 。

所以總體會像這樣：

遍歷整個棋盤做check
check 函式中:
a. 依次檢查是否存活(alive)，並加總周圍八格的存活細胞數量
b. 若本身當前存活 -> 檢查** 周圍存活數是 2或3時，將自己加上2**
c. 否則(本身死亡 )，若周圍存活數 是3 ，將自己加上2
alive 函式中:
a. 若超出邊界則回傳0
b. 否則回傳該格數值除以2的餘數
全數檢查完後呼叫next 函式更新狀態
next 函式: 遍歷整個棋盤，將值除以2取整數 。

一般典型的話理論上邊界應該要互相連接，
(走到最底會通往最上面，走到最右邊會連通最左邊)
但我們這邊就不考慮這個問題了。

Java

Java的部分，計算八方向我們使用了一個d(direction)的二維陣列來記錄，
除了邊界條件以外沒有特別需要注意的地方。

Python

Python的部分，d的方面我們可以用list comprehension ，
扣掉自身(0, 0)來建構。除了留意子函式的定義，
要在拿來做為global的部分後面(才能拿來用) ，
在呼叫之前(因為是腳本執行) 以外，
其他沒有什麼特別的地方XD

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

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

「如果棋盤無限大？」
(那應該要找出一個pattern來表示它才對，
不可能真的開出一個無限大的棋盤)

「首尾相接的話？」
(Python直接按照負數index會發生的事情處理，
Java要自己計算過界的狀況)

「還能簡化嗎？」
(理論上相鄰的兩個點會共用到4個鄰居點 ，
應該可以再節省一點計算時間，但時間複雜度是一樣的 )

相似及延伸

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

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

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

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
第二階段Medium優惠(額滿即截止)： https://hiskio.com/courses/319?promo_code=VEQZV7E

從LeetCode學演算法 - 74 Linked List (8)

Mon, 16 Dec 2019 00:00:00 +0800

0234. Palindrome Linked List (Easy)

Question

Given a singly linked list, determine if it is a palindrome.

Example 1

1
2


Input: 1->2
Output: false

Example 2

1
2


Input: 1->2->2->1
Output: true

Follow up:
Could you do it in O(n) time and O(1) space?

分析/解題

給定一個單向鏈結串列，試判斷它是否是palindrome(回文)。
所謂palindrome就是從尾到頭和從頭到尾看起來會相同 。
在這題當中，由於我們的結構是Linked List，無法很輕鬆的到達尾端，
也無法輕易的回頭，那麼該怎麼辦呢？
要判斷回文有一個重點，就是從中間切開來兩邊是對稱的 。
因此，我們可以設定fast/slow的兩個pointer，
以之前常用的技巧，每次fast走兩步，slow走一步 ；
讓fast走到底時，slow剛好走到一半 。
節點總數是偶數時，切開來的第二段應該是從slow的下一個節點 開始，
所以當fast不是NIL 時，我們應該讓slow多走一步 。
(例如總共有10個節點，按上面的方法走完，
fast會在10，slow會在5，但第二段應該從6開始，所以slow要往下走一步)

所以比較「從slow到串列尾端的反轉串列 」及
「從head往下的對應節點 」，即可檢驗串列是否為回文。

那麼要怎麼反轉串列呢？上上篇文章 不就是嗎XD
我們可以用之前的reverse函數進行反轉，
反轉後再對兩個串列一一進行比較，
一旦值不相等即回傳false。

依此，寫成程式碼如下：

Java

我們也可以使用另一種思路，
先多設定一個rev節點，
在slow/fast行進時，將slow經過節點進行反轉連接，
這樣在走完的時候，讓rev 變成前半段反轉後的串列的開頭 ，
而slow 則是後半段的串列的開頭 。最後同樣一個一個檢查，
即可判斷整個串列是否是回文。

Python

務必請留意這麼做的缺點是整個串列就被我們拆成兩半了 ，
如果不是要求空間複雜度是O(1)的話，
用別的資料結構輔助去存入一半的節點，能夠保有原先的結構。

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

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

「如果不計較空間複雜度，有沒有辦法保留原先的linked list呢？」
(Python的話可以使用list來做兩邊儲存比較的動作，
或者要使用stack來置入前半段的節點，後面pop出來做比較也可以)

相似及延伸

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

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

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

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium限額5名優惠(額滿即截止)： https://hiskio.com/courses/319?promo_code=VE9NJQE

問卷抽書＆取得上架通知： https://pse.is/MS2J2
如果你對線上課程不放心，
也可以先來12/17(二) 我在天瓏分享的講座看看！
講座連結： https://pse.is/JS3LJ

從LeetCode學演算法 - 73 Trie (2)

Mon, 09 Dec 2019 00:00:00 +0800

0208. Implement Trie (Prefix Tree) (Medium)

Question

Implement a trie with insert, search, and startsWith methods.

Example:

1

Trie trie = new Trie();

1
2
3
4
5
6


trie.insert("apple");
trie.search("apple"); // returns true
trie.search("app"); // returns false
trie.startsWith("app"); // returns true
trie.insert("app");
trie.search("app"); // returns true

Note:

You may assume that all inputs are consist of lowercase letters a-z.
All inputs are guaranteed to be non-empty strings.

分析/解題

試實作一個trie，當中包含插入，搜尋，是否含前綴判斷的函式。

我們很早以前講過一題使用Trie來進行解題的問題，這次再來複習一下XD
Trie跟樹非常相像，通常用來作字典搜尋，所以又叫做字典樹 。
在實作Trie的時候，我們通常會實作TrieNode作為每個節點的單位，
這當中每個節點主要會記錄兩件事：
1. 這個節點是否到這邊構成一個字
因為可能是經過的節點，比如word -> w, o, r, d，
假設我們插入了一個這樣的字，那麼總共會生成4個節點，
但只有d 這邊應該被判定到此構成一個字 。
所以就這題而言，
我們可以使用一個boolean值(True/False)來儲存這個狀態，
也就是下面程式碼中看到的isWord 。

2. 這個節點往下連接的節點群
以這題來說，由於僅限定a到z，所以我們其實可以用長度為26的節點陣列，
來表達下一個連結。當節點不存在時，表該路徑不存在/尚未生成，
在Java中我們用一個TrieNode[] next來儲存。

但對Python而言，因為語言特性，
我們無法在TrieNode內直接宣告TrieNode(會報錯)，
所以會選擇使用一個字典進行記錄。

最後，留意到由於我們每次進行路徑移動時，
所使用的index要嘛是該字元減去’a’ (Java)，
要嘛乾脆是當前的字元 (Python)，
所以我們不需要額外耗費空間記錄字元值 。
此外，若題目有要求記錄被存入的相同字的次數，
就需要額外的count變數來儲存。(另外可以將isWord改成count用作判斷)

所以整個的思路就會很明顯了：

定義一個TrieNode class，當中有isWord跟next。
在Trie中，初始化時宣告一個根節點root的TrieNode。
insert: 節點從root處開始查找，沿著每個字元連接到下一個TrieNode，
並且如果節點尚未建立就將其建立，走到底後，將isWord設為true。
search: 一樣從root開始，沿著每個字元往下走，
若碰到沒有建立則可直接回傳false。
當走到該節點以後，依據isWord的狀態來判斷要回傳true or false。
startWith: 由於只要路過即可，所以前面和search一樣，
但最後只要能走到，即可回傳true。

Java

Java的部分留意到使用了c - ‘a’的方式來取得index，
因為char是可以當作正整數來相減的。
TrieNode的建構式理論上可省略，
但直接先寫可以降低編譯器還要幫你生成的麻煩，
Submit實測上似乎平均會快一點點XD
(沒有大量測試，有興趣的讀者可再比較看看)
在最開頭的TrieNode代表著根，但它本身並不代表任何字元 ，
請留意這點。

Python

Python的部分額外提供了一個LeetCode上找到解答較快的版本，
是使用#的符號來取代isWord的功能，並用一個多層的字典名為tree，
來記錄整個字典樹的結構。
這個方法的好處是無需另外產生一個TrieNode的物件，
但缺點是必須使用一個不會出現在字串中的符號 。
(如果今天這個字串內會含#的話，這個解就會無法使用了XD)

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

「時間/空間複雜度？」
(插入：O(N)/空間全新的話O(N)
搜尋：O(N)/O(1)
前綴：O(N)/O(1)
當中N代表字串長。)

「如果要支援刪除呢？」
(要實作刪除函式時，不是使用TrieNode的話，
就要留意去處理自己製造的結束標記。
一般使用TrieNode很簡單，使用search找到該字，
並將isWord設成false/False即可。
記得詢問找不到該字要怎麼回傳。)

相似及延伸

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

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

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

從LeetCode學演算法 - 72 Linked List (7)

Mon, 02 Dec 2019 00:00:00 +0800

0206. Reverse Linked List (Easy)

Question

Reverse a singly linked list.

Example:

1
2


Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL

分析/解題

試反轉一個單向鏈結串列。
很久以前我們嘗試解過這題的較困難的版本
(0092. Reverse Linked List II (Medium))，
不過是透過stack的輔助，這題較為簡單，
我們來嘗試不使用其他資料結構來試試看吧XD！

先舉一個簡單的例子：
head -> a -> b -> c -> d -> NIL
這個單向鏈結串列在反轉的時候應該會變成：
NIL <- head <- a <- b <- c <- d

我們可以先看head, a, b這段，
在反轉時，我們要將head的next從a改成別的指向；
但如果先改掉的話，那就喪失掉a的位置了，
所以我們需要一個tmp來記錄a的位置，
再將head的next指向到前一個node (這邊一開始是NIL)，
最後讓tmp這個node做為下一個要處理的對象。
反覆處理，最終當head是null的時候，
回傳前一個node即為新的linked list的開頭(反轉前的尾端)。

所以以迭代法的步驟上會像這樣：

先宣告一個NIL的ListNode，我們命名為prev
當head非null時，進行迴圈：
2-1. 宣告一個節點n，位置指定到head的位置
2-2. head往下走到其next
2-3. n的next位置指定成prev
2-4. 再將prev的位置指定到n
迴圈完成後回傳prev即可

1

1. (prev=NIL) head -> a -> b ...

1
2


2. (n)
 (prev=NIL) head -> a -> b ...

1
2


2-3 (head)
 prev=NIL <- n a -> b ...

1

2-4 NIL <- prev head=a -> b ...

以第一輪的迴圈推導會如上面，讀者也可以自行嘗試推演看看。

若用遞迴的話也可以達到相同效果：

呼叫一個遞迴函式rev，將(null, head)做為參數傳入
(在rev中，參數為前一個節點prev，跟當前的節點n)
如果n為NIL的話則直接回傳prev
宣告一個tmp節點，其位置指定為n.next
再將n.next的位置指定給prev
回傳rev(n, tmp)

所以不論哪一種方式，
我們基本上都是使用宣告的節點去記錄next的部分，
再將當前的節點的next指向到prev，從而完成將鏈結反向的工作。

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

Java

Python

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

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

相似及延伸

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

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

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

從LeetCode學演算法 - 71 Hash Table (4)

Tue, 26 Nov 2019 00:00:00 +0800

0205. Isomorphic Strings (Easy)

Question

Given two strings *s * and *t *, determine if they are isomorphic.

Two strings are isomorphic if the characters in *s * can be replaced to get *t *.

All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.

Example 1

1
2


Input: s = "egg", t = "add"
Output: true

Example 2

1
2


Input: s = "foo", t = "bar"
Output: false

Example 3

1
2


Input: s = "paper", t = "title"
Output: true

分析/解題

給定兩個字串s和t，試判斷它們是否同構(isomorphic)
若s和t同構，表示可以透過將s中的相同的字元轉換成另一個字元，
保有其順序，使得在轉換過後的s和t完全一樣。
兩個不同的字元不可映射到相同的字元 ，
但一個字元可以映射到原來的字元(也就是不變)。

這個題目簡而言之，就是在找尋用特定方式轉換對應字的方法，
比如範例中的paper -> title有以下的轉換對應：
p <-> t, a <-> i, e <-> l, r <-> e

由於同構並沒有限制轉換方向，所以既要轉得過去，也要轉得回來，
這代表了他們對應必須要1對1才行。
因此，我們可以想到以下的方式：

先檢查兩邊長度，不相等則直接回傳False (怎麼轉都沒用XD)
可以選擇建立一個HashMap/Dict 並額外處理雙向 的對應檢查，
或者選擇開出2個陣列/Dict(也可用串列，不過要自己轉換) 來做檢查。
每次從s, t中各取出一個字元 (假設現在在index i )：
3-1. 兩字元都未進入 陣列對應 -> 將s[i] 與t[i] 放入兩個陣列的對應
3-2. 兩字元都進入 陣列對應 -> 檢查s[i] 是否對到t[i] ，t[i] 是否對到s[i]
(只要其中一個對錯或沒對到，即可判定為False )
當所有字元均檢查完，表示順利全數對應到，回傳True 。

簡單吧！
在Java的部份，
我們可以直接利用char可以自動轉換成int當作陣列的index。
沒有對應則會拿到預設值(0)，依此寫成以下程式碼：

Java

Python的部份，方便起見我們使用了dict來紀錄，
預設值使用get放入0。

另外提供一個特別的用法，可以使用maketrans 及translate ，
來進行兩個表的轉換。但由於中間可能有重複，
所以要先經過set(刪去重複)和list, join 以後，
重新依照原先的字母排列排序(用key＝s.index) ，
最終看看s經過轉換以後是否和t相同。

Python

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

「時間/空間複雜度？」
(O(N)/O(N), 但空間複雜度最高取決於實際用到的字數，
亦可視為O(1)，因限縮在ASCII Code的話也才128種類)

相似及延伸

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

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

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

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

從LeetCode學演算法 - 70 Linked List (6)

Wed, 20 Nov 2019 00:00:00 +0800

0203. Remove Linked List Elements (Easy)

Question

Remove all elements from a linked list of integers that have value *val *.

Example:

1
2


Input: 1->2->6->3->4->5->6, val = 6
Output: 1->2->3->4->5

分析/解題

題目要求將一個給定的linked list上值是val的所有元素均去除掉。

前面已經講過一些linked list的題目了，
在處理的重點上，不外乎就是在於如何進行遍歷，
以及移動和取代的不同，是很多人容易弄混的。

我們先假定有一組node的連結長這樣：
prev -> curr -> next

今天如果想要遍歷的話，我們應該做的事情是先宣告一個node，
並將prev的位置指定給node：

1
2
3
4
5
6


Java:
ListNode node = prev;
while (node != null) {
 System.out.println(node.val);
 node = node.next;
}

1
2
3
4
5


Python:
node = prev
while node:
 print(node.val)
 node = node.next

這當中，node = node.next的方式變動了node所指向的記憶體位址，
使其切換到下一個(也就是curr所在的位址)，但prev仍然在原地 。

回歸到題目本身，
題目要求的是跳過特定的val值，例如1->2->6->3，目標val是6。
遇到val值時，應該要將2的連接從6改到3 ，換言之，
當結點node走到2時，發現node.next.val跟目標val一樣，
連接上就會變成：
node.next = node.next.next

此外，為了要進行遍歷，所以每次node都需要往下一個前進，
在前一個狀況下已經確定了會將node.next接到node.next.next去了，
若val不同的話，則需要將node的位置移到下一個 去：
node = node.next

還有一個問題，就是如果一開頭的値就符合val的話，
刪去頭會導致原先的head消失，
為了避免麻煩，常見的做法是宣告一個dummy node，將其連接到head處。
中間不論如何都不去動dummy，結尾時再將dummy.next 回傳即可。

Java的部分，我們初始化一個dummy node並另開一個curr來進行移動。
**每次curr.next的値符合時，就將curr.next接到curr.next.next，
否則就讓curr往下走。**這麼一來，只要不斷檢查curr.next是否為NIL並遞進即可。

Java

Python的部分大同小異。

Python

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

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

相似及延伸

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

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

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

我將於11/26 開設系列同名線上課程**「從Leetcode學演算法｜基礎篇」。** 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
問卷抽書＆取得上架通知： https://pse.is/MS2J2
Leetcode解題挑戰拿優惠： https://pse.is/NAUVP
如果你對線上課程不放心，
也可以先來12/17(二) 我在天瓏分享的講座看看！
講座連結： https://pse.is/JS3LJ

從LeetCode學演算法 - 69 Hash Set (1)

Tue, 19 Nov 2019 00:00:00 +0800

0202. Happy Number (Easy)

Question

Write an algorithm to determine if a number is “happy”.

A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.

Example:

1
2
3
4
5
6
7


Input: 19
Output: true
Explanation:
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

分析/解題

給定一個數，試檢查其是否為快樂數(happy number) 。
所謂的快樂數就是從一個正整數n開始，將其每一個位數的平方和加總，
作為新的n值，反覆操作，若n最終等於1的話則為快樂數，
否則若n最終會進入一個不包含1的循環的話，則不是快樂數。

之前我們介紹過HashTable(HashMap/Dictionary)，
Java的HashSet和Python的set 其實是類似的概念，不過僅限於單值，
也就是說它們每筆資料只存放一個值 ，而非key/value相對。
一個Hash Set裡面，相同的值不能夠重覆出現，
同時利用了hash的性質，其插入/查找 的速度也是O(1) 。

這題當中我們唯一需要考慮的問題就是當陷入循環的時候怎麼作判定，
所以我們可以使用Hash Set來進行記錄，當中若碰到n等於1的時候，
可以直接回傳true；其他狀況則檢查n是否在Hash Set內 ，
若是，則表示已經碰到循環了，則可脫離迴圈回傳false 。

在循環內計算下一個n基本上就是將除以10的餘數平方並移位後加總，
這邊就不再贅述。

對Java而言，檢查是否在HashSet內請使用contains() 。

Java

如果對快樂數有更進一步的認識的話，
當非快樂數陷入循環時會是固定的模式：
4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4

同時，除了1和7以外，低於10的其他數均是非快樂數 。
所以也可以像上面寫到的另一種解法來處理這個問題，
在執行時間上對測試資料目前看起來是比較快的。

對Python而言，使用in來檢查即可。

Python

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

「時間/空間複雜度？」
(時間複雜度不確定，空間複雜度O(1))

相似及延伸

這題也可以不使用HashSet/set來解，
請思考看看如果用two pointers的方式的話可以怎麼寫XD

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

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

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

從LeetCode學演算法 - 68 Bitwise Operation (5)

Mon, 11 Nov 2019 00:00:00 +0800

0201. Bitwise AND of Numbers Range (Medium)

Question

Given a range [m, n] where 0 <= m <= n <= 2147483647, return the bitwise AND of all numbers in this range, inclusive.

Example 1

1
2


Input: [5,7]
Output: 4

Example 2

1
2


Input: [0,1]
Output: 0

分析/解題

給定一個範圍m, n，且0≤m≤n≤2147483647(也就是2³¹-1)，
回傳這個範圍內(inclusive，即含n)的所有數字的bitwise AND的結果。

首先這題要先理解inclusive表示頭跟尾都要 ，
例如[5, 7]，其範圍內的所有數字就是5, 6, 7。
再者如前面提到過的bitwise operation的部份，
這邊做的是對每個bit一一對應做AND的操作。

我們先來看一下範例1，將其化成二進位：

1
2
3
4


5 : 101
6 : 110
7 : 111
AND : 100 => Output: 4

注意到由於AND操作要求兩個bit都是1結果才是1 ，
所以中間一旦出現任意一個0的話，當個bit的AND結果最終必然是0 。
由於

已經知道m≤n了，假設m跟n前面存在一組位元長得一模一樣，
例如：

1
2


m: 100100101000 (2344)
n: 100100111111 (2367)

可以明顯看出從m到n的部份，1001001 的位元是完全不變的，
AND出來這部分顯然也會保留 ，因為每個數字的這部份都一樣。

那麼後面呢？
由於m ≤ n，
所以在後面不相同的狀況下，開始不相同的m的第一個bit顯然會是0 ，
n的第一個bit顯然會是1 ，那麼從m一路到n的bit變化，
就必然有從011…1到100…0 的情況，
所以後面的所有bit皆至少有出現過一次0 ，
這會使得後面的區塊經過AND完以後肯定是0 。

所以整個問題就可以化簡成：
找到m和n的最前面相同的bit，再將後面補上0即為答案 。

要找這個很簡單，每次檢查m, n是否相等，若否，
則各自向右移動一個bit，最終到** m, n相等時，
只要乘上對應的位移倍數，即為解答。
讀者可以自行選用將factor視為位移位數** 或必須相乘的倍數 ，
兩者速度基本相似。

除此之外還有另一個思路，既然我們只是想要n的前面那區bits，
那就一次從n剝離一個bit
( n &= n-1 , 先前的題目有提到可以用來一次去除最低位的bit)，
直到n≤m為止。這時候留下來的n即為答案，因為低位的全被剝離了。

依此，寫成程式碼。
(三者速度差異不大，但最後一種看起來最簡單，讀者可以自行斟酌選擇)

Java

Python

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

「時間/空間複雜度？」
(O(n的長度)/O(1)，
因為要做到哪一步端看什麼時候找到m和n前面相同的位置)

相似及延伸

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

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

從LeetCode學演算法 - 67 Bitwise Operation (4)

Tue, 05 Nov 2019 00:00:00 +0800

0191. Number of 1 Bits (Easy)

Question

Write a function that takes an unsigned integer and return the number of ‘1’ bits it has (also known as the Hamming weight).

Example 1

1
2
3


Input: 00000000000000000000000000001011
Output: 3
Explanation: The input binary string 00000000000000000000000000001011 has a total of three '1' bits.

Example 2

1
2
3


Input: 00000000000000000000000010000000
Output: 1
Explanation: The input binary string 00000000000000000000000010000000 has a total of one '1' bit.

Example 3

1
2
3


Input: 11111111111111111111111111111101
Output: 31
Explanation: The input binary string 11111111111111111111111111111101 has a total of thirty one '1' bits.

Note:

Note that in some languages such as Java, there is no unsigned integer type. In this case, the input will be given as signed integer type and should not affect your implementation, as the internal binary representation of the integer is the same whether it is signed or unsigned.
In Java, the compiler represents the signed integers using 2’s complement notation. Therefore, in Example 3 above the input represents the signed integer -3.

分析/解題

給定一個unsigned integer(正整數或0)，試回傳其位元為1的個數。

這題其實比上一題還要再簡單一點XD
假設我們將數字稱為n，要計算其位元為1的個數的方式一般有兩個：

看當前的位數是否為1 來決定是否遞增記錄累積的cnt(count)，
再將n向右位移1位，直到做完全部32個位元。
將n每次和n-1相AND，可以去掉最低次的位元。
舉例來說：
n=11100 => 11100 & 11011 = 11000
(減1時最低位的1會被借位，導致該位變成0，
其後的位數變成1，從而在相AND時全都會變成0)
n=10011 => 10011 & 10010 = 10010
(最低位的1一開始就在最右邊，顯然減完最右邊變成0，
同樣會符合去掉最低次的位元的特性)

Java

Python的部份，也可以轉成二進位以後再用count去數'1’。
(不需要考慮前面的0b因為沒差XD)

Python

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

「時間/空間複雜度？」
(O(1)/O(1)，因最多32次迴圈就結束了XD)

相似及延伸

Special Thanks suggestions/corrections from viewers: 這題其實一樣可以有更精妙的解法，但同樣不建議在面試時使用。
(除非你要面試的就是非常在乎效能加速的公司)請參見JDK所使用的Integer.bitCount() 函式原始碼講解：
https://juejin.im/post/5c3969b76fb9a049a5712060

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

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

從LeetCode學演算法 - 66 Bitwise Operation (3)

Sat, 02 Nov 2019 00:00:00 +0800

0190. Reverse Bits (Easy)

Question

Reverse bits of a given 32 bits unsigned integer.

Example 1

1
2
3


Input: 00000010100101000001111010011100
Output: 00111001011110000010100101000000
Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.

Example 2

1
2
3


Input: 11111111111111111111111111111101
Output: 10111111111111111111111111111111
Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10111111111111111111111111111111.

Note:

Note that in some languages such as Java, there is no unsigned integer type. In this case, both input and output will be given as signed integer type and should not affect your implementation, as the internal binary representation of the integer is the same whether it is signed or unsigned.
In Java, the compiler represents the signed integers using 2’s complement notation. Therefore, in Example 2 above the input represents the signed integer -3 and the output represents the signed integer -1073741825.

分析/解題

題目要求將一個32bit長度的integer進行反轉。
(也就是將二進位制的各個bit 0變成1，1變成0)

先前我們談過二進位的問題，以及一些位元運算 。
如果這題有要求處理正負號的問題的話，就會稍微複雜一點，
因為如題目提示的說明，Java中的有號的integer會使用**二補數
(2’s complement)**來表示，這件事情隱含了如果將bit位移時，
需要考慮是»或»>的問題。
負數使用»時最高位會補1，而»>時最高位會補0 ，
由於最高位用來記錄正負號，這會影響到實際得到的結果。

但我們這邊單純只是要將整個32 bit順序反過來的話就沒有太大問題XD

我們先從簡單一點的開始，
比如有一個數字n是1001100(也就是十進制的76)，
假設我們要將這7個bit反轉，應該要得到0011001，這個過程怎麼來的呢？

先將我們的答案叫做r(result)，一開始為0，我們先這樣表示：

1
2


r:
n: 1001100

接下來我們要找下一個對應的bit的話，
n必須要取最右邊的bit才行，記錄完以後，
為了讓下一次的n的最右邊依然是我們要的bit，
可以將n進行一次向右位移，即可對到最右邊。
另外，r為了要記錄下一個位元，每次要向左位移一格，空出最右邊來。

重複相同的操作，直到n等於0或全部位元操作完畢即可。

1
2


r: -> 0 -> 00 -> 001 -> 0011 -> 00110 -> 0011001
n:1001100 -> 100110 -> 10011 -> 1001 -> 100 -> 10 -> 1 -> 0

觀察上面的規律，我們可以歸納出對32位元的操作：
1. 令res為0
2. 執行32次以下的迴圈：
2–1. res向左位移1位
2–2. 將n的最右邊的bit加到res上
2–3. 將n向右位移1位
3. 最終res即為答案

依此，可以寫成如下的程式碼：
Java的部分，我們使用«=和»=進行各自位移後再回存。
而對應到2-2的部分，除了如第8行的寫法，
將n和1進行AND運算 來確認最右邊的位元 以外，
也可以用AND完以後跟res進行OR 的方法。
此外，由於最開始res是0，
所以先將其往左位移一次是不會對答案造成影響的。

Java

Python的部分提供一個看到比較特別的寫法：
使用format將n進行轉換，
當中0:032b的第一個0可以不用寫 (因為format中也只有一個數字)，
第二個0代表多出來的部份必須進行補0 (補完反轉才不會有問題)，
轉成32位的bit後，將其從尾往頭擺順序，
再用int轉換回integer(指定前面那段是二進制)即可。

Python

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

「時間/空間複雜度？」
(O(N)/O(N)，因為必然經過每個位元)

「如果檢查n是否為0做為結束條件，執行速度是否會較快？」
(不一定，要看n反轉後的最接近高位的0有多接近，
否則每次多檢查一次未必比較快)

相似及延伸

Special Thanks suggestions/corrections from viewers:
From ** 程式人雜誌 — 公益出版** ** - Novus Chou**:
「現實中比較講究的位元操作，會盡可能一次處理多位元，
而且最好不動用迴圈。

以 8 bit 為例

12345678
=> 21 436587 (奇偶交換)
=> 4321 8765 (兩兩一組交換)
=> 87654321 (前後半交換)

類似 C 風格的寫法大概長這樣，
最後一輪利用整數自然截位所以不用 mask（當然這點要看語言特性）。

x = (((x & 0xAA) » 1) | ((x & 0x55) « 1));
x = (((x & 0xCC) » 2) | ((x & 0x33) « 2));
x = (x » 4) | (x « 4);

更快的作法就是半查表，也就是把問題分解到某階段改用查的。 」
(註：利用連續的bit mask進行處理，可達到交換的目的，
這個方法對於在意效能 來說，
由於if/while/for 等需要判斷 或有分歧狀況 的程式碼，
皆須花費相對於位元運算而言較多的時間，
能夠單純利用位元運算達成互換會是在實際狀況較棒的解法。)

(但，其實沒特別用過的話，面試時其實頗難回想出這種解法就是了XD)
有興趣的話可以參考這兩篇：

另外，Java中內建的bitCount 函式(計算某個數的二進位制含有1的數量)，
也運用了類似的手法達到目的。
參見： https://www.jishuwen.com/d/2HPI/zh-tw

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

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

1

如果你／妳覺得這篇文章不錯，請給我5個Like。(點開SHOW EMBED!)

從LeetCode學演算法 - 65 Array (13)

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

0926. Flip String to Monotone Increasing (Medium)

Flip String to Monotone Increasing (Easy)

Question

A string of '0's and '1's is monotone increasing if it consists of some number of '0's (possibly 0), followed by some number of '1's (also possibly 0.)

We are given a string S of '0's and '1's, and we may flip any '0' to a '1' or a '1' to a '0'.

Return the minimum number of flips to make S monotone increasing.

Example 1

1
2
3


Input: "00110"
Output: 1
Explanation: We flip the last digit to get 00111.

Example 2

1
2
3


Input: "010110"
Output: 2
Explanation: We flip to get 011111, or alternatively 000111.

Example 3

1
2
3


Input: "00011000"
Output: 2
Explanation: We flip to get 00000000.

分析/解題

一個只含'0’和'1’的字串在以下的狀況成立時會被視為單調遞增 ：
數個'0’作為開頭(也可能是0個)，其後接著數個'1’作為開頭(也可能是0個)。
(簡單說就是0後面接1就對了，也可以全0或全1)
給定一個字串s ，且可以將當中任意的'0’翻轉成'1’，
也可以將任意的'1’翻轉成'0’，
試求要將s經過翻轉操作成為單調遞增 的狀態所需的最小翻轉次數 。

這題其實某種程度隱含了一點動態規劃的概念在內，
但相對而言算是較簡單的。

我們先思考根據單調遞增特性，由於這個特性，
注定了一旦在某個點變為1，其後的每個單位也必須要是1 才可以。
若將最後的結果分成兩個狀況的話，事情會變比較簡單：

全部都是0
前面0後面1(含全部都是1)

考慮做到第i位時，要保持單調遞增所需翻轉的次數:
a. 如果第i位是0，對狀況1來說，不需額外作任何事情即可保持
b. 如果第i位是1，對狀況1來說，要將第i位翻轉為0(翻轉次數+1)
c. 如果第i位是0，對狀況2來說，要將第i位翻轉為1(翻轉次數+1)
d.如果第i位是1，對狀況2來說，相當於從第i-1位時選擇狀況1/狀況2均可

若我們將上面的狀況1所需的翻轉次數叫做f0，
狀況2的所需次數叫做f1的話，
上面的a/c就是第i位碰到'0’的狀況 ，此時從第i-1位的f0/f1 更新到第i位 時，
新的f0不需改變 ，但f1必須遞增 ；
b/d就是碰到'1’的狀況 ，更新時新的f1要取原先的f0, f1中較小的値 ，
且f0必須要遞增 。

一開始什麼都還沒做，所以我們可以定f0, f1均為0 ，
接下來從頭到尾依照碰到的字元進行操作。

最終，答案只要取f0/f1中較小值 即可。

依此寫成程式碼：
Java的部分可以利用for each的語法蜜糖來取出單個char，
(記得S要先轉成char array)
且需要留意f0的遞增要在取完f1之後 (不然值會錯)。

Java

Python的部分亦同，記得只有+=沒有++這種東西XD

Python

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

「時間/空間複雜度？」
(O(N)/O(1)，需遍歷整個String的長度，但記錄用輔助變數只需常數單位)

相似及延伸

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

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

從LeetCode學演算法 - 64 Array (12) / Two Pointer (3)

Tue, 22 Oct 2019 00:00:00 +0800

0080. Remove Duplicates from Sorted Array II (Medium)

Question

Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array ** in-place** with O(1) extra memory.

Example 1

1

Given nums = [1,1,1,2,2,3],

1

Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.

1

It doesn't matter what you leave beyond the returned length.

Example 2

1

Given nums = [0,0,1,1,1,1,2,3,3],

1

Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.

1

It doesn't matter what values are set beyond the returned length.

Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference , which means modification to the input array will be known to the caller as well.

Internally you can think of this:

1
2


// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

1
2
3
4
5


// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
 print(nums[i]);
}

分析/解題

給定一個已排序的陣列nums，將其重復超過2次的部分捨棄掉，
且使用in-place的方式來操作(在原陣列操作)，回傳最終結果的長度。

這題算是之前的0083. Remove Duplicates from Sorted List (Easy)的延伸，說真的我認為這題不該當作Medium難度XD

再次提醒，當題目要求使用in-place的時候，
對一些語言的確是可以真的用刪掉單點 的方式來處理(例如Python)，
但刪除這件事情也是較耗時的操作，所以沒特別要求的話，
請依照題目希望你的方向來撰寫(面試則依照面試官的限制條件 )。

我們先來講筆者直觀想到的解法，再來提leetcode上另一位高手的解。

直觀而言，要怎麼能夠知道有沒有碰到3個以上的重復呢？
最直接的方式就是使用一個cnt變數來記錄。
同時，為了要確認是否是重複的數，
我們需要記錄上一次開始重復的數last。

那麼步驟就會像這樣：

如果nums長度 ≤ 2 的話，表示完全不用更動，
直接回傳nums的長度 即可。
將last設為nums[0], cnt設為1, 預計要覆蓋的** index j設為1。**
令i從1開始一個迴圈來遍歷整個nums:
3-a. 如果nums[i]不等於last 的話，表示數字不同 ，
必須將其覆蓋到j的位置 。
同時，我們必須更新last為nums[i]，j要遞增，
cnt要重設為1 (用來做下一次比較)。
3-b. 否則，如果兩者相等且cnt小於2 ，
代表重複未超過2次，同樣要進行複寫和遞增j，但cnt要遞增 。
當整個迴圈完畢以後，j 應該是位在處理過後的陣列的尾端+1 的位置。
所以回傳j即可代表新的陣列的總長 。

聽起來有點多，但其實寫起來並不困難，
但還有更厲害的解法XD

這邊提供了LeetCode上StefanPochmann 的解，
簡單來說呢，我們可以換個思路：
由於整個陣列是排序過的 ，當我們遍歷陣列時，
某個數字應不應該要覆蓋到index上 ，
(筆者之前的解法將這個index叫做j，相當於這個解裡的i)
取決於前面兩個數字是否跟它一樣 ；
都一樣的話，就產生了三個相同的數 的狀況，
自然不需要再被取用，且由於排序的關係，
我們只需要比較前面兩個數字中較前面的那個 即可。

當i小於2時，直接無條件覆蓋( 因為不可能重複超過2次)；
當遍歷到的値n大於num[i-2] 時，代表數字不一樣 或重複未超過2次 ，
則應將其值覆蓋過去並遞增i 。

各自寫成程式碼如下：

Java

Python

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

「時間/空間複雜度？」
(O(N)/O(1)，我們需要遍歷整個陣列，且儲存用的輔助變數只有常數個)

相似及延伸

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學演算法 - 62 Tree (10)

Wed, 16 Oct 2019 00:00:00 +0800

0102. Binary Tree Level Order Traversal (Medium)

Question

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

return its level order traversal as:

1
2
3
4
5


[
 [3],
 [9,20],
 [15,7]
]

分析/解題

給定一個二元樹，回傳其節點値的層序遍歷結果。

我們在先前的文章中，
已經提到過層序走訪(level-order traversal)的概念了，
按照題目範例，這邊要將level分層開來。

對於遞迴解來說，如果使用一般的DFS的話，
我們將不知道哪一個節點位在哪一個level上，
故我們將必須加入變數level ，
讓level的值來幫助我們辨別要加到List的哪個level區塊中。

所以對於遞迴解而言，在主函式 中：

檢查根節點
將root的值加入第0層的list 中，再將該list加到答案res 中
呼叫幫助用的函式，將level遞増代入 (表下一層)

在幫助用函式 中：

先檢查代入進來的節點，
若遇到NIL則表示到此為止 ，進行回傳即可。
檢查目前res的size 和level 的關係，
若相等則表示要開一個新的list(因為level從0起算 )；
否則，找到對應level的list，將該節點的值加入。
分別檢查左節點和右節點進行遞迴 。

觀察這樣子的遍歷方式，讀者應該可以發現一點：
幫助用的函式本質上就是在做pre-order traversal。 之所以會達成我們想要的效果，是因為我們額外記錄了level這個資訊。

如果使用迭代法 來解呢？
我們可以建立一個Queue ，在每一層先行取得Queue的大小(長度) ，
每次迴圈只要剛好執行這個次數，
就可以不斷利用相同的Queue來堆出不同的層數 ，
再分頭將對應的左節點和右節點推入Queue中 。
(記得要先檢查，非NIL才需要推入)
最終所有節點都遍歷過一遍時，
剛好Queue裡面也不會留存任何節點。

依照上述說明，請參考對應的程式碼。

Java的部分，記得用來檢查的isEmpty() ，以及可以用LinkedList 來實作Queue 的部分。

Java

Python用deque (記得我們提到過的，list在移除左端的部分效率較差 )
另外，若幫助函式沒有要再被其他函式使用，
是可以考慮如底下34行以後這樣子寫成子函式的方式再呼叫的，
可以省去要加一堆self的狀況。
(但要記得：Python函式要先宣告才能呼叫 )

Python

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

「時間/空間複雜度？」
(O(N)/O(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學演算法 - 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學演算法 - 58 Two Pointer (2)

Tue, 01 Oct 2019 00:00:00 +0800

0075. Sort Colors (Medium)

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

Question

Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note: You are not supposed to use the library’s sort function for this problem.

Example:

1
2


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

Follow up:

A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0’s, 1’s, and 2’s, then overwrite the array with the total number of 0’s, then 1’s and followed by 2’s.
Could you come up with a one-pass algorithm using only constant space?

分析/解題

給定一個陣列當中有n個物件，被著色成紅、白、藍，
請將其以in-place的方式將同顏色排序至相鄰，並順序亦為紅白藍。
這裡給定的陣列顏色紅/白/藍分別以0/1/2代表。

如果有印象的話，大家可能還記得之前有一題Move Zeroes，
差別在於這題是0, 1, 2，我們依舊可以用類似的概念來解題。

使用3個變數來分別記錄0/1/2的個數，
等到計完了，再依序覆寫到nums裡面，就可以得到答案，
這麼做會需要掃過陣列兩次，第一次用來計數，第二次用來填入新的値。

那麼，題目也問了：
有沒有辦法給出一個one-pass 的演算法來解此題呢？
(one-pass algorithm意思是指說只掃過整個資料一次，詳見wiki)

我們可以仿照先前的Two Pointer 的概念來思考。
首先，1在這個陣列當中是我們較不在意的部分，
因為它一定是排在整個陣列的中間，
然後左邊區塊最後會是0，右邊區塊最後會是2。

假設我們要排序，所要做的就是將0的部分都往左邊擺，
將2的部分都往右邊擺；最開始的時候，因為還沒排過，
我們可以將下一個要擺放的位置命名為i0和i2，
並假定應該要擺在0和n-1的位置。(陣列的最左邊和最右邊)
接下來，依序掃描整個陣列(假設迭代的index為i)，會有以下三個情況。

碰到1:
因為將0和2都擺完以後1自然在中間，所以完全不用管它XD
碰到0:
我們應該將其擺放在i0的位置 ，
但原先i0所在的値不能平白消失，所以將其和i位置的値相交換。
換完之後，i0 因為已經填入0了，
故下個要填入0的位置必須更新 ，所以將i0遞增 。
碰到2:
同理，將其擺在i2的位置，和i位置的値相交換，再遞減i2 ；
需要注意的是由於i的位置換到我們不知道值的部分 ，
(前面碰到0的時候換的應該都是1，所以沒有影響)
所以將i遞減，抵銷掉i在整個迴圈中每次加1的部分 ，
以便迴圈的下一輪能檢查相同的位置。(檢查換過來的値 )

這整個迴圈的結束時間點應該在i和i2交錯的時候 ，
因為這代表後面都是2，既然後面已經相當於排完，
就可以結束整個迴圈了！

寫成程式碼如下，
幾個需要簡單注意的地方是，
當使用第一種方法 的時候，
其實可以直接開一個長度為3的陣列 來儲存數字出現次數；
其次，使用第二種方法 時，Python當需要判定條件會改變的狀 況時，
請使用while迴圈 ，因為for in range的寫法沒辦法動態地去改變條件。
(另外別忘記Python沒有++或 — ，請用+=和-=)

Java

Python

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

「時間/空間複雜度？」
(O(N)/O(1)，不論哪個解法，最多就是掃描過2次的nums的長度，
且我們基本上只會用到三個記錄各自數量的變數或三個索引值)

相似及延伸

1.0148. Sort List (Medium) 2.0324. Wiggle Sort II (Medium)

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

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

從LeetCode學演算法 - 57 Binary Search (4)

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

0074. Search a 2D Matrix (Medium)

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

Question

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted from left to right.
The first integer of each row is greater than the last integer of the previous row.

Example 1

1
2
3
4
5
6
7
8


Input:
matrix = [
 [1, 3, 5, 7],
 [10, 11, 16, 20],
 [23, 30, 34, 50]
]
target = 3
Output: true

Example 2

1
2
3
4
5
6
7
8


Input:
matrix = [
 [1, 3, 5, 7],
 [10, 11, 16, 20],
 [23, 30, 34, 50]
]
target = 13
Output: false

分析/解題

給定一個m x n的矩陣，此矩陣每列(row)都是從左到右升冪排序；
同時此矩陣每列的第一個值都比前一個列的最後一個值還要大。
試找出一個有效率的演算法，
來處理在這個矩陣搜尋一個值是否在這裡面。

有沒有覺得很熟悉？
其實這題的延伸題目就是上一題，作為同樣Medium難度的題目，
這題就要來得簡單許多。
為什麼呢？
因為按照題目的定義的話，
我們假設從每一列的尾巴接到下一列的頭，
最終就會得到一個完整的已排序陣列。
那麼，已排序陣列的搜尋方式，
我們以前已提到過了，就使用基本的二元搜尋法(Binary Search) 即可。
(還沒弄清楚或還不知道二元搜尋法的讀者，可以參見前面這篇 。)

那麼我們所要做的，就只剩下將matrix上的index，
轉為如果攤平以後對應到的陣列index即可。
對於matrix[i][j]來說，
由於有m列n行，i代表從0到i(總共i+1個列) ，
所以前面會經過i列，共 (i * n) 個數字；
接著要往右邊移動，
j代表從0到j有j+1個數字 ，再相加起來，
所以matrix[i][j]是整個攤平以後的第(i * n + j + 1)個數字，
從0開始起算的話就是(i * n + j)。

因此，如果我們找到某一個中間index mid ，
要轉換成i, j 的型式的話，
就只需要分別取除以n得到的商和餘數 即可。

依此進行二元搜尋的時候，其方式就和一般的二元搜尋一模一樣，
若跳出迴圈則代表該目標值不存在於matrix中，則回傳false 。

Java

Python的部分請不要忘記取整數除法要用雙斜線"//"。

Python

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

「時間/空間複雜度？」
(O(log(mn))/O(1))

相似及延伸

0240. Search a 2D Matrix II (Medium)

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

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

從LeetCode學演算法 - 56 Binary Search (3)

Thu, 26 Sep 2019 00:00:00 +0800

0240. Search a 2D Matrix II (Medium)

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

Question

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted in ascending from left to right.
Integers in each column are sorted in ascending from top to bottom.

Example:

Consider the following matrix:

1
2
3
4
5
6
7


[
 [1, 4, 7, 11, 15],
 [2, 5, 8, 12, 19],
 [3, 6, 9, 16, 22],
 [10, 13, 14, 17, 24],
 [18, 21, 23, 26, 30]
]

Given target = 5, return true.

Given target = 20, return false.

分析/解題

給定一個m x n的矩陣，此矩陣每列(row)都是從左到右升冪排序；
同時此矩陣每行(column)都是由上到下升冪排序。
試找出一個有效率的演算法，
來處理在這個矩陣搜尋一個值是否在這裡面。

這題乍看之下沒有這麼直觀，如果我們從matrix[0][0]出發的話，
顯然馬上就會碰到問題：
「好現在target比1大，我該往哪邊走？」 看來怎麼走都不對是吧？如果透過暴力的方式來一排一排找，
結果時間複雜度會是O(mn) 。
就算有想到Binary Search 可以處理已排序的陣列，
每次取一行或一列來搜尋值，
時間複雜度也只會降到O(m log n)或O(n log m) ，
似乎還是不那麼理想。

那麼，該怎麼考慮這個題目呢？
翻了翻提示，居然也是寫Binary Search；
而Binary Search的精髓，
其實就在於可以在每次的抉擇中保留需要的那部分的選項 。

那麼，回頭看看上面的矩陣，想要能夠靠選擇每次去掉選項，
我們考慮看看15這個點如何？

當target等於15 的時候，就直接是答案了，回傳true 。
當target不是15 的時候，可以分成比15大，或比15小 。

比15大 的狀況：
代表原先15的一整列(1, 4, 7, 11, 15)已經都不用考慮了 ，
因為15已經是這整列的最大值 ，故我們可以挑到19，
因為19這行還沒看過，
同時(15, 19, 22, 24, 30)這當中也是越來越大，
所以挑選19可以繼續進行比較，
這個操作就相當於扣掉一整列的備選 。
比15小 的狀況：
代表原先15的一整行(15, 19, 22, 24, 30)不用考慮了，
理由跟1.講得相似，只是這次我們就變成往右走挑到11 ，
整個操作相當於扣掉一整行的備選 。

我們每次刪去一行或一列，那麼總共有m列n行的話，
最多就要操作m+n次 才能確認target是否在matrix中。
(因為每次扣掉一行或一列的備選嘛)

所以其實再仔細一看，
如果我們將這個矩陣往逆時針轉45度，
(或將你的頭順時針轉45度)，
你會發現這整個矩陣其實可以當作一個以15為根結點的二元樹 。
(不過由於它的特性，可以想像它還有其它不只二元樹的連結)
(或者更準確的說，它就是有向圖(Oriented Graph) )

所以我們的整個演算法如下：

檢查matrix是否正常，不正常則直接回傳false
將初始點定在**(i, j)=(0, n-1)** 的位置
當i和j都沒有超過邊界 的時候，進行下面的迴圈：
3-a. 若target和當前點的値相等，回傳true
3-b. 否則若target較大，將i遞增
3-c. 否則將j遞減
若迴圈結束尚未回傳，代表這個值不在矩陣內，
回傳false結束。

寫成程式碼如下所附。
(也有人判斷第一步的時候用< 1而非==0，但測試目前沒有明顯差異，
讀者依自己喜好選擇寫法即可。)

Java

Python

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

「時間/空間複雜度？」
(O(m+n)/O(1)，因為每次都會刪去一行或一列，最差狀況就是全部刪完。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
Python Taiwan 王彥珽：** 直行橫列**才對(註：中國才是橫行直列XD)
(但我工作就會講row跟column啦)

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

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

1
2


如果你／妳覺得這篇文章不錯，請給我5個拍手，並且給我5個Like。
(點開最上面的SHOW EMBED!)

從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學演算法 - 53 Binary Search (2)

Sat, 21 Sep 2019 00:00:00 +0800

0278. First Bad Version (Easy)

Question

You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.

Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad.

You are given an API bool isBadVersion(version) which will return whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.

Example:

1

Given n = 5, and version = 4 is the first bad version.

1
2
3


call isBadVersion(3) -> false
call isBadVersion(5) -> true
call isBadVersion(4) -> true

1

Then 4 is the first bad version.

分析/解題

一個正在由你主導的團隊所開發的產品在最新的版本沒過品質檢驗。
由於每個版本都是由前面的版本進版，所以當某個版本壞掉了，
其後的版本也都會是壞的。
假定有n個版本，你要找出第一個開始壞掉的版本。

這題其實蠻真實的，
除了一般來說不會有什麼API，
可以看這個版本是不是壞掉這種東西(都嘛要自己測XD)
而實際碰到這種狀況的時候，
通常做的也是先想辦法倒回到某個版本時間點。
這時候Project Owner就會叫大家先不要commit了，
開始從上一個好的版本到這個版本中列出所有commits，
再來切一半 的位置來檢查中間的版本 有沒有問題，
沒有問題 的話就代表這個中間點到尾端 這區間才有問題；
有問題 的話就代表是開頭到中間點 這個區間有問題。

所以每次我們都可以排查掉一半的可能性並縮小範圍，
最終就找到那個元凶的commit，視情況決定要做revert或其他動作。

所以我們可以發現，這種連續性的東西，
也可以用Binary Search的方式來解，只是要處理的條件就不同了。

我們將較小的版本叫lo，較大的版本叫hi，
一開始lo=1, hi=n，取中間的版本mid，
當mid剛好是bad version時，並不代表可以回傳mid ，
應該將hi設定為mid (也就是可能的範圍是1~mid )。
否則的話，代表1~mid都是清白的 ，
我們可以將lo設定為mid+1 ，縮小範圍繼續搜尋。

最終，當lo和hi交會的時候，
代表我們找到出問題的那個版本，所以最後要回傳lo 。

Java的部分考慮到int要盡量避免溢位，
一樣使用lo + (hi - lo) / 2的形式來計算。

Java

Python的部分一樣請記得要整數除法。

Python

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

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

相似及延伸

1.0035. Search Insert Position 2.0034. Find First and Last Position of Element in Sorted Array

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

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

從LeetCode學演算法 - 52 Array (11)

Fri, 20 Sep 2019 00:00:00 +0800

0268. Missing Number (Easy)

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

Question

Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array.

Example 1

1
2


Input: [3,0,1]
Output: 2

Example 2

1
2


Input: [9,6,4,2,3,5,7,0,1]
Output: 8

Note :
Your algorithm should run in linear runtime complexity.
Could you implement it using only constant extra space complexity?

分析/解題

給定一個陣列內含n個不同的數字，
(從0~n之間選n個，也就是說會少一個)
試找出漏掉的那個數。

首先最笨最暴力的方法當然是排序過後再從0開始看nums[i]是否為i。
這個做法顯然經過排序就需要O(NlogN)的時間，
但其實還是可以通過測資XD

我們考慮比較簡單一點的作法：
我們都知道梯形公式(以及那個聰明的高斯XD)，
從0加到n的總和會是n * (n+1) / 2。

所以想要知道中間漏掉哪個，就將0~n的總和，
減去nums的所有元素全部加起來即可。

Java

在Python中不要忘記了除法取整數要用「//」，
並且陣列的和可以用sum來取得。

Python

這種解法要留意一點，如果在有限制int的狀態下，
n*(n+1)是有機會溢位的！所以如果有時間的話，
還是可以嘗試一下下面提到的解法。

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

「時間/空間複雜度？」
(O(N)/O(1)，乘法只做一次，加法會做n次，儲存的部分只有幾個輔助的變數)

「這題有別的解法嗎？」
(其實用Bitwise Operation來解也很簡單，
這邊留給讀者可以自行嘗試看看(用XOR)。)

相似及延伸

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

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

從LeetCode學演算法 - 51 BST (4)

Tue, 17 Sep 2019 00:00:00 +0800

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

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

Question

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

Given binary search tree: root = [6,2,8,0,4,7,9,null,null,3,5]

Example 1

1
2
3


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

Example 2

1
2
3


Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
Output: 2
Explanation: The LCA of nodes 2 and 4 is 2, 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 BST.

分析/解題

給定一個二元搜尋樹及其中兩個不同的節點，
試找出它們的最近共同祖先(LCA)。

題目有標註說一個節點可以視作自己的後裔(descendant)，
這點會有影響，還請留意。

那麼，我們如何尋找這個最近共同祖先呢？
首先要知道，這是一棵二元搜尋樹，假設這個LCA的節點叫作L好了，
兩個節點分別叫p跟q，那麼我們可以考慮以下幾個狀況：

如果L是p或q其中之一的話，先遇到誰，就代表誰是那個LCA 。
(因為先遇到的節點會是後面的那個節點的祖先)
如果L不是p或q其中之一 的話，L的値的範圍必在p.val和q.val之間 ，
也就是說兩者會位在L的不同側的子樹。
(即p.val < L.val < q.val或p.val > L.val > q.val)

如果從root開始判斷的話，就可以分成幾種情況：

root的値和p或q的值相等 => ** 直接回傳root** (p或q就是L)
root的値在p和q的值的範圍之內 => ** 直接回傳root**
(即p.val < L.val < q.val 或p.val > L.val > q.val )
p和q的値都小於 root的值 => 往下找root.left 的狀況遞迴
p和q的値都大於 root的值 => 往下找root.right 的狀況遞迴

也就是說，最終總會找到L是p或q之一 ，或者L能將兩個節點拆成兩邊 。
於是我們可以輕鬆解出這個題目，在Python的部分，
除了要留意a < b < c這種形式是Python才能用的，Java不接受以外，
這邊在Java的解答中要提供一個較簡潔的解法。

仔細思考的話，我們可以發現1, 2其實可以看作一件事情：
root.val - p.val和root.val - q.val的關係。
當符合1. 的時候，上面的兩個式子會有一個等於0 ；
當符合2. 的時候，上面的兩個式子會一正一負 。
所以兩者相乘 時，符合1.跟2.的條件的狀況下，
結果會<=0 (或<1，因為值是int)。

同時，當不符1.且不符2.時，由於p, q已經確定是同邊 了，
只需要拿p來比較即可，不用再去比較q。

根據上面的推導我們可以寫成Java的答案版本。
同時，由於每次遞迴都只有動到root所指向的節點，
所以我們也可以很簡單地將其改動成迭代的解法，
由於不需call stack，總體速度有可能會有些許的加快。

Java

Python

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

「時間/空間複雜度？」
(Worst case: O(N)/O(N) (如果節點都在同一邊)
平衡樹的話最大會走到整個深度的節點，是O(logN))
(用迭代解的話，因為不用call stack，空間複雜度為O(1))

「用相乘的方法會有什麼副作用？」
(在有限定變數是int的狀況下，相乘有機會導致溢位 ，所以如果這題的測試資料刁鑽一點的話，請不要用相乘的，一組一組判斷就好。)

相似及延伸

1.0236. Lowest Common Ancestor of a Binary Tree (如果這棵樹只是二元樹 而非二元搜尋樹呢？)

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

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

從LeetCode學演算法 - 50 Tree (9)

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

0226. Invert Binary Tree (Easy)

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

Question

Invert a binary tree.

Example:

Input:

Output:

Trivia:
This problem was inspired by this original tweet by Max Howell:

Google: 90% of our engineers use the software you wrote (Homebrew), but you can’t invert a binary tree on a whiteboard so f*** off.

分析/解題

題目要求反轉一個二元樹。

我們今天來看一題經典的題目，
這題經典的原因也許不是在於它有多困難，
而是在於這問題背後的故事XD

或許另一方面也可以看看他本人在Quora上的回應。
所以演算法很重要有沒有XDD
(據稱有一種說法是說當時的題目是要求min-max的反轉，這邊暫不討論，
我們以左右反轉為準)

相信大家經過前面的一堆二元樹相關題目以後，
應該已經對二元樹駕輕就熟了，應該可以輕鬆地寫出遞迴方式的版本。

跟之前的Symmetric Tree相似，
只是這次我們直接將一棵樹的左右節點交換，
除了交換以外，它們的左右子樹的部分也要再度進行交換。

所以我們會拆成：

檢查root是不是null (是的話代表這條路到底了，直接回傳null)
將root.left和root.right進行交換
將root.left和root.right分別做為參數，呼叫函式進行遞迴

Java

Python寫得再簡單一點，不過意思是一樣的XD

Python

你以為這樣就結束了嗎？
我們將繼續來探討一下如果是迭代解的話該怎麼處理。

如果思考一下前面的遞迴解，
會發現一件事情：
對於一個我們造訪的節點而言，
我們所影響到的只有其左節點和右節點，
當下這個節點的値並不會受任何影響。
所以我們只需要保證當走到這個節點的時候，
關於這個節點以上的操作已經做完 即可，
那麼要保證這點的話，只要使用level order 的方式，
我們按順序操作即可做完所有反轉的動作。

由於是先將同一層的做完才會進到下一層，
也可以視作是BFS的方式。
按順序作的話，
可以使用Queue來處理這樣子的問題，步驟大致上是：
0. 檢查root是否為NIL，是的話直接回傳NIL

建立一個queue(python請用deque )
將root放入queue中
每次從queue中取出一個節點，將其左右位置互換 ，
並分別將左右節點中非NIL的節點放入queue中
重複3直到queue中沒有節點
回傳root

Java:

Python:

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

「時間/空間複雜度？」
(因每個節點均要和另一個位置進行對調，所以時間複雜度為O(N)。
空間複雜度會受到樹的平衡程度影響。
平衡狀態 的話空間複雜度對遞迴解來說是O(logN)(call stack) ，
而對迭代解來說是O(N) (因為最大是最底部那層)
(這時候反而越不平衡每層的節點會越不容易太多))

「這兩種解哪種是DFS？哪種是BFS？」
(遞迴解是DFS(一路走到最深才回頭)，迭代解是BFS(當層走完才往下層走))

相似及延伸

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

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

從LeetCode學演算法 - 49 Hash Table (3)

Fri, 13 Sep 2019 00:00:00 +0800

0217. Contains Duplicate (Easy)

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

Question

Given an array of integers, find if the array contains any duplicates.

Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

Example 1

1
2


Input: [1,2,3,1]
Output: true

Example 2

1
2


Input: [1,2,3,4]
Output: false

Example 3

1
2


Input: [1,1,1,3,3,4,3,2,4,2]
Output: true

分析/解題

給定一個整數陣列，若陣列有任何重複的數，則回傳true，否則回傳false。

今天來點簡單的，畢竟中秋節嘛XD
和之前找出單一元素的題目不同，因為這題沒有限定重複出現的次數 ，
所以並不適用於bitwise operation 的方法。

以暴力法來說要O(N²)，排序後再比要O(NlogN) ，
均不理想，所以一般常見的想法是，
一樣引入hashmap或dictionary 來解題。

而由於我們只在意數字有沒有出現 ，對於Java來說，
還有另外一個名為HashSet 的方式可以使用。
HashSet在新增方面複雜度同於HashMap均為O(1) ，
但HashSet同時具備Set的特性，同個資料只能出現在Set當中一次 ，
若有相同資料要被新增時，則新增會失敗(回傳false) ；
我們可以利用這點，每次對HashSet新增當前的數字，
失敗則代表已經出現重複了(直接回傳true)，
若全數新增完畢則代表不存在重複(回傳false)。

Java

Python的set新增時碰到重複的資料時不會進行任何動作 ，
所以這邊還是使用dictionary。
另一種作法是可以使用set來進行化簡後，直接檢查總長度是否改變 ，
即可知道是不是含有重複的元素。

Python

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

「時間/空間複雜度？」
(O(N), O(N)，因為每次插入均為O(1))

「如果限制不用HashSet/Dictionary，但給你nums值的範圍呢？」
(建立一個array/list，總長為整個範圍，
將其拿來做為輔助陣列使用即可。)

相似及延伸

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

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

從LeetCode學演算法 - 48 Trie (1)

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

0819. Most Common Word (Easy)

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

Question

Given a paragraph and a list of banned words, return the most frequent word that is not in the list of banned words. It is guaranteed there is at least one word that isn’t banned, and that the answer is unique.

Words in the list of banned words are given in lowercase, and free of punctuation. Words in the paragraph are not case sensitive. The answer is in lowercase.

Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Input:
paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
banned = ["hit"]
Output: "ball"
Explanation:
"hit" occurs 3 times, but it is a banned word.
"ball" occurs twice (and no other word does), so it is the most frequent non-banned word in the paragraph.
Note that words in the paragraph are not case sensitive,
that punctuation is ignored (even if adjacent to words, such as "ball,"),
and that "hit" isn't the answer even though it occurs more because it is banned.

Note:

1 <= paragraph.length <= 1000.
0 <= banned.length <= 100.
1 <= banned[i].length <= 10.
The answer is unique and written in lowercase (even if its occurrences in paragraph may have uppercase symbols, and even if it is a proper noun.)
paragraph only consists of letters, spaces, or the punctuation symbols !?',;.
There are no hyphens or hyphenated words.
Words only consist of letters, never apostrophes or other punctuation symbols.

分析/解題

給定一個段落和一個被禁止的字的列表，回傳這個段落裡面出現次數最高且沒有在禁止字列表內的字。
(題目保證至少有一個字不會被禁止且答案只會有一個)

禁止字表會以小寫字給定且不需考慮標點符號，
在段落中的字並不限定大小寫(也就是視作相同的字)，
答案要用小寫表示。

這題一般而言會使用HashMap或dict來解題，
但隨著總字數的增加，一些重複的字母不斷出現感覺其實相對浪費，
所以今天就要專門來介紹一個資料結構來解決這個問題，
這個資料結構就是字典樹(Trie)。

Trie (From Wikipedia)

字典樹長得基本上就是樹的一種，通常儲存的是字串。
其根節點代表著空字串 ，而每個連結出去的節點，
都代表在前面的基礎上加上一個字元(char) 。
換句話說，我們只要知道從根到葉走了哪些鏈結，
就知道最終葉所代表的字串是什麼，如上圖所示。

在這題當中，我們可以自行定義一個class TrieNode，
當中包含了links (從這個節點連出去26個字母)，
cnt (這個字在整個段落出現的次數)，以及word (實際上這個字是什麼)。

其實word可以如上面所說一步一步加起來，
不過寫起來稍微麻煩一點點，這邊就讓我偷懶一下吧XD

在Java的部分，設定條件是：
當被要求大多數的字串處理函式都禁止使用時，
該怎麼一步一步寫出我們所要的東西。

首先要建TrieNode，除了上面所述外，我們需要三個函式：

1. insert
透過每個字母沿links的路徑走，
如果curr.links[index] == null 則表示前面還沒走過，
要自行new出來，並設定其word變數。
在走到底的時候我們要將cnt數加1 。
(代表這個word出現在段落裡次數加1次)

行走的路徑如之前提過的，直接使用字元來減去’a’ 即可，
這邊將links[0]視為是’a’，而links[25]視為是’z’ 。
當走到某一條links[index]還沒初始化時，
就將其初始化並給定其word值。
每次往下走時不要忘記將用來迭代到下一個字元的curr指到下一個位置 。

2. ban
只要將該string對應的TrieNode中的cnt設成零 即可。
如果在走的路徑途中遇到null，表示段落裡不存在這個string，
直接return即可。

3. findMax
遍歷所有TrieNode並找到最大的cnt及對應的word。
(這邊使用到res作為結果 的字串及maxcnt作為儲存當前最大值的變數 )
只需要從root的位置開始，往下搜尋有cnt的值，
一一比較即可，當這層搜尋完時，
我們還要往下一層去，所以用迴圈往下再進行遞迴。
(這部分是DFS )

回到mostCommonWord 函式中，
我們先產生一個StringBuilder(命名為st) 及一個root(TrieNode) ，
並用isString 來表示現在st是否構成一個word。
每次將paragraph中的字元取出來，檢查其是否是大小寫字母，
並將字母統一成小寫後接到st上；
一旦發現遇到非大小寫字母的字元，且設定的isString為真 ，
則表示現在st構成一個word，將其丟進root中插入到字典樹內。
(不要忘記最後面還要再檢查一次 ，
因為有可能還沒插入就離開迴圈了)
接著再ban 及findMax 後，就可以回傳res 作為答案了!

Java

Python的部分思路跟Java相近，
不過因直譯器的特性，這邊選擇將對應的函式拉到class Solution來做。
讀者可以兩邊互相對照看看差異。
此外，由於banned測資似乎存在會重複的狀況，
所以可以使用set來縮小總長。

另這邊也提供leetcode上lee215的解：
使用re.findall ，用正規表示式直接將words找出，
再利用Counter直接計算頻率，最終取出最高頻率的字。
(應該是目前最快的解法)

Python

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

「時間/空間複雜度？」
可以從不同面向來考慮。由於有點長，且不好解釋，
這邊直接貼筆者在leetcode上回答的內容。

「這個解法有沒有再更優化的方法？」
(至少有兩個，如果讀者有興趣的話可以嘗試看看：

將word的部分去除(也就是只使用中間的鏈結來取得整個字)
其實可以先做ban再作insert (ban可將cnt設為**-1** ，而insert時先檢查cnt是否為-1，是的話可以直接跳過)
(這個方法可以同步在insert時更新res和maxcnt，所以會變成先ban再insert完以後，就可以直接回傳答案了，速度應該會再快一點點。))

「Java如果允許使用split呢？」
(可以這樣用：
String[] words = paragraph.toLowerCase().split(“[ !?’,;.]+”); 當然，前提是你不要中間的標點符號漏打XD)

相似及延伸

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

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

從LeetCode學演算法 - 47 Array (10)

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

0204. Count Primes (Easy)

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

Question

Count the number of prime numbers less than a non-negative number, *n *.

Example:

1
2
3


Input: 10
Output: 4
Explanation: There are 4 prime numbers less than 10, they are 2, 3, 5, 7.

分析/解題

給定一個非負整數n，試求所有小於這個n的質數。

讓我們來複習一下國中(還是國小？)數學：
質數的定義就是除了1和自己 以外，沒有其他數可以整除它的正整數。

透過這個特點我們可以再延伸：
因為合成數必然可以拆成質數相乘 ，
所以我們要判定某個數是否是質數的話，
只要將其他比它小的質數 測試它是否是目標的因數 即可。

另外，由於一個數若能拆成2數相乘，
那麼其中一個因數會小於等於這個數的開根號 ；
另一個因數則是大於等於這個數的開根號 。
如此一來，我們只要檢驗2**~目標數的開根號** 的數是否能整除目標數 即可。

所以老師會教你一個消去法：
首先將2的倍數排除掉，再將3的倍數排除掉，
再將5的倍數排除掉……(2倍以上，不含自己)
一個個操作，走到沒有被排除掉的數即為質數 。

我們可以再進一步處理一點：
假設現在處理到i，
那麼其實我們應該知道i*2, i*3, …, i*(i-1 )的部分，
應該都被前面的操作排除了，
故每次我們只要從i*i開始，排除到n，
也就是i走到最大n的開根號即可。

故整個程式會從2到根號n，每次將對應i的i倍以上的部分設為非質數，
最後計算總質數有多少個。

Java的部分，由於boolean預設為false，
這邊使用nPrime代表not prime，所以nPrime為false代表這個數是質數，
要設定成不是質數時請用nPrime[j] = true。
在處理完後請記得bound後面的質數個數要記得加起來。

Java

Python的部分，sqrt可以直接用n ** 0.5，
並且我們可以用1代表質數，0代表非質數，
讀者可以仔細看一下第8行，其實和Java迴圈的目的是一樣的，
不過這邊直接最後才算prime陣列的總和來取得質數個數。

Python

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

「時間/空間複雜度？」
(O(n), O(n log log n))
(外層迴圈的boundary上限是sqrt(n)，
內層j的次數上限會從n/2 -> sqrt(n)，具體計算我也不會XD
以Wikipedia提供的時間複雜度為O(n log log n)。
https://zh.wikipedia.org/wiki/%E5%9F%83%E6%8B%89%E6%89%98%E6%96%AF%E7%89%B9%E5%B0%BC%E7%AD%9B%E6%B3%95)

Special Thanks suggestions/corrections from viewers:
Python Taiwan, 林宣丞：此篩選方式又稱 埃拉托斯特尼篩法(sieve of Eratosthenes)。

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

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

1
2


如果你／妳非常喜歡這篇文章，可以按著拍手直到50下。
也請記得「Follow」我，隨時收看最新的文章。

從LeetCode學演算法 - 46 BFS (2) / Queue (3)

Sat, 07 Sep 2019 00:00:00 +0800

0199. Binary Tree Right Side View (Medium)

另外筆者昨天生日，快補祝我生日快樂XDDDDD

Question

Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

Example:

1
2
3


Input: [1,2,3,null,5,null,4]
Output: [1, 3, 4]
Explanation:

1
2
3
4
5


 1 <---
 / \
2 3 <---
 \ \
 5 4 <---

分析/解題

給定一棵二元樹，想像你站在樹的右邊往左看，
試回傳從上到下依序所看到的值。

這題一看就知道某種程度上屬於level-order traversal，
(還不清楚或不知道什麼是level-order的讀者請參閱這篇)
只是要求的部分有點不一樣而已，這邊只要求最右邊的數字。

那麼要注意囉！可能會有人想，我能不能只走最右邊 取值就好呢？
答案是當然不行！！！因為你可能會遇到類似這樣的狀況：

你看到的最右邊不是人家的最右邊XD

如果只取最右邊的話，顯然我們會走1-3-0然後就結束了，
但還有一個4落在中間，所以這題無論如何還是要乖乖遍歷所有節點才行。

我們可以用BFS的方式來解這題(DFS也行，但要用到遞迴，這裡暫不討論)，步驟如下：

先新增一個queue用來存放當層(level)的所有節點，
另外開一個串列res(result)用來存放結果。
記錄當下queue的總數cnt(count)。
執行一個cnt次數的迴圈，依序將當層的節點取出
每取出一個節點，就分別檢查其左右節點是否存在，
存在則以先左後右 的順序放入queue中。
迴圈執行完後，queue中應該全是下一層的節點；
同時最後一個取出的節點 ，就是每層最右邊的節點，
將其值取出放入res中。
重複2~5的動作，直到queue中沒有節點為止。

讀者會發現這樣的做法唯一的差別就是要記錄最後一個取出的節點 ，
其他和level-order traversal一樣，利用queue先進先出的原則，
每次恰好處理一層的節點。

依此我們可以寫成程式碼，
Java的部分List和Queue都可以使用LinkedList，
且TreeNode的部分由於Java必須給定值，故一開始last先行給定為null。

Java

Python的部分不要忘記當需要從左邊取值時deque 的速度會較List快，
另外last其實可以不用先給值也可以順利通過。

Python

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

「時間/空間複雜度？」
(O(N), O(N)，每個節點都會遍歷過，
同時因為使用Queue的時候中間會儲存整個level，
空間複雜度還是跟總數相關。)

「可以使用DFS嗎？」
(可以，但需要對每項記錄其level，解法相對較難處理，讀者可嘗試看看)

「如果題目改成從左邊看呢？」
(一樣要遍歷所有節點，但改成在每一層的第一項就將值置入到答案中)

相似及延伸

1.0102. Binary Tree Level Order Traversal

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學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 44 Linked List (5)

Tue, 03 Sep 2019 00:00:00 +0800

0160. Intersection of Two Linked Lists (Easy)

Question

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

begin to intersect at node c1.

Example 1

1
2
3


Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
Output: Reference of the node with value = 8
Input Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,0,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.

Example 2

1
2
3


Input: intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
Output: Reference of the node with value = 2
Input Explanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [0,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.

Example 3

1
2
3
4


Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
Output: null
Input Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
Explanation: The two lists do not intersect, so return null.

Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.
You may assume there are no cycles anywhere in the entire linked structure.
Your code should preferably run in O(n) time and use only O(1) memory.

分析/解題

有兩個單向連結串列，試找出其交會開始的節點。
如果它們彼此之間沒有相交，則回傳null。
(注意中提到最好時間使用O(n)且空間僅使用O(1)。)

這題其實相當簡單，但要特別留意一點：
就算兩個節點的值相等，也並不代表它們是同一個節點。
從Example 1中就可以看到這個例子，
節點值都是1，但並非同節點，這部分要特別留意。
不過我們並未特別針對ListNode去實作相等的function的狀況下，
直接用**==** 判斷即可。

那麼，怎麼來找共同的交會節點呢？
我們可以先假設它們有一個交會點，
那麼list A跟list B在這個交會點(含)以後的節點數會相等。
(因為重合了XD)

所以比如說A總長度是9，B總長度是6，
我們可以先讓A從開頭走3步 ，(這樣才能對齊 )
接著兩邊開始依序走訪比對走到的節點是否交會，
若交會則回傳；若走到底還沒有看到相同的節點，
則回傳null(或None)。

所以大體上的操作如下：

設定iteA/iteB作為走訪list A/list B用的節點
先各自走訪過一輪來取得A和B分別的長度
長度相減，讓比較長的list的起始節點先多走相差的節點數
同時開始第二次的走訪，一邊比對節點是否交會，
是則回傳該節點，不是則走到至少一邊走完為止
若4走完尚未回傳則回傳null(表示沒有交會)

寫成程式碼如下。

Java

Python的部分可以寫得稍微簡潔一點，
留意用來遞進用的迴圈這裡的for會使用單底線，
因為我們只想要使用重複diff或-diff次的功能，
並不在意迴圈執行到第幾次。

Python

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

「時間/空間複雜度？」
(O(N), O(1)，我們共遍歷了最多兩次的list，
且只有額外使用到幾個輔助用的節點和變數。)

相似及延伸

1.0599. Minimum Index Sum of Two Lists

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

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

從LeetCode學演算法 - 43 BFS (1) / Queue (2)

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

1161. Maximum Level Sum of a Binary Tree (Medium)

Question

Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.

Return the smallest level X such that the sum of all the values of nodes at level X is ** maximal**.

Example 1

1
2
3
4
5
6
7


Input: [1,7,0,7,-8,null,null]
Output: 2
Explanation:
Level 1 sum = 1.
Level 2 sum = 7 + 0 = 7.
Level 3 sum = 7 + -8 = -1.
So we return the level with the maximum sum which is level 2.

Note:

The number of nodes in the given tree is between 1 and 10^4.
-10^5 <= node.val <= 10^5

分析/解題

給定一個二元樹的根節點，若將該層(level)稱為1，
其子節點所在層稱為2，……以此類推，
嘗試找出最小的x層，這層的所有節點和是在所有層裡面最大的 。

這題其實存在不同的解法，若讀者有興趣的話也可以使用DFS的解法，
本篇只介紹BFS的作法。

如果有看過先前對於Tree的介紹的話，
我們應該有提到過不同方式的走訪，而這題問的，
如果限定在迭代法解的話，就適合使用層序走訪(level-order traversal) 。
層序走訪的概念很簡單：
每次先走完這一層的所有節點，再走下一層的所有節點 。

用遞迴來看的話顯然是沒辦法的，
因為每次往下都是走往下一層 (左子樹或右子樹)，
所以我們需要用非遞迴的方式，並使用Queue來作輔助。

大概步驟會像這樣子：(下面將Queue命名為q)

將根節點放入q中
當q中有節點時，先求q現在的節點數量cnt
(註：這個節點數量就是目前這整層的所有節點數 )
開始一個迴圈，這個迴圈執行cnt次 :
3-a. 每次從q中取出一個節點n ，並將其值加到當前總和total 中
3-b. 檢查左右節點，如果不是NIL則放進q中
(註：第3步做完以後，
q中前一層的cnt個節點應該已經全數移除，並加入下一層的所有節點)
檢查total是否大於當前的最大總和 ，
若是，則替換掉最大總和 及所求答案的層數
遞增當前的層數(level)
重複2~5的動作，直到q中沒有任何節點為止

由上面的步驟可知，每一次我們均藉由Queue來走遍所有同一層 的節點。
在非樹的題目中，類似的作法是先走所有離自己一步距離的可能，
再往下一層去處理，由於是先求廣度 ，
這樣子的作法我們稱之為廣度優先搜尋(BFS, Breadth-First Search) 。

Java的部分，我們可以使用不同的Queue的實作方式，
讀者可以選用ArrayList, LinkedList或ArrayDeque。
(一般來說ArrayList效率會較差，
有人說ArrayDeque號稱比LinkedList好，
但筆者實測看起來沒有明顯差異XD)

Java的Queue放入和取出的寫法是offer/poll ，總數使用size ，
檢查是否為空則用isEmpty 。

Java

Python的部分則使用前面提過的deque 來處理，
放入和取出分別是append 跟popleft ，總數使用len ，
是否為空則直接拿其本體來判斷 (裡面是空的則會是False )

Python

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

「時間/空間複雜度？」
(O(N), O(N)，因為會遍歷整棵樹，而空間占用最大的時候會占用最下面的一整層，所以最糟的狀況也會是O(N)。)

「題目有告訴我們node總數最大是10^4，如果這棵二元樹是處在平衡的狀態的話，有沒有比較方便的解法？」
(平衡二元樹代表中間該填滿的都填滿了，
所以可以利用這點去算最大的層數，
新增一個陣列/串列來記錄某一層的總和；
直接利用層數來進行DFS，將走到的點的值加到對應的位置，
最後加總完以後再來看哪一個level總和最大。)

「可以用DFS來解這題看看嗎？」
(可以，只是traversal的時候記得要傳遞層數的值，
並且開一個ArrayList/List來存放每層的總和。)

相似及延伸

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

從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學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 41 Hash Table (2)

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

0242. Valid Anagram (Easy)

Example 1

1
2


Input: s = "anagram", t = "nagaram"
Output: true

Example 2

1
2


Input: s = "rat", t = "car"
Output: false

Note:
You may assume the string contains only lowercase alphabets.

Follow up:
What if the inputs contain unicode characters? How would you adapt your solution to such case?

分析/解題

給定兩個字串s跟t，
寫出一個函式來判斷t是否是a的一個anagram(易位構詞)。

所謂的anagram就是指將這個字串的字母搬動順序以後，
可以組成另一個字串的遊戲，這在很多推理小說裡都有出現過，
比如達文西密碼或者哈利波特XD

那麼，怎麼確切知道s跟t是否是彼此的anagram呢？
我們比較幸運只需要檢查正確與否就好，所以一般常見的解法有幾個：

排序(暴力?)法
既然完全是由相同的字母及相同使用字母的個數組成，
那就代表只要將兩個字串進行排序，最後它們會長得一模一樣 。
但這樣作的時間複雜度為O(n log n)(n為字串長) 。
雖然能夠通過測試，但似乎不是很理想。
Hash Table 法
上次我們已經介紹過了Hash Table的概念，那麼這次我們應該也可以使用相同的方式來處理。由於題目已經告知字串僅含小寫字母，也就是a-z，
只要依序掃瞄過兩個字串，將字串所含每個字母的個數計算是否相等，
即可判定結果。
這麼作只需要O(n) 的時間複雜度，空間部分只需要O(1) 。
(因為是26個字母 ，所以陣列長是固定的)

我們可以利用上一次提到的ASCII的方式，
來對a-z 的部分位移到一個計數陣列的0到25 ，
同時，掃過s 的時候將對應的字母計數遞增 ，
掃過t 時將對應的字母計數遞減 ；
一旦有字母是遞減到小於零 的話就可以直接判定s和t彼此並非anagram。

Java的版本完整演示了上述的流程。

Java

Python的部分這邊也可以另外使用別的方法，
這邊提供幾個比較簡便且複雜度一樣的方法：

使用count 跟all 來計算(所以對每個字母都會分別檢查一次)
(all是用來判定所有會迭代的狀況是否全數為TRUE)
使用Counter 計算後再比較(所以會先算完全部再來檢查)

Python

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

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

「如果大小寫視為相同？」
(使用類似Java的方式，但每個字元要先確認是否是大寫，
若是，先將其轉為小寫才往陣列中存放，之後的做法應該是一致的。)
(ASCII中A-Z是65~~90而a-z是97~~122，可以先平移對應的相差量)

「如果還有其他英文字母以外的字元？」
(將陣列改成用HashMap，
key存放字元，value存放出現次數。Python則用Dict即可)

「如果大小寫視為相同，空格及標點符號要省略呢？
(沒錯，就跟達文西密碼的留法一樣，沒人在管標點的XD)」
(可以嘗試刪去不需要的，或只取英文字母的部分。)

相似及延伸

1.0049. Group Anagrams 2.0438. Find All Anagrams in a String

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

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

從LeetCode學演算法 - 40 Array (9)

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

0238. Product of Array Except Self (Medium)

Question

Given an array nums of n integers where n > 1, return an array outputsuch that output[i] is equal to the product of all the elements of numsexcept nums[i].

Example:

1
2


Input: [1,2,3,4]
Output: [24,12,8,6]

Note: Please solve it ** without division** and in O(n).

Follow up:
Could you solve it with constant space complexity? (The output array does not count as extra space for the purpose of space complexity analysis.)

分析/解題

題目給定一個陣列nums，目標是產生一個output陣列，
這個output上的output[i]都相當於除了nums[i]以外其他的乘積。
要求不能用除法且必須在O(n)的時間完成。
延伸要求：用來做為輸出的output不算在額外的空間內的話，
是否可使用常數空間複雜度來解決此題？(即僅使用O(1)空間)

這題如果用暴力法來解的話，
就是使用兩層for-loop，將每個output[i]先初始化為1，
再進行對其他值的相乘(也就是要乘N-1次)，
所需的總乘法會是N*(N-1)，故時間複雜度為O(N²)。

這樣顯然速度不太好，我們再來考慮一下實際的情形。

1
2
3
4


nums 2 3 4 5
res 3*4*5 2*4*5 2*3*5 2*3*4
l 2 2*3 2*3*4
r 3*4*5 4*5 5

假設有一個陣列是[2, 3, 4, 5]，而我們要求的結果是res，
按照定義我們可以先將res的結果寫出。
仔細觀察我們可以發現，如果將res的每項拆成兩組相乘 ，
我們可以拆分成l, r兩個陣列，
當中l從index 1 開始往後推 有數值，依序是2, 2*3, 2*3*4 。
r則從index 2 開始往回推 有數值，依序是5, 4*5, 3*4*5 。

(這邊的拆分就是取明顯有斷層的部分，空出來的部分為1 )

所以我們可以先將res初始化，用它承載l 的部分，
再依次將r從1開始，把5,4,3依序乘上去一個值以後依序乘到res中，
這樣一來計算res的時候就只有分別經歷過兩次O(N)，
時間複雜度會維持在O(N)。
同時，因為前面第一次利用了res來儲存l的部分，
第二次只用單個變數r來依序記錄要乘的順序，
故扣除res以後空間複雜度為O(1)。

Java

Python

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

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

相似及延伸

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

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

從LeetCode學演算法 - 39 Array (8) / Hash Table (1)

Sun, 25 Aug 2019 00:00:00 +0800

1160. Find Words That Can Be Formed by Characters (Easy)

Question

You are given an array of strings words and a string chars.

A string is good if it can be formed by characters from chars (each character can only be used once).

Return the sum of lengths of all good strings in words.

Example 1

1
2
3
4


Input: words = ["cat","bt","hat","tree"], chars = "atach"
Output: 6
Explanation:
The strings that can be formed are "cat" and "hat" so the answer is 3 + 3 = 6.

Example 2

1
2
3
4


Input: words = ["hello","world","leetcode"], chars = "welldonehoneyr"
Output: 10
Explanation:
The strings that can be formed are "hello" and "world" so the answer is 5 + 5 = 10.

Note:

1 <= words.length <= 1000
1 <= words[i].length, chars.length <= 100
All strings contain lowercase English letters only.

分析/解題

給定字串陣列words和一個字串chars，
如果陣列中的一個字串能被定義為good，
代表它是能由chars的中的字元組成(每個字元最多只能使用一次 )，
試將所有good的字串長度加總回傳。

一般用來描述某個項目儲存多少值都會使用HashTable/HashMap，
對應到Python則通常可使用dictionary。
HashTable相關的儲存方式有搜尋為O(1) 的特性，
和一般常見的搜尋資料結構如Binary Search Tree需要O(log N) 不同，
原因是因為會實作hash function，令不同的值儲存的時候能夠得到不同的hash值，從而直接找到對應的位置。
(但當hash function的選擇不好 ，或儲存的東西太多時，
有機會發生碰撞(collision) 問題，導致查找時間加長，這裡暫不討論。)

在題目的條件限定在英文字母相關的時候或有特定長度限制時，
我們常可以用很簡單的方式來進行hash table/hash map的操作，
例如英文字母a~z只有26個，
如果題目和計算字母出現的次數有關聯性的話，
我們可以直接以一個長度為26的陣列/串列來記錄 。

以這題來說，題目所要求的檢查方式，
就是先確認chars裡面有幾個a, 幾個b, …… , 幾個z ，
接下來對每個字串 確認其組成，
一旦組成需要的個數大於chars所擁有的，我們就可以直接跳過它 ；
反之若每個字母所需的個數都滿足，
則將要回傳的結果加上這個字串的長度，
一直到全數檢查完畢即可回傳結果。

下面Java的程式碼部分演示了上面所提到的步驟。
裡面用到語法蜜糖(Syntactic sugar)的作法，讀者應稍加掌握，
如for迴圈Java有提供連續從array中依序取出單個變數的寫法，
類似於Python中**”for word in words”** 的方式。
我們將check的部分獨立出來，作為檢查並回傳長度的部分，
一旦沒有成立，直接回傳0，若最終檢查通過則將len(word)回傳。

之前應該也提到過char可以使用ASCII的代表數字來加減 ，
所以這邊取a到z來做為index 0到26，起始的基準點是’a’。

Java

Python的部分，使用Counter 可以很簡便的計算一個字串中的字母組成，
我們可以直接檢查每個key的值的大小來確認是否足夠組成，
但需留意Counter並不會放置沒有出現的字母的key，
故每次要先檢查是否dic中本來就沒有現在要檢查的key值，
避免發生錯誤。

更簡便的方式是直接使用count 來計算某個字母在字串裡面出現的次數。
這個應該是目前Python答案中跑最快的方法，
但可能是因為測試資料中比較常出現False的狀況，
導致word不用每個字母都算完就結束了 。
不然在最糟的狀況下，word的每個字母應該都會算一次count，
且相同的字母在不同的位置上還會重新再算過一次；
雖然時間複雜度還是一樣(字串最長限定是100)，
若整份資料比較容易是good的字居多的話，
並不建議用這樣子的方式操作。

Python

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

「時間/空間複雜度？」
(Java: O(N)/O(1)，
準確來說，最大要走完所有字的長度(所以應該可以說N個字*長度L)，
空間的部分，使用了26個字母來做為查表用的分類，
所以同一時間用到的只會有2組長度26的陣列及幾個暫存用變數
Python: 對二個解也都是 O(N)/O(1)，
但第二個解在最差的狀況下會每個字母都重覆掃過。)

相似及延伸

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

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

從LeetCode學演算法 - 38 Array (7)

Fri, 23 Aug 2019 00:00:00 +0800

0088. Merge Sorted Array (Easy)

Question

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.

Note:

The number of elements initialized in nums1 and nums2 are m and n respectively.
You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.

Example:

1
2
3


Input:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3

1

Output: [1,2,2,3,5,6]

分析/解題

這題雖然相對比較無聊，
但merge的過程中其實蠻像merge sort的merge的，
所以選來讓讀者熟悉一下merge的概念，對上上篇提的應該會有幫助。

題目給定兩個陣列及有放元素的對應長度，兩者除了未放元素的0以外，
其他均已排序。同時，題目也假設第一個陣列必定有足夠空間，
可以放入全部的元素。請嘗試將兩個陣列merge成一個排序的陣列，
放置在第一個陣列中 。

由於最終要放在nums1裡，我們可以先考慮會有的情形：

n等於0：不用搬了，因為只有nums1有非0值。
m等於0：只要把nums2的全搬過來即可
其他：按照merge的原則，將雙方依序填入nums1中。

到這邊讀者可能會想到常規的merge是開一個新陣列 將雙方依次比較，
每次將較小的值放入新陣列，最後排序完成。
現在說想放到nums1當然是可以，但nums1前面有值 ，
直接這麼做會蓋掉耶！那怎麼辦呢？
答案很簡單，我們已經知道兩邊的長度是m跟n，
那麼合併後的長度就會是m+n ，尾端的index會是m+n-1 。
我們只要將**「每次將較小的值放入開頭」** 改成**「每次將較大的值放入結尾」** ，最後即可達到相同的狀況。

所以操作順序會是：

令i, j, k分別為m-1, n-1, m+n-1 2. 當i和j都≥0 時：
如果nums1的值比nums2的值大，
將nums1的尾端放到k的位置，同時遞減i跟k以更新。
如果nums1的值比nums2的值小(或相等)，
將nums2的尾端放到k的位置，同時遞減j跟k以更新。
重複這個迴圈直到跳出，代表有一邊陣列放完了 。
當 i ≥ 0 時，表示其實我們已經做完了，所以不用任何操作。
(剩下nums1前面的部分，不需要再動了)
當 j ≥ 0 時，表示 i 的部分已經被用完了，
剩下的就是一路將 j 的對應值填入即可。

Java的部分，可以利用**”–“** 讓對應index先填入以後再進行遞減，
步驟流程請參考上面演算方式並對照。

Java

Python沒有++或 – 這種東西，所以遞減時要乖乖的自己等於自己減一，
不過可以將需要遞減的寫在同一行，會稍微簡潔一點點。

Python

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

「時間/空間複雜度？」
(O(m+n)，O(1)
前者是典型merge的時間，後者是因為我們只有使用常數變數，
其他都是原有的記憶體空間，故僅額外占用到O(1)的空間)

相似及延伸

1.0021. Merge Two Sorted Lists (Easy) 2. 0148. Sort List (Medium)

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學演算法 - 36 Merge Sort (1)

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

0148. Sort List (Medium)

Question

Sort a linked list in O(n log n) time using constant space complexity.

Example 1

1
2


Input: 4->2->1->3
Output: 1->2->3->4

Example 2

1
2


Input: -1->5->3->4->0
Output: -1->0->3->4->5

分析/解題

試以O(n log n)的時間複雜度來排序一個linked list。
這題其實還有設定一個constant space complexity的條件，
但要達成這個條件的話，要很仔細的使用迭代的方式來做merge sort才行，
這邊主要會講一般的遞迴解(也就是空間複雜度不會是O(1))，
若對迭代解有興趣，可以參考 theoneneo 或 ** sladkey**** 的解法。**

關於排序有很多不同的方式，
我們這邊先來講一個相當常見且經典的排序法：合併排序法(Merge Sort)

合併排序法的概念是先拆半再合併 ，一般在演算法中為了遞迴起見，
會直接把拆半的部分叫mergesort ，而合併的部分就稱為merge 。

什麼是拆半？就是每次將整組資料分成兩半，
一路拆分直到只剩下一個，這時候每一個單位而言均為排序好的狀態。
(廢話XD 就一個而已當然是排好的)

拆分完以後，要進行合併的動作。
合併就是指將同一層的兩組資料，按大小由小到大 置入。
我們可以參考範例的動畫，一開始由於拆到每組只剩下一個，
可以很輕易的比較誰大誰小，進而每次將較小的放入到合併的陣列中，
所以每一次合併 完以後，我們都可以得到一個**由小排到大的一組資料，
同時下一次我們依舊可以使用兩組各自由小排到大的資料，
使用two pointer的方式就可以依序將其合併。**最後合併回最開始那一層，我們就可以得到一個排序好的陣列了。

Merge Sort範例

最後排序完的結果

這樣子將目標先拆小以後再進行合併的手段，
我們通常稱之為分治法(divide-and-conquer) ，
也就是將大問題拆成小問題解決的一套思路。
由於一定要拆成每組只有單筆資料，每次拆分為一半，
故拆分的時候，會拆成logN層；又每次合併也都需要掃過每筆資料，
總時間複雜度必須再乘上N，所以最終的時間複雜度為O(NlogN) 。

當中每次合併都需求一個新的位置來作為承接它的狀態，
所以一般來說可使用O(N) 的空間來儲存。

總體而言，一個mergesort的演算法流程大致如下：

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


function mergesort(arr, l, r) {
 if r > l {
 m = (l+r)/2
 mergesort(arr, l, m)
 mergesort(arr, m+1, r)
 merge(arr, l, m, r)
 }
}
function merge(arr, l, m, r) {
 開一個新的陣列tmp，將arr的index l到index r的部分複製過去(包含r)
 i = l, j = m+1, cnt = 0
 比較tmp[i]和tmp[j]，將較小的複製到arr[l+cnt]並遞增cnt跟有被複製的i/j其一
 重複上一個步驟直到一方沒有可以比較的部分，將剩餘的數字全數依序放入arr中
}

回到我們的問題，
現在要排序的應該是LinkedList，和陣列的唯一差別是，
我們需要一些手段才能取到中間點，這裡同樣使用slow跟fast兩個pointer的方式，讓slow一次走一格，而fast一次走兩格，直到fast到底的時候(遇到NIL)就代表slow應該走到一半了，此時不要忘記將中間的slow的前一個節點prev跟slow進行斷開 ，prev的用途就是用來紀錄slow的前一個節點的。
(因為不是陣列，我們是依靠next是否為NIL 這點來判斷節點的分組)

接著在merge的部分，我們取用了一個n作為dummy node(也就是用來紀錄開頭用的節點)，接著使用iterator(ite)來進行檢查，同樣是檢查哪個比較小，
這時對於Linked List而言應該是將節點串接在後面 即可。(不要忘記串接了某一個以後，該節點也要往下走，相當於陣列中的i跟j其一要遞增。)

最後同樣，若有一方無法比較，則我們可以直接把剩下的節點接上去。
(ite.next = n1或ite.next = n2)
範例程式碼的部分這邊採用了leetcode使用者jeantimex的解法，
筆者加了一點註解，搭配前面文章的說明，
使用者應該可以較輕鬆地了解整個解題的思路和作法。

Java

Python

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

「時間/空間複雜度？」
(O(NlogN), O(logN)
將一個串列不斷拆成二等份，直到剩下單一節點，
相當於在求N可以被二分拆幾次，乘上最終會有N個單節點再次合併，
故總體時間複雜度為O(NlogN)。)
(註:這只是很粗糙的說法，有興趣可以翻閱演算法書籍，會有較嚴謹的證明)
(對於每一次的拆分搜尋都需要用O(1)的記憶體來儲存這層的stack，
理想狀況下會有logN層，故平均空間複雜度為O(logN)，
最差的狀況則為O(N))

「還有一些常見的排序，你能說出它們的時間複雜度嗎？」
(selection/insertion/bubble等均為O(N²)，quick/merge均為O(NlogN)，
需留意quicksort的worst case是O(N²))

相似及延伸

1.0021. Merge Two Sorted Lists (Easy)

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

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

從LeetCode學演算法 - 35 BST (3)

Tue, 20 Aug 2019 00:00:00 +0800

0108. Convert Sorted Array to Binary Search Tree (Easy)

Question

Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differs by more than 1.

Example:

1

Given the sorted array: [-10,-3,0,5,9],

1

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

分析/解題

給定一個陣列，其元素以升冪排序 (也就是後面的一定比前面大)，
試將其轉成一個高度平衡的二元搜尋樹。

高度平衡的樹由於已在先前的題目中講過了(0110. Balanced Binary Tree)，
這邊就不再贅述，簡言之就是對每個節點，
其兩邊的子樹深度相差均<=1就對了！

我們知道要達到這個條件，最基本的就是一個root的左右兩邊要公平，
所以最簡單的作法就是取中位數作為根，其左邊就是左子樹的所有節點，
右邊就是右子樹的所有節點；再分別讓各自的左右子樹再次拆分，直到分到沒有節點為止。

這樣作可以讓每一層都均分節點，從而讓每個分支的深度基本接近一致。
故整體流程如下：

檢查陣列是否是空的或者null，是的話直接回傳
呼叫一個用來遞迴建立BST的函式，這邊命名成getNode()
getNode會輸入陣列以及當下的左右邊界(nums, l, r)
(一開始l = 0, r = N-1, N是nums的總數)
每次先檢查左右邊界是否黃金交叉(表示已經完成了，可以回傳null)
讓mid = l加r的一半，直接建立一個root節點
root節點的左節點 就應該是呼叫getNode(nums, l, mid-1) 得到的結果
root節點的右節點 則會是getNode(nums, mid+1, r) 得到的結果
回傳root

我們可以看到每次會抓中間值產生一個節點，再利用已排序的特性，
繼續進入遞迴往下將左邊和右邊的節點處理完畢。
思考它的執行流程，應該會發現總體而言我們會先一路來到最左邊的節點，
再回頭建立每個遞迴函式的右邊節點；
也就是說，程式執行的優先順序是先往深處的方向走 而非先將這一層的狀況處理完，這種模式我們稱之為深度優先搜尋(Depth-First Search, DFS) ；
如果換作是優先順序是先廣泛地處理完這一層，再往下一層走 ，這種模式就稱之為廣度優先搜尋(Breadth-First Search, BFS) 。

程式碼的部分，僅需留意Java因為想避免overflow的狀況，
計算的方式為 start + (end - start) / 2 ，而非(start + end) / 2。

Java

Python

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

「時間/空間複雜度？」
(O(N), O(N)
每個節點都會掃過一遍，且基本和其他節點沒有太多連帶關係。)

「那麼如果要將一個BST轉成排序陣列 呢？」
(原則上可用Inorder Traversal ，
但留意不加NIL的狀況其實中間樹的架構資訊可能會就此流失掉)

相似及延伸

0109. Convert Sorted List to Binary Search Tree (起始給的從陣列/串列改成排序好的LinkedList)

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

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

從LeetCode學演算法 - 34 Array (6)

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

0977. Squares of a Sorted Array (Easy)

Question

Given an array of integers A sorted in non-decreasing order, return an array of the squares of each number, also in sorted non-decreasing order.

Example 1

1
2


Input: [-4,-1,0,3,10]
Output: [0,1,9,16,100]

Example 2

1
2


Input: [-7,-3,2,3,11]
Output: [4,9,9,49,121]

Note:

1 <= A.length <= 10000
-10000 <= A[i] <= 10000
A is sorted in non-decreasing order.

分析/解題

給定一個非遞減排序(也就是相等或遞增)的陣列，
以排序好的狀況回傳其每個元素平方後所得的陣列。

一般我們所熟知的排序應該需要至少O(NlogN)的狀況才能達成，
(之後筆者會再挑一題來專門作排序這個部分的問題)
但這題在平方過以後，並不算完全散亂的狀態，
原先負整數的部分平方後會由大到小排列 ；
原先0到正整數的部分平方後則會由小到大排列 。
利用這點我們可以使用two pointer的模式來進行處理，
每次將兩邊的元素絕對值進行比較，比較大的代表其平方後比較大，
將其取出置於新的陣列/串列的最右邊，依序往回填。

實作上，如果不限制A必須保持原樣的話，
也可以先將負號的部分全數去掉，再進行後面的比較時，
就可免去取絕對值了。

Java的部分兩個方法皆有提供，讀者可依實際狀況決定寫法。

Java

Python的部分，還另外提供了一個偷吃步的方法：
使用sorted函式搭配list comprehension，一行即可解決問題，
但其時間複雜度為O(NlogN) (因為直接使用排序法)

神奇的是，這個方法還比較快XD
(估計是A的長度限制在比較小的範圍，可能測試資料也不是很大，
所以主動用排序帶來的負面效益較低的原因)

Python

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

「時間/空間複雜度？」
(O(N), O(N)
每個陣列均會掃過一次，且會產生一個新的陣列。)

「這題在產生新的陣列的時候跟合併排序(Merge Sort)其實很像，
可以概略描述Merge Sort的作法嗎？」
(可以XD 這個我們之後會專門寫一題講解)
(如果不想等的話，可以先查詢Merge Sort，應該有蠻多資料的，
但簡言之，就是每次將陣列拆兩半，
分別各自排序過後(mergesort)，再依序合併起來(merge)。)

相似及延伸：
1. 0021. Merge Two Sorted Lists (Easy)
2. 0148. Sort List (Medium)

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

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

從LeetCode學演算法 - 33 Array (5)

Sun, 18 Aug 2019 00:00:00 +0800

0905. Sort Array By Parity (Easy)

Question

Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.

You may return any answer array that satisfies this condition.

Example 1

1
2
3


Input: [3,1,2,4]
Output: [2,4,3,1]
The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.

Note:

1 <= A.length <= 5000
0 <= A[i] <= 5000

分析/解題

給定一個不含負整數的整數陣列A，回傳一個陣列，
這個陣列的前面會是所有A的偶數的元素，
跟在後面的是所有A的奇數的元素的部分。

這題我們在先前的Move Zeros題目中有提到過類似的部分，
如果當時我們只想把0往後挪而不需考慮保留原順序，
可以從兩端開始掃描，找到左邊是0而右邊非0並交換 就可以解完此題；
這題概念是一樣的，只是變成要左邊全是偶數，右邊全是奇數 。
演算的順序大概會像這樣：

分別取兩端的index作為起始(i = 0, j = l-1, l為A的長度)
先確認i的位置是否為奇數，若否，則遞增i，直到A[i]為奇數
再確認j的位置是否為偶數，若否，則遞減j，直到A[j]為偶數
交換A[i], A[j]
重複前述2~4的操作直到i不再小於j(開始前也要檢查)
此時全數交換完畢，所有偶數應排在奇數之前

這邊程式碼需要注意continue的作用，
目的是讓每次index變動都進行i<j的檢查，
唯有這個條件成立，我們才有可能需要進行交換。

Java

Python的部分後面提供了一個非in-place的作法，
也就是各自將偶數和奇數的串列累積起來，
最後再將其連接。好處是比較簡單，缺點是要額外的空間來存，
端看使用者需求和題目需求來決定。

Python

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

「時間/空間複雜度？」
(O(N), O(1)
two pointer會掃過整個陣列，所以時間複雜度為O(N)；
如果不另外開陣列/串列的話，可以用in-place達到則空間複雜度為O(1)，
如果像Python額外提到的方法的話則由於額外儲存的關係需要O(N))

「如果除了偶數在前，奇數在後以外，要按照原先順序排列呢？」
(Python的另一個解就會按順序排)

相似及延伸：
1. ** 0283**. Move Zeros

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

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

從LeetCode學演算法 - 32 BST (2)

Fri, 16 Aug 2019 00:00:00 +0800

0700. Search in a Binary Search Tree (Easy)

Question

Given the root node of a binary search tree (BST) and a value. You need to find the node in the BST that the node’s value equals the given value. Return the subtree rooted with that node. If such node doesn’t exist, you should return NULL.

For example,

1
2
3
4
5
6


Given the tree:
 4
 / \
 2 7
 / \
 1 3

1

And the value to search: 2

You should return this subtree:

In the example above, if we want to search the value 5, since there is no node with value 5, we should return NULL.

Note that an empty tree is represented by NULL, therefore you would see the expected output (serialized tree format) as [], not null.

分析/解題

給定一個二元搜尋樹及一個值，試找到這個樹上含有該值的節點；
如果找不到任何節點的值和此值相等的話，回傳NULL。

一個Binary Search Tree在進行搜尋特定值上最大的好處就是，
**碰到相等是目標，比完較小往左走，
比完較大往右走，走到盡頭就沒有。(XDDDD)**類似binary search，只是我們的每次切半/改動上下界的操作，
更改為往左走或往右走。

所以我們只要進行遞迴，直到走到NULL(NIL)或走到剛好對的值即可，
下面的程式碼中，由於判斷root是否為NIL 及root的值等於目標值 的狀況，
均為回傳root (雖然一種情況是NIL，另一種情況不是)，
所以我們可以將之合併。

而當val < root.val 的時候，
選擇往左走 去找比當下的root更小的值來比較，反之則往右走。

在實測上以筆者目前的觀察，是否全數使用if/elif連貫的判斷式，
或者前面root的回傳是否合併成一個情況，
均對執行的速度沒有特別明顯的影響 ，
故讀者可依自己的喜好選擇撰寫的方式，只需邏輯正確即可。

此外，之前可能有提到過的三元運算子 ( ? : )也僅是方便縮短行數，
同樣對結果沒有影響。

Java

Python

如果讀者習慣於使用LeetCode解二元樹或二元搜尋樹的題目，
應該會發現其實二元搜尋樹是可以使用陣列/串列的方式進行輸入 的。
這麼做的好處是只要管理好index，就可以用index的操作 來達到走訪某個節點的目的，而不用真的去把每個節點都進行連結到left/right。
缺點的部分則是有些地方必須輸入null進去(因為有可能會是null節點)。

讀者可以找一些題目來思考一下，
(像是前面的0094. Binary Tree Inorder Traversal)
如果從index i想要走到其left/right節點，這兩個的節點index會是多少呢？
讀者可以開啟Testcase中的Tree Visualizer，
來觀看輸入的陣列會長成的樹的形狀。
(註：這種表示法未必是通用的，但可以做為參考。)

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

「時間/空間複雜度？」
(Worst case O(N)/Average Case O(logN) , O(1)，
最糟的狀況是所有節點集中在同一側，一路搜尋到最底下；
平均來說，如果節點較接近平衡的分布的話，
每次搜尋往下走能去掉一半的可能性，所以會是O(logN)。
由於不需要額外的紀錄，所以空間複雜度為O(1))

相似及延伸

1.0701. Insert into a Binary Search Tree

Special Thanks suggestions/corrections from viewers: 感謝Tony Kuo 的建議，這邊附上之前講的BST定義及validation的文章。
從LeetCode學演算法 — 16 BST (1) (0098. Validate Binary Search Tree)

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

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

從LeetCode學演算法 - 31 Linked List (4)

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

0141. Linked List Cycle (Easy)

Question

Given a linked list, determine if it has a cycle in it.

To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.

Example 1

1
2
3


Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the second node.

Example 2

1
2
3


Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the first node.

Example 3

1
2
3


Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.

Follow up:

Can you solve it using O(1) (i.e. constant) memory?

分析/解題

給定一個Linked List，試檢查其是否含有一個環(Cycle) 在裡面。
我們有一小段時間沒有講Linked List，這邊不再贅述其基礎特性，
想要複習的讀者可以參閱第4篇的說明。

當我們在考慮這個題目的時候，會留意到兩個特性：

這個Linked List是指Single Linked List(也就是指向的方向只有單向)。
如果有環的話，應該會從最後一個節點再連接到前面的節點。
(從中間的話就會產生分歧的狀況)

在以上的特性狀況下，假設有一個環在Linked List中的話，
取一個節點從head開始不斷往其next走，會先經過最後一個節點，
接著再接回到前面某個節點再往下走，這樣會是一個循環；
更重要的是，顯然一進入這個環中，接下來就會一直在環內移動 。
(因為走到尾端又會再接回來)

這裡我們引入一個蠻常用的解題方式：設定快速和慢速的指標 。
我們讓fast和slow先設定在head的位置，每次fast走兩步，slow走一步 ，
它們就像是國小時針分針追趕的感覺一樣。

接下來我們可以將狀況分成以下兩種：

假設有環的狀況，
不管走多快多慢都會陷入這個環內 ，
所以會變成每次fast多走了一步，這一步用來追趕slow 。
因為slow也沒別的地方可以躲，所以fast每次多走一步一定可以趕得上
(也因為一步一步趕所以沒有追上卻錯開的可能)。
因此，我們知道fast和slow最終會來到相同的位置(也就是兩者相等 )
假設沒有環 的狀況，
由於不會重複，故最終fast一定會先走到尾端 ，最後看到NIL 。

故我們要做的事情很簡單，只要先設定fast跟slow，
在它們沒有走到NIL之前，每次去檢查fast是否有追上slow。
追上的話就回傳true ，而如果看到fast的下一個節點是NIL 的話，
就代表走到盡頭了 ，此時應該要回傳false 。

整個演算的順序：

考量起始的狀況，我們必須先檢查head跟head.next 當中是否有NIL值
開始一個迴圈，
開始前讓fast被設定為fast.next.next，slow則被設定為slow.next 。
當fast還沒有遇到NIL前，每次各自走相應步數，再檢查兩者是否相等。
(相等表示有環 ，回傳true )
請注意：當fast和fast.next 都處於非NIL 的狀況時，迴圈才能夠執行。
當fast或fast.next是NIL的話：表示走到盡頭了！跳離迴圈後，
將其return false 以表示它當中並沒有環。

寫成程式碼大概如下面所示：

Java

Python這邊額外提供了LeetCode使用者 StefanPochmann 的做法，
這個做法使用了try…except來進行錯誤處理，
有興趣的讀者不妨試試看。

Python

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

「時間/空間複雜度？」
(O(N), O(1)
由於fast比slow每次多走一步，我們可預期在走環的部分時，為了相遇走的長度的複雜度為O(K)。那麼K最大也頂多就是囊括所有節點，
所以時間的複雜度最大就會取決於N 。
當然，還有另一種狀況是裡面沒有環 ，
時間複雜度也是O(N)。(走到底就結束了)
另外，我們沒有另外需要存下其他整個LinkedList的節點，所以僅有一些必要的節點被宣告，故空間複雜度為O(1))

相似及延伸：
1. ** 0142.** Linked List Cycle II

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

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

從LeetCode學演算法 - 30 Tree (7)

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

0144. Binary Tree Preorder Traversal (Medium)

Question

Given a binary tree, return the preorder traversal of its nodes’ values.

Example:

1
2
3
4
5
6


Input: [1,null,2,3]
 1
 \
 2
 /
 3

1

Output: [1,2,3]

Follow up: Recursive solution is trivial, could you do it iteratively?

分析/解題

題目給定一個二元樹，試求其Preorder Traversal(前序走訪)。

先前我們介紹過Inorder Traversal，對於Preorder，大家應該也會有一個心理準備，就是使用遞迴會很簡單，迭代則會不容易思考XD。
再複習一下，所謂的Preorder指的是走訪的順序依序為根->左->右 ，走訪的時候遇到根的時後先輸出，接著優先往左邊走，當左邊的全走完時，
才檢查右邊的節點，依此順序將所有節點輸出。

作為遞迴的方式，我們每次將根節點的值放進res(result)中，接著再呼叫遞迴依序進行左邊節點和右邊節點的走訪即可。
Java中使用add，Python中則用append，在前面不要忘記檢查當走到NIL(null/None)的時候要退回到上一層(直接return)。

那麼，迭代的方式呢？
由於之前我們已經提到過在Python裡面，List的append/pop可以拿來當作stack的push跟pop來使用，要用Queue的話則必須用Deque。
所以我們這邊依舊使用stack的思路來解題。

我們已經知道對於stack來說有LIFO(後進先出) 的特性，
利用這點，我們可以讓進入stack的順序設定為右->左->根，
如此pop出來的時候順序即會符合根->左->右的狀態。

思路如下：(前面應先檢查root是否為NIL)

設置一個stack名為st，將root放入，再設一個記錄結果的串列res。
當st裡面有節點時，pop出一個節點n 。
將n的右節點 push至st(如該節點不為NIL)
將n的左節點 push至st(如該節點不為NIL)
將n的值 放到res中
重複2~5直到st中沒有任何節點

這樣一來，我們可以使用一個迴圈，令res依preorder的順序拿到節點值。

Java

Python

這題比較困難的部分就在於迭代法的解法，
如果讀者一時無法理解，請嘗試用紙筆列出一些狀況操作，
會較能夠體會該方法是如何利用迴圈來達到目標的。

同時，存入根節點的值的時間點不同 ，
基本就決定了它是哪一種Traversal。

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

「時間/空間複雜度？」
(O(N), O(N)，因為最終都需要儲存整份樹攤平的結果)

「樹的形狀會影響其時間空間複雜度嗎？」
(只會影響中間空間暫存需要的大小(因為有stack或call stack)，
但複雜度不變 )

「給定一棵二元樹，
請依序寫出preorder/inorder/postorder/levelorder的結果」
(簡單卻重要，請讀者務必自己畫一棵並嘗試寫一下順序，
看看是否有搞混的地方，尤其是每次印出根節點的時機很重要。)

「如果該樹是BST，且改為inorder的話，
能否找到任二節點相差的絕對值當中的最小值？」
(利用inorder的狀態排出來的順序會是遞增排列，每次檢查相鄰的數即可。)

相似及延伸

0145. Binary Tree Postorder Traversal

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學演算法 - 27 Array (4)

Fri, 09 Aug 2019 00:00:00 +0800

0189. Rotate Array (Easy)

Question

Given an array, rotate the array to the right by k steps, where k is non-negative.

Example 1

1
2
3
4
5
6


Input: [1,2,3,4,5,6,7] and k = 3
Output: [5,6,7,1,2,3,4]
Explanation:
rotate 1 steps to the right: [7,1,2,3,4,5,6]
rotate 2 steps to the right: [6,7,1,2,3,4,5]
rotate 3 steps to the right: [5,6,7,1,2,3,4]

Example 2

1
2
3
4
5


Input: [-1,-100,3,99] and k = 2
Output: [3,99,-1,-100]
Explanation:
rotate 1 steps to the right: [99,-1,-100,3]
rotate 2 steps to the right: [3,99,-1,-100]

Note:

Try to come up with as many solutions as you can, there are at least 3 different ways to solve this problem.
Could you do it in-place with O(1) extra space?

分析/解題

題目給定一個陣列，將其往右輪轉k步，
要求直接將該陣列調整成輪轉後的結果。

這題一旦沒有Note的要求的話瞬間簡單一百倍 。
舉例來說，我們可以直接將後k項和前l-k項合併起來(l為陣列長度)，
就會是答案了；或者，將整個陣列重複銜接一次，取[(l-k):(2*l-k)]亦可。
(這兩個解法筆者列在Python的註解中供讀者參閱)
但，它們都不是in-place。

要考慮到in-place的話，我們必須知道，
一定有方法能讓他們跑到該有的地方，且不需用到超過O(1)以外的空間，
一般就意味著會在陣列進行swap的操作(交換兩個元素)。

先看一下原本的例子：
[1,2,3,4,5,6,7] and k = 3 -> [5,6,7,1,2,3,4]
先不論其他的部分，我們可以發現57從最尾端3個變成最前面的3個了；
與此同時，14自然從最前面4個變成最尾端4個。
我們先不論大家的順序，先將整個陣列倒過來的話，
可以先達到1~~4，5~~7分別占據目標的區塊的效果：[7,6,5 ,4,3,2,1]。
接著再比對一下，發現區塊是對了，但各自剛好被顛倒過一次 ，
那麼我們再對7~~5及4~~1分別各進行一次反轉 ，就會得到我們要的結果。

所以整個流程就會變成：

將整個陣列 進行反轉
將前k個數 進行反轉
將後l-k個數 進行反轉

反轉是很基本的操作，希望讀者能熟練掌握，
原則上利用two pointer的方式，每次將兩個元素進行交換 ，
並對pointer位置進行遞增/遞減的操作，直到相交 為止。
(例: [1 ,2,3,4 ]->[4,2 ,3 ,1]->[4,3,2,1])
Java的部分的兩數交換需要宣告一個暫存值tmp(temp)，
Python的部分則可直接使用a, b = b, a的方式進行交換。
最後，操作之前不要忘記將k先取除以l的餘數。

Java

Python

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

「時間/空間複雜度？」
(O(N), O(1)(如果是使用3次reverse的方法))

「如不限制空間複雜度必須O(1)？」
(可以參照上面Python程式碼中註解的做法)

相似及延伸

0031. Next Permutation (可以用到swap跟reverse的操作來解題)

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

從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學演算法 - 25 Array (3)

Tue, 06 Aug 2019 00:00:00 +0800

0283. Move Zeroes (Easy)

Question

Given an array nums, write a function to move all 0’s to the end of it while maintaining the relative order of the non-zero elements.

Example:

1
2


Input: [0,1,0,3,12]
Output: [1,3,12,0,0]

Note :

You must do this in-place without making a copy of the array.
Minimize the total number of operations.

分析/解題

題目給定一個陣列nums並要求將所有當中的0全部都放到最後面，
且必須保持所有非0的元素的原有相對排列。
另外Note中還要求必須要in-place且最小化總共操作的次數。

這題其實有很多變形，雖然簡單，
務必請留意題目所要求的條件，不要倉促作答。

首先題目強調必須in-place(in-place的部分先前的文章有提到過)，
故諸如開一個ArrayList/List來將所有非0的部分一個一個存起來的方法，
在這裡就完全行不通了。

直覺上或許讀者會想到諸如以下的方法：

從頭開始找到第一個0元素(位置假設為a)
找到從這個0元素以後第一個非0的元素
將兩者交換
從a+1開始找到下一個0元素
再找到從這個0元素以後第一個非0的元素
按照這樣的邏輯直到沒有更多的0元素，或找到0元素以後，
其後沒有非0的元素為止。
(上面的方法沒有很嚴謹，因為1有可能就已經找不到0元素了，
僅為大概的範例)

但這樣的方法對每一個0元素都有可能需要掃瞄過一整個陣列，
總體的時間複雜度會來到O(N^2)。

有更好的方法嗎？
我們可以先考慮：
如果我們將原先的陣列當成額外開的ArrayList或List來使用的話呢？
先將所有的非0值從index 0開始放入，直到沒有非0的元素為止，
接著，和開新的空間不同，後面多出來的部分相當於被排開的0 ，
所以我們要將後面的值全部設為0 。

這麼做只需要記錄當前非0的部分放到哪邊，在其後再進行補0的動作即可，
最極端的狀況是全部都是0(即完全不用更動陣列)，
以及全部都非0(即將原本的位置複寫相同的數字一次)；
一旦中間有出現0的狀況，只代表其後的數字被往前挪一格，
讀者可以紙筆稍加操作看看即可確認不會有非0的數字會被吃掉XD~

我們使用了index來記錄下一個即將被寫入非0數字的位置，
遍歷整個陣列/串列，當元素非0時，則將其寫入index的位置，
並遞增index，其程式碼如下所示。

Java

Python

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

「時間/空間複雜度？」
(O(N), O(1)，因為最多只須掃過陣列兩次即可)

「如果不要求順序保持相同的話呢？」
(使用two pointer的方式，i由頭至尾，j由尾至頭，
分別找到0和非0的元素進行交換，直到彼此交會即可。
時間/空間複雜度相同但可預期因只須掃過一次陣列，有機會較快)

「如果不要求要in-place呢？」
(以python為例:
res=[x for x in nums if x != 0]
res += (len(nums)- len(res))*[0]
(後面再接上對應個數的0即可)
(時間/空間複雜度O(N),O(N))

所以，有些題目簡單歸簡單，看到的時候，還是請留心限制條件，
它有可能跟你熟悉的題目有些出入！有時候一旦限制條件不同，
可以用的手段和時間/空間複雜度可能就會完全不同了！

從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學演算法 - 23 Array (2)

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

0229. Majority Element II (Medium)

Question

Given an integer array of size n,
find all elements that appear more than ⌊ n/3 ⌋ times.

Note: The algorithm should run in linear time and in O(1) space.

Example 1

1
2


Input: [3,2,3]
Output: [3]

Example 2

1
2


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

分析/解題

跟上一篇相似，這篇將出現超過二分之一改變為三分之一，
要求求所有出現超過三分之一次數的數值，
這使得可能超過三分之一的種類會變成2種，但並不保證一定會有2種。
按照上一篇的摩爾投票算法的思路，
我們可以取2個數(n1, n2)暫存，
每次拿一個新的來檢驗並處理每三個相消的動作，
這樣我們即可以保證留下來的會有當中超過三分之一的元素。

要特別留意的是，兩個數有可能會是一致的，
且不一定每次都存在2種超過三分之一的元素，
所以最後我們要個別重新確認留在n1及n2上的元素，
其個數是否有超過三分之一。

Java

Python的部分，我們這邊除了同於Java的解法以外，
再提供一個簡單的作法：使用Counter。
利用Counter可以將一個列表轉換成Counter物件，
儲存的方式是(key:元素及 value: 該元素出現的次數)
在迴圈中的取用基本上跟字典類似。
只要檢查每個元素出現次數是否大於三分之一的數量即可加至結果。

(請留意如果認真按照題目要求的話，
這個解法因為會佔用額外O(n) 空間，
故不是一個在O(1)空間內可以完成的算法。)

Python

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

「時間/空間複雜度？」
(O(n), O(1)。
要經過整個陣列兩次，且額外並沒有需求常數次數以外的空間)

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

從LeetCode學演算法 - 22 Array (1)

Wed, 31 Jul 2019 00:00:00 +0800

0169. Majority Element (Easy)

Question

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.

You may assume that the array is non-empty and the majority element always exists in the array.

Example 1

1
2


Input: [3,2,3]
Output: 3

Example 2

1
2


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

分析/解題

嗨，大家今天過得好嗎？歡迎回到軟工宅宅(誤)。
接下來的幾題我們會著墨一下有關陣列(Array)或列表(List)相關的內容。

題目給定了一個長度為n的陣列，
已知當中有一個majority element(佔大多數的元素)，
這個數的個數會多過於⌊ n/2 ⌋。
(此符號代表向下取整數，如⌊ 5/2 ⌋=2。
別忘了是more than，所以如果n是5的話，
代表majority element至少要有3個)

題目還貼心地告訴我們，可以假定陣列不是空的，
且一定存在majority element，所以這邊可以省掉一些常用的檢查。

怎麼解這題呢？
一般來說的直覺可能會想使用HashMap來解(Python則用dict)，
將每個數塞入HashMap/字典中，最後找最大的那個數就是了。
這麼做的時間複雜度為O(n)，空間複雜度亦為O(n)，
因為插入耗費的時間為O(1)，插入n個數即為O(n)，
同時，我們只能保證最多有n - ⌊ n/2 ⌋的不同種類的數，
所以空間上還是保持在O(n)的複雜度。
在中途過程中在去檢驗是否有超過半數的element也可以，
但由於過程不保證會先碰到超過半數，所以額外檢驗的時間，
和省下來後面可能不用做完的時間相比，是不能肯定誰效率比較好的。

那麼，有沒有比較節省空間的做法呢？
有的！這裡介紹一個演算法，全名叫做：
Boyer–Moore majority vote algorithm(摩爾投票算法)
這個算法的核心在於，
刪去一個數列中的兩個不同的數字，不會影響該數列的majority element。

假想有一群人要投票，候選人有A、B、C，假設A已知會過半數的話，
任取其中2個人取消他們的投票資格，會有以下的狀況：

被取消資格的是B跟C -> 顯然A還是過半數(而且比例更高了XD)
被取消資格的是(A, B)或(A, C) -> 一個投A的和一個不投A的同步被排除，所以無法改變A會過半數的狀況。

同理，在不只3個候選人(數字)的時候，每次取2個人取消投票資格(移除)，亦無法改變投票結果(A還是會是majority element)。

註：
所以我們可以知道，當你跟你的家人政治立場不同時，
只有兩個人的狀況下都不去投票是沒有用的，
有用的方式是在投票前夕帶著跟你立場相反的家人們出國去玩 ，
多於1人時，每多一個人你就多賺一張選票差距 ，但你的荷包可能會哭。
(不要說是我教的！)

依此，我們可以使用下列的方式來進行陣列運算：

取出第一個數放到一個暫存的變數(res)，
將計數器(cnt)設定為1，代表這個數出現1次。
取出下一個數nums[i]，如果和res相等，則將計數器+1；
如果和res不同，且計數器>0時，將計數器-1；(代表取這兩個數成對移除)
如果和res不同但是計數器=0時，將res更改為nums[i]並將計數器+1(代表res已經用完了，現在還沒被移除的是nums[i])
反覆進行步驟2直到陣列結尾，剩下的res即為答案。
(因為兩兩移除到最後一定是非majority element的先被移光)

Java

還有另一種作法，是將陣列進行排序，
無論如何majority element一定會通過中間的位置。
這種方式的時間複雜度為O(nlogn)，空間複雜度視你的呼叫方式而定，
可能是O(1)也可能是O(n)(將排序的結果放到別的地方的話)

Python

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

「時間/空間複雜度？」
(O(n), O(1)，除了一些變數以外我們沒有使用到額外的空間)

「各方法的優劣為何？」
(可以參照Solution的頁面，這篇作者分析的內容很完整)

從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學演算法 - 20 Tree (6)

Sat, 27 Jul 2019 00:00:00 +0800

0110. Balanced Binary Tree (Easy)

Question

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as:

a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example 1

Given the following tree [3,9,20,null,null,15,7]:

Return true.

Example 2

Given the following tree [1,2,2,3,3,null,null,4,4]:

Return false.

分析/解題

題目給定一個二元樹，試檢查其是否為高度平衡的狀態。
前面已經提到過很多次，若是一棵樹長得不夠平均(例如都長在同一邊)，那麼在進行一些操作的時候會相當耗時間，
這也是為什麼我們會在意一棵樹高度是否平衡的原因。

而題目給的條件其實以更常見的定義來說，會定義成如下所述。
假如底下3點成立，一棵非空的二元樹就被稱作是平衡的：

二元樹的左子樹是平衡的
二元樹的右子樹是平衡的
二元樹的左右子樹高的差不大於1 對於一個樹的高度(或稱作深度)，
是指從樹的根節點走到葉節點的最大長度，所以基於這點，我們的流程應該是從根節點往下，檢查以每個節點為基準的左右子樹高的差均不大於1，該二元樹即為平衡的，反之則為不平衡。

依此，我們會需要知道除了根以外，每個節點的深度，
故可以簡單利用遞迴來操作：

先試寫看看maxdp這個函式的虛擬碼(假設你要求root這個node的深度)：

1
2
3
4
5
6


maxdp(root) {
 if root == NIL return 0
 l = maxdp(root.left)
 r = maxdp(root.right)
 return max(l, r) + 1
}

當我們要求某個節點的深度時，
就相當於求其左右兩邊子樹深度的較大值+1 。
(+1是因為經過了自己這個節點)

回到我們原本的問題，我們想要求左右子樹的深度差不能大於1的話，只需要在maxdp函式中增加去判斷左右深度差即可。
我們同時可以使用一個變數res來記錄是否已經發生不平衡的情況，
一旦發生，其實可以不用繼續往下做。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


let res = true
maxdp(root) {
 if (root == NIL or !res) return 0
 l = maxdp(root.left)
 r = maxdp(root.right)
 if (abs(l-r) > 1) {
 res = false
 return 0
 }
 return max(l, r) + 1
}

在一開始的解答的isBalanced函式中呼叫maxdp，
最後將res回傳即可得到答案。

Java

Python這邊展示了一個再進一步的思路：
如果我們已經發現不平衡的狀況，可以使用-1做為代表，因為深度只可能大於或等於0，那麼，只要每次檢查是否出現-1，就不用使用額外的res變數來儲存結果，我們只需要檢查回傳是否為-1就可以判定二元樹是不是平衡了！

Python

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

「時間/空間複雜度？」
(最差狀況是樹很平衡，每一層都要檢查，時間複雜度是O(N)
自行宣告的額外空間是O(1)，但遞迴中需有Call Stack，
最糟的狀況也是O(N)(全擠在同一邊))

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

從LeetCode學演算法 - 19 Tree (5)

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

0111. Minimum Depth of Binary Tree (Easy)

Question

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Note: A leaf is a node with no children.

Example:

Given binary tree [3,9,20,null,null,15,7],

return its minimum depth = 2.

分析/解題

題目給定一個二元樹，要求找到最小的深度，也就是從根節點到最近的葉節點的路徑長。(葉節點是指它底下沒有其他小孩 了)
上一題我們講解了一題Hard的題目，讓我們稍微喘口氣，
來看個這個比較基本的題目吧！

這題概念並不複雜，只要稍微弄明白要被遞迴的主體即可。
對一個節點來說，我們已經知道所謂的深度就是從根走到這個節點的長度 。
既然我們要求最小的路徑長度，可以選擇的方式就是分別看兩邊有多深，
最後選擇較小的那邊 ，加上1即可。(因為從根走到根的左/右節點要計算到)
那麼，左右各自有多深同樣也要取最小的路徑，
故一樣使用相同的方法再往下遞迴。

依此嘗試寫成遞迴的虛擬碼：

1
2
3
4
5
6
7
8
9


minDepth(root) {
 if root == NIL return 0
 l = minDepth(root.left)
 r = minDepth(root.right)
 if l == 0 or r == 0
 return l + r + 1 // 等同於取非NIL那條的路徑或取1(當左右都是NIL)
 else
 return min(l, r) + 1 // 左右都有時取較小的路徑
}

再化成程式碼如下：

Java

Python的部分使用判斷是否是None來處理，
本質上是一樣的，讀者可依個人喜好來選用寫法。

Python

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

「時間/空間複雜度？」
(由於必須遍歷所有節點，時間複雜度為O(N)，空間複雜度則依照stack深度而定，最糟的狀況也是O(N)，最好的狀況則是O(logN))

「可以用迭代解嗎？」
可以，但比較難想，有興趣的讀者可以嘗試使用我們還沒有仔細講過的level-order traversal 來解此題，大致的思路是使用Queue來保存相同深度的所有節點 ，並且用另一個Queue和level進行記錄，一旦在某次出現了node.left和node.right均為NIL 的狀況，代表在這層就遇到葉子，那麼就可以回傳level即為解答 。
這麼做的時間複雜度和空間複雜度均和最小深度 有關，若最小深度為D，
時間空間複雜度均為O(2^D)，雖然看起來比較可怕，
但其實最糟的狀況是這棵二元樹是平衡的，這時2^D-1 = N；
而其他狀況下複雜度肯定小於O(N)。

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

從LeetCode學演算法 - 18 Tree (4)

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

0124. Binary Tree Maximum Path Sum (Hard)

Question

Given a non-empty binary tree, find the maximum path sum.

For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along with the parent-child connections. The path must contain at least one node and does not need to go through the root.

Example 1

1

Input: [1,2,3]

1

Output: 6

Example 2

1

Input: [-10,9,20,null,null,15,7]

1

Output: 42

分析/解題

題目給定一個二元樹，試求其上最大的路徑和的值。
所謂路徑，就是在二元樹上任意挑兩個節點，從一個節點走到另一個節點，包含它們自己，所經過的所有節點值的和。
最小的條件是兩個節點相同，這時候的路徑長等同於這個節點的值。

嫌前面太簡單了嗎？別急，Hard等級的題目這不就來了嗎XD
在講解以前，建議讀者先思考一下有沒有任何頭緒並寫下來，再接著往下面看分析，相信會有比較好的收穫。

開始囉！

如果我們多拿幾組節點來進行觀察，會發現從一個節點要走到另一個節點，要先經過它們最低的共同祖先節點(這邊指從雙方往上走第一個碰頭的位置)，再走下來才行。
以Example 1來說，2和3的最低共同祖先是1，
以Example 2來說，15和7的最低共同祖先是20。

那麼，我們怎麼決定兩個節點的路徑長呢？
假設我們知道AB兩個節點的話，它們一定會有一個最低的共同祖先節點，
當中可能是A或B自身，也可能是其他節點 (如前面的範例就都是其他節點，而如果取的是-10跟15的話那最低的共同祖先節點就是-10)，
所以每個節點都可以有做為節點的最低共同祖先節點的可能 。

我們姑且將最低共同祖先節點叫做中繼點好了，比較方便XD
接著，將不含中繼點的左邊的最大路徑和叫做l，右邊的最大路徑和叫做r，對於某個中繼點(node n)而言：

通過中繼點n的最大路徑和 = max(n.val, n.val + l, n.val + r, n.val + l + r)
(因為l或r都有可能是負的，所以要把這四種都考慮在內)

接著我們要考慮的是，如果中繼點是別的點而不是現在這個點 ，
我們只是經過它但想知道包含這個點往下走最大路徑和 是多少的話，
那我們只能去考慮n.val/n.val+l/n.val+r 這三種狀況。
(因為n.val+l+r代表這個點是做為中繼點才會有分支)

所以我們可以嘗試用遞迴的方式解題，從root開始往下走到每個節點，計算該節點往下走的最大路徑和 ，並且每經過一個節點就考慮看看這個節點是中繼點的狀況，一旦發現最大值比現有記錄的大，就更新成新的最大值 。
由於用來遞迴的函式是一路優先往下一層節點進入(一直到最底下才能回頭依序得到各自的l跟r)，這種優先往深的方向走的方式我們一般稱為深度優先搜尋 (DFS, Depth-First Search)。

寫成虛擬碼如下：

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


define res
maxPathSum(root){
 res = root.val
 dfs(root)
 return res
}
dfs(n){
 l = (n.left != NIL) ? dfs(n.left) : 0
 r = (n.right != NIL) ? dfs(n.right) : 0
 m = n.val
 m = max(m, l + m, r + m) // 單做為經過點的最大路徑和
 res = max(res, m, l + r + n.val) // m已比過3種可能，故只需再考慮中繼點
 return m
}

在這個虛擬碼當中，我們先考慮左右是否還有連接節點 ，有的話就進行dfs往下找出經過點 的最大路徑和，沒有的話則補上0 ；接著先考慮m的部分，再利用已經比過大小的m來和作為中繼點的狀況比較，最後和當前最大路徑和相比並更新結果，完整走完所有流程即可得到回傳的答案。

Java的部分，這邊使用了if來作比較，實測上和一組一組依序使用Math.max來相比並沒有明顯速度上的區別，讀者可依自己喜好使用。

Java

Python的部分，留意呼叫時加上的self.即可，
且max可適用於多個傳入值，比起Java會再方便一點。

Python

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

「時間/空間複雜度？」
(每個節點均會走過一遍，故時間複雜度為O(N)
除了res, l, r, m以外沒有額外的空間了，自行宣告的空間複雜度為O(1)，
但進入遞迴會用到Stack，最大應該是這棵二元樹的高度，
也就是最糟的狀況下可以到O(N)，最好的狀況則是O(logN))

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

從LeetCode學演算法 - 17 Tree (3)

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

0094. Binary Tree Inorder Traversal (Medium)

Question

Given a binary tree, return the inorder traversal of its nodes’ values.

Example:

1
2
3
4
5
6


Input: [1,null,2,3]
 1
 \
 2
 /
 3

1

Output: [1,3,2]

Follow up: Recursive solution is trivial, could you do it iteratively?

分析/解題

給定一個二元樹，題目要求以inorder(中序)方式回傳其節點值。
由於上一題的關係(讀者可以回頭參照第16篇)，我們已經講解過In-order的方式了，原則上就是經過左邊的部分->中間的部分->右邊的部分 的順序。
請留意這題輸出並不一定會由小到大(因為並沒有限制是二元搜尋樹)。

我們先來嘗試遞迴解法，通常較為簡單，這邊重新列出上一篇提到的：

1
2
3
4
5
6


inorder(root) {
 if root == NIL return
 inorder(root.left)
 print(root.val) // Or add/append to the list
 inorder(root.right)
}

若讀者感到不太能夠掌握這個流程的運作，可回頭參考第16篇的gif動畫。
總體而言，每次我們都會走到當前所能走到的左邊 ，直到左邊再也沒有node(變成NIL )時，會回到上一層 (return)，印出值 (或將其放到list中)，接著再往自身的右邊找 ；每次同樣的模式操作完以後，我們可以保證對於每個子樹，都是先拿到其左邊的節點值(們)，再來是自身，最後才是右邊的節點值(們)，從而保證這個演算法是得以遵照目標的順序完成的。

由於我們會使用一個ArrayList或List來存放inorder得到的值，所以下面是採用先宣告再將其放置到另一個遞迴用函式中處理的方式。當然，如讀者只想使用一個函式來遞迴，也可以宣告一個Solution的class變數，這樣就不需要每次傳遞了。兩者各有好處，讀者可依自己喜好決定。

Java

Python

那麼，如果是要求要迭代解(iterative solution)呢？
我們回顧一下前面的作法，遞迴的時候之所以我們能回到上一層，其實是因為我們的程式有記錄上一層的函式的執行狀態，從而在return時能返回到應該繼續的那一行執行。由於最後一層函式在返回時必須先被呼叫到 ，所以電腦在儲存時是採用Stack 的形式(因為要後進先出)。(這個堆疊又叫做The Stack或Call stack(呼叫堆疊))

因此，我們想要能夠不用遞迴解的話，
顯然我們應該要自己使用一個Stack來處理整個流程。

在In-order的流程中，首先我們是先一路走到最左邊的node，
中途經過的node我們應該要將其放進Stack中，這樣才能回到上一層去，
我們將這個node暫時命名為curr(current)。
curr一路向左最終一定會遇到NIL，表示這排從root一路向左邊走，
沿途的node全數放入到Stack中了。
那麼我們應該要將最後一個node從Stack中拿出來(因為後進先出，最後一個node應該是最左邊的node才對)，將其放到list當中。
接著將curr設為自己右邊的node。
反覆上面的流程，一直到curr和stack都空掉為止。

寫成虛擬碼如下：

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


create a list named res
create a stack named stack
curr = root
while ( curr != NIL or !stack.isEmpty() ) {
 while (curr != NIL) {
 stack.push(curr)
 curr = curr.left
 }
 curr = stack.pop()
 res.add(curr.val)
 curr = curr.right
}
return res

Java

Python

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

「時間/空間複雜度？」
（O(N), O(N)，因為要走訪過整棵樹，且list要儲存整個二元樹攤平的結果）

「如果我將res放在class Solution的level有什麼優缺點？」
(優點：
有機會速度快一點點，且通常不用傳位址給函式，因為直接能存取到。
缺點：
對整個class均為可見，如果這個函式是要被反複使用的話，
要注意初始化的問題，且也有可能被其他函式修改到。)

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

從LeetCode學演算法 - 16 BST (1)

Sun, 21 Jul 2019 00:00:00 +0800

0098. Validate Binary Search Tree (Medium)

Question

Given a binary tree, determine if it is a valid binary search tree (BST).

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than the node’s key.
Both the left and right subtrees must also be binary search trees.

Example 1

1
2


Input: [2,1,3]
Output: true

Example 2

1
2
3


Input: [5,1,4,null,null,3,6]
Output: false
Explanation: The root node's value is 5 but its right child's value is 4.

分析/解題

題目給定一個二元樹，檢查它是否是二元搜尋樹(Binary Search Tree)。
終於我們來到二元樹的進階版了！
二元搜尋樹如同題目說明，要符合以下三個特性：

任一個節點的左子樹的所有節點值 均小於該節點自身的值
任一個節點的右子樹的所有節點值 均大於該節點自身的值
二元搜尋樹的左子樹 和右子樹 也都是二元搜尋樹

直觀來說，當我們從某個節點開始往左邊走的時候，一定要比自己小；
反之往右邊走的時候，要比自己大。也因為這個特性，當這棵樹足夠平衡時(節點分布的很均勻時)，會相當有利於搜尋值，因為每次都幾乎可以排除掉一半的可能性 。

Binary Serach Tree (Balanced, Complete, Perfect)

以下面的圖來說，我們想要從一個有15個節點的二元搜尋樹找到58這個值，
就要從根節點開始，每次比較大小，若58比較大就往右邊走，比較小就往左邊走，直到找到剛好的值，或是碰到NIL(沒有別的節點可以搜尋)為止 。
可以看到圖中由於深度一樣 的關係，不論搜尋什麼值，我們可以預期最多就只需要4次的比對就可以找出任意一個值是否在這棵樹裡面；每次刪去一半的可能性 ，所以如果總節點有N個的話，搜尋的複雜度最高即為O(logN) 。
(記得我們提過二元樹不一定非得要全部都有連接節點，這個結果是建立在這棵二元搜尋樹是平衡(balanced) 的狀況，如果這棵樹全部都改成只有左邊的節點的話，結果可是會變成O(N)的！)

Binary Search for value 58

我們同樣以上面這棵樹為例，
如果我們想知道它從小到大的節點怎麼排序呢？
這裡就需要使用到In-order Traversal了。
In-order的順序為左-中-右，代表每次我們目標要先拿到左邊的值，接著是中間，最後才是右邊的值；我們最後希望拿到的是[18, 20, 22, 33, 36, 37, 38, 43, 52, 54, 58, 61, 63, 66, 68]的話，我們要先一路走到最左邊 的節點，代表左邊沒有更小的值 了，才能將其印出來(18)，接著第二小的值則是最左邊節點的父節點(20)，而對33來說，還有20的右節點22比它還要小，最後以此類推，每次找到下一個最小值。
寫成虛擬碼如下：

1
2
3
4
5
6


inorder(root) {
 if root == NIL return
 inorder(root.left)
 print(root.val)
 inorder(root.right)
}

讀者可以嘗試使用上面的遞迴的方式走過一遍，或者參照下面的示意圖，
相信會較為理解這整個流程。留意上面由於當發現NIL的時候就直接return回到了遞迴的上一層，所以就會造成類似往上走一層 的效果。

In-order Traversal

回到我們的題目，我們已經知道在In-order的狀況下，對於二元搜尋樹可以得到一個由小到大的順序，所以只要記住上一個節點，每次去比較上一個節點和現在走到的節點，當現在的節點跟上一個節點相比較小或相等時，表示這不是二元搜尋樹(因為越後面的節點必須較大才行)；反之，當每個節點都走完沒有錯誤時，這時候就可以確認這個二元樹是二元搜尋樹了。

寫成虛擬碼如下：

1
2
3
4
5
6
7
8


let last = NIL
isValidBST(root) {
 if root == NIL return true
 if !isValidBST(root.left) return false
 if last != NIL and root.val <= last.val return false
 last = root // 更新上一個節點的位置
 return isValidBST(root.right)
}

Java的寫法部分，我們可以宣告一個class的變數last，
用來存放上一個走到的節點(放在函式內部的話會被洗掉)

Java

Python的部分，請留意到記得在呼叫時使用self的關鍵字，
否則可能會無法在isValidBST中取得last。

Python

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

「時間/空間複雜度？」
（O(N), O(1)，因為要走過整個BST，
但除了幾個變數外，不需額外的資料結構）

「可否不用遞迴呢？」
(可以，使用Stack，可以用迴圈讓每次先將root塞入，一路向左邊走將每個左節點放入Stack中，接下來同樣每次取出一個節點，判斷和前一個的大小比較。最後每個左側處理完以後，再將位置移向右節點，迴圈重複即可。)

「可以不用class的變數來解此題嗎？」
(可以，有一種解法是記錄對某個節點的最小值和最大值限制 ，將遞迴函式增加為傳入root, min, max 並隨著每次看到的節點更新其底下的限制條件，這樣就不需要按照in-order的方式移動，也不需要class的變數。Java的解法這邊收錄 ryanswizzle在Leetcode的解法如下。)

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


public class Solution {
 public boolean isValidBST(TreeNode root) {
 return isValid(root, null, null);
 }

 public boolean isValid(TreeNode root, Integer min, Integer max) {
 if(root == null) return true;
 if(min != null && root.val <= min) return false;
 if(max != null && root.val >= max) return false;

 return isValid(root.left, min, root.val) && isValid(root.right, root.val, max);
 }
}

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

從LeetCode學演算法 - 15 Bitwise Operation (2)

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

0136. Single Number (Easy)

Question

Given a non-empty array of integers, every element appears twice except for one. Find that single one.

Note:

Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

Example 1

1
2


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

Example 2

1
2


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

分析/解題

給定一個非空的整數陣列，當中每個元素都出現兩次，只有一個出現一次而已，題目要求找出那個單獨的數字。

在進一步往BST之前，先來一個簡單但一般不會想到的問題。
這題如果我們以暴力法來解的話，假設不用任何額外的資料結構，我們可以每拿一個數字就對整個陣列做比較，直到找到沒有重複的數字為止。但這樣除了時間複雜度會是O(N)以外(對單一數字，所以每個數字都做完就是O(N^2))，最後會發現有可能會有拿到先前拿過一次的數字，所以顯然是不太行的。

那輔以資料結構呢？
比較常用的方法是使用HashMap(Python則用dict)，為每個數字計數，計數完以後就掃過整個對應，看誰只有被數到一次，就是我們要的答案了。
這個方法要先走訪過一遍陣列，再走訪一遍HashMap或dict，時間/空間複雜度均為O(N)，但還是稍嫌慢了一些。

那有沒有更厲害的解法呢？有！
要了解這個解法怎麼操作，首先我們需要複習一下Bitwise Operation。
當中的XOR的內容是：將兩個數的每個位元兩兩相對，一個0一個1的時候，結果會是1，否則結果會是0 。
這可以讓數字運算得到一些神奇的特性，第一個特性是：

1

a XOR a = 0

我們拿11=1011(二進位)來試試看：

1
2
3


11 = 1011
11 = 1011
11 XOR 11 = 0000 = 0

因為每一位數都相同，XOR後每一位就都會是0。
第二個特性是：

1

0 XOR a = a, a XOR 0 = a

因為一邊都是0，所以那個位數是0或1，端看原先a的位元。
再來其他一些重要的特性是：

1
2


a XOR b = b XOR a (交換律)
(因每個位元的結果端看該位元總共有奇數或偶數個1，和順序無關)

1
2
3


(a XOR b) XOR c = a XOR (b XOR c) = a XOR (c XOR b) = a XOR c XOR b
(不論哪邊先做，結果都是看有奇數個1->結果是1，偶數個1->結果是0)
(最前面的部分是標準的結合律)

推而廣之，我們可以得到XOR具有交換律 和結合律 。將它的運算的數字左右調換，或者哪個先做，哪個後做，均不影響結果。

回到問題來，假設我們目標的答案是r，那麼將陣列中所有的數字XOR起來，會發生什麼事情呢？我們根據前面的已知，將陣列自己調換一下，應該可以變成：
r XOR a XOR a XOR b XOR b XOR c XOR c ……的形式。
(因為怎麼換都不應該影響結果)

於是，陣列全部XOR的結果會等於r XOR 0 XOR 0 XOR…… = r
(其它的兩兩XOR後會變0)
也就是說，將每個數都進行XOR後，結果會留存下那個唯一單獨的數字。
寫成程式碼如下，宣告變數為0後從index 0開始，或直接將陣列的第一個數指派給它並從index 1開始，實測上沒有特別感受到時間差異，讀者依照自己的喜好和習慣嘗試即可。

Java的部分用了語法蜜糖 ，
int e:nums代表自nums陣列按順序每次拿一個數並交給e。

Java

Python

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

「時間/空間複雜度？」
(由於只要整個陣列掃過一次就結束了且無須額外的陣列空間，
時間複雜度為O(N)，空間複雜度則為O(1))

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

註：感謝zhoumax的提醒修正一些敘述和筆誤。

從LeetCode學演算法 - 14 Tree (2) / Queue (1)

Wed, 17 Jul 2019 00:00:00 +0800

0101. Symmetric Tree (Easy)

Question

Given a binary tree, check whether it is a mirror of itself
(ie, symmetric around its center).

For example, this binary tree [1,2,2,3,4,4,3] is symmetric:

But the following [1,2,2,null,3,null,3] is not:

Note:
Bonus points if you could solve it both recursively and iteratively.

分析/解題

題目給定一個二元樹，要求檢查是否為左右對稱(Symmetric)。
繼前一篇的樹的基本以後，今天同樣來談談另一個基本題，幫助大家熟悉以外，也介紹一個資料結構Queue，用來說明我們怎麼來解迭代解的。

這邊講的左右對稱是指從根節點將左右切開來看，左邊和右邊恰巧要對稱。
要解決這個問題並不困難，但要留意小細節。

首先，如果給定的根是NIL(null/None) =>
沒有東西仍然是可以達成左右對稱，所以必須回傳真值 (true/True)。

扣掉這個狀況，再來觀察上面的圖可以發現，根節點毫不影響，
接著要比較的應該是左子樹跟右子樹是否對稱。
和前一題不同，以[1,2,2,3,4,4,3]為例，要符合對稱的條件，
應該要符合下面三點：

左子樹根的值=右子樹根的值
左子樹 自己的左子樹 (以本例是最左邊的3)要和右子樹 自己的右子樹 對稱
左子樹 的右子樹 要和右子樹 的左子樹 對稱

請留意1的部分，
如果兩者均為NIL ，表示下面不用比(空了)且兩者相等 ，
這時候應該回傳真值 ；而接下來再判斷其一為NIL 的狀況，表示兩者一定不相等(一個有節點一個是NIL )，這個技巧在上一篇同樣有使用到。
上面都沒成立的話，再判斷兩者值是否相等 。

所以直觀上我們可以寫出這樣的遞迴模式：
(註:留意我們這樣寫只是用來表達整個演算的流程，它通常並不能用來在某個語言執行，這樣的用來表達概念的代碼叫作虛擬碼(pseudocode)，虛擬碼通常不用嚴格按照特定規範，目的只是要先將你的流程想法釐清為主。 )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


isSym(root) {
 if root == NIL return true
 return isSymmetric(root.left, root.right)
}
isSymmetric(l, r) {
 if l == NIL and r == NIL return true
 if l == NIL or r == NIL return false
 if l.val != r.val return false
 return isSymmetric(l.left, r.right) and
 isSymmetric(l.right, r.left)
}

寫成Java如下，注意我們這邊將isSymmetric函式的前2行合併了，
使用者也可以依自己習慣決定要不要這麼寫，速度上並不會有明顯差異。
同時，對Java而言，我們可以定義同名的函式，只要輸入的參數(parameter)型態或數量不同，JVM就可以知道哪一條式子是呼叫哪一個函式才正確。
這個做法稱為函式多載(Method Overloading) 。

Java

Python並不支援函式多載，所以我們可以定義不同的名字來使用。
(註: 對於所有程式語言來說，
代表"且 “的操作，只要第一個條件為假，後面就不會再進行判斷；
代表”或 “的操作，只要第一個條件為真，後面也不會再進行判斷。
這個特性是為了節省時間，因為結果已經確定了 。
讀者可以留意一下這點，
避免將一些希望一定要被執行的函式放在判斷條件的第二個以後，
以免發生預期要做的事情結果沒做的狀況。)

Python

上面是遞迴的部分，接下來我們改成嘗試來使用迭代法解看看。
這邊首先要介紹一個資料結構Queue(隊列/佇列)。
隊列基本上就跟現場排隊名店一樣，扣除掉一些現實中的插隊之類的糟糕狀況外，基本上是先排隊的可以先離開排隊序列而進場，也就是說它的特性是先進先出(FIFO)。 我們將放一個東西到Queue中的操作叫作”Offer “(提供)，會放到隊列尾端；
從Queue裡面拿一個東西出來的操作叫作”Poll “(獲得)，會從隊列頭拿出。

這樣的特性對於解這題有什麼幫助呢？
我們可以如下操作：

首先判斷root的部分，沒有問題的話拿出其左右(l跟r)，放到Queue裡面。
此時Queue裡面有東西，一次拿兩個出來(poll兩次)，判斷l跟r本身
(如同遞迴時一樣)
接下來我們應該要判斷的是l.left, r.right跟l.right, r.left ，
所以我們將這四個節點依序offer至Queue中。
重複2~3的動作直到Queue空掉 或當中判斷為假 的狀況即回傳假。
如果Queue空掉了才離開循環，代表結果為真，回傳真值。

這裡我們利用了Queue的特性，只要依照我們目標的順序將東西放進Queue，我們就可以一直按照正確的方式拿到2個需要被判斷的節點。
這邊要注意一點，如果兩個節點均為NIL，只代表這個部分往下沒有節點了，不能直接回傳真值 (因為其他部分還沒比較完)，只是我們在這個位置不需要再放節點進到Queue中而已。

寫成虛擬碼如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


isSymmetric(root) {
 create a queue named q
 if root == NIL return true
 q.offer(root.left)
 q.offer(root.right)
 while q is not empty {
 l = q.poll()
 r = q.poll()
 if l == NIL and r == NIL continue
 if l == NIL or r == NIL return false
 if l.val != r.val return false
 q.offer(l.left)
 q.offer(r.right)
 q.offer(l.right)
 q.offer(r.left)
 }
 return true
}

注意continue 是用來表示這輪的迴圈不再繼續，直接跳到下一輪。

Java的LinkedList 已經有實作包含Queue的資料結構了，所以我們定義一個Queue時，實際上可以使用LinkedList作為宣告的物件。

Java

Python的部分，由於list的特性和Queue不太一致，
從開頭取出 這點會讓用list模擬Queue的行為消耗大量的時間。
針對這點，Python有提供一個deque 的物件可以使用，取出請用popleft() ，放入請用append() 即可。除了像Java這樣子的寫法以外，我們也可以將其使用list的形式每兩個作為一個單位來操作，請參閱下面的程式碼。

Python

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

「時間/空間複雜度？」
(最糟的狀況均為O(N)，因為要查完所有資料有可能要塞完全部的node
遞迴的狀況如果該樹是平衡的話，空間複雜度可以降到O(logN))

「可以將左右比較的順序調過來嗎？」
(只要對應的節點是正確的，先比左邊還是先比右邊並無差異)

「如果我不想在前面單獨判斷root的話，有可能嗎？」
(去掉第4行，並將第一次offer的(root.left, root.right)改成(root, root)即可。)

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

從LeetCode學演算法 - 13 Tree (1)

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

0100. Same Tree (Easy)

Question

Given two binary trees, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical and the nodes have the same value.

Example 1

1
2
3


Input: 1 1
 / \ / \
 2 3 2 3

1

 [1,2,3], [1,2,3]

1

Output: true

Example 2

1
2
3


Input: 1 1
 / \
 2 2

1

 [1,2], [1,null,2]

1

Output: false

Example 3

1
2
3


Input: 1 1
 / \ / \
 2 1 1 2

1

 [1,2,1], [1,1,2]

1

Output: false

分析/解題

給定兩個二元樹，試寫出一個函式來檢查二者是否相等。
(相等的定義是指樹的結構相同，且其相同位置節點的值也相等)

到了第13篇，終於來到樹的部分了，想當年大學時在演算法的課上被各種資料結構搞得眼花撩亂，當中二元樹/二元搜尋樹真的只能算小兒科XD
(不信？有心更進階的讀者可以試試看了解一下紅黑樹)

扯遠了，我們回頭來談樹。
在程式的領域中，樹是指資料之間以一種長得像樹的方式連結在一起的資料結構(廢話XD)，以外型而言就像樹狀圖 或族譜那樣子，不過它們有一點比較特別，那就是他們的根通常是畫在上方 ，下面才是支幹。
如下圖我們所看到的：

每個圈圈我們稱之為節點(node) 。2.最上面的節點是整棵樹的起始，所以我們就稱之為根(root) 。3. 就如族譜一樣，上面節點是下面直接連接的父母，
所以我們稱如A是B和C的父節點(parent) (不要問我為什麼不叫母節點XD)，而B和C是A的子節點(child)， 同時B和C是兄弟節點(siblings) 。
任何從自身追尋血脈上去可以到達的節點均為你的祖先(ancestor) 。
比如A是所有人的祖先，而B不是G的祖先。

From Wikipedia: Tree

樹本身並沒有規定一個節點要連接多少個節點或總共有多少個節點，
你可以子孫滿堂開枝散葉，也可以孑然一身孤苦伶仃，只要有一個根在，
就可以被稱做一棵樹。

不過這邊要介紹的是二元樹(binary tree) ，就有比較明確的限制了，
每個節點最多只能有2 個分支。且左右分支是視作不同 的，將它們互相交換的話，前後兩個二元樹會被視為不同的二元樹。由於只有2個分支，所以一個節點的兩個子節點又可以分別被叫做左節點和右節點(left/right node)，
單就這兩個節點來看，都可以各自視為一個二元樹，
同樣依照左右被稱作左子樹/右子樹(left/right subtree) 。
後續還有一個規範更嚴格，也更常被用到的二元樹稱為二元搜尋樹(Binary Search Tree, BST) ，這個我們之後會專門再開一篇講解。上面這些均為樹的相當基本的部分，並不困難，還請詳加閱讀後再往下。

如同先前提過的linked list一樣，當一個節點它有一邊沒有連接，或者是已經沒有子節點的時候，嚴謹的資料結構會將其連接至NIL (表示什麼都沒有)，而在Java中用null，Python則用None 表示。

一個Binary Tree, 15的左邊/17, 23, 25的左右其實都是NIL(恩，其實它也是BST)

回到問題，其實問題的輸入是透過array或list的型式，但這邊LeetCode應該已經妥善處理好建造二元樹的過程了，我們暫且不管它。
我們如何判斷兩個二元樹是否相等呢？
由於相等的前提是結構相同且所有對應的節點的值 也相同，我們勢必要一個一個檢查才能知道結果，所以我們必須要走訪整棵樹(Tree Traversal )。
一個標準的走訪分成四種模式：
前序、中序、後序以及層序(Pre-order/In-order/Post-order/Level-order) 我們這次只會先從最直覺的前序遍歷開始。

假設如題目所提，我們有兩棵二元樹，他們的root分別是p跟q，
那麼檢查它們是否相等的話，我們要做的事情是：

檢查p和q是否相等
檢查p的左子樹 和q的左子樹 是否相等
檢查p的右子樹 和q的右子樹 是否相等
唯有這三項均成立，我們才能說p跟q兩棵二元樹相等，否則即為不相等。
接下來，我們先考慮2和3的部分，
其實就等同於反複拿更小的子樹去做1~3的動作，
直到比對的兩邊當中有不同或空掉的狀況。

我們拿下面的圖為例，可以簡單推論出，
當檢查兩個節點是否相等 的狀況有幾個可確定：
a. 一邊有節點，另一邊沒有節點 => 結構已經不一樣了，所以兩棵樹不同 。
b. 兩邊均無節點 => 結構相同 且沒有子節點，所以這個位置的子樹相同 。
c. 兩邊都有結點 => 檢查值是否相同，相同的話，再檢查左右子樹 。
(也就是回到上一段那邊的2~3)

所以，我們可以用連續呼叫自己這個解題函式的方式來解決這個問題，
其演算方式可以大致列成這樣：

1
2
3
4
5


isSameTree(p, q) {
 若p和q均為NIL，回傳真
 若p或q為NIL，回傳假(因為表示恰有一個是NIL)
 回傳 (p.val==q.val) 且 isSameTree(p.left, q.left) 且 isSameTree(p.right, q.right)
}

注意這樣子的比較，我們每次是先比較根節點 ，再比較左節點 的部分，最後才是比較右節點 ，同時，每次呼叫isSameTree時，會一路往左邊先找下去，直到左子樹找完了才會走訪右子樹的部分，所以順序是根-左-右 ，也就是一般所謂的前序遍歷(Pre-order Traversal)。

這種不斷呼叫自己來求解的方式，我們稱之為遞迴(Recursion，或譯遞歸) ，這樣的解法一般稱為遞迴解(Recursive solution) ，一般來說還會有另一種解法，主要是透過額外的資料結構及迴圈 ，來解決問題，這種方式叫做迭代法/迭代解(Iterative method/Iterative solution) 。比較熟練的讀者若有興趣，可以自行嘗試使用Queue或Deque來解本題看看。

Java

Python的部分，由於NIL是用None來表示，
所以檢查可以用if not的方法來處理，且not運算的優先層級高於and/or ，
所以我們不用額外幫它加括號。

Python

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

「時間複雜度/空間複雜度？」
(如果答案為真的話，那麼每個節點均會走訪一次，故為O(N) )
(空間複雜度的話，遞迴同樣會佔用記憶體空間，層數則取決於樹的層數，
如果是平衡樹(balanced tree)的話，因為分布要平衡(填滿)，
每層的節點數量會是1, 2, 4, 8, 16, …, 總和N=2的n次方-1，n為層數。
所以空間複雜度會是O(logN) ，N為節點的總數。
最差的狀況下，節點全部連在同一邊，那空間複雜度可以達到O(N)。)

「可以不用遞迴解嗎？」
(可以，有興趣的讀者可以嘗試看看，具體方式是使用Queue或Deque，先將兩個根節點放入，接著每次取出一組節點對；先比較節點，再將兩樹其左右node成對地放入裡面 ，重複迴圈，直到有不相等 的狀況產生，或直到Queue/Deque內再無節點 。)

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

從LeetCode學演算法 - 12 Linked List (3)/ Stack (1)

Fri, 12 Jul 2019 00:00:00 +0800

0092. Reverse Linked List II (Medium)

Question

Reverse a linked list from position m to n. Do it in one-pass.

Note: 1 ≤ m ≤ n ≤ length of the list.

Example:

1
2


Input: 1->2->3->4->5->NULL, m = 2, n = 4
Output: 1->4->3->2->5->NULL

分析/解題

給定一個linked list，在只經過一次的操作下(每個node不會額外再走訪)，
題目要求將m到n的位置的節點進行反轉。

由範例可知這邊的m跟n是以開頭為1而非0來計算，這點讀者請特別留意。

我們先從理論上來看這題應該怎麼處理：
首先根據題目要求，m可能和n相等，
相等的狀況下其實完全不用做事，回傳head即可。

那麼如果是不相等的狀況呢？
在Linked List中，要知道某個位置的節點為何，唯有從頭一路走到該節點 。
我們想要反轉的是mn的位置：
以範例來說，會將24的位置進行反轉。
如何反轉呢？首先我們要先走到2的左邊，當我們把中間的部分反轉後，
我們還要將它們和左右兩邊接起來，要記得2的左邊跟4的右邊的節點才行。
(不然接不起來就GG了XD)
這邊將2的左邊命名為left，一路往下走的迭代節點命名為node，
走到m-1以前先記錄下left節點，再繼續往下走。

接下來問題來了，如何將2~4的部分反向連接呢？
你可以選擇一個一個拆解並重新鍵結，
但這裡筆者想介紹一個常用的資料結構：Stack(堆疊，或稱棧/堆棧)。
Stack的樣子，就跟某些苦命的辦公室人員的書桌一樣：
你會嘗試將書桌上的文件/工作處理完，但老闆總是會往上面再加新的。 也就是說，每次如果你選擇從最上面開始拿 (別從中間或下面，這麼高的文件可是會塌的！)，你會拿到最新的 工作。

Stack也是如此，假設你將1, 2, 3, 4, 5依序放入Stack中，那麼當你從Stack裡面拿東西的時候，拿出來的順序會是5, 4, 3, 2, 1。最後放進去的會最先被拿出來 ，這樣子的特性我們稱之為Last In First Out(後進先出，簡寫為LIFO)。有另一種資料結構叫Queue(隊列，或稱佇列) 跟它剛好相反，是先進先出 ，我們以後找機會再講解它。

如果這題應用上Stack的話，就簡單許多：
我們將2~4的部分通通丟進Stack中，再一個一個拿出來 ，
這時候順序就會變成4, 3, 2了！那麼，只要將剛剛存好的left，以及後面我們邊走邊看到4的時候，將它的右邊記錄起來的node，兩者再和中間的節點連結起來，就完成整個反轉的流程。

重新整理解題的順序：

判斷m是否和n相等，相等則直接回傳原先的head。
定義一個迭代用節點node，先走到m-1的位置以取得節點left。
讓node從m一路走到n，將每個node放入到Stack中。
(註:放入的術語在堆疊中叫作push)
node再額外走一步會走到n+1的位置
依次將Stack中的節點取出，並且依序連接所有節點的next，
直到Stack中再也沒有節點。
(註:取出的術語在堆疊中叫做pop)
將反轉完的尾巴和node做連接，結束整個反轉的流程。

這當中還有額外一點需要注意的是m=1 的狀況，
因為我們最後回傳的是用head 來代表整個linked list，
如果m為1的話，代表head其實已經被改變了，
我們需要同步更新head的部分。

請參照Java的寫法，我們採用了l1和l2兩個節點來處理依序連接的部分。
我們會先取出堆疊中第一個節點，這個節點會被left連接，
接下來使用l2 = st.pop(); l1.next=l2; l1 = l2;
來進行一次取一個node，將前後連接好以後，
將位置移到下一個準備連接的點。
也就是說，每次l1所在的位置，都是當前準備進行連接next的節點 。
(若讀者對這邊的說明感到抽象，請務必在紙上試著操作一下會較清楚)

在Java中，Stack的宣告方式是：

1

Stack<> st = new Stack<>();

請在"<>“之中填入你想要使用的資料型態，
在本例中為題目已經定義的class ListNode。

函式用法的部分，push()用來放入節點，pop()用來取出節點，
isEmpty()則是檢查Stack是否是空的。
(還有一個peek()，是用來看Stack最上面節點，
但不會真的將節點從Stack中移除)

Java

在Python中，list的特性可以方便的用來當作Stack使用，
放入節點可以使用append()，取出節點使用pop()。

Python

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

「時間/空間複雜度？」
(O(N), O(n-m)，因為我們的堆疊最多只需要存中間的部分和兩旁的node)

「可以只用O(1)的空間嗎？」
(可以，如果我們按順序一個一個處理m~n之間的連結，
最後再將n和m和左右兩邊連起來，是可以不使用Stack的
中間的連接方式會像是：

1
2
3
4


third = cur.next
cur.next = prev
prev = cur
cur = third

讀者有興趣的話可以嘗試看看。)

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

從LeetCode學演算法 - 11 Bitwise Operation (1)

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

0089. Gray Code (Medium)

Question

The gray code is a binary numeral system where two successive values differ in only one bit.

Given a non-negative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.

Example 1

1
2
3
4
5
6
7


Input: 2
Output: [0,1,3,2]
Explanation:
00 - 0
01 - 1
11 - 3
10 - 2

1
2


For a given n, a gray code sequence may not be uniquely defined.
For example, [0,2,3,1] is also a valid gray code sequence.

Example 2

1
2
3
4
5


Input: 0
Output: [0]
Explanation: We define the gray code sequence to begin with 0.
 A gray code sequence of n has size = 2n, which for n = 0 the size is 20 = 1.
 Therefore, for n = 0 the gray code sequence is [0].

分析/解題

格雷碼是一個二進位表示的編碼系統，當中每個連續(相鄰)的二個值之間的表示方式只會相差一個位元(bit)。題目給定n個bits，試求出其表達的格雷碼序列。(格雷碼序列一定是從0開始)

在這邊簡單講解一下Bitwise Operation。
(註:本題雖然不會用到太多，
但熟悉這些操作對於一些題目和實際應用上很有幫助，
故在此先行列出給讀者學習。)

先前的文章中已經提到了，電腦對於二進位制的東西操作起來是較為得心應手的，當然我們可以不用像電腦這麼熟悉，但只要會用就可以了XD
二進位之間的一些操作運算，就像是邏輯學上的運算一樣，
有AND/OR/NOT/XOR，以及位移運算(bit shifts)等，這些速度在相同狀況下是由CPU進行支援的，運算速度往往會比一般的四則運算還快。

AND(且):
邏輯上的AND，代表著前後皆為真的狀況結果才為真，否則為假 ，
也就是兩者皆成立才行。在位元運算中，1被視為真，0被視為假。
(所以在如C/C++中你可能會看到使用IF 1或IF 0的開關)
延伸到多個bit的狀況，就是將前後兩者每個bit兩兩相對，
當兩者為1時，運算完的那個新的bit為1，否則為0。
如 110 AND 100的結果會是100(只有最左邊的bit是兩個1)
Java和Python中的AND運算符號均為"&" 。
(請留意，如果判斷兩個運算結果的是否為真 的邏輯運算，
Java是"&&"，Python則是"and" ，
以位元為基準的運算和求真偽的邏輯運算是不同的，記得不要搞混了！)

OR(或):
前後兩者只要其一為真結果即為真，
也就是只有兩者皆不成立時，結果才會是假 。
所以在位元運算中，
兩兩相對，除了兩個bit都是0的運算結果是0外，其餘都會是1 。
如 110 OR 100的結果會是110(只有最右邊的bit是兩個0)
Java和Python中的OR運算符號均為"|" 。
(如果是邏輯運算的話，Java是"||"，Python則是"or" )

NOT(非):
邏輯上的NOT，代表將該真/假狀況轉為原先的相反 ，
真的變假的，假的變真的 。
在位元運算中，對每個bit操作，
只要原先是1的均變為0，為先為0的則變為1 。
如NOT 110的結果會是001。
Java和Python中NOT運算符號均為"~" 。
(如果是邏輯運算的話，Java是"!"，Python則是"not" )

XOR(互斥或，Exclusive OR):
邏輯上的XOR，代表前後兩個狀況剛好有一個成立時為真 ，
即前真後假/前假後真，其餘皆為假。
位元運算的部分，兩兩相對檢查，當發現是一個1一個0的時候，
結果為1，否則均為0。
如1100 XOR 1010的結果會是0110。
Java和Python中的XOR運算符號均為"^" 。

位移運算:
將一個數的所有bit的東西往左或往右移動指定的位元數，
超出儲存空間的部分捨棄，被位移走的原處則補0。
Java和Python中使用"«“和”»“分別代表向左位移及向右位移。
例如:
2 « 1 的結果會是4，因為2的二進位是"10”，
這個操作代表2向左位移1個bit，空白的部分補零，
所以會得到"100"也就是十進位制的4。

9 » 2的結果會是2，因為9的二進位是"1001"，
這個操作代表向右位移2個bit，所以"01"的部分移出儲存範圍了被捨棄掉，
會得到"10"，也就是十進位的2。

直觀上我們可以將位移N個bit視作乘以或除以2的N次方，
但要注意範圍是否正確，以及是否要處理正負號 的部分。

上面介紹了位元運算以後，讓我們回到題目。
在通訊傳輸的過程中，有可能因為受到雜訊干擾等狀況，
使得當中的位元反轉(0變成1，1變成0)。倘若我們按照正常的表達方式，
例如7=0111, 8=1000，對於某些臨界狀況而言，小範圍的變動值會需要大幅度的修改bit，同時當某個高位數的bit出錯的狀況，值就有可能受到大幅度的改變，這顯然是比較糟糕的。

所以格雷碼的設計就是希望能夠讓更動小數值的時候，只更動較少的bit數量即可，且當有其中的bit受到干擾而出錯時，數值的影響範圍也較小。

那怎麼計算呢？
我們從1個bit開始推導看看：
由於要求要從0開始，
故我們應該是拿0代表0，1代表1，這樣就完成了1個bit的格雷碼。
2個bit的話，由於用10來表示會一次更動2個bit(01->10)，
所以我們只能拿11來表示2，而10則表示3。

當然，也可以用00, 10, 11, 01來進行表示，但這種方式相對較複雜，
我們直接去考慮前面的方式的邏輯就好。

再來我們可以思考，在不要動到前面的數的狀況下，
下面我們要怎麼表達3個bit的狀況呢？
已經知道：

我們想要剛好用3個bit表示07，
那唯有讓47的部分的最左邊的bit均為1才行。
(因為前面的2個bit組合已經被用過了)
同時我們又想要符合相鄰只動一個bit 的原則，
所以4的表示方式就只剩下110了!

同時，我們也知道前面03符合這個只動一個bit的表達方式，
那麼後面填入57的方式，就可以按照上下鏡向 的狀況填入，
自然會符合格雷碼的要求。也就是除了最左邊是1以外，
4對應到3，5就對應到2，6對應到1，7對應到0即可。

同樣的道理，變成4個bit時，將後面的8個數的最左邊的bit填入1，
其它的部分鏡向填入即可。

歸納一下這題的解法：

先放入0(最開始的部分，也是n=0時的解答)
定義一個變數adder，用來表示這輪要加上去的bit所代表的值
(初始值是2的0次方=1)
每次將答案的尾端加上一個新的值，
這個新的值是鏡向對應到的值加上adder。
(鏡向對應的方式，可以從尾端開始往回算，或者用adder-1-index來計算)
計算完畢一輪以後，將adder變為2倍，作為下一輪要額外加上去的值。
一路操作直到完成n輪為止，最後將結果回傳。

Java

Python

讀者可以看到兩個解法中一個使用+adder，另一個使用|add，
結果上是一樣的，因為加上去的那個bit一定是跟0相加，
故可以用OR運算會加快一點速度。(讀者可以修改成+來比較看看速度)
*2和«=1的部分，同樣可以等價於位移一個bit，
但速度上應該不會有特別差異才對。

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

「時間複雜度？」
(O(2的n次方)，因為n個bit可以表示2的n次方個數)

「(Python)能不能不要用append來解？」
(可以用extend，
每次將res的部分反轉接上後，再進行add的加總)

「為什麼你要用"_"？」
(因為第一個迴圈事實上只是處理執行n次這件事情，
我們並不需要用到其數值，在習慣上會盡量用底線來命名，
避免去用到有意義的命名方式。)

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

從LeetCode學演算法 - 10 Linked List (2)

Wed, 10 Jul 2019 00:00:00 +0800

0083. Remove Duplicates from Sorted List (Easy)

Question

Given a sorted linked list, delete all duplicates such that each element appears only once.

Example 1

1
2


Input: 1->1->2
Output: 1->2

Example 2

1
2


Input: 1->1->2->3->3
Output: 1->2->3

分析/解題

題目給定一個已排序好的linked list，要求將所有重複的node皆刪除，
使得每個元素均只出現一次。

這題也算是比較簡單的linked list類型，只要確定連接正確的話並不難解。
由於已經排序過的原因，所有會重複的元素值均會相鄰，那麼我們所要做的就是遇到重複時總共只保留一個就好了 。
保留哪一個呢？當然是保留第一個囉！

我們可以先宣告一個ListNode，命名為ite用來做為iterator(迭代器)，
每次取得ite的下一個node(命名為tmp)做為暫存。
接下來開始一路往下尋找，如果ite和tmp前後值相等時，就讓tmp開始往下一直走到底部(表示後面值都一樣) 或者找到下一個不同的值。 對於前者的狀況 而言，表示結束，tmp會指到null(或None)，
只要將ite.next指向到tmp 即可。

對於後者的狀況 ，這時候tmp的位置就在下一個相異值的點 。
像是1->2->2->2->3->4這樣子，從ite在碰到第一個2以後，
tmp會一路找到3的位置，所以我們只要將ite.next指向到tmp ，
即可將第一個2接到3的位置，從而中間的部分就等於被我們刪去了。

討論完兩者狀況後，我們會發現無論是哪一種，
結果都會是將ite.next指向到tmp，
最後要記得ite本身要遞移到下一個開始找的位置，
所以我們還需要將tmp的位置交給ite。

Java

以Python的部分來說，還記得判斷式可以直接適用於if的話，
就可以寫得看起來簡潔一些。

Python

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

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

其它應該沒什麼好問的，至少我沒想到XD
這篇主要是協助讀者再熟悉一下這些連接/斷開的操作。

從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學演算法 - 8 String Manipulation (1)

Fri, 05 Jul 2019 00:00:00 +0800

0067. Add Binary (Easy)

Question

Given two binary strings, return their sum (also a binary string).

The input strings are both non-empty and contain only characters 1 or 0.

Example 1

1
2


Input: a = "11", b = "1"
Output: "100"

Example 2

1
2


Input: a = "1010", b = "1011"
Output: "10101"

分析/解題

題目給定兩個二進位字串，試求其和(同樣以二進位字串表達)。
在電腦的世界裡，本質上是由0和1所構成的，因為對它來說，最容易的表達方式就是電路的開路和斷路兩種狀態。
如果大家忘記二進位的表示方式，可以從wiki的說明大概回憶一下XD
這裡只要知道要轉為10進位的話，就是由右至左從2⁰開始相乘相加就對了。
例: 1010 -> 0*2⁰ + 1*2¹ + 0*2² + 1*2³ = 0 + 2 + 0 + 8 = 10
每個位數之間是2倍，每滿2就要向左邊進一位。

那麼給定的是字串的話，要怎麼做處理呢？
這題很重要的一點是要先確認你是使用什麼程式語言做操作的。

如果是C/C++/Java等規範相對嚴格的語言的話，
以Java 為例，其int變數型態一般是用32-bit 來儲存並且含有正負號，
也就是它只可以接受範圍在**-2³¹~2³¹-1** 之間的數字，超過這個範圍即會overflow(溢位)，這也是這個題目之所以會用字串表達的原因。
(不同的語言的int變數所涵蓋的範圍不一定相同)

Python就沒有這種限制，直譯器已經處理好很多事情了，
所以下面就會看到一些比較簡單(偷吃步)的做法。

對Java而言，我們既然擔心會溢位導致不能夠直接轉換，
那麼只好一位一位去做操作了。我們可以使用StringBuilder這個處理字串的類別，從第0位開始將兩邊的數字相加，並且處理進位(carry)的部分。

對Java而言，字串(String)拆出來的每個單位叫字元(char)，
使用String.charAt(i)函式，可以將index i的字元拆解出來。
拆出來的字元其實已經可以用數字的形態印出了，
但它是代表ASCII code表上的位置，而非真的數字，
要得到它實際的數字的話，由於'0’~‘9’在表上是連續的，
我們可以減去'0’的位置48，即可得到實際的數字；
或者記不了的話，直接拿該字元去減掉'0’ ，也可以得到相同的結果。
這樣的操作也適用於大小寫的英文字母上，請多留意。

那麼問題就簡單了: 只要是還有位數的狀況下，就取出字元減掉'0’，
否則就當作是0(代表另一個字串比較長)，最後比到兩邊長度都用完，
這時候StringBuilder應該沿路將所有位數從最低位組合到最高位 了，
最後處理最高位有可能的進位後，只要再將其進行反轉(reverse)操作，
再轉為字串(toString)即可。

Java

Python的部分相對簡單的多(可以偷吃步XD)，
只要將a跟b先轉成int，相加後再轉成二進位即可。
轉成int的作法是int(num, base) ，
num表示你的字串，base表示這段字串的進位方式 。

相加後轉成bin要特別注意Python的表達方式是以**’0b’** 為開頭，
所以我們只保留index 2以後的部分。

Python

簡單吧!

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

「時間複雜度？」( O(max(len(a), len(b))) )

「Python解是很簡單啦，但可以用一個一個比較的方法嗎？」
(請仿照Java的方式寫給他XD)
(補充: Python的ASCII和數字順序的互轉是 ord(c)跟 chr(a)，
前者字元轉數字，後者數字轉字元)

「(Java)j++ 和**++j** 有什麼不同？」
(++本身是代表將這個值增加1，
而擺在變數後面代表這整行執行完畢以後，才進行遞增 ；
後者則代表先將自己本身增加1以後，才執行這整行的操作 )

從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學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 6 Binary Search

Wed, 03 Jul 2019 00:00:00 +0800

0035. Search Insert Position (Easy)

Question

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

Example 1

1
2


Input: [1,3,5,6], 5
Output: 2

Example 2

1
2


Input: [1,3,5,6], 2
Output: 1

Example 3

1
2


Input: [1,3,5,6], 7
Output: 4

Example 4

1
2


Input: [1,3,5,6], 0
Output: 0

分析/解題

給定一個排序的陣列和目標值，假定陣列的數字不會重複。
題目要求找到目標值在這個陣列中的位置；
若無，則回傳如果要將其插入時，應插入的位置。

這題是很典型的二元搜索法(Binary Search) 。
所謂的Binary Search，就是資料已處於被排序的狀態，那麼在這些資料內搜索某個特定值就不用一個一個找，我們可以用比較快的方法來搜尋。
假設我們有一組排序過的陣列，
搜尋的第一步就是取得中間點的那個值，我們先稱之為mid，
那mid左邊的數必然小於mid，反之mid右邊的數必然大於mid 。
(按順序排的嘛XD)
所以我們拿目標值target跟mid比較，
如果target == mid ，那mid所在的位置 就是我們要的答案；
如果target > mid ，表示答案只可能在mid右邊到尾端之間(不含mid) ；
如果target < mid ，表示答案只可能在mid左邊到開頭之間(不含mid) 。
如此一來，每次取得區塊的中間點的值，並和target做比較，
則每次都可以至少刪掉一半的可能的數量 ，
直到找到答案(target == mid) ，
或是區塊上下限交錯(那就表示target不存在於陣列之中) ，
我們同樣可以將下限的index輸出，因為它就代表應該被插入的點。

例1. nums=[1,3,5,6], target=2
首先取下限lo = 0, 上限up = 3(頭跟尾), 中間點mi = (lo + up) / 2 = 1 ->
nums[1]為3, 3 > 2 -> 將up改為mi-1=0 -> mi = (0 + 0) / 2 = 0 ->
nums[0]為1, 1 < 2 -> 將lo改為mi+1=1 ->
lo和up已交叉，故結果應輸出1。

中間的值的變化如下：

1
2
3
4


lo up mi nums[mi]
0 3 1 3
0 0 0 1
1 0 0 1

例2. nums=[1,3,5,6], target=5
首先取下限lo = 0, 上限up = 3(頭跟尾), 中間點mi = (lo + up) / 2 = 1 ->
nums[1]為3, 3 < 5 -> 將lo改為mi+1=2 ->mi = (2+3)/2 = 2 ->
nums[2]為5, 5==5 -> 直接輸出mi的值2即是答案。

中間的值的變化如下：

1
2
3


lo up mi nums[mi]
0 3 1 3
2 3 2 5

下面也列出[1,3,5,6], 7跟[1,3,5,6], 0的值變化的過程，
有興趣或對整個邏輯還沒有弄得很明白的讀者可以嘗試推導一遍。

nums=[1,3,5,6], target=7 -> ans = 4

1
2
3
4
5


lo up mi nums[mi]
0 3 1 3
2 3 2 5
3 3 3 6
4 3 3 6

nums=[1,3,5,6], target=0 -> ans = 0

1
2
3
4


lo up mi nums[mi]
0 3 1 3
0 0 0 1
0 -1 -1 6 #(這個是用python輸出的，所以nums[-1] == 6)

底下的解法看個人喜好命名均可。

Java

Python

在這個解題過程，由於每次我們都會將範圍縮小一半，
所以總共比對的次數就相當於求這個陣列的長度是2的幾次方，
故時間複雜度為O(logN) 。
(電腦科學領域的對數一般不特別提的話通常是以2為底)

事實上，Java中也有提供 Arrays.binarySearch(int[] a, int key) 於utils的函式庫中，但有一點不一樣的是，當找不到target的時候，
如果插入該key所在位置為index，則回傳值為**-index-1** 。
取負號是為了和key存在於陣列的狀況做分隔，
額外減1則是為了將key在0的位置 及key應該要插入在0的位置 做區分。
(因為0取負號還是0)

Binary Search是在排序陣列或一些有序的資料結構中很常用到的演算法，
以後在談到二元搜尋樹(BST, Binary Search Tree) 的時候也會用到它。
所以如何寫一個二元搜尋的簡單方法是很有用的，可以的話務請熟練XD

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

「(Java)如果上限接近Integer.MAX_VALUE的話相加有overflow的可能？」
(將(lo+up)/2改成lo + (up-lo)/2，可以保證不會溢出)

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

「我想知道到底結果target是否存在array中，但不想額外加回傳的值？」
(如上面提到的，將插入的狀況改為**-index-1** 來表達)

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

從LeetCode學演算法 - 5 In-Place

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

0026. Remove Duplicates from Sorted Array (Easy)

Question

Given a sorted nums array, remove the duplicates in-place such that each element appears only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array ** in-place** with O(1) extra memory.

Example 1

1

Given nums = [1,1,2],

1

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.

1

It doesn't matter what you leave beyond the returned length.

Example 2

1

Given nums = [0,0,1,1,1,2,2,3,3,4],

1

Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.

1

It doesn't matter what values are set beyond the returned length.

分析/解題

題目要求將一個已排序陣列中所有的重複數字刪去，使得這個陣列的每個數字只出現一次，並且必須要以in-place的方式來處理。
最終處理過後，回傳新陣列的長度。

題目其實並不困難，設定一個i用來記錄目前存放到哪個位置，
再設定一個j用以完整遍歷整個陣列，
每當發現有不同的數字時，就將j的數字塞到i的位置，再往下推進即可。

最後由於要回傳的是新陣列的長度，所以應該要回傳i+1。(陣列由0開始)

這邊要順便提到的一個名詞叫in-place algorithm 。
所謂的in-place，就是指所有的操作修改，除了一些計數用的變數外，
基本上都在原先的資料結構內解決 ，像這題就是完全只有操作原陣列。
如果沒有這樣的限制，這題也是可以使用ArrayList，每當發現一個不同的數就將其往List尾端加，最後再將其轉為array，
同樣可以得到解，但它的空間複雜度就會變成O(N)，
因為我們開了一組額外的記憶體來存放它。

所以in-place algorithm會應用在一些不希望大量增加記憶體使用量 的狀況，且在這個限制條件下，有時候我們不一定能像這題這樣得到跟非in-place時一樣時間複雜度的解法。
所以in-place algorithm通常會有拿時間換取空間效率的狀況 。
總之，如果原先的資料被修改或打亂也沒關係 的話，
就有使用in-place algorithm的機會，也有可能會被面試官問到，
但請務必謹慎地確認是否這個狀況下，
你真的會必須用比較差的時間複雜度達到相同的目的。

Java

Python

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

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

「如果不要求in-place，改成新開list/arraylist來做會比較快嗎？」
(不會，因為時間複雜度相同，但要額外花時間做記憶體配置)

「如果題目今天給的是未排序陣列要去除duplicate，
但不用in-place，也不用保留順序的話？」
(使用HashMap/dict，將整個陣列掃過一遍，最後遍歷輸出)
(時間/空間複雜度為O(N), O(N))

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

從LeetCode學演算法 - 4 Linked List (1)

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

0021. Merge Two Sorted Lists (Easy)

Question

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

Example:

1
2


Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4

分析/解題

題目要求將兩個已排序的linked lists合併，
且所產生的新list必須由原有的節點(node)所構成。

Linked List是一個很常見的資料結構，資料與資料連接的方式是單向的，
通常從第一個節點(node)往後連接到最後一個節點(node)。
每個節點上會存放一個(或一組)資料以及連結(link)，
每個連結會指向到下一個節點 的位置(記憶體位址)。
(在C/C++裡面連結基本上就是指標(pointer))

你可能會問，那麼最後一個節點呢?
最後一個節點除了儲存資料以外，因為連結沒有東西了，所以會給定空值。在演算法的書中一般會稱為NIL ，NIL在英文裡面就是nothing 的意思，
表示沒有任何東西。

在Java中有LinkedList的資料結構，它同樣是List的一種。
但一般遇到題目的時候會給的通常是一個node，
用來指向到該List的第一個節點。

我們會看到如果你打開LeetCode選擇Java時，
上方已經先用註解告訴你這個ListNode的結構了：

1
2
3
4
5
6
7
8


/**
 * Definition for singly-linked list.
 * public class ListNode {
 * int val;
 * ListNode next;
 * ListNode(int x) { val = x; }
 * }
 */

也就是說，題目預先定義了一個class叫做ListNode，
val用來存放每個node的值，next用來指向到下一個node ，
有一個ListNode(int x) 的建構子(constructor)，
可以讓你在產生一個新的節點時給定其值。

對於LinkedList來說，它最大的好處在於新增/刪除節點時相當方便。
例如現在有a->b，我想要加一個資料值為20的c節點，放在b後面的話，
以Java而言只需要:

1
2
3


ListNode b = a.next; // 因為一開始我們只知道a的位置而已XD
ListNode c = new ListNode(20);
b.next = c;

如果是插入在a跟b中間呢？也不難，
只是我們要先記住b，不然一旦沒有人記它，它就消失在時空裂縫中了(誤)
(會依照各自編譯器的規範，只是以我們而言是真的就沒辦法找到它了)

1
2
3
4
5


// a -> c -> b
ListNode b = a.next;
ListNode c = new ListNode(20);
a.next = c;
c.next = b;

請留意如果你調動了一些節點的順序，留意他們的next是否被妥善處理，
該被清空的請給定NIL。在Java中是用null來表示，而Python則是用None。 回到題目，我們該如何去合併排列好的兩個LinkedList呢？
這邊提供一個很簡單的遞迴思路。
(遞迴的概念，我們之後再專門做一篇相關的來講解)
我們合併兩個list的狀況目標還是要呈現排序好的樣子，
那麼怎麼排呢？
由於原先的list已經是排好的，
我們拿出最左邊的node比較，稱為l1跟l2。
l1是全空的狀況下，那其實答案就是l2(因為後面就不用繼續排了)，
反之l2是全空的話，答案就是l1。
那麼如果l1的值小於l2的值的話，那麼l1應該要當頭，
接下來我們要拿l1.next 跟l2 來做比較大小，比較小的，
就會是新的l1連接的下一個節點。
一直連接到最後，我們就可以得到合併好的list了！
相等的狀況因為題目沒有特別要求要分辨是l1還是l2的節點，
所以任取一個均可。

例：
l1: 1 -> 3 -> 5 ->8 ->10, l2: 2 -> 4 -> 4
1先跟2比，1比較小所以當頭(1) ->
3跟2比，2比較小(1->2) ->
3跟4比(1->2->3) ->
5跟4比(1->2->3->4) ->
5跟4比(1->2->3->4->4) ->
l2的部分已經空了，填入l1中5以後剩下的部分
(1->2->3->4->4-> 5 ->8 ->10)

寫成Java的程式如下。

Java:

當然我們也可以用迴圈(迭代)的方法來解，
但這時候我們就要比較仔細的去處理節點間的關係了。
在Python中判斷是否為None可以使用if，
通過if的話節點就代表該節點是有值的，
你也可以加入not的關鍵字來處理你所需要的判斷式。
比如我可以用if not (l1 and l2)來表達其中一個以上是空的狀況，
並回傳不是None的那個node。

操作上，我們需要一個dummy node做為旁觀者，
讓它從頭到尾都只保持在同樣的位置 ，並指向到第一個節點。

接著我們定義一個節點叫做prev，
prev的next 會指定給下一個比較過後較小的那個節點 。
那麼，每次將prev的next拿到以後，
l1或l2(看哪個比較小)就自己遞移到下一個節點 ，
並且prev也往下走到自己的next，準備接取下一個節點；
重覆上面的動作直到其中一邊節點用光 ，
即可把剩下的直接全接到prev.next上。

最終我們回傳的答案是dum.next ，因為只有dum沒有被動過，
其他的節點其實都已經被改動過指向的位址了。

Python

在有關linked list的部分，因為牽扯到位址的概念，
所以操作上要稍微再思考一下，比較不容易搞混。
最重要的是，對於Java和Python來說，由於所使用的都是class來建立node，
所以其實你看到的等號，除了給定val的狀況以外，
其他其實都是在做把右邊放的記憶體位址存到左邊 的動作，
所以指向的記憶體位址變了，代表的節點也就跟著變了 ，務必要留意這點。

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

「請用iterative(迭代或迴圈)/recursive(遞迴)的方式來解」
(上面Java是recursive solution，Python是iterative solution，
讀者可以嘗試改成另一個語言試看看)

「使用遞迴的話會有什麼限制？」
(有可能受到編譯器規範的最大function stack上限限制，
同時，連續的函式呼叫的效率，相對於在迴圈中執行來說會較差)

「那為什麼你會用遞迴？」
(因為遞迴比較好想啊XDDDDD)(別這麼誠實，雖然大家都知道XD)
(因為在一般狀況下，遞迴解通常會較為容易閱讀，
也比較符合人類的思路模式，就像推骨牌一樣，
當起始條件和後續的脈絡定下來以後，後面的結果就會水到渠成。)

「時間複雜度是？」
( worst case是O(N1+N2)，best case是O(min(N1, N2))。)

「如果希望你另外開一個新的linked list，不用原本的節點來解這題呢？」
(這樣會比較簡單，一樣兩兩比較，但改成較小的取其val來產生一個新的ListNode，接在你的新的linked list後面，讀者可以嘗試看看，
別忘記要留dummy node歐！)

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

從LeetCode學演算法 - 3 Two Pointers

Sat, 29 Jun 2019 00:00:00 +0800

0015. 3Sum (Medium)

Question

Given an array nums of n integers, are there elements a, b, c in numssuch that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note:

The solution set must not contain duplicate triplets.

Example:

1

Given array nums = [-1, 0, 1, 2, -1, -4],

1
2
3
4
5


A solution set is:
[
 [-1, 0, 1],
 [-1, -1, 2]
]

分析/解題

題目要求從陣列中找出所有數組a, b, c，
使得三者相加為0，且不能重覆。

老話一句，請記得問有沒有排序XD~
以暴力法解本題的話，會發現每次取三個做組合，
顯然會得到一個O(N³)的時間複雜度的解。
那麼，嘗試排序看看能得到比較好的解嗎？
我們先拿題目的例子來看看，排序過後為
[-4, -1, -1, 0, 1, 2]
按順序排列會有什麼好處呢？
假設我們先固定最左邊的-4為a(因為要組合，我們可以令a<=b<=c)，
那麼b+c必須等於4，這邊使用一個簡單的技巧，
先將b指定給-1的位置，c指定給2的位置，
兩者相加等於1，表示應該要取更大的值 才有機會讓和等於4，
於是我們可以將b的位置向右移一格(這裡是重覆的所以可以跳過)，
再次檢查和目標的大小比較。

那麼很容易可以發現一件事情：
當現在的值比目標值大時，表示應該要取更小的值 ，
只有將c往左移動 才有可能達到。
反之，
當現在的值比目標值小時，表示應該要取更大的值 ，
只有將b往右移動 才有可能達到。
因此，在固定a值的時候，只要將後面的數按照上面的方法，
一次移動一格的掃過一遍，就可以得到這個a值所可以成立的組合。

所以最終我們只要將a從0~len(nums)-3按順序跑過一遍，
將中間符合的組合都放進list中，即可得到答案。

重覆性的部分，只要記得檢查前一個和這一個用的數字是否相同即可避免。

上述的做法，由於使用到兩個指標(指針)，並透過移動它們來達到掃描陣列的目的，我們通常稱這樣的解法為Two Pointer ，是蠻常用的技巧。
時間複雜度的部分，排序的一般狀況是O(NlogN)，
而a的長度是O(N)，每次都要掃完其後的長度，掃描部分即為O(N²)，
所以總體的時間複雜度為O(N²)。

Java

這邊使用i, j, k標記，要用a, b, c也可XD
使用Arrays.asList可以將一串元素塞成ArrayList。

Python

Python的部分提供了另一個的思路，
這是由 RouRouKerr在討論區所提出的解法，這邊是改成Python3版本。
他的想法是，在固定第一個數v的狀況，那當其中一個數為x，
另一個數只能是-v-x(因為加總要等於0)。
故每次將對應的互補數加入到dict中，
我們只要從頭到尾檢查，即可得到所有的正確組合。
這個想法跟前面Two Sum的解法概念是一樣的。
(對應到Java版本的解法也附在註解處)

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

「(Python)前面不檢查的話後面你怎麼處理重覆？」(用set)
「假設目標不是0的話？」(方法應該是一樣的)
「(Python)dictionary的部分使用set代替會比較快嗎？」(實測過會變慢XD)
「(Java)如果可以改變input/output的變數形態的話，你會希望改動什麼？」
(改output，因為輸出應該固定會是3元組的組合(長度必然是3)，
那大可以使用List<int[]>，用List<List>其實較不理想)

只要掌握了Two Pointers的概念，很多題目其實可以在排序後輕鬆解決，
但記得注意有些題目可以比O(NlogN)快的話，排序會提高時間複雜度歐！

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

從LeetCode學演算法 - 2

Fri, 28 Jun 2019 00:00:00 +0800

0014. Longest Common Prefix (Easy)

Question

Write a function to find the longest common prefix string amongst an array of strings.

If there is no common prefix, return an empty string "".

Example 1

1
2


Input: ["flower","flow","flight"]
Output: "fl"

Example 2

1
2
3


Input: ["dog","racecar","car"]
Output: ""
Explanation: There is no common prefix among the input strings.

Note:

All given inputs are in lowercase letters a-z.

分析/解題

題目要求從一組字串陣列中找出其最長的共用前綴，
字串只會由a到z所構成，若沒有的話則回傳空字串。

同樣的，若遇到這個問題，請第一時間記得問他們有沒有排序XD
依據資料的分布不同，不同的解法應該會有不同的優勢，
但非特殊情況的話，總體時間複雜度應為: O(單一字串長 * 總字串數)

最直觀的想法，就是從頭開始將每個相同位置的字元比對一次，
相同則往下繼續做，不同則停下將結果輸出，
但這麼做可能前面每次都要掃過相同位置的所有字元。

我們可以換個角度想，若先拿第一個字串當作common prefix(命名作pre)，
接下來用其餘的字串來檢查這個pre是否是其prefix，是的話則檢查下一個，
不是的話就將pre的尾端刪去重新檢查，這樣一旦當中有一個字串有大幅度差異，我們很快就能將pre縮減到很短。

Java

留意這當中我們使用了String.indexOf()來檢查，
我們只想要pre在剛好0的位置，所以不論這個值是>0(表示出現在中間)
或<0(根本沒出現)，都代表pre需要被調整。
實測上這個解是當前LeetCode上對test cases跑最快的版本(0 ms)。

如果是Python的話，會有比較有趣的解法。
Python支援的min()和max()可以讓我們在List[str]中列出依字母排列順序 最小和最大的字串。當我們可以很簡單拿到這個值時，
我們可以換一個思路，從頭到尾比較的時候，我們其實只需比最小和最大的兩個字串就好，當它們是相同字元時則往下繼續，否則就回傳至目前為止的substring。(因為排序最大和排序最小在某個index字元相同時，即代表著中間其他字串在此index字元亦相同)

Python

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

「如果不能用indexOf的話你會怎麼做？」
(可使用String.toCharArray()轉成陣列後再操作)
「如果這組陣列被預期長短差異很大呢？」
(先掃過一遍陣列，拿最短的當pre)
「Best Case和Worst Case的時間複雜度？什麼狀況下會發生？」
(依照你的解法應該有所不同)
「如果加入<0的判斷式的話可以提升這個程式的效率嗎？」
(不一定，因為不保證多快能遇到前綴完全不同的字串 ，
所以端看這組資料是預期很有可能出現結果為空字串，
還是大多數都會有共同前綴來決定。)

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

從LeetCode學演算法 - 1

Thu, 27 Jun 2019 00:00:00 +0800

0001. Two Sum (Easy)

Question

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have *exactly * one solution, and you may not use the same element twice.

Example:

1

Given nums = [2, 7, 11, 15], target = 9,

1
2


Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

分析/解題

題目要求是，在一組陣列中找出兩個數，其加總恰等於給定值。
每個數不能被重複使用，且必剛好只有一個解。
像這種題目，由於被擺在第一題，大多數狀況都不會被拿來考XD
但，凡事總有例外。

我們先來分析一下，如果按照原題的要求該怎麼解。
如果input長度為N，那麼暴力解就是將數字兩兩相加看是不是解，
這樣的解法要算N(N-1)/2次，也就是O(N²)的時間複雜度。

該怎麼降低複雜度呢？我們會希望每個數只要查一次就知道結果，
有沒有這樣的結構？當然有，在Java中可以用HashMap ，
而在Python中可以用dictionary 。

只要每一次從map中確認當下target-num是否在map中，
在的話就表示找到了，可以將結果取得，
沒找到的話，就將一組(num, index)放進map中，
依此流程，最壞的狀況整個array遍歷後，就可以得到答案。

時間複雜度：
由於HashMap在put和get最好的狀況都是O(1)，
遍歷整個Map需要O(N)。

Java:

Python:

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

這裡有一個原則：
***不論是什麼問題，不論你當下想到的方法有多暴力有多爛，
有想到方法就先講沒關係。***以這題為例，你應該先提出最先的O(N²)解，大概描述完以後，
再說但這樣時間複雜度比較高，
如果應用HashMap(python用dict)的話，
可以讓每個數只需要花O(1)作搜尋，複雜度就會降到O(N)。

先講出一個可能的解法，再想辦法延伸修改或者改進它，
這是大多數公司建議(尤其Google)的方式，
一來可以讓面試官知道你不是腦袋空空，至少先有個基本分，
二來在講這個暴力解時，你可以有緩衝的時間去想更好的解法。

還有一些需要注意的東西可以做為你和面試官互動和溝通的部分，
或有可能是面試官問你的進一步問題，
在平常每題解完後，都應該留點時間給自己去思考一下可能的變化。
以此題為例：
「請問這個陣列是否是排序好的？」(排好的解法就又不同了XD)
「如果我想要的是回傳那兩個數字而非indices的話呢？」(修改pair即可)
「你剛剛提到了排序，那怎樣的狀況先對陣列作排序會比較好？」
「如果答案存在很多組，能否找出所有的解？」
「如果當中存在重覆的數字的話呢？」
「為什麼HashTable/HashMap的存取是O(1)？」(這可能就扯比較遠了XD)
「那麼它們的worst case呢？什麼狀況下會發生？」

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

從LeetCode學演算法 - 0

Wed, 26 Jun 2019 00:00:00 +0800

你應該知道的面試基礎和解題技巧

What is an algorithm?

所謂的演算法，就是描述一個計算/操作的過程，
這個過程可以用有限的長度來描述如何解決問題。
或者更簡單的說法：
*演算法，就是解決問題的方法流程。 *

Why do we need to learn algorithms?

先講一下筆者的經歷：筆者當了7年多的工程師，當中有2.5年和Android kernel/HAL/framework相關，2年跟Android App和一般Software有關，後面則是ML/Deep Learning為主，在面試時也分別面過不同的職位，唯獨幾乎萬變不離其宗的，就是白板題。

面試官拿出一道你見過或沒見過的題目，問你該怎麼解，
你思考後給出回答，並且討論可以改進的方式及可能的錯誤，
這應該是所有面試者都會歷經的流程。

那麼，你是否經歷過這樣的狀況？

「這個題目的類型看起來好眼熟，可是不知道從何下手，該怎麼辦 QQ」

白板題的重點，就在於演算法 。掌握好演算法，就跟數學學會公式一樣，
可以將一些複雜的東西簡單化，平常練習的題目多了，
套起公式來自然得心應手，就算題目再怎麼變，也萬變不離其宗。

當然，後面還會衍生出一個問題：一個題目該用哪種演算法比較好？
但這是另一個故事了，我們以後再談XD

Why LeetCode?

那麼，現在網路上可以供作練習的網站相當之多，除了LeetCode外，
你可能還聽過HackerRank及CodeWar等，
那麼為什麼是用LeetCode而不是其他呢？

以筆者的經驗，HackerRank相當適合做為熟悉語言特性使用 ，但不適合目標是熟練解題的人。你可以在其 “LANGUAGE PROFICIENCY”的分類中針對特定的程式語言一路寫到尾，這樣可以對這個語言有一個比較基本的認識。
而雖然它們有”Interview Preparation Kit”的部分，但相對題目較為簡單，涵蓋範圍也較少。舉例來說，在Tree的分類上只有5題，這一點點的量，其實相當不足。同時，HackerRank的題目往往較長，限制也通常較多，(這裡是指Problem Solving分類)，和一般面試會遇到的題目型態較為不同。
但若今天的形式是給你1個半小時解3題 的話，
那麼HackerRank的模式就會很適合你。

Codewar的話，較為偏向打怪(題目)升級的模式，每個題目都會有一個等級，解決題目累積經驗值並提升自己的level會有一種練功的感覺。筆者不推薦的原因在於

網站讀取速度偏慢
題目沒有編號 ，你會做到不知道哪裡去也不確定自己有沒有準備好XD
Discuss區不像LeetCode傾向於分享整組解法

那LeetCode呢？
當前(2019/06/26)的題目量總共有1096題，Easy佔了當中的319題。
筆者練習的題目總量為348題: Easy 266, Medium 65, Hard 17。

2020/08/18:
當前的的題目量總共有1553題，Easy佔了當中的430題。
筆者練習的題目總量為502題: Easy 288, Medium 179, Hard 35。

以筆者的個人經驗，只要將LeetCode的Easy難度寫過一輪，
搭上少量的Medium和些許的Hard題目，便足以應付絕大多數的白板題。
這當中要求的是盡可能不要去翻別人的答案，自己先兜出解法後，
在能力範圍內去盡力提升這個解的速度，
真的不行或卡超過半小時才去參考別人的解答。

在練習到一般的白板題都不能難倒你後，就可以將注意力集中在你主要經驗相關的領域了。(如筆者找AI職缺，那麼就會偏向ML相關的知識)

What’s the plan?

接下來的系列，將會以LeetCode從第1題開始順序往下，以Easy題目為主，參雜少量Medium題，搭配題目分析及演算法講解，在整理先前自我學習的過程中，希望能對大家有所幫助。解題所用的程式語言會以Java 及Python 為主，但概念基本上不會差多少，若是使用其他語言的朋友應該也可能從中理解思路。使用的解有些可能會因為我看到更好的解法，會使用其他人在Discuss區塊提出來的解，筆者會盡量標明是哪一位LeetCode user所寫的。

除此以外，若文章中有錯字、寫錯或有任何讓人感到疑問的地方，
歡迎留言告訴我！

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

PS. 因應建議，將文章目錄連結貼在底下，方便大家查找。
(請使用Ctrl+F輸入想要查找的題目或題型)

從LeetCode學演算法 - 1

Two Sum (Easy)

從LeetCode學演算法 - 2
0014. Longest Common Prefix (Easy)

從LeetCode學演算法 - 3 Two Pointers
0015. 3Sum (Medium)

從LeetCode學演算法 - 4 Linked List (1)
0021. Merge Two Sorted Lists (Easy)

從LeetCode學演算法 - 5 In-Place
0026. Remove Duplicates from Sorted Array (Easy)

從LeetCode學演算法 - 6 Binary Search
0035. Search Insert Position (Easy)

從LeetCode學演算法 - 7 Dynamic Programming (1)
0053. Maximum Subarray (Easy)

從LeetCode學演算法 - 8 String Manipulation (1)
0067. Add Binary (Easy)

從LeetCode學演算法 - 9 Dynamic Programming (2)
0070. Climbing Stairs (Easy)

從LeetCode學演算法 - 10 Linked List (2)
0083. Remove Duplicates from Sorted List (Easy)

從LeetCode學演算法 - 11 Bitwise Operation (1) 0089. Gray Code (Medium)

從LeetCode學演算法 - 12 Linked List (3)/ Stack (1)
0092. Reverse Linked List II (Medium)

從LeetCode學演算法 - 13 Tree (1) 0100. Same Tree (Easy)

從LeetCode學演算法 - 14 Tree (2) / Queue (1)
0101. Symmetric Tree (Easy)

從LeetCode學演算法 - 15 Bitwise Operation (2)
0136. Single Number (Easy)

從LeetCode學演算法 - 16 BST (1)
0098. Validate Binary Search Tree (Medium)

從LeetCode學演算法 - 17 Tree (3)
0094. Binary Tree Inorder Traversal (Medium)

從LeetCode學演算法 - 18 Tree (4)
0124. Binary Tree Maximum Path Sum (Hard)

從LeetCode學演算法 - 19 Tree (5)
0111. Minimum Depth of Binary Tree (Easy)

從LeetCode學演算法 - 20 Tree (6)
0110. Balanced Binary Tree (Easy)

從LeetCode學演算法 - 21 Dynamic Programming (3)
0062. Unique Paths (Medium)

從LeetCode學演算法 - 22 Array (1)
0169. Majority Element (Easy)

從LeetCode學演算法 - 23 Array (2)
0229. Majority Element II (Medium)

從LeetCode學演算法 - 24 Dynamic Programming (4)
0063. Unique Paths II (Medium)

從LeetCode學演算法 - 25 Array (3):
0283. Move Zeroes (Easy)

從LeetCode學演算法 - 26 Dynamic Programming (5)
0096. Unique Binary Search Trees (Medium)

從LeetCode學演算法 - 27 Array (4)
0189. Rotate Array (Easy)

從LeetCode學演算法 - 28 Dynamic Programming (6)
0198. House Robber (Easy)

從LeetCode學演算法 - 29 Dynamic Programming (7)
0213. House Robber II (Medium)

從LeetCode學演算法 - 30 Tree (7)
0144. Binary Tree Preorder Traversal (Medium)

從LeetCode學演算法 - 31 Linked List (4)
0141. Linked List Cycle (Easy)

從LeetCode學演算法 - 32 BST (2)
0700. Search in a Binary Search Tree (Easy)

從LeetCode學演算法 - 33 Array (5)
0905. Sort Array By Parity (Easy)

從LeetCode學演算法 - 34 Array (6)
0977. Squares of a Sorted Array (Easy)

從LeetCode學演算法 - 35 BST (3)
0108. Convert Sorted Array to Binary Search Tree (Easy)

從LeetCode學演算法 - 36 Merge Sort (1)
0148. Sort List (Medium)

從LeetCode學演算法 - 37 Dynamic Programming (8)
0121. Best Time to Buy and Sell Stock (Easy)

從LeetCode學演算法 - 38 Array (7)
0088. Merge Sorted Array (Easy)

從LeetCode學演算法 - 39 Array (8) / Hash Table (1)
1160. Find Words That Can Be Formed by Characters (Easy)

從LeetCode學演算法 - 40 Array (9)
0238. Product of Array Except Self (Medium)

從LeetCode學演算法 - 41 Hash Table (2)
0242. Valid Anagram (Easy)

從LeetCode學演算法 - 42 Backtracking (1) / Tree (8)
0257. Binary Tree Paths (Easy)

從LeetCode學演算法 - 43 BFS (1) / Queue (2)
1161. Maximum Level Sum of a Binary Tree (Medium)

從LeetCode學演算法 - 44 Linked List (5)
0160. Intersection of Two Linked Lists (Easy)

從LeetCode學演算法 - 45 DFS (1)
0200. Number of Islands (Medium)

從LeetCode學演算法 - 46 BFS (2) / Queue (3)
0199. Binary Tree Right Side View (Medium)

從LeetCode學演算法 - 47 Array (10)
0204. Count Primes (Easy)

從LeetCode學演算法 - 48 Trie (1)
0819. Most Common Word (Easy)

從LeetCode學演算法 - 49 Hash Table (3)
0217. Contains Duplicate (Easy)

從LeetCode學演算法 - 50 Tree (9)
0226. Invert Binary Tree (Easy)

從LeetCode學演算法 - 51 BST (4)
0235. Lowest Common Ancestor of a Binary Search Tree (Easy)

從LeetCode學演算法 - 52 Array (11)
0268. Missing Number (Easy)

從LeetCode學演算法 - 53 Binary Search (2)
0278. First Bad Version (Easy)

從LeetCode學演算法 - 54 DFS (2)
0114. Flatten Binary Tree to Linked List (Medium)

從LeetCode學演算法 - 55 DFS (3)
0236. Lowest Common Ancestor of a Binary Tree (Medium)

從LeetCode學演算法 - 56 Binary Search (3)
0240. Search a 2D Matrix II (Medium)

從LeetCode學演算法 - 57 Binary Search (4)
0074. Search a 2D Matrix (Medium)

從LeetCode學演算法 - 58 Two Pointer (2)
0075. Sort Colors (Medium)

從LeetCode學演算法 - 59 Backtracking (2) / DFS (4)
0079. Word Search (Medium)

從LeetCode學演算法 - 60 Backtracking (3) / DFS (5)
0078. Subsets (Medium)

從LeetCode學演算法 - 61 Dynamic Programming (9)
1140. Stone Game II (Medium)

從LeetCode學演算法 - 62 Tree (10)
0102. Binary Tree Level Order Traversal (Medium)

從LeetCode學演算法 - 63 Backtracking (4) / DFS (6)
0077. Combinations (Medium)

從LeetCode學演算法 - 64 Array (12) / Two Pointer (3)
0080. Remove Duplicates from Sorted Array II (Medium)

從LeetCode學演算法 - 65 Array (13)
0926. Flip String to Monotone Increasing (Easy)

從LeetCode學演算法 - 66 Bitwise Operation (3)
0190. Reverse Bits (Easy)

從LeetCode學演算法 - 67 Bitwise Operation (4)
0191. Number of 1 Bits (Easy)

從LeetCode學演算法 - 68 Bitwise Operation (5)
0201. Bitwise AND of Numbers Range (Medium)

從LeetCode學演算法 - 69 Hash Set (1)
0202. Happy Number (Easy)

從LeetCode學演算法 - 70 Linked List (6)
0203. Remove Linked List Elements (Easy)

從LeetCode學演算法 - 71 Hash Table (4)
0205. Isomorphic Strings (Easy)

從LeetCode學演算法 - 72 Linked List (7)
0206. Reverse Linked List (Easy)

從LeetCode學演算法 - 74 Linked List (8)
0234. Palindrome Linked List (Easy)

從LeetCode學演算法 - 75 Array (14)
0289. Game of Life (Medium)

從LeetCode學演算法 - 76 Hash Table (5)
0290. Word Pattern (Easy)

從LeetCode學演算法 - 77 String (2)
1071. Greatest Common Divisor of Strings (Easy)

從LeetCode學演算法 - 78 Two Pointer (4) / Binary Search(5)
0392. Is Subsequence (Easy)

從LeetCode學演算法 - 79 Hash Table (6)
0383. Ransom Note (Easy)

從LeetCode學演算法 - 80 Linked List (9)
0082. Remove Duplicates from Sorted List II (Medium)

從LeetCode學演算法 - 81 Backtracking (5) / DFS (7)
0093. Restore IP Addresses (Medium)

從LeetCode學演算法 - 82 Linked List (10)
0086. Partition List (Medium)

從LeetCode學演算法 - 83 Dynamic Programming (10)
0091. Decode Ways (Medium)

從LeetCode學演算法 - 84 Tree (11) / DFS (8)
0116. Populating Next Right Pointers in Each Node (Medium)

從LeetCode學演算法 - 85 String (3)
1332. Remove Palindromic Subsequences (Easy)

從LeetCode學演算法 - 86 Hash Table (7)
1331. Rank Transform of an Array (Easy)

從LeetCode學演算法 - 87 Bitwise Operation (6)
1342. Number of Steps to Reduce a Number to Zero (Easy)

從LeetCode學演算法 - 88 Hash Table (8)
0575. Distribute Candies (Easy)

從LeetCode學演算法 - 89 HashTable (9)
1346. Check If N and Its Double Exist (Easy)

從LeetCode學演算法 - 90 Dynamic Programming (11) / DFS (9)
0576. Out of Boundary Paths (Medium)

從LeetCode學演算法 - 91 String (4)
0678. Valid Parenthesis String (Medium)

從LeetCode學演算法 - 92 String (5)
0680. Valid Palindrome II (Easy)

從LeetCode學演算法 - 93 Tree (12) / DFS (9)
0687. Longest Univalue Path (Easy)

從LeetCode學演算法 - 94 Hash Table (10)
0438. Find All Anagrams in a String (Easy)

從LeetCode學演算法 - 95 Dynamic Programming (12)
1143. Longest Common Subsequence (Medium)

從LeetCode學演算法 - 96 BST (5)
1008. Construct Binary Search Tree from Preorder Traversal (Medium)

從LeetCode學演算法 - 97 Dynamic Programming (13)
0368. Largest Divisible Subset (Medium)

從LeetCode學演算法 - 98 Tree (13) / DFS (10)
0129. Sum Root to Leaf Numbers (Medium)

從LeetCode學演算法 - 99 Tree (14) / DFS (11)
0404. Sum of Left Leaves (Easy)

從LeetCode學演算法 - 100 Dynamic Programming (14)
1510. Stone Game IV (Hard)

從LeetCode學演算法 - 101 String (6)
1529. Bulb Switcher IV (Medium)

從LeetCode學演算法 - 102 Tree (15) / DFS (12)
1530. Number of Good Leaf Nodes Pairs (Medium)

從LeetCode學演算法 - 103 Tree (16) / DFS (13) / BFS (3) / Queue (4)
0112. Path Sum (Easy)

從LeetCode學演算法 - 104 Tree (17) / DFS (14) / Backtracking (6)
0113. Path Sum II (Medium)

從LeetCode學演算法 - 105 Tree (18) / DFS (15) / Backtracking (7)
0437. Path Sum III (Medium)

從LeetCode學演算法 - 106 Tree (19) / DFS (16)
0563. Binary Tree Tilt (Easy)

從LeetCode學演算法 - 107 String (7) / Stack (2)
1544. Make The String Great (Easy)

從LeetCode學演算法 - 108 Tree (20) / DFS (17)
1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree (Medium)

從LeetCode學演算法 - 109 Array (15) / Hash Table (11)
1640. Check Array Formation Through Concatenation (Easy)

從LeetCode學演算法 - 110 Array (16) / Greedy Algorithm (1)
0881. Boats to Save People (Medium)

從LeetCode學演算法 - 111 DFS (18) / Backtracking (8)
0784. Letter Case Permutation (Medium)

從LeetCode學演算法 - 112 Binary Search (6) / Newton’s Method
0367. Valid Perfect Square (Easy)

從LeetCode學演算法 - 113 BFS (4) / Queue (5)
1091. Shortest Path in Binary Matrix (Medium)

從LeetCode學演算法 - 114 Stack (3)
0946. Validate Stack Sequences (Medium)

從LeetCode學演算法 - 115 Graph(1) / Union Find (1)
0684. Redundant Connection (Medium)

從LeetCode學演算法 - 116 Tree (21) / DFS (19)
0814. Binary Tree Pruning (Medium)

從LeetCode學演算法 - 117 Array (17)
0941. Valid Mountain Array (Easy)

從LeetCode學演算法 - 118 DFS (20) /BFS (5) / Queue (6)
0934. Shortest Bridge (Medium)

從LeetCode學演算法 - 119 Graph (2) / DFS (21)
0797. All Paths From Source to Target (Medium)

從LeetCode學演算法-120 (0547. Number of Provinces)
Categories: Graph/Union Find, Level: Medium
English Version: https://desolve.medium.com/51a78df0670c

從LeetCode學演算法-121 (0802. Find Eventual Safe States)
Categories: Graph/DFS, Level: Medium
English Version: https://desolve.medium.com/b3b88410d561