[LintCode] Find the Weak Connected Component in the Directed Graph

Find the number Weak Connected Component in the directed graph. Each node in the graph contains a label and a list of its neighbors. (a weak connected component of a directed graph is a subgraph in which any two vertices are connected by direct edge path.)

Sort the element in each component in increasing order.

Example

Given graph:

A----->B  C
 \     |  | 
  \    |  |
   \   |  |
    \  v  v
     ->D  E <- F

Return {A,B,D}, {C,E,F}. Since there are two connected component which are {A,B,D} and {C,E,F}

 

Analysis

The difference between this problem and Connected Component in Undirected Graph is that in this problem we have a directed graph, not undirected.

In Connected Component in Undirected Graph both bfs and union find can be used to solve that problem. However, bfs is not suited for this problem of directed graph. An incoming edge to a bfs source vertex is not visible to this source vertex, causing it unable to include its upstream vertex into the same weak connected component.  Union find is a solution that works well both on undirected and directed graphs.

 

Algorithm

1. Define a union find with hashmap as its internal storage data structure.

2. Connect all graph nodes using all the edges.

3. Iterate through the uf and collect all weakly connected components. Add nodes that share the same root to the same component.

 

/**
 * Definition for Directed graph.
 * class DirectedGraphNode {
 *     int label;
 *     ArrayList<DirectedGraphNode> neighbors;
 *     DirectedGraphNode(int x) { label = x; neighbors = new ArrayList<DirectedGraphNode>(); }
 * };
 */
public class Solution {
    /**
     * @param nodes a array of Directed graph node
     * @return a connected set of a directed graph
     */
    private class UnionFind {
        private HashMap<Integer, Integer> father = null;
        public UnionFind(HashSet<Integer> labels){
            father = new HashMap<Integer, Integer>();
            for(int label : labels){
                father.put(label, label);
            }
        }
        public int find(int label){
            int parent = father.get(label);
            while(parent != father.get(parent)){
                parent = father.get(parent);
            }
            int next;
            while(label != father.get(label)){
                next = father.get(label);
                father.put(label, parent);
                label = next;
            }
            return parent;
        }
        public void connect(int x, int y){
            int root_x = find(x);
            int root_y = find(y);
            if(root_x != root_y){
                father.put(root_x, root_y);
            }
        }
    }
    public List<List<Integer>> connectedSet2(ArrayList<DirectedGraphNode> nodes) {
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if(nodes == null || nodes.size() == 0){
            return results;
        }
        HashSet<Integer> labels = new HashSet<Integer>();
        for(DirectedGraphNode node : nodes){
            labels.add(node.label);
            for(DirectedGraphNode neighbor : node.neighbors){
                labels.add(neighbor.label);
            }
        }
        UnionFind uf = new UnionFind(labels);
        for(DirectedGraphNode node : nodes){
            for(DirectedGraphNode neighbor : node.neighbors){
                uf.connect(node.label, neighbor.label);    
            }
        }
        getAllWCC(labels, uf, results);
        return results;
    }
    private void getAllWCC(HashSet<Integer> labels,
                            UnionFind uf,
                            List<List<Integer>> results){
        HashMap<Integer, ArrayList<Integer>> wcc = new HashMap<Integer, ArrayList<Integer>>();
        for(int label : labels){
            int labelRoot = uf.find(label);
            if(!wcc.containsKey(labelRoot)){
                wcc.put(labelRoot, new ArrayList<Integer>());
            }
            wcc.get(labelRoot).add(label);
        }
        for(ArrayList<Integer> comp : wcc.values()){
            Collections.sort(comp);
            results.add(comp);
        }
    }
}

 

 

Related Problems

Connected Component in Undirected Graph