[LintCode] Connected Component in Undirected Graph

Find the number connected component in the undirected graph. Each node in the graph contains a label and a list of its neighbors. (a connected component (or just component) of an undirected graph is a subgraph in which any two vertices are connected to each other by paths, and which is connected to no additional vertices in the supergraph.)

Each connected component should sort by label.

 

Example

Given graph:

A------B  C
 \     |  | 
  \    |  |
   \   |  |
    \  |  |
      D   E

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

 

Solution 1. BFS

Algorithm.

Iterate all nodes in the input graph and do the following.

1. For each unvisited graph node s, do a bfs starting from it and add all nodes that can be reached from s to a list as one connected component. Add each visited nodes to a global set that tracks which nodes have been visited.

2. Sort each connected component.

 

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

//Algorithm 1. bfs 
public class Solution {
    public List<List<Integer>> connectedSet(ArrayList<UndirectedGraphNode> nodes) {
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if(nodes == null || nodes.size() == 0)
        {
            return results;
        }
        Set<UndirectedGraphNode> visited = new HashSet<UndirectedGraphNode>();
        //bfs on each node to get all the connected components
        for(UndirectedGraphNode node : nodes)   
        {
            if(!visited.contains(node))
            {
                bfs(node, visited, results);
            }
        }
        return results;
    }
    private void bfs(UndirectedGraphNode node, 
                    Set<UndirectedGraphNode> visited,
                    List<List<Integer>> results)
    {
        ArrayList<Integer> comp = new ArrayList<Integer>();
        Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
        queue.offer(node);
        visited.add(node);
        comp.add(node.label);
        
        while(!queue.isEmpty())
        {
            UndirectedGraphNode curr = queue.poll();
            for(UndirectedGraphNode neighbor : curr.neighbors)
            {
                if(!visited.contains(neighbor))
                {
                    queue.offer(neighbor);
                    visited.add(neighbor);
                    comp.add(neighbor.label);
                }
            }
        }
        Collections.sort(comp);
        results.add(comp);
    }
}

 

 

Solution 2. Union Find

Algorithm.

1. Add each node to a union find data structure and connect these nodes based on the graph edges. A hash map is better suited for the union find since the input graph nodes' labels do not necessarily starts from 0 and are not guranteed to be consecutive. 

2. Iterate through the uf and create a mapping bewteen a root label and its represented node labels. Sort each map value and add it to the final result.

 

//Algorithm 2. Union Find
public class Solution {
    class UnionFind {
        private HashMap<Integer, Integer> father = null;
        public UnionFind(HashSet<Integer> labels){
            father = new HashMap<Integer, Integer>();
            for(Integer i : labels){
                father.put(i, i);
            }
        }
        public int find(int x){
            int parent = father.get(x);
            while(parent != father.get(parent)){
                parent = father.get(parent);
            }
            
            //compress path
            int next;
            while(x != father.get(x)){
                next = father.get(x);
                father.put(x, parent);
                x = 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>> connectedSet(ArrayList<UndirectedGraphNode> nodes) {
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if(nodes == null || nodes.size() == 0){
            return results;
        }
        //store all nodes' labels in a hash set
        HashSet<Integer> nodeLabels = new HashSet<Integer>();
        for(UndirectedGraphNode node : nodes){
            nodeLabels.add(node.label);
            for(UndirectedGraphNode neighbor : node.neighbors){
                nodeLabels.add(neighbor.label);
            }
        }
        //connect all nodes based on the edges
        UnionFind uf = new UnionFind(nodeLabels);
        for(UndirectedGraphNode node : nodes){
            for(UndirectedGraphNode neighbor : node.neighbors){
                uf.connect(node.label, neighbor.label);
            }
        }
        getAllCC(nodeLabels, uf, results);
        return results;
    }
    private void getAllCC(HashSet<Integer> nodeLabels, UnionFind uf, List<List<Integer>> results){
        //key: root representative of each connected component
        //value: connected component
        HashMap<Integer, List<Integer>> cc = new HashMap<Integer, List<Integer>>();
        for(int i : nodeLabels){
            int root = uf.find(i);
            if(!cc.containsKey(root)){
                cc.put(root, new ArrayList<Integer>());
            }
            cc.get(root).add(i);
        }
        //sort answers
        for(List<Integer> comp : cc.values()){
            Collections.sort(comp);
            results.add(comp);
        }
    }
}

 

 

Related Problems

Graph Valid Tree

Find the Weak Connected Component in the Directed Graph