Number of Connected Components in an Undirected Graph

Number of Connected Components in an Undirected Graph - Problem

Imagine you have a network of n computers scattered across different locations. Some computers are directly connected to each other through cables, forming small groups or clusters. Your task is to determine how many separate network clusters exist.

You are given:

n - the total number of computers (labeled from 0 to n-1)
edges - an array where each edges[i] = [a, b] represents a direct cable connection between computer a and computer b

Goal: Count the number of connected components (separate network clusters) in this undirected graph.

Note: Two computers belong to the same component if there's a path of cables connecting them, either directly or through other computers.

Input & Output

example_1.py — Basic Connected Components

$ Input: n = 5, edges = [[0,1],[1,2],[3,4]]

› Output: 2

💡 Note: There are 2 connected components: {0,1,2} and {3,4}. Node 0 connects to 1, and 1 connects to 2, forming one component. Nodes 3 and 4 form another component.

example_2.py — All Separate Nodes

$ Input: n = 5, edges = []

› Output: 5

💡 Note: With no edges, each of the 5 nodes forms its own separate connected component: {0}, {1}, {2}, {3}, {4}.

example_3.py — Single Large Component

$ Input: n = 4, edges = [[0,1],[1,2],[2,3]]

› Output: 1

💡 Note: All nodes are connected in a chain: 0-1-2-3, forming a single connected component {0,1,2,3}.

Visualization

Tap to expand

Understanding the Visualization

Initialize Components

Start with each node as its own separate component

Process Edges

For each edge, merge the components of the two connected nodes

Union by Rank

When merging, attach smaller tree under root of larger tree

Path Compression

Flatten tree paths during find operations for efficiency

Count Roots

The number of distinct root parents equals connected components

Key Takeaway

🎯 Key Insight: Union-Find efficiently maintains disjoint sets with near-constant time operations, making it perfect for connectivity problems where we need to group elements and count distinct groups.

Time & Space Complexity

Time Complexity

⏱️

O(E × α(n))

E edges × inverse Ackermann function (practically constant)

✓ Linear Growth

Space Complexity

O(n)

Parent and rank arrays for Union-Find

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 2000
0 ≤ edges.length ≤ 5000
edges[i].length == 2
0 ≤ a_i ≤ b_i < n
a_i != b_i
No duplicate edges in the input

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses Union-Find (Disjoint Set Union) data structure to efficiently merge connected components. Start with n separate components, then for each edge, union the two nodes' sets. The final count of distinct root parents gives us the number of connected components in O(E × α(n)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Disjoint Set) - Optimal	O(E × α(n))	O(n)	Use Union-Find data structure to efficiently group connected nodes
Breadth-First Search Approach	O(V + E)	O(V + E)	Use BFS to explore connected components level by level
Brute Force (DFS from Every Node)	O(V + E)	O(V + E)	Perform DFS from every unvisited node to find all connected components

Union-Find (Disjoint Set) - Optimal — Algorithm Steps

Initialize Union-Find with n components (each node is its own parent)
For each edge [a, b], union the sets containing a and b
After processing all edges, count distinct root parents
Return the count of distinct components

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each node is its own parent (component)

Union Edge

Merge two components when processing edge

Path Compression

Optimize future finds by flattening tree

Count Roots

Final count of distinct root parents

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int* parent;
    int* rank;
    int components;
    int size;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->components = n;
    uf->size = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]); // Path compression
    }
    return uf->parent[x];
}

void unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x);
    int py = find(uf, y);
    if (px == py) return;
    
    // Union by rank
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
    
    uf->components--;
}

int countComponents(int n, int** edges, int edgesSize, int* edgesColSize) {
    UnionFind* uf = createUnionFind(n);
    
    for (int i = 0; i < edgesSize; i++) {
        unionSets(uf, edges[i][0], edges[i][1]);
    }
    
    int result = uf->components;
    
    // Cleanup
    free(uf->parent);
    free(uf->rank);
    free(uf);
    
    return result;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E × α(n))

E edges × inverse Ackermann function (practically constant)

✓ Linear Growth

Space Complexity

O(n)

Parent and rank arrays for Union-Find

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 2000
0 ≤ edges.length ≤ 5000
edges[i].length == 2
0 ≤ a_i ≤ b_i < n
a_i != b_i
No duplicate edges in the input

73.3K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Union-Find (Disjoint Set) - Optimal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler