Find Eventual Safe States - Practice Coding Problems

Find Eventual Safe States - Problem

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.

Input & Output

Example 1 — Basic Graph with Cycle

$ Input: graph = [[1,2],[2,3],[5],[0],[5],[],[]]

› Output: [2,4,5,6]

💡 Note: Node 0: leads to cycle 0→1→2→5→0, so unsafe. Node 1: leads to same cycle, unsafe. Node 2: leads to node 5 (terminal), so safe. Node 3: leads to cycle, unsafe. Node 4: leads to node 5 (terminal), safe. Nodes 5,6: terminal nodes, safe.

Example 2 — Simple Linear Graph

$ Input: graph = [[1,2,3,4],[1,2],[3],[4],[]]

› Output: [4]

💡 Note: Only node 4 is terminal (no outgoing edges). All paths from nodes 0,1,2,3 eventually lead to cycles or unsafe states. Only node 4 is guaranteed safe.

Example 3 — All Terminal Nodes

$ Input: graph = [[],[],[]]

› Output: [0,1,2]

💡 Note: All nodes are terminal (no outgoing edges), so all nodes are safe by definition.

Constraints

n == graph.length
1 ≤ n ≤ 10⁴
0 ≤ graph[i].length ≤ n
0 ≤ graph[i][j] ≤ n - 1
graph[i] is sorted in a strictly increasing order

Visualization

Tap to expand

Understanding the Visualization

Input Graph

Directed graph with potential cycles

Cycle Detection

Find nodes that are part of or lead to cycles

Safe Nodes

Nodes that only lead to terminal nodes

Key Takeaway

🎯 Key Insight: Safe nodes never lead to cycles - use DFS with state tracking or reverse graph topology

Asked in

G Google 35 F Facebook 28 A Amazon 22 M Microsoft 18

The key insight is recognizing that safe nodes are those not part of any cycle. The optimal approach reverses the graph and uses topological sorting starting from terminal nodes. Time: O(V + E), Space: O(V + E).

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Cycle Detection	O(V + E)	O(V)	Use DFS to detect cycles and mark unsafe nodes
Reverse Graph + Topological Sort	O(V + E)	O(V + E)	Reverse the graph and use topological sorting to find safe nodes

DFS with Cycle Detection — Algorithm Steps

Initialize state array for all nodes
For each unvisited node, start DFS
Mark nodes as visiting during traversal
If we reach a visiting node, it's a cycle
Mark completed nodes as safe or unsafe

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

All nodes start as unvisited (white)

DFS Traversal

Mark nodes as visiting (gray) during traversal

Cycle Detection

If we reach a gray node, we found a cycle

Mark Safe

Nodes not in cycles are marked safe (green)

Code -

solution.c — C

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

#define MAX_N 10000
int graph[MAX_N][MAX_N];
int graph_size[MAX_N];
int state[MAX_N]; // 0: unvisited, 1: visiting, 2: safe
int n;

bool dfs(int node) {
    if (state[node] != 0) {
        return state[node] == 2;
    }
    
    state[node] = 1; // Mark as visiting
    
    for (int i = 0; i < graph_size[node]; i++) {
        if (!dfs(graph[node][i])) {
            return false;
        }
    }
    
    state[node] = 2; // Mark as safe
    return true;
}

int* solution(int* returnSize) {
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < n; i++) {
        if (dfs(i)) {
            result[(*returnSize)++] = i;
        }
    }
    
    return result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Simple parsing for 2D array
    n = 0;
    char* ptr = line + 1; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            graph_size[n] = 0;
            
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    int num = 0;
                    while (*ptr >= '0' && *ptr <= '9') {
                        num = num * 10 + (*ptr - '0');
                        ptr++;
                    }
                    graph[n][graph_size[n]++] = num;
                }
                if (*ptr == ',') ptr++;
            }
            if (*ptr == ']') ptr++;
            n++;
        }
        if (*ptr == ',') ptr++;
    }
    
    int returnSize;
    int* result = solution(&returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex and edge once during DFS traversal

✓ Linear Growth

Space Complexity

O(V)

State array and recursion stack depth up to V nodes

✓ Linear Space

125.0K Views

Medium Frequency

~25 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

DFS with Cycle Detection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler