Find Eventual Safe States solution and explanation

from collections import deque, defaultdict

def eventualSafeNodes(graph):
    G = defaultdict(list)
    rg = defaultdict(list)
    outdegree = [0] * len(graph)
    for u in range(len(graph)):
        for v in graph[u]:
            G[u].append(v)
            rg[v].append(u)
        outdegree[u] = len(graph[u])

    q = deque([])
    for i in range(len(graph)):
        if outdegree[i] == 0:
            q.append(i)

    res = []
    while q:
        u = q.popleft()
        res.append(u)
        for v in rg[u]:
            outdegree[v] -= 1
            if outdegree[v] == 0:
                q.append(v)

    return sorted(res)

graph = [[1, 2], [2, 3], [5], [0], [5], [], []]
print(eventualSafeNodes(graph))

import java.util.*;

class Solution {
    public List<Integer> eventualSafeNodes(int[][] graph) {
        // Implementation
        return new ArrayList<>();
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] graph = {{1, 2}, {2, 3}, {5}, {0}, {5}, {}, {}};
        List<Integer> result = sol.eventualSafeNodes(graph);
        System.out.println(result);
    }
}

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

void findEventualSafeNodes(int** graph, int graphSize, int* graphColSize, int* returnSize) {
    // Implementation
}

int main() {
    int n = 7;
    int graphColSize[] = {2, 2, 1, 1, 1, 0, 0};
    int graphData[7][2] = {{1, 2}, {2, 3}, {5}, {0}, {5}, {}, {}};
    int* graph[7];
    for (int i = 0; i < 7; i++) {
        graph[i] = graphData[i];
    }
    int returnSize = 0;
    findEventualSafeNodes(graph, 7, graphColSize, &returnSize);
    return 0;
}

#include <vector>
#include <iostream>
using namespace std;

vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
    // Implementation
    return {};
}

int main() {
    vector<vector<int>> graph = {{1, 2}, {2, 3}, {5}, {0}, {5}, {}, {}};
    vector<int> result = eventualSafeNodes(graph);
    for (int node : result) {
        cout << node << " ";
    }
    return 0;
}

var eventualSafeNodes = function(graph) {
    // Implementation
    return [];
};

let graph = [[1, 2], [2, 3], [5], [0], [5], [], []];
console.log(eventualSafeNodes(graph));

using System;
using System.Collections.Generic;

public class Solution {
    public IList<int> EventualSafeNodes(int[][] graph) {
        // Implementation
        return new List<int>();
    }

    public static void Main(string[] args) {
        Solution sol = new Solution();
        int[][] graph = new int[][] { new int[] { 1, 2 }, new int[] { 2, 3 }, new int[] { 5 }, new int[] { 0 }, new int[] { 5 }, new int[0], new int[0]};
        var result = sol.EventualSafeNodes(graph);
        Console.WriteLine(String.Join(", ", result));
    }
}

func eventualSafeNodes(graph [][]int) []int {
	n := len(graph)
	indeg := make([]int, n)
	rg := make([][]int, n)
	q := []int{}
	for i, vs := range graph {
		for _, j := range vs {
			rg[j] = append(rg[j], i)
		}
		indeg[i] = len(vs)
		if indeg[i] == 0 {
			q = append(q, i)
		}
	}
	for len(q) > 0 {
		i := q[0]
		q = q[1:]
		for _, j := range rg[i] {
			indeg[j]--
			if indeg[j] == 0 {
				q = append(q, j)
			}
		}
	}
	ans := []int{}
	for i, v := range indeg {
		if v == 0 {
			ans = append(ans, i)
		}
	}
	return ans
}