【Lintcode】178. Graph Valid Tree

题目地址：

https://www.lintcode.com/problem/graph-valid-tree/description

判断一个无向图是否构成一棵树。

树的定义有非常多个版本。比较容易编程判断的是如下的版本：

一个无向图是树，当且仅当：
1、其连通
2、其边数等于顶点数 - 1

第二条的顶点与边的关系，主要保证了这个图是无环的，也保证了任意两点之间有且仅有一条路径可以到达。

第二条性质非常好判断，而要判断第一条性质的话，我们只需要从图中任意一点出发，去做搜索，如果搜索完成之后发现已经访问过的点的个数正好等于顶点数，那就说明了图是连通的。

法1：BFS。由于要BFS来搜索图的时候，需要知道每个顶点的邻边都有哪些，所以我们需要在搜索之前把图建立为一个邻接表。代码如下：

import java.util.*;

public class Solution {
    /**
     * @param n: An integer
     * @param edges: a list of undirected edges
     * @return: true if it's a valid tree, or false
     */
    public boolean validTree(int n, int[][] edges) {
        // write your code here
        // 如果顶点和边的个数关系不成立，直接返回false        
        if (n - 1 != edges.length) {
            return false;
        }
        // 接下来建图，用邻接表
        Map<Integer, Set<Integer>> graph = buildGraph(n, edges);
        // 为了BFS，开一个队列和哈希表。哈希表主要用于判断是否访问过，以避免重复访问
        Queue<Integer> queue = new LinkedList<>();
        Set<Integer> visited = new HashSet<>();
        // 我们可以从顶点0开始出发去搜索整个图，将0入队，也加入哈希表
        queue.offer(0);
        visited.add(0);
        
        while (!queue.isEmpty()) {
            int cur = queue.poll();
    		// 得到当前访问顶点的邻居们
            for (int neighbor : graph.get(cur)) {
            	// 如果该邻居没有访问过，则将其入队，也标记其邻居为访问过
                if (visited.add(neighbor)) {
                    queue.offer(neighbor);
                }
            }
        }
        // 如果总共访问过的顶点个数刚好为n，说明图是连通的，可以构成一棵树，返回true，否则返回false
        return visited.size() == n;
    }
	
	// 用邻接表建图
    private Map<Integer, Set<Integer>> buildGraph(int n, int[][] edges) {
    	// key是顶点编号，value是该顶点的邻居编号
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        for (int i = 0; i < n; i++) {
            graph.put(i, new HashSet<>());
        }
    
        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;
    }
}

时空复杂度$O(V+E)$。

法2：并查集。先判断一下边和顶点的个数是否满足关系，然后判断是否连通。连通与否可以用并查集判断，将边上的两个顶点union起来，最后看一下是不是所有顶点都属于同一个集合即可。代码如下：

public class Solution {
    
    class UnionFind {
        int[] parent, rank;
        int group;
        
        public UnionFind(int n) {
            parent = new int[n];
            rank = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
                rank[i] = 1;
            }
            
            group = n;
        }
        
        public int find(int p) {
            if (p != parent[p]) {
                parent[p] = find(parent[p]);
            }
            
            return parent[p];
        }
        
        public void union(int p, int q) {
            int pRoot = find(p), qRoot = find(q);
            if (pRoot == qRoot) {
                return;
            }
            
            if (rank[pRoot] < rank[qRoot]) {
                parent[pRoot] = qRoot;
            } else if (rank[pRoot] > rank[qRoot]) {
                parent[qRoot] = pRoot;
            } else {
                parent[pRoot] = qRoot;
                rank[qRoot]++;
            }
            
            group--;
        }
    }
    
    /**
     * @param n:     An integer
     * @param edges: a list of undirected edges
     * @return: true if it's a valid tree, or false
     */
    public boolean validTree(int n, int[][] edges) {
        // write your code here
        if (n == 0) {
            return true;
        }
        
        if (n - 1 != edges.length) {
            return false;
        }
        
        UnionFind uf = new UnionFind(n);
        for (int[] edge : edges) {
            uf.union(edge[0], edge[1]);
        }
        
        return uf.group == 1;
    }
}

时间复杂度$O(V{\log }^{\ast }V)$，空间$O(V)$。