Count the Number of Complete Components - Practice Coding Problems

Count the Number of Complete Components - Problem

You're given an undirected graph with n vertices numbered from 0 to n-1, along with a list of edges connecting these vertices. Your task is to find how many complete connected components exist in this graph.

Let's break this down:

A connected component is a group of vertices where you can reach any vertex from any other vertex within the group, but no vertex in the group connects to vertices outside the group.
A connected component is complete if every pair of vertices within it has a direct edge between them (forming a clique).

Example: If you have vertices [0,1,2] in a component with edges [[0,1], [0,2], [1,2]], this forms a complete component because every vertex connects to every other vertex in the group.

Return the total count of such complete connected components in the graph.

Input & Output

example_1.py — Python

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

› Output: 2

💡 Note: Component {0,1,2} has 3 vertices and edges between every pair (complete). Component {3,4} has 2 vertices and 1 edge between them (complete). Component {5} is a single vertex (complete by definition).

example_2.py — Python

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

› Output: 1

💡 Note: Component {0,1,2} is complete (triangle). Component {3,4,5} has 3 vertices but only 2 edges - missing edge between 4 and 5, so not complete.

example_3.py — Python

$ Input: n = 3, edges = []

› Output: 3

💡 Note: Each vertex forms its own component: {0}, {1}, {2}. Single vertex components are complete by definition.

Visualization

Tap to expand

Understanding the Visualization

Build Graph

Create adjacency list representation of the undirected graph

Find Components

Use DFS to identify all connected components

Check Completeness

For each component with k vertices, verify it has k*(k-1)/2 edges

Count Results

Return the total number of complete components found

Key Takeaway

🎯 Key Insight: Instead of checking every pair of vertices in each component (O(k²)), we can use the mathematical property that complete graphs have exactly k*(k-1)/2 edges, reducing the verification to O(1) per component.

Time & Space Complexity

Time Complexity

⏱️

O(V² + E)

O(V + E) for DFS traversal, plus O(V²) in worst case for checking all pairs in components

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list, visited array, and recursion stack

✓ Linear Space

Constraints

1 ≤ n ≤ 50
0 ≤ edges.length ≤ n * (n - 1) / 2
edges[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i != b_i
No duplicate edges

Asked in

G Google 24 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses DFS to find connected components combined with the mathematical insight that a complete graph with k vertices must have exactly k*(k-1)/2 edges. This avoids checking all pairs explicitly and achieves O(V + E) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS + Pairwise Check)	O(V² + E)	O(V + E)	Find all components using DFS, then check every pair of vertices in each component
Two-Pass: DFS + Edge Count Verification	O(V + E)	O(V + E)	First pass finds components with DFS, second pass counts edges in each component

Brute Force (DFS + Pairwise Check) — Algorithm Steps

Build adjacency list from edges
Use DFS to find all connected components
For each component, check every pair of vertices
Count components where all pairs are connected

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Components

Use DFS to identify all connected components

Check All Pairs

For each component, verify every pair of vertices has an edge

Count Complete

Increment counter for components where all pairs are connected

Code -

solution.c — C

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

#define MAX_N 50

int adj[MAX_N][MAX_N];
int adjSize[MAX_N];
bool visited[MAX_N];
int component[MAX_N];
int compSize;

void dfs(int node) {
    visited[node] = true;
    component[compSize++] = node;
    for (int i = 0; i < adjSize[node]; i++) {
        int neighbor = adj[node][i];
        if (!visited[neighbor]) {
            dfs(neighbor);
        }
    }
}

bool isComplete() {
    for (int i = 0; i < compSize; i++) {
        for (int j = i + 1; j < compSize; j++) {
            bool found = false;
            for (int k = 0; k < adjSize[component[i]]; k++) {
                if (adj[component[i]][k] == component[j]) {
                    found = true;
                    break;
                }
            }
            if (!found) return false;
        }
    }
    return true;
}

int countCompleteComponents(int n, int** edges, int edgesSize, int* edgesColSize) {
    // Initialize
    for (int i = 0; i < n; i++) {
        adjSize[i] = 0;
        visited[i] = false;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        adj[u][adjSize[u]++] = v;
        adj[v][adjSize[v]++] = u;
    }
    
    int completeCount = 0;
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            compSize = 0;
            dfs(i);
            if (isComplete()) {
                completeCount++;
            }
        }
    }
    
    return completeCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(V² + E)

O(V + E) for DFS traversal, plus O(V²) in worst case for checking all pairs in components

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list, visited array, and recursion stack

✓ Linear Space

Constraints

1 ≤ n ≤ 50
0 ≤ edges.length ≤ n * (n - 1) / 2
edges[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i != b_i
No duplicate edges

28.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Brute Force (DFS + Pairwise Check) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler