Minimum Number of Vertices to Reach All Nodes

Minimum Number of Vertices to Reach All Nodes - Problem

Graph Medium

Imagine you're a network administrator managing a directed acyclic graph (DAG) representing a data flow network. You have n vertices numbered from 0 to n-1, and an array edges where edges[i] = [from_i, to_i] represents a directed edge from node from_i to node to_i.

Your task is to find the smallest set of starting vertices from which all nodes in the graph can be reached. Think of it as finding the minimum number of "entry points" needed to access every node in the network.

Since the graph is acyclic, there's guaranteed to be a unique solution. You can return the vertices in any order.

Example: If you have vertices [0,1,2,3] with edges [[0,1],[0,2],[2,3]], you only need to start from vertex 0 to reach all other vertices (0→1, 0→2→3).

Input & Output

example_1.py — Basic DAG

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

› Output: [0]

💡 Note: From vertex 0, we can reach all other vertices: 0→1, 0→2→3→4, 0→2→3→5. Only vertex 0 has no incoming edges.

example_2.py — Multiple Sources

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

› Output: [3,4]

💡 Note: We need both vertex 3 and 4 as starting points. From 3 we can reach 1, from 4 we can reach 0,2. Together they cover all vertices.

example_3.py — Single Nodes

$ Input: n = 3, edges = []

› Output: [0,1,2]

💡 Note: With no edges, each vertex is isolated and has in-degree 0. We need all vertices as starting points.

Visualization

Tap to expand

Understanding the Visualization

Identify Reporting Structure

Map out who reports to whom in the organization

Find Top Executives

Locate all people who don't report to anyone (zero in-degree)

Verify Coverage

These executives can reach all employees through their reporting chains

Key Takeaway

🎯 Key Insight: In any DAG, nodes with zero in-degree are exactly the minimum set needed to reach all other nodes. No smaller set exists because these nodes cannot be reached from anywhere else!

Time & Space Complexity

Time Complexity

⏱️

O(E)

Single pass through all edges to count in-degrees

✓ Linear Growth

Space Complexity

O(V)

HashSet to store vertices with incoming edges

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
1 ≤ edges.length ≤ min(10⁵, n × (n - 1) / 2)
edges[i].length == 2
0 ≤ from_i, to_i < n
All pairs (from_i, to_i) are distinct
The graph is acyclic

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses in-degree analysis. In any DAG, vertices with zero in-degree (no incoming edges) form the minimum set needed to reach all nodes. Simply track which vertices are destinations of edges, then return all vertices not marked as destinations. This elegant approach runs in O(E) time and O(V) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS from Every Node)	O(2^n × (V + E))	O(V + E)	Try DFS from every possible subset of nodes to find minimum set
In-Degree Tracking (Optimal)	O(E)	O(V)	Find all vertices with zero in-degree in a single pass

Brute Force (DFS from Every Node) — Algorithm Steps

Generate all possible subsets of vertices (2^n subsets)
For each subset, perform DFS from all vertices in the subset
Check if all n vertices can be reached
Keep track of the smallest valid subset found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible subsets of vertices

Test Each Subset

For each subset, run DFS to see if all nodes reachable

Track Minimum

Keep the smallest valid subset found

Code -

solution.c — C

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

void dfs(int node, int** graph, int* graphSize, bool* visited) {
    visited[node] = true;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (!visited[neighbor]) {
            dfs(neighbor, graph, graphSize, visited);
        }
    }
}

bool canReachAll(int* subset, int subsetSize, int** graph, int* graphSize, int n) {
    bool* visited = (bool*)calloc(n, sizeof(bool));
    
    for (int i = 0; i < subsetSize; i++) {
        if (!visited[subset[i]]) {
            dfs(subset[i], graph, graphSize, visited);
        }
    }
    
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (visited[i]) count++;
    }
    
    free(visited);
    return count == n;
}

int* findSmallestSetOfVertices(int n, int** edges, int edgesSize, int* edgesColSize, int* returnSize) {
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    
    // Count edges for each node
    for (int i = 0; i < edgesSize; i++) {
        graphSize[edges[i][0]]++;
    }
    
    // Allocate memory
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(graphSize[i] * sizeof(int));
        graphSize[i] = 0;
    }
    
    // Fill adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
    }
    
    int* minSet = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) minSet[i] = i;
    int minSize = n;
    
    // Try all subsets
    for (int mask = 1; mask < (1 << n); mask++) {
        int subset[n], subsetSize = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = i;
            }
        }
        
        if (subsetSize < minSize && canReachAll(subset, subsetSize, graph, graphSize, n)) {
            for (int i = 0; i < subsetSize; i++) {
                minSet[i] = subset[i];
            }
            minSize = subsetSize;
        }
    }
    
    *returnSize = minSize;
    return minSet;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × (V + E))

2^n subsets to check, each requiring O(V + E) DFS traversal

⚠ Quadratic Growth

Space Complexity

O(V + E)

Space for adjacency list and DFS recursion stack

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
1 ≤ edges.length ≤ min(10⁵, n × (n - 1) / 2)
edges[i].length == 2
0 ≤ from_i, to_i < n
All pairs (from_i, to_i) are distinct
The graph is acyclic

65.0K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force (DFS from Every Node) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler