2685. Count the Number of Complete Components

import java.util.*;

class Solution {

    public int countCompleteComponents(int n, int[][] edges) {

        List<Integer>[] graph = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            graph[i] = new ArrayList<>();
        }

        for (int[] edge : edges) {
            graph[edge[0]].add(edge[1]);
            graph[edge[1]].add(edge[0]);
        }

        boolean[] visited = new boolean[n];
        int complete = 0;

        for (int i = 0; i < n; i++) {

            if (visited[i]) continue;

            Queue<Integer> queue = new LinkedList<>();
            List<Integer> component = new ArrayList<>();

            queue.offer(i);
            visited[i] = true;

            while (!queue.isEmpty()) {

                int node = queue.poll();
                component.add(node);

                for (int next : graph[node]) {
                    if (!visited[next]) {
                        visited[next] = true;
                        queue.offer(next);
                    }
                }
            }

            int size = component.size();
            boolean ok = true;

            for (int node : component) {
                if (graph[node].size() != size - 1) {
                    ok = false;
                    break;
                }
            }

            if (ok) complete++;
        }

        return complete;
    }
}

from collections import deque

class Solution:
    def countCompleteComponents(self, n: int, edges):

        graph = [[] for _ in range(n)]

        for u, v in edges:
            graph[u].append(v)
            graph[v].append(u)

        visited = [False] * n
        complete = 0

        for i in range(n):

            if visited[i]:
                continue

            queue = deque([i])
            visited[i] = True
            component = []

            while queue:

                node = queue.popleft()
                component.append(node)

                for nxt in graph[node]:
                    if not visited[nxt]:
                        visited[nxt] = True
                        queue.append(nxt)

            size = len(component)
            ok = True

            for node in component:
                if len(graph[node]) != size - 1:
                    ok = False
                    break

            if ok:
                complete += 1

        return complete

class Solution {
public:
    int countCompleteComponents(int n, vector<vector<int>>& edges) {

        vector<vector<int>> graph(n);

        for (auto &edge : edges) {
            graph[edge[0]].push_back(edge[1]);
            graph[edge[1]].push_back(edge[0]);
        }

        vector<bool> visited(n, false);
        int complete = 0;

        for (int i = 0; i < n; i++) {

            if (visited[i]) continue;

            queue<int> q;
            vector<int> component;

            q.push(i);
            visited[i] = true;

            while (!q.empty()) {

                int node = q.front();
                q.pop();

                component.push_back(node);

                for (int nxt : graph[node]) {
                    if (!visited[nxt]) {
                        visited[nxt] = true;
                        q.push(nxt);
                    }
                }
            }

            int size = component.size();
            bool ok = true;

            for (int node : component) {
                if ((int)graph[node].size() != size - 1) {
                    ok = false;
                    break;
                }
            }

            if (ok) complete++;
        }

        return complete;
    }
};

var countCompleteComponents = function(n, edges) {

    const graph = Array.from({ length: n }, () => []);

    for (const [u, v] of edges) {
        graph[u].push(v);
        graph[v].push(u);
    }

    const visited = new Array(n).fill(false);
    let complete = 0;

    for (let i = 0; i < n; i++) {

        if (visited[i]) continue;

        const queue = [i];
        visited[i] = true;
        const component = [];

        while (queue.length) {

            const node = queue.shift();
            component.push(node);

            for (const nxt of graph[node]) {
                if (!visited[nxt]) {
                    visited[nxt] = true;
                    queue.push(nxt);
                }
            }
        }

        const size = component.length;
        let ok = true;

        for (const node of component) {
            if (graph[node].length !== size - 1) {
                ok = false;
                break;
            }
        }

        if (ok) complete++;
    }

    return complete;
};