Скачать или смотреть 802. Find Eventual Safe States |leetCode Problem of the day I Java I dsa I Ad-astra

**Explanation and Logic of the Code**:

The code identifies all "eventual safe nodes" in a directed graph. A node is considered safe if it does not lead to a cycle, either directly or indirectly. Here's the logic broken down step-by-step:

1. **Input Representation**:
The graph is represented as an adjacency list, where `graph[i]` contains the neighbors of node `i`.

2. **Reverse Graph Construction**:
A reverse graph is created where edges are reversed, i.e., if there is an edge from `i` to `j` in the original graph, then in the reverse graph, there is an edge from `j` to `i`.
This reversal helps in processing nodes with no outgoing edges (terminal nodes) first.

3. **Out-degree Calculation**:
`outDegree[i]` stores the number of outgoing edges for each node.
Nodes with an `outDegree` of `0` (terminal nodes) are immediately identified as safe and added to a queue.

4. **Topological Sorting Using BFS**:
The algorithm uses a queue to iteratively process nodes with `outDegree` of `0`.
For each node processed:
It is added to the result list since it is safe.
Its neighbors in the reverse graph have their `outDegree` decremented. If any neighbor's `outDegree` becomes `0`, it is added to the queue.

5. **Result Sorting**:
The resulting list of safe nodes is sorted in ascending order to meet the problem's requirements.

6. **Output**:
The function returns a list of all safe nodes in sorted order.

This approach ensures efficient computation using a reverse graph and topological sorting, handling cycles and dependencies effectively.