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 find the number of connected components in an undirected graph.
Example 1:
0 3
| |
1 --- 2 4
Given n = 5 and edges = [[0, 1], [1, 2], [3, 4]], return 2.
Example 2:
0 4
| |
1 --- 2 --- 3
Given n = 5 and edges = [[0, 1], [1, 2], [2, 3], [3, 4]], return 1.
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.
这道题和 是一个思路，一个count初始化为n，union find每次有新的edge就union两个节点，如果两个节点(u, v)原来不在一个连通图里面就减少count并且连起来，如果原来就在一个图里面就不管。用一个索引array来做，union find优化就是加权了，每次把大的树的root当做parent，小的树的root作为child。
Java:
public class Solution { public int countComponents(int n, int[][] edges) { int count = n; // array to store parent init(n, edges); for(int[] edge : edges) { int root1 = find(edge[0]); int root2 = find(edge[1]); if(root1 != root2) { union(root1, root2); count--; } } return count; } int[] map; private void init(int n, int[][] edges) { map = new int[n]; for(int[] edge : edges) { map[edge[0]] = edge[0]; map[edge[1]] = edge[1]; } } private int find(int child) { while(map[child] != child) child = map[child]; return child; } private void union(int child, int parent) { map[child] = parent; }} Python:
# Time: O(nlog*n) ~= O(n), n is the length of the positions# Space: O(n)class UnionFind(object): def __init__(self, n): self.set = range(n) self.count = n def find_set(self, x): if self.set[x] != x: self.set[x] = self.find_set(self.set[x]) # path compression. return self.set[x] def union_set(self, x, y): x_root, y_root = map(self.find_set, (x, y)) if x_root != y_root: self.set[min(x_root, y_root)] = max(x_root, y_root) self.count -= 1class Solution(object): def countComponents(self, n, edges): """ :type n: int :type edges: List[List[int]] :rtype: int """ union_find = UnionFind(n) for i, j in edges: union_find.union_set(i, j) return union_find.count
类似题目：