[LintCode] 拓扑排序

BFS:

/**
 * Definition for Directed graph.
 * struct DirectedGraphNode {
 *     int label;
 *     vector<DirectedGraphNode *> neighbors;
 *     DirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    /**
     * @param graph: A list of Directed graph node
     * @return: Any topological order for the given graph.
     */
    vector<DirectedGraphNode*> topSort(vector<DirectedGraphNode*> graph) {
        // write your code here
        vector<DirectedGraphNode*> topo;
        unordered_map<DirectedGraphNode*, int> degrees = compute_indegree(graph);
        queue<DirectedGraphNode*> zeros;
        for (auto itr = degrees.begin(); itr != degrees.end(); itr++)
            if ((*itr).second == 0)
                zeros.push((*itr).first);
        while (!zeros.empty()) {
            DirectedGraphNode* zero = zeros.front();
            zeros.pop();
            topo.push_back(zero);
            for (DirectedGraphNode* neigh : zero -> neighbors)
                if (--degrees[neigh] == 0)
                    zeros.push(neigh);
        }
        return topo;
    }
private:
    unordered_map<DirectedGraphNode*, int> compute_indegree(vector<DirectedGraphNode*>& graph) {
        unordered_map<DirectedGraphNode*, int> degrees;
        for (DirectedGraphNode* node : graph) {
            if (degrees.find(node) == degrees.end())
                degrees[node] = 0;
            for (DirectedGraphNode* neigh : node -> neighbors)
                degrees[neigh]++;
        }
        return degrees;
    }
};

DFS:

/**
 * Definition for Directed graph.
 * struct DirectedGraphNode {
 *     int label;
 *     vector<DirectedGraphNode *> neighbors;
 *     DirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    /**
     * @param graph: A list of Directed graph node
     * @return: Any topological order for the given graph.
     */
    vector<DirectedGraphNode*> topSort(vector<DirectedGraphNode*> graph) {
        // write your code here
        vector<DirectedGraphNode*> topo;
        unordered_set<DirectedGraphNode*> visited;
        for (DirectedGraphNode* node : graph)
            if (visited.find(node) == visited.end())
                dfs(graph, node, visited, topo);
        reverse(topo.begin(), topo.end());
        return topo;
    }
private:
    void dfs(vector<DirectedGraphNode*>& graph, DirectedGraphNode* node, 
             unordered_set<DirectedGraphNode*>& visited, 
             vector<DirectedGraphNode*>& topo) {
        visited.insert(node);
        for (DirectedGraphNode* neigh : node -> neighbors)
            if (visited.find(neigh) == visited.end())
                dfs(graph, neigh, visited, topo);
        topo.push_back(node);
    }
};