LeetCode "Course Schedule II"

This one lets you print out one topological sorted sequence. Either BFS or DFS works. But there are tricky details.
This is my reference: https://leetcode.com/discuss/35605/two-ac-solution-in-java-using-bfs-and-dfs-with-explanation

BFS(please note the comment):

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites)
    {
        vector<int> ret;

        map<int, int> counts;
        for (int i = 0; i < numCourses; i++)
            counts.insert(make_pair(i, 0));

        map<int, vector<int>> m;
        for (auto &r : prerequisites)
        {
            m[r.second].push_back(r.first);
            counts[r.first] ++;
        }

        //    Get roots
        queue<int> q;
        for (auto &r : counts)
            if (r.second == 0)    q.push(r.first);

        while (!q.empty())
        {
            int topInx = q.front();    q.pop();
            ret.push_back(topInx);

            for (int to : m[topInx])
            {
                counts[to] --;
                //  IMPORTANT: we only put it in when all its dependents are removed
                if (counts[to] == 0) q.push(to);
            }
        }
        return ret.size() == counts.size() ? ret : vector<int>();
    }
};

DFS. We have to go backwards!

#define MAX_BIT 2000
typedef pair<int, int> Edge;
typedef map<int, vector<int>> Graph;

class Solution {
    set<int> visited;
    bitset<MAX_BIT> onstack;
    vector<int> ret;
public:
    bool go(int from, Graph &g)
    {
        visited.insert(from);
        onstack[from] = 1;
        
        for(auto to : g[from])
        {
            if(visited.find(to) == visited.end())
            {
                if (!go(to, g)) return false;
            }
            else if(onstack[to] == 1)
            {
                return false;
            }
        }

        onstack[from] = 0;
        ret.push_back(from);

        return true;
    }
    vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) 
    {
        //    Compse graph
        Graph adjs;
        for(auto &r : prerequisites)
        {
            adjs[r.second].push_back(r.first);
        }

        //    DFS
        for(auto &r : adjs)
        {
            if((visited.find(r.first) == visited.end()) && !go(r.first, adjs))
                return vector<int>();
        }
        //    undependent ones?
        for(int i = 0; i < numCourses; i ++)
            if (visited.find(i) == visited.end())
                ret.push_back(i);

        //
        std::reverse(ret.begin(), ret.end());
        return ret;
    }
};