The Earliest Moment When Everyone Become Friends - Problem

There are n people in a social group labeled from 0 to n - 1. You are given an array logs where logs[i] = [timestamp_i, x_i, y_i] indicates that x_i and y_i will be friends at the time timestamp_i.

Friendship is symmetric. That means if a is friends with b, then b is friends with a. Also, person a is acquainted with a person b if a is friends with b, or a is a friend of someone acquainted with b.

Return the earliest time for which every person became acquainted with every other person. If there is no such earliest time, return -1.

Input & Output

Example 1 — Basic Case

$ Input: logs = [[20,0,1],[5,2,3],[15,3,4],[18,0,2]], n = 5

› Output: 20

💡 Note: At time 5: {2,3} connected. At time 15: {2,3,4} connected. At time 18: {0,2,3,4} connected. At time 20: {0,1,2,3,4} all connected - everyone knows everyone!

Example 2 — Already Connected

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

› Output: 0

💡 Note: At time 0, persons 0 and 1 become friends, so everyone is connected immediately

Example 3 — Impossible Case

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

› Output: -1

💡 Note: Person 3 never gets connected to anyone, so it's impossible for everyone to be connected

Constraints

2 ≤ n ≤ 100
1 ≤ logs.length ≤ 10⁴
logs[i].length == 3
0 ≤ logs[i][1], logs[i][2] ≤ n - 1
logs[i][0] ≤ 10⁹
logs[i][1] ≠ logs[i][2]

Visualization

Tap to expand

Asked in

f Facebook 25 G Google 15

The key insight is to use Union-Find to efficiently track connected components as friendships form over time. Sort events by timestamp and merge components using union operations. Return the timestamp when all people form one connected component. Best approach: Union-Find with Time: O(m log m + mα(n)), Space: O(n).

Common Approaches

✓ Brute Force with DFS

⏱️ Time: O(m × n²) Space: O(n²)

Sort logs by timestamp, then for each time point, build the friendship graph and use DFS to check if all people are in one connected component. Return the first timestamp where everyone is connected.

Union-Find (Disjoint Set Union)

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

Sort friendship events by timestamp. Use Union-Find to merge components when friendships form. Return the timestamp when we have exactly one component (all people connected).

Brute Force with DFS — Algorithm Steps

Sort logs by timestamp
For each timestamp, build adjacency list
Use DFS to count connected components
Return first time with only 1 component

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Events

Sort friendship events by timestamp

Add Edge & Check

Add friendship edge and run DFS to count components

Found Answer

Return timestamp when components = 1

Code -

solution.c — C

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

void dfs(int node, int** graph, int* graphSize, bool* visited) {
    visited[node] = true;
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (!visited[neighbor]) {
            dfs(neighbor, graph, graphSize, visited);
        }
    }
}

int countComponents(int** graph, int* graphSize, int n) {
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int components = 0;
    
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            dfs(i, graph, graphSize, visited);
            components++;
        }
    }
    
    free(visited);
    return components;
}

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

int solution(int** logs, int logsSize, int n) {
    if (n <= 1) return n == 1 ? 0 : -1;
    
    qsort(logs, logsSize, sizeof(int*), compare);
    
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < logsSize; i++) {
        int timestamp = logs[i][0];
        int x = logs[i][1];
        int y = logs[i][2];
        
        graph[x][graphSize[x]++] = y;
        graph[y][graphSize[y]++] = x;
        
        if (countComponents(graph, graphSize, n) == 1) {
            for (int j = 0; j < n; j++) free(graph[j]);
            free(graph);
            free(graphSize);
            return timestamp;
        }
    }
    
    for (int i = 0; i < n; i++) free(graph[i]);
    free(graph);
    free(graphSize);
    return -1;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int** logs = (int**)malloc(1000 * sizeof(int*));
    int logsSize = 0;
    
    int len = strlen(line);
    if (len >= 2) {
        line[len-2] = '\0';
        char* modified = line + 1;
        
        char* bracket = strchr(modified, '[');
        while (bracket != NULL) {
            char* end_bracket = strchr(bracket, ']');
            if (end_bracket != NULL) {
                *end_bracket = '\0';
                
                int* row = (int*)malloc(3 * sizeof(int));
                int rowSize;
                parseArray(bracket, row, &rowSize);
                
                if (rowSize == 3) {
                    logs[logsSize++] = row;
                } else {
                    free(row);
                }
                
                *end_bracket = ']';
                bracket = strchr(end_bracket + 1, '[');
            } else {
                break;
            }
        }
    }
    
    int n;
    scanf("%d", &n);
    
    int result = solution(logs, logsSize, n);
    printf("%d\n", result);
    
    for (int i = 0; i < logsSize; i++) {
        free(logs[i]);
    }
    free(logs);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n²)

For each of m logs, we potentially run DFS on n nodes taking O(n²) time

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency list stores up to O(n²) edges plus O(n) recursion stack

⚠ Quadratic Space

32.1K Views

Medium Frequency

~25 min Avg. Time

890 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

The Earliest Moment When Everyone Become Friends - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler