Find Eventual Safe States - Practice Coding Problems

Find Eventual Safe States - Problem

Find Eventual Safe States is a fascinating graph problem that challenges you to identify which nodes in a directed graph are safe.

You're given a directed graph with n nodes labeled from 0 to n-1, represented as an adjacency list graph where graph[i] contains all nodes that node i points to.

A node is considered safe if every possible path starting from that node eventually leads to a terminal node (a node with no outgoing edges). Think of it like finding all the starting points in a maze where no matter which path you take, you'll eventually reach an exit and won't get stuck in an infinite loop.

Goal: Return all safe nodes in ascending order.

Example: If node 0 points to node 1, and node 1 points back to node 0, then both nodes are unsafe because you can get stuck in an infinite cycle. However, if a node eventually leads to a dead-end (terminal node), it's safe.

Input & Output

example_1.py — Basic Graph with Cycle

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

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

💡 Note: Node 2 leads to node 5 (terminal), node 4 leads to node 5 (terminal), nodes 5 and 6 are terminal nodes. Nodes 0, 1, 3 are part of cycles or lead to cycles.

example_2.py — Simple Cycle

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

› Output: [4]

💡 Note: Only node 4 is terminal (safe). All other nodes either form cycles or eventually lead back to cycles.

example_3.py — All Terminal Nodes

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

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

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

Visualization

Tap to expand

Step 1: Start at Entry A, mark as "Under Inspection" (GRAY)🛣️ Step 2: Follow road to B, mark B as "Under Inspection" (GRAY)⚠️ Step 3: B leads back to A (already GRAY) → Dangerous loop detected!❌ Step 4: Mark A and B as permanently unsafe (stay RED)🏁 Step 5: Start at Entry C, mark as "Under Inspection" (GRAY)🏖️ Step 6: C leads to Rest Area (terminal) → Safe route!✅ Step 7: Mark C and Rest Area as permanently safe (GREEN)📋 Final Report: Safe entry points = [C, Rest Area]

Understanding the Visualization

Mark Roads Under Inspection

When exploring a route, mark it as 'currently inspecting' (GRAY)

Detect Dangerous Loops

If we encounter a road already under inspection, we found a dangerous loop

Certify Safe Routes

Routes that lead to rest areas without loops are marked safe (BLACK)

Report Safe Entry Points

Return all highway entrances that guarantee safe journeys

Key Takeaway

🎯 Key Insight: The three-color DFS technique efficiently detects cycles by marking nodes currently under exploration, allowing us to identify dangerous loops immediately when we encounter a node we're already exploring.

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Each node and edge is visited at most once during DFS traversal

✓ Linear Growth

Space Complexity

O(V)

Color array and recursion stack in worst case

✓ Linear Space

Constraints

1 ≤ graph.length ≤ 10⁴
0 ≤ graph[i].length ≤ graph.length
0 ≤ graph[i][j] ≤ graph.length - 1
graph[i] is sorted in a strictly increasing order
The graph may contain self-loops and parallel edges

Asked in

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

The optimal solution uses three-color DFS to detect cycles efficiently. By marking nodes as WHITE (unvisited), GRAY (currently exploring), or BLACK (safe), we can identify unsafe cycles when encountering a GRAY node during traversal. This achieves O(V + E) time complexity with a single pass through the graph.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Color Coding (Optimal)	O(V + E)	O(V)	Use three-color DFS to detect cycles and determine safety in one pass
Brute Force (Path Enumeration)	O(2^n)	O(n)	For each node, enumerate all possible paths to check if any leads to a cycle

DFS with Color Coding (Optimal) — Algorithm Steps

Initialize all nodes as WHITE (unvisited)
For each unvisited node, start DFS
Mark node as GRAY when we start exploring it
If we encounter a GRAY node, we found a cycle - mark as unsafe
After exploring all neighbors, mark as BLACK if safe
Nodes marked BLACK are safe nodes
Return sorted list of safe nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

All nodes are initially WHITE (unvisited)

Mark GRAY

When exploring a node, mark it GRAY

Detect Cycle

If we encounter GRAY node, cycle detected

Mark BLACK

Safe nodes are marked BLACK when done

Code -

solution.c — C

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

bool dfs(int node, int* color, int** graph, int* graphColSize) {
    if (color[node] != 0) {
        return color[node] == 2;
    }
    
    color[node] = 1; // GRAY
    for (int i = 0; i < graphColSize[node]; i++) {
        int neighbor = graph[node][i];
        if (color[neighbor] == 1 || !dfs(neighbor, color, graph, graphColSize)) {
            return false;
        }
    }
    
    color[node] = 2; // BLACK
    return true;
}

int* eventualSafeNodes(int** graph, int* graphColSize, int graphSize, int* returnSize) {
    int* color = (int*)calloc(graphSize, sizeof(int));
    int* result = (int*)malloc(graphSize * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < graphSize; i++) {
        if (dfs(i, color, graph, graphColSize)) {
            result[(*returnSize)++] = i;
        }
    }
    
    free(color);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Each node and edge is visited at most once during DFS traversal

✓ Linear Growth

Space Complexity

O(V)

Color array and recursion stack in worst case

✓ Linear Space

Constraints

1 ≤ graph.length ≤ 10⁴
0 ≤ graph[i].length ≤ graph.length
0 ≤ graph[i][j] ≤ graph.length - 1
graph[i] is sorted in a strictly increasing order
The graph may contain self-loops and parallel edges

38.2K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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 with Color Coding (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler