[LintCode] Topological Sorting

 Given an directed graph, a topological order of the graph nodes is defined as follow:

• For each directed edge A -> B in graph, A must appear before B in the order list.
• The first node in the order can be any node in the graph with no nodes direct to it.

Find any topological order for the given graph.

Example

For graph as follow:

The topological order can be:

[0, 1, 2, 3, 4, 5]
[0, 2, 3, 1, 5, 4]
...

Challenge 

Can you do it in both BFS and DFS?

 

Solution 1. DFS, O(n + m) runtime, O(n) space

Algorithm:

1. for each node that has not been explored, dfs on it. The recursive dfs call stops at sinking vertices that have no outgoing edges. At the beginning of each recursive dfs call, mark the current node as explored; Before exiting each recursive dfs call, push the current graph node to a global stack.

2. After all nodes have been explored, pop the stack and add them to the result list.

Proof of correctness: Sinking vertices in the current subgraph are always pushed to the stack first. 

 

/**
 * Definition for Directed graph.
 * class DirectedGraphNode {
 *     int label;
 *     ArrayList<DirectedGraphNode> neighbors;
 *     DirectedGraphNode(int x) { label = x; neighbors = new ArrayList<DirectedGraphNode>(); }
 * };
 */

public class Solution {
    public ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
        ArrayList<DirectedGraphNode> result = new ArrayList<DirectedGraphNode>();
        if(graph == null || graph.size() == 0)
        {
            return result;
        }
        Stack<DirectedGraphNode> stack = new Stack<DirectedGraphNode>();
        HashSet<DirectedGraphNode> visited = new HashSet<DirectedGraphNode>();
        for(DirectedGraphNode node : graph)
        {
            if(!visited.contains(node))
            {
                topSortHelper(node, visited, stack);
            }
        }
        while(!stack.empty())
        {
            result.add(stack.pop());
        }
        return result;
    }
    private void topSortHelper(DirectedGraphNode node,
                            HashSet<DirectedGraphNode> visited,
                            Stack<DirectedGraphNode> stack)
    {
        visited.add(node);
        for(DirectedGraphNode neighbor : node.neighbors)
        {
            if(!visited.contains(neighbor))
            {
                topSortHelper(neighbor, visited, stack);
            }
        }
        stack.push(node);
    }
}

 

Solution 2. BFS, O(n + m) runtime, O(n) space 

Algorithm:

1. construct a map that stores the number of incoming edges of each graph node. O(m) runtime

2. add graph nodes that have no incoming edges to the queue and result list. O(n) runtime

3. dequeue nodes from the queue one at a time, and update its neighbors's incoming edges by deducting 1.

4. if a neighbor node's incoming edges number becomes 0, add this neighbor node to the queue and the result list.

5. repeat the steps 3 and 4 until the queue is empty. 

public class Solution {
    public ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
        ArrayList<DirectedGraphNode> result = new ArrayList<DirectedGraphNode>();
        //this hash map stores how many incoming edges each node has.
        //if a node has 0 incoming edges, then it does not get stored in this hash map
        HashMap<DirectedGraphNode, Integer> map = new HashMap<DirectedGraphNode, Integer>();
        for(DirectedGraphNode node : graph)
        {
            for(DirectedGraphNode neighbor : node.neighbors)
            {
                if(map.containsKey(neighbor))
                {
                    map.put(neighbor, map.get(neighbor) + 1);
                }
                else
                {
                    map.put(neighbor, 1);
                }
            }
        }
        
        Queue<DirectedGraphNode> queue = new LinkedList<DirectedGraphNode>();
        //First add all the nodes that only have outgoing edges 
        //the order among these nodes do not matter
        for(DirectedGraphNode node : graph)
        {
            if(!map.containsKey(node))
            {
                queue.offer(node);
                result.add(node);
            }
        }
        while(!queue.isEmpty())
        {
            //node has been added to the result list, so we need to deduct 1
            //for node's all neighbors.
            DirectedGraphNode node = queue.poll();
            for(DirectedGraphNode neighbor : node.neighbors)
            {
                map.put(neighbor, map.get(neighbor) - 1);
                //neighbor has no incoming edges in the remaining subgraph
                if(map.get(neighbor) == 0)
                {
                    result.add(neighbor);
                    queue.offer(neighbor);
                }
            }
        }
        return result;
    }
}

 

Related Problems

Parallel Courses

Course Schedule 

Course Schedule II

Sequence Reconstruction