[LeetCode] 323. Number of Connected Components in an Undirected Graph 无向图中的连通区域的个数

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.

这道题和305. numbers of islands II 是一个思路，一个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 -= 1
 
 
class 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