LeetCode 261: Graph Valid Tree

Note:

1. Need check whether the node is the last node or not.

2. Need add a counter for counting how many branches it has.

class Solution {
    public boolean validTree(int n, int[][] edges) {
        if (n < 2) {
            return true;
        }
        Map<Integer, Set<Integer>> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            map.put(i, new HashSet<>());
        }
        
        for (int[] edge : edges) {
            map.get(edge[0]).add(edge[1]);
            map.get(edge[1]).add(edge[0]);
        }
        Queue<Integer> queue = new LinkedList<>();
        for (int v : map.keySet()) {
            if (map.get(v).size() == 1) {
                queue.offer(v);
            }
        }
        List<Integer> leaves = new ArrayList<>();
        int branch = 0;
        while (!queue.isEmpty()) {
            int current = queue.poll();
            if (map.get(current).size() > 0) {
                int child = map.get(current).iterator().next();
                map.get(child).remove(current);
                if (map.get(child).size() == 1) {
                    queue.offer(child);
                }
            } else {
                branch++;
            }
            map.remove(current);
            leaves.add(current);
        }
        return branch == 1 && leaves.size() == n;
    }
}

 

 

UnionFind

class Solution {
    public boolean validTree(int n, int[][] edges) {
        if (n < 2) {
            return true;
        }
        
        int[] parent = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
        
        for (int[] edge: edges) {
            int indexA = findParent(parent, edge[0]);
            int indexB = findParent(parent, edge[1]);
            
            if (indexA == indexB) {
                return false;
            }
            
            if (indexA < indexB) {
                parent[indexB] = indexA;
            } else {
                parent[indexA] = indexB;
            }
        }
        int root = 0;
        for (int i = 0; i < n; i++) {
            if (parent[i] == i) {
                root++;
            }
        }
        return root == 1;
    }
    
    private int findParent(int[] parent, int value) {
        while (parent[value] != value) {
            parent[value] = parent[parent[value]];
            value = parent[value];
        }
        return value;
    }
}