261. 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.

For 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.

Hint:

1. Given n = 5 and edges = [[0, 1], [1, 2], [3, 4]], what should your return? Is this case a valid tree? Show More Hint 

Note: 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.

链接： http://leetcode.com/problems/graph-valid-tree/

5/13/2017

算法班，抄答案

8ms, 39%

被hashCode跑偏了，没有想起来怎么做这道题。

最后用顶点做hashset比用边要好。因为用边不容易检测到环。

http://www.jiuzhang.com/solutions/graph-valid-tree/

public class Solution {

    public boolean validTree(int n, int[][] edges) {
        // make sure E == V - 1
        if (edges == null || edges.length != n - 1) {
            return false;
        }
        Map<Integer, Set<Integer>> graph = initializeGraph(n, edges);
        Queue<Integer> queue = new LinkedList<Integer>();
        Set<Integer> set = new HashSet<Integer>();
        queue.offer(0);
        set.add(0);
        
        while (!queue.isEmpty()) {
            Integer v = queue.poll();
            for (Integer neighbor: graph.get(v)) {
                if (!set.contains(neighbor)) {
                    queue.offer(neighbor);
                    set.add(neighbor);
                }
            }
        }
        return set.size() == n;
    }
    private Map<Integer, Set<Integer>> initializeGraph(int n, int[][] edges) {
        Map<Integer, Set<Integer>> map = new HashMap<>();
        
        for (int i = 0; i < n; i++) {
            map.put(i, new HashSet<Integer>());
        }
        for (int i = 0; i < edges.length; i++) {
            int e = edges[i][0];
            int o = edges[i][1];
            map.get(e).add(o);
            map.get(o).add(e);
        }
        return map;
    }
}

顺便实现了一次hashCode

    class Edge {
        final int either, other;
        Edge(int[] edge) {
            if (edge[0] < edge[1]) {
                this.either = edge[0];
                this.other = edge[1];                
            } else {
                this.other = edge[0];
                this.either = edge[1];
            }
        }
        @Override
        public boolean equals(Object obj) {
            if (obj == null) return false;
            if (!(obj instanceof Edge)) return false;
            Edge o = (Edge) obj;
            if (o.either == this.either && o.other == this.other) {
                // because we already ordered the two V, no need to check other direction
                return true;
            }
            return false;
        }
        @Override
        public int hashCode() {
            int hash = 7;
            hash = 71 * hash + this.either;
            hash = 71 * hash + this.other;
            return hash;        
        }
    }

还有union-find的方法。

1ms, 73%

public class Solution {
    class WeightedUnionFind {
        int[] parent;
        int[] size;
        
        WeightedUnionFind(int n) {
            parent = new int[n];
            size = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
                size[i] = 1;
            }
        }
        int find(int p) {
            while (parent[p] != p) {
                parent[p] = parent[parent[p]]; //1-pass path compression, every other node in the path points to its grandfather
                p = parent[p];
            }
            return p;
        }
        void union(int p, int q) {
            int rootP = find(p);
            int rootQ = find(q);
            // check if already connected or not
            if (rootP == rootQ) {
                return;
            }
            if (size[rootP] < size[rootQ]) {
                parent[rootP] = rootQ;
                size[rootQ] += size[rootQ];
            } else {
                parent[rootQ] = rootP;
                size[rootP] += size[rootQ];
            }
        }
        boolean connected(int p, int q) {
            return find(p) == find(q);
        }
    }
    public boolean validTree(int n, int[][] edges) {
        if (edges == null || edges.length != n - 1) return false;
        WeightedUnionFind uf = new WeightedUnionFind(n);
        for (int i = 0; i < edges.length; i++) {
            int p = edges[i][0];
            int q = edges[i][1];
            if (uf.connected(p, q)) return false;
            uf.union(edges[i][0], edges[i][1]);
        }
        return true;
    }
}

更多讨论：

https://discuss.leetcode.com/category/330/graph-valid-tree