All Ancestors of a Node in a Directed Acyclic Graph

All Ancestors of a Node in a Directed Acyclic Graph - Problem

Imagine you have a family tree or a company hierarchy represented as a directed graph where edges show direct relationships. Your task is to find all the ancestors (predecessors) for each person or position in the hierarchy.

You are given a positive integer n representing the number of nodes in a Directed Acyclic Graph (DAG). The nodes are numbered from 0 to n - 1.

You are also given a 2D integer array edges, where edges[i] = [from_i, to_i] denotes that there is a unidirectional edge from from_i to to_i in the graph.

Goal: Return a list answer, where answer[i] is the list of ancestors of the i-th 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 (there exists a path from u to v).

Input & Output

example_1.py — Basic DAG

$ Input: n = 8, edges = [[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]]

💡 Note: Node 0 has no ancestors. Node 3 can be reached from nodes 0 and 1, so ancestors of 3 are [0,1]. Node 7 can be reached from 0→3→7, 1→3→7, and 2→7, so ancestors are [0,1,2,3].

example_2.py — Linear Chain

$ Input: n = 5, edges = [[0,1],[1,2],[2,3],[3,4]]

› Output: [[],[0],[0,1],[0,1,2],[0,1,2,3]]

💡 Note: This forms a linear chain 0→1→2→3→4. Each node's ancestors are all nodes that appear before it in the chain.

example_3.py — No Edges

$ Input: n = 4, edges = []

› Output: [[],[],[],[]]

💡 Note: With no edges, no node can reach any other node, so every node has an empty ancestor list.

Visualization

Tap to expand

Understanding the Visualization

Build the Hierarchy

Create the reporting structure from the given relationships

Trace from Top

Starting from each position, find everyone they can influence (descendants)

Reverse the Relationship

If A can influence B, then A is a manager/ancestor of B

Compile Results

Sort the manager lists for each employee position

Key Takeaway

🎯 Key Insight: Instead of searching upward from each node to find ancestors, we search downward from each node to find descendants, then reverse the relationship. This reduces redundant path exploration and gives us O(n × (V + E)) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n * (V + E))

We perform DFS from each of the n nodes, each DFS takes O(V + E) time

✓ Linear Growth

Space Complexity

O(n + E)

Space for adjacency list, visited set, and result storage

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
0 ≤ edges.length ≤ min(2000, n × (n - 1) / 2)
edges[i].length == 2
0 ≤ from_i, to_i ≤ n - 1
from_i ≠ to_i
There are no duplicate edges
The graph is acyclic

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 12 f Meta 8

The optimal approach uses DFS from each node to find all descendants, then reverses the relationship. For each node, we perform DFS to find all reachable nodes and add the current node as an ancestor to each reachable node. This gives us O(n × (V + E)) time complexity, which is efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ DFS from Each Node (Optimized Brute Force)	O(n * (V + E))	O(n + E)	Perform DFS from each node to find all descendants, then reverse the relationship

DFS from Each Node (Optimized Brute Force) — Algorithm Steps

Build adjacency list from edges
For each node, perform DFS to find all reachable nodes
For each reachable node, add current node as its ancestor
Sort ancestor lists for all nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin DFS from node 0

Mark Descendants

All reachable nodes get 0 as ancestor

Next Node

Repeat for nodes 1, 2, 3...

Combine Results

Each node accumulates its ancestors

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Simplified C implementation showing the concept
int** getAncestors(int n, int** edges, int edgesSize, int* edgesColSize, int* returnSize, int** returnColumnSizes) {
    // Allocate memory for adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSizes = (int*)calloc(n, sizeof(int));
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u] = (int*)realloc(graph[u], (graphSizes[u] + 1) * sizeof(int));
        graph[u][graphSizes[u]++] = v;
    }
    
    // Allocate result
    int** result = (int**)malloc(n * sizeof(int*));
    *returnColumnSizes = (int*)calloc(n, sizeof(int));
    *returnSize = n;
    
    // Initialize result arrays
    for (int i = 0; i < n; i++) {
        result[i] = (int*)malloc(n * sizeof(int)); // Max n ancestors
        (*returnColumnSizes)[i] = 0;
    }
    
    // DFS implementation would go here
    // This is a simplified version
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * (V + E))

We perform DFS from each of the n nodes, each DFS takes O(V + E) time

✓ Linear Growth

Space Complexity

O(n + E)

Space for adjacency list, visited set, and result storage

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
0 ≤ edges.length ≤ min(2000, n × (n - 1) / 2)
edges[i].length == 2
0 ≤ from_i, to_i ≤ n - 1
from_i ≠ to_i
There are no duplicate edges
The graph is acyclic

23.5K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

DFS from Each Node (Optimized Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler