You are given a positive integer n representing the number of nodes of a Directed Acyclic Graph (DAG). The nodes are numbered from 0 to n - 1 (inclusive).
You are also given a 2D integer array edges, where edges[i] = [fromi, toi] denotes that there is a unidirectional edge from fromi to toi in the graph.
Return a list answer, where answer[i] is the list of ancestors of the ith node, sorted in ascending order.
A node u is an ancestor of another node v if u can reach v via a set of edges.
Example 1:
Input: n = 8, edgeList = [[0,3],[0,4],[1,3],[2,4],[2,7],[3,5],[3,6],[3,7],[4,6]]
Output: [[],[],[],[0,1],[0,2],[0,1,3],[0,1,2,3,4],[0,1,2,3]]
Explanation:
The above diagram represents the input graph.
- Nodes 0, 1, and 2 do not have any ancestors.
- Node 3 has two ancestors 0 and 1.
- Node 4 has two ancestors 0 and 2.
- Node 5 has three ancestors 0, 1, and 3.
- Node 6 has five ancestors 0, 1, 2, 3, and 4.
- Node 7 has four ancestors 0, 1, 2, and 3.
Example 2:
Input: n = 5, edgeList = [[0,1],[0,2],[0,3],[0,4],[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
Output: [[],[0],[0,1],[0,1,2],[0,1,2,3]]
Explanation:
The above diagram represents the input graph.
- Node 0 does not have any ancestor.
- Node 1 has one ancestor 0.
- Node 2 has two ancestors 0 and 1.
- Node 3 has three ancestors 0, 1, and 2.
- Node 4 has four ancestors 0, 1, 2, and 3.
Constraints:
1 <= n <= 1000
0 <= edges.length <= min(2000, n * (n - 1) / 2)
edges[i].length == 2
0 <= fromi, toi <= n - 1
fromi != toi
There are no duplicate edges.
The graph is directed and acyclic.
有向無環圖中一個節點的所有祖先。
給你一個正整數 n ，它表示一個 有向無環圖 中節點的數目，節點編號為 0 到 n - 1 （包括兩者）。給你一個二維整數陣列 edges ，其中 edges[i] = [fromi, toi] 表示圖中一條從 fromi 到 toi 的單向邊。
請你返回一個陣列 answer，其中 answer[i]是第 i 個節點的所有 祖先 ，這些祖先節點 升序 排序。
如果 u 透過一系列邊，能夠到達 v ，那麼我們稱節點 u 是節點 v 的 祖先 節點。
思路
這裡我用一個類似反向 DFS 的方法解決這道題。題意是找圖中每個節點的祖先。因為圖本身是有向無環圖（DAG），每條邊是有方向的，所以為了找祖先，我們可以在建圖的時候把每條邊反過來理解。比如如果有一條邊是從 A 到 B 的，那麼我們在建圖的時候可以把 A 加到 B 的鄰接表上，意思是如果從 B 出發，能走到他的祖先 A。
下面的步驟就跟一般的圖的遍歷很類似了，我們還是需要一個 boolean 陣列記錄遍歷過程中每個點是否被訪問到，具體參見程式碼。
複雜度
時間O(n)
空間O(n)
程式碼
Java實現
class Solution {
public List<List<Integer>> getAncestors(int n, int[][] edges) {
List<Integer>[] graph = new List[n];
for (int i = 0; i < n; i++) {
graph[i] = new ArrayList<>();
}
// 反向建圖
for (int[] edge : edges) {
graph[edge[1]].add(edge[0]);
}
List<Integer>[] res = new List[n];
for (int i = 0; i < n; i++) {
res[i] = new ArrayList<>();
}
boolean[] visited = new boolean[n];
for (int i = 0; i < n; i++) {
Arrays.fill(visited, false);
dfs(graph, visited, i);
visited[i] = false; // res[i] 不含 i
for (int j = 0; j < n; j++) {
if (visited[j]) {
res[i].add(j);
}
}
}
return Arrays.asList(res);
}
private void dfs(List<Integer>[] graph, boolean[] visited, int u) {
visited[u] = true;
for (int v : graph[u]) {
if (!visited[v]) {
dfs(graph, visited, v);
}
}
}
}