Count the Number of Complete Components

Count the Number of Complete Components - Problem

You are given an integer n. There is an undirected graph with n vertices, numbered from 0 to n - 1. You are given a 2D integer array edges where edges[i] = [ai, bi] denotes that there exists an undirected edge connecting vertices ai and bi.

Return the number of complete connected components of the graph.

A connected component is a subgraph of a graph in which there exists a path between any two vertices, and no vertex of the subgraph shares an edge with a vertex outside of the subgraph.

A connected component is said to be complete if there exists an edge between every pair of its vertices.

Input & Output

Example 1 — Mixed Components

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

› Output: 3

💡 Note: Component {0,1,2} has 3 vertices and 3 edges, needs 3×2/2=3 edges ✓. Component {3,4} has 2 vertices and 1 edge, needs 2×1/2=1 edge ✓. Component {5} is single vertex ✓. Total: 3 complete components.

Example 2 — No Edges

$ Input: n = 4, edges = []

› Output: 4

💡 Note: No edges means 4 isolated vertices: {0}, {1}, {2}, {3}. Each single vertex forms a complete component by definition.

Example 3 — Incomplete Triangle

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

› Output: 0

💡 Note: Component {0,1,2} has 3 vertices but only 2 edges. For completeness, needs 3×2/2=3 edges. Missing edge (0,2), so not complete.

Constraints

1 ≤ n ≤ 50
0 ≤ edges.length ≤ n × (n - 1) / 2
edges[i].length == 2
0 ≤ ai, bi ≤ n - 1
ai ≠ bi
There are no repeated edges.

Visualization

Tap to expand

Asked in

M Meta 8 G Google 6 a Amazon 4

The key insight is that a complete component with k vertices must have exactly k×(k-1)/2 edges. Best approach uses DFS to find connected components then verifies completeness by counting edges. Time: O(n + m), Space: O(n + m)

Common Approaches

✓ Brute Force - Check All Subsets

⏱️ Time: O(2ⁿ × n²) Space: O(n)

For every possible subset of vertices, check if it forms a connected component and if it's complete (has edges between all pairs). This approach considers all 2^n possible subsets.

DFS - Find Connected Components

⏱️ Time: O(n + m) Space: O(n + m)

Traverse the graph using DFS to identify all connected components. For each component, verify if it's complete by checking if the number of edges equals k*(k-1)/2 where k is the component size.

Brute Force - Check All Subsets — Algorithm Steps

Generate all possible subsets of vertices
For each subset, check if it's connected
For each connected subset, verify it's complete
Count valid complete components

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible vertex combinations

Test Connectivity

Use DFS to verify each subset forms a connected component

Check Completeness

Count edges and verify k*(k-1)/2 formula

Code -

solution.c — C

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

int solution(int n, int edges[][2], int edgesSize) {
    // Build adjacency matrix
    bool graph[n][n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            graph[i][j] = false;
        }
    }
    
    for (int i = 0; i < edgesSize; i++) {
        graph[edges[i][0]][edges[i][1]] = true;
        graph[edges[i][1]][edges[i][0]] = true;
    }
    
    int count = 0;
    // Generate all possible subsets
    for (int mask = 1; mask < (1 << n); mask++) {
        int subset[n];
        int subsetSize = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = i;
            }
        }
        
        // Check if connected
        bool connected = true;
        if (subsetSize > 1) {
            bool visited[n];
            for (int i = 0; i < n; i++) visited[i] = false;
            
            int stack[n];
            int stackSize = 1;
            stack[0] = subset[0];
            visited[subset[0]] = true;
            int visitedCount = 1;
            
            while (stackSize > 0) {
                int node = stack[--stackSize];
                for (int i = 0; i < n; i++) {
                    if (graph[node][i] && !visited[i]) {
                        // Check if i is in subset
                        bool inSubset = false;
                        for (int j = 0; j < subsetSize; j++) {
                            if (subset[j] == i) {
                                inSubset = true;
                                break;
                            }
                        }
                        if (inSubset) {
                            visited[i] = true;
                            stack[stackSize++] = i;
                            visitedCount++;
                        }
                    }
                }
            }
            
            connected = (visitedCount == subsetSize);
        }
        
        // Check if complete
        bool complete = true;
        if (connected && subsetSize > 1) {
            int edgeCount = 0;
            for (int i = 0; i < subsetSize; i++) {
                for (int j = i + 1; j < subsetSize; j++) {
                    if (graph[subset[i]][subset[j]]) {
                        edgeCount++;
                    }
                }
            }
            complete = (edgeCount == subsetSize * (subsetSize - 1) / 2);
        }
        
        if (connected && complete) {
            count++;
        }
    }
    
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    // Parse edges array
    int edges[1000][2];
    int edgesSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* ptr = line + 1; // Skip '['
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                edges[edgesSize][0] = atoi(ptr);
                while (*ptr && *ptr != ',') ptr++;
                ptr++; // Skip ','
                edges[edgesSize][1] = atoi(ptr);
                while (*ptr && *ptr != ']') ptr++;
                ptr++; // Skip ']'
                edgesSize++;
            }
            ptr++;
        }
    }
    
    int result = solution(n, edges, edgesSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n²)

2^n subsets to check, each requiring O(n²) time to verify connectivity and completeness

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and temporary subset storage

⚡ Linearithmic Space

18.9K Views

Medium Frequency

~25 min Avg. Time

485 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler