[LintCode] Graph Valid Tree

 Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), write a function to check whether these edges make up a valid tree.

You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.

Example

Given n = 5 and edges = [[0, 1], [0, 2], [0, 3], [1, 4]], return true.

Given n = 5 and edges = [[0, 1], [1, 2], [2, 3], [1, 3], [1, 4]], return false.

 

Algorithm:

For an undirected graph of n vertices, if the number of edges is not n - 1, then this graph can not be a valid tree. This graph is either cyclic in the case of more than n - 1 edges, or disconnected in the case of fewer than n - 1 edges. If there are n - 1 edges, then further check is needed to detect if there is any cycle in the graph. If there is a cycle, then this graph is not a valid tree. If there is no cycles, then it is a valid tree.

 

Solution 1. BFS, O(V + E) runtime, O(V + E) space 

Start from a random node and do a BFS, if all vertices can be reached then we know there can not be any cycles, we have a valid tree.

public class Solution {
    public boolean validTree(int n, int[][] edges) {
        if(edges.length != n - 1)
        {
            return false;
        }
        HashMap<Integer, HashSet<Integer>> graph = initializeGraph(n, edges);
        
        //bfs
        Queue<Integer> queue = new LinkedList<Integer>();
        HashSet<Integer> visitedSet = new HashSet<Integer>();
        
        queue.offer(0);
        visitedSet.add(0);
        int visitedNodes = 0;
        while(!queue.isEmpty())
        {
            int node = queue.poll();
            visitedNodes++;
            for(Integer neighbor : graph.get(node))
            {
                if(visitedSet.contains(neighbor))
                {
                    continue;
                }
                visitedSet.add(neighbor);
                queue.offer(neighbor);
            }
        }
        return visitedNodes == n;
    }
}

 

Solution 2. DFS to count all reachable nodes, O(V + E) runtime, O(V + E) space for graph representation, O(n) for the set of visited nodes. The recursion stack space usage should be taken into account too.

public class Solution {
    public boolean validTree(int n, int[][] edges) {
        if(edges.length != n - 1)
        {
            return false;
        }
        HashMap<Integer, HashSet<Integer>> graph = initializeGraph(n, edges);
        HashSet<Integer> visited = new HashSet<Integer>();
        visited.add(0);
        dfs(0, graph, visited);
        return visited.size() == n;   
    }
    private HashMap<Integer, HashSet<Integer>> initializeGraph(int n, int[][] edges)
    {
        HashMap<Integer, HashSet<Integer>> graph = new HashMap<Integer, HashSet<Integer>>();
        for(int i = 0; i < n; i++)
        {
            graph.put(i, new HashSet<Integer>());
        }
        for(int i = 0; i < edges.length; i++)
        {
            int u = edges[i][0];
            int v = edges[i][1];
            graph.get(u).add(v);
            graph.get(v).add(u);
        }
        return graph;
    }
    private void dfs(int startNode, 
                    HashMap<Integer, HashSet<Integer>> graph,
                    HashSet<Integer> visited){
        for(Integer neighbor : graph.get(startNode)){
            if(!visited.contains(neighbor)){
                visited.add(neighbor);
                dfs(neighbor, graph, visited);
            }
        }        
    }
}

 

Solution 3. DFS to check if there is any cycle

//Algorithm 3. dfs all nodes to check if there is a cycle in this graph. 
//O(m + n) time, O(m + n) space, if not considering the recursion space usage
public class Solution {
    public boolean validTree(int n, int[][] edges) {
        if(n == 0 || edges.length != n - 1)
        {
            return false;
        }
        HashMap<Integer, HashSet<Integer>> graph = initializeGraph(n, edges);
        return hasCycleDFS(graph) == false;
    }
    private HashMap<Integer, HashSet<Integer>> initializeGraph(int n, int[][] edges)
    {
        HashMap<Integer, HashSet<Integer>> graph = new HashMap<Integer, HashSet<Integer>>();
        for(int i = 0; i < n; i++)
        {
            graph.put(i, new HashSet<Integer>());
        }
        for(int i = 0; i < edges.length; i++)
        {
            int u = edges[i][0];
            int v = edges[i][1];
            graph.get(u).add(v);
            graph.get(v).add(u);
        }
        return graph;
    }
    private boolean hasCycleDFS(HashMap<Integer, HashSet<Integer>> graph){
        HashSet<Integer> visited = new HashSet<Integer>();
        for(Integer node : graph.keySet()){
            if(!visited.contains(node)){
                boolean flag = hasCycleDFSUtil(node, visited, -1, graph);
                if(flag){
                    return true;
                }
            }
        }
        return false;
    }
    private boolean hasCycleDFSUtil(int node, 
                                    HashSet<Integer> visited, 
                                    int parent,
                                    HashMap<Integer, HashSet<Integer>> graph){
        visited.add(node);
        for(Integer neighbor : graph.get(node)){
            //if we skil this check, then when the logic check its parent node
            //it will mistakenly think a cycle is found. 
            //e.g, A -- B -- C, start dfs from A. When visiting C, its parent B
            //has been added to the visited set, if we only rely on the visited.contains(B)
            //check, it will cause this method return true. We should only return true
            //when its neighbor has been visited and this neighbor is not its parent node
            if(neighbor == parent){
                continue;
            }    
            if(visited.contains(neighbor)){
                return true;
            }
            boolean hasCycle = hasCycleDFSUtil(neighbor, visited, node, graph);
            if(hasCycle){
                return true;
            }
        }
        return false;
    }
}

 

Solution 4. Union Find

//Algorithm 4.  Union Find, O(m + n) time, O(n) space, m is the number of edges
// n is the number of nodes
class UnionFind {
    private int[] father = null;
    private int count = 0;
    public UnionFind(int n){
        father = new int[n];
        count = n;
        for(int i = 0; i < n; i++){
            father[i] = i;
        }
    }
    public int find(int x){
        if(father[x] == x){
            return x;
        }
        return father[x] = find(father[x]);
    }
    public void connect(int a, int b){
        int root_a = find(a);
        int root_b = find(b);
        if(root_a != root_b){
            father[root_a] = father[root_b];
            count--;
        }
    }
    public int queryCount(){
        return count;
    }
}    
public class Solution {
    public boolean validTree(int n, int[][] edges) {
        if(edges.length != n - 1)
        {
            return false;
        }
        UnionFind uf = new UnionFind(n);
        for(int i = 0; i < edges.length; i++){
            uf.connect(edges[i][0], edges[i][1]);
        }
        return uf.queryCount() == 1;
    }
}

 

 

 

Related Problems

Connecting Graph

Connected Component in Undirected Graph