The Earliest Moment When Everyone Become Friends

The Earliest Moment When Everyone Become Friends - Problem

You're managing a social network where friendships form over time. Given n people labeled from 0 to n-1, you need to find the earliest moment when everyone becomes connected in one giant social circle.

You're given an array logs where logs[i] = [timestamp, x, y] indicates that person x and person y become friends at time timestamp. Remember:

Friendship is symmetric: if A is friends with B, then B is friends with A
Friendship is transitive through acquaintances: if A knows B and B knows C, then A is acquainted with C

Goal: Return the earliest timestamp when every person is acquainted with every other person (directly or through mutual friends). If this never happens, return -1.

Example: With 4 people and friendships forming at different times, you need to find when the last "island" of people connects to form one unified group.

Input & Output

example_1.py — Basic Friendship Network

$ Input: logs = [[20190101,0,1],[20190104,3,4],[20190107,2,3],[20190211,1,5],[20190224,2,4],[20190301,0,3],[20190312,1,2],[20190322,4,5]], n = 6

› Output: 20190301

💡 Note: At timestamp 20190301, when persons 0 and 3 become friends, it connects the final two separate groups: {0,1,5,2} and {3,4}, making everyone acquainted.

example_2.py — Already Connected Small Group

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

› Output: 3

💡 Note: After timestamp 3, all 4 people are connected: 0-2-1 and 0-3 form one connected component covering everyone.

example_3.py — Impossible Connection

$ Input: logs = [[9,3,0],[0,2,1],[8,0,1],[1,3,2],[2,2,0],[5,3,1]], n = 4

› Output: 2

💡 Note: All people become connected at timestamp 2 when the friendship network forms a complete connected graph.

Constraints

1 ≤ n ≤ 100
1 ≤ logs.length ≤ 10⁴
logs[i].length == 3
0 ≤ timestamp_i ≤ 10⁹
0 ≤ x_i, y_i ≤ n - 1
x_i ≠ y_i
All timestamps are distinct
All friendships are bidirectional

Visualization

Tap to expand

Understanding the Visualization

Initial State

Everyone starts as isolated individuals (n separate components)

First Connections

Early friendships create small groups, reducing total components

Group Merging

Strategic friendships merge existing groups into larger networks

Final Connection

The last friendship connects all groups into one unified network

Key Takeaway

🎯 Key Insight: Union-Find transforms an O(n²m) connectivity problem into an elegant O(m log n) solution by tracking components instead of individual connections!

Asked in

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

This problem is a classic application of Union-Find (Disjoint Set Union). The key insight is to track connected components efficiently rather than checking full connectivity after each friendship. Sort logs by timestamp, then use Union-Find to merge components as friendships form. When the number of components reaches 1, everyone is connected. Time complexity: O(m log n) where m is the number of friendship logs.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(m log n)	O(n)	Use Union-Find to efficiently track connected components as friendships form
Brute Force (DFS/BFS After Each Connection)	O(n²m)	O(n²)	After each friendship, check if all people are connected using graph traversal

Union-Find (Optimal) — Algorithm Steps

Sort logs by timestamp
Initialize Union-Find with n separate components
For each friendship log, union the two people
Track number of connected components
When components == 1, return current timestamp

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each person is their own component

Union Operation

Merge components when friendship forms

Path Compression

Optimize future find operations

Check Components

Return timestamp when components = 1

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 = malloc(sizeof(UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->rank = 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];
}

int unionSets(UnionFind* uf, int x, int y) {
    int rootX = find(uf, x);
    int rootY = find(uf, y);
    
    if (rootX != rootY) {
        // Union by rank
        if (uf->rank[rootX] < uf->rank[rootY]) {
            uf->parent[rootX] = rootY;
        } else if (uf->rank[rootX] > uf->rank[rootY]) {
            uf->parent[rootY] = rootX;
        } else {
            uf->parent[rootY] = rootX;
            uf->rank[rootX]++;
        }
        
        uf->components--;
        return 1;
    }
    return 0;
}

int compare(const void* a, const void* b) {
    int* logA = *(int**)a;
    int* logB = *(int**)b;
    return logA[0] - logB[0];
}

int earliestAcq(int** logs, int logsSize, int* logsColSize, int n) {
    qsort(logs, logsSize, sizeof(int*), compare);
    
    UnionFind* uf = createUnionFind(n);
    
    for (int i = 0; i < logsSize; i++) {
        int timestamp = logs[i][0];
        int x = logs[i][1];
        int y = logs[i][2];
        
        if (unionSets(uf, x, y)) {
            if (uf->components == 1) {
                int result = timestamp;
                free(uf->parent);
                free(uf->rank);
                free(uf);
                return result;
            }
        }
    }
    
    free(uf->parent);
    free(uf->rank);
    free(uf);
    return -1;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log n)

Sorting logs takes O(m log m), Union-Find operations are nearly O(1) with path compression

⚡ Linearithmic

Space Complexity

O(n)

Parent and rank arrays for Union-Find structure

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~15 min Avg. Time

2.5K 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

Union-Find (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler