Largest Study Group

Largest Study Group - Problem

In a university, there are n students numbered 0 to n - 1. Some students are friends.

You are given a 2D array friendships where friendships[i] = [u, v] means students u and v are friends. Friendship is transitive.

Return the size of the largest study group.

Input & Output

Example 1

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

› Output: 4

💡 Note: Group {0,1,2,3}=4, Group {4,5,6}=3. Largest=4.

Example 2

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

› Output: 4

💡 Note: All connected.

Example 3

$ Input: n=5, friendships=[]

› Output: 1

💡 Note: Each alone.

Constraints

1 ≤ n ≤ 2×10^5
0 ≤ friendships.length ≤ 2×10^5
0 ≤ u, v < n

Visualization

Tap to expand

Asked in

a Amazon 0 M Meta 0

The answer is the size of the largest connected component. BFS explores each. Union-Find tracks sizes.

Common Approaches

✓ BFS Component Counting

⏱️ Time: O(V+E) Space: O(V+E)

Build adjacency list. BFS from each unvisited node. Track max component size.

Union-Find with Size

⏱️ Time: O(E×α(V)) Space: O(V)

Init each node size=1. Union friendships, merge sizes. Return max.

BFS Component Counting — Algorithm Steps

Build adjacency list
BFS each unvisited node
Count component size
Return max

Visualization

Tap to expand

Step-by-Step Walkthrough

BFS from 0: size=4

BFS from 4: size=3

Result

max=4

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#define MAXN 200001
#define MAXE 400002
int head[MAXN], to[MAXE], nxt[MAXE], ecnt;
int visited[MAXN], queue[MAXN];
void addEdge(int u, int v) {
    to[ecnt] = v;
    nxt[ecnt] = head[u];
    head[u] = ecnt++;
    to[ecnt] = u;
    nxt[ecnt] = head[v];
    head[v] = ecnt++;
}
int main() {
    int n, ch, num, neg, u, v, i;
    ecnt = 0;
    memset(head, -1, sizeof(head));
    while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')))
        ;
    neg = 0;
    num = 0;
    if (ch == '-') {
        neg = 1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        num = num * 10 + (ch - '0');
        ch = getchar();
    }
    n = neg ? -num : num;
    while ((ch = getchar()) != EOF && ch != '[')
        ;
    while (1) {
        ch = getchar();
        if (ch == EOF || ch == ']')
            break;
        if (ch == '[') {
            while ((ch = getchar()) != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')))
                ;
            neg = 0;
            num = 0;
            if (ch == '-') {
                neg = 1;
                ch = getchar();
            }
            while (ch >= '0' && ch <= '9') {
                num = num * 10 + (ch - '0');
                ch = getchar();
            }
            u = neg ? -num : num;
            while (ch != EOF && !(ch == '-' || (ch >= '0' && ch <= '9')))
                ch = getchar();
            neg = 0;
            num = 0;
            if (ch == '-') {
                neg = 1;
                ch = getchar();
            }
            while (ch >= '0' && ch <= '9') {
                num = num * 10 + (ch - '0');
                ch = getchar();
            }
            v = neg ? -num : num;
            addEdge(u, v);
            while (ch != ']' && ch != EOF)
                ch = getchar();
        }
    }
    memset(visited, 0, sizeof(int) * n);
    int maxSz = 0;
    for (int s = 0; s < n; s++) {
        if (visited[s])
            continue;
        int sz = 0, front = 0, back = 0;
        queue[back++] = s;
        visited[s] = 1;
        while (front < back) {
            int nd = queue[front++];
            sz++;
            for (i = head[nd]; i != -1; i = nxt[i]) {
                if (!visited[to[i]]) {
                    visited[to[i]] = 1;
                    queue[back++] = to[i];
                }
            }
        }
        if (sz > maxSz)
            maxSz = sz;
    }
    printf("%d\n", maxSz);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V+E)

Visit each once

✓ Linear Growth

Space Complexity

O(V+E)

Adj list + visited

✓ Linear Space

2 Views

High Frequency

~12 min Avg. Time

0 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

BFS Component Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler