Graph on 跟著 Desolve 學程式

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

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

Categories: Graph/DFS

Level: Medium

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

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

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

Question

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

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

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

Example 1

1
2
3
4
5


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

Example 2

1
2
3


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

Constraints

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

Analysis/Approach:

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

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

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

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

Here is the code implementation in both Java and Python:

Java

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

Python

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

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

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

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

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

Learn Algorithms from LeetCode — See you next time!

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

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

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

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

Categories: Graph/DFS

Level: Medium

寫在前面

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

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

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

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

Question

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

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

Example 1

1
2
3
4
5


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

Example 2

1
2
3
4


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

Constraints

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

分析/解題

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

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

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

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

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

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

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

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

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

依此，寫成程式碼如下：

Java

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

Python

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

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

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

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

相似及延伸

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

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

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

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

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

Learn Algorithms from LeetCode-120 (0547. Number of Provinces)

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

Categories: Graph/Union Find

Level: Medium**

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

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

Question

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]

Analysis/Approach:

There are n cities, some of which are directly connected to each other, while others are not. If city a is directly connected to city b, and city b is directly connected to city c, then city a is indirectly connected to city c. (That’s a lot of unnecessary words LOL)

A province is a group of cities that are directly or indirectly connected, and there are no other cities in this group. (In other words, if you can walk from x to y, they are considered part of the same province).

Given an n x n matrix isConnected, where isConnected[i][j] = 1 means the ith city is directly connected to the jth city, and isConnected[i][j] = 0 means they are not directly connected, return the total number of provinces.

We have discussed many concepts related to graphs in Article 115 and the previous article. Today, let’s take a closer look at the usage of Union Find.

Since the variable name “isConnected” is too long, we will use “edges” to refer to it for convenience.

First, we need to find the number of provinces, which is another typical scenario where Union Find can be used. However, as we mentioned before, if we only trace back along the edges to find the root, the find operation for a single point can potentially take O(n) time. Therefore, we need to simplify the process by performing ** path compression** during the ** union** operation.

In the union operation, instead of arbitrary assignment as before, we can now choose to check which root has a higher rank and merge the group with the lower rank into the group with the higher rank. The root of the group with the lower rank should be set as the root of the group with the higher rank. This way, during the union process, since we always merge the smaller group into the larger one, it will be less likely to create long chains of connections. This technique is called path compression .

Therefore, our implementation of the find operation and union operation will look like this:

find(root, i) :

Initialize r as root[i]
If r and root[r] are not equal (indicating that we haven’t reached the node that is the root), enter the loop:
Set root[r] as root[root[r]]
Set r as root[r] (move up one level and continue the evaluation)
After the loop (steps 2–4) ends, set root[i] as r, indicating that the topmost leader of node i is r.

union(root, rank, x, y):

Apply the find operation to x and y separately to obtain their respective roots rx and ry .
If rx and ry are the same , it means they are already in the same group, so return false .
If they are different, compare the ranks rank[rx] and rank[ry]:

If rank[rx] ≥ rank[ry] , increase rank[rx] by rank[ry] and set root[ry] as rx .
Otherwise, if rank[rx] < rank[ry] , increase rank[ry] by rank[rx] and set root[rx] as ry .

After initializing root and rank (from 1 to n-1 and ** 1**), we can use a nested loop to call the union operation for the pairs of cities that are connected by edges. Finally, we iterate through each node and perform the find operation to determine the ** unique roots** and store them in a HashSet. The answer can be obtained by checking the size of the HashSet.

Here is an implementation in Java:

Java

We can use Arrays.fill() to set values in Java. Since we don’t specifically need the true/false return value for the union operation, we can change its return type to void and modify the necessary parts accordingly. Finally, we can use a HashSet to record the answers, iterate through i, call find(), and add the results. The final answer can be obtained by checking the size of the HashSet.

Notice that you could start j from i+1 rather than 0.

Python

In Python, the implementation is similar except for the use of sub-functions.

Potential Interview Questions:
“What are the time and space complexities?”
(O(n²)/O(n), as even with path compression, traversing all edges still takes O(n²) time, and the space complexity only needs to consider the space for recording roots and ranks.)

Similar and Extended Topics: 0684. Redundant Connection (Medium)

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

Learn Algorithms from LeetCode — See you next time!

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

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

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

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學程式

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

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

Categories: Graph/DFS

Level: Medium

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

Question

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

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

Example 1

1
2
3


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

Example 2

1
2


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

Constraints

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

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

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

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

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

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

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

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

The steps for solving this problem are as follows:

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

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

Java

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

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

Python

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

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

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

Learn Algorithms from LeetCode — See you next time!

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

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

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

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

0797. All Paths From Source to Target (Medium)

寫在前面

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

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

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

Question

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

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

Example 1

1
2
3


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

Example 2

1
2


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

Constraints

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

分析/解題

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

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

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

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

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

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

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

列出解題步驟如下：

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

依此，寫成程式碼如下：

Java

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

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

Python

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

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

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

相似及延伸

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

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

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

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

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