def earliest_moment_everyone_friends(number_people, friendships):
    for current_time, person_one, person_two in friendships:
        # Add the current friendship to the network
        friend_network = build_friend_network(friendships, current_time)

        # Check if everyone is connected
        if all_connected(number_people, friend_network):
            return current_time

    return -1

def build_friend_network(friendships, current_time):
    friend_network = {}
    for time_stamp, person_one, person_two in friendships:
        if time_stamp <= current_time:
            if person_one not in friend_network:
                friend_network[person_one] = []
            if person_two not in friend_network:
                friend_network[person_two] = []
            friend_network[person_one].append(person_two)
            friend_network[person_two].append(person_one)
    return friend_network

def all_connected(number_people, friend_network):
    if not friend_network:
        return number_people == 1

    first_person = next(iter(friend_network))
    visited = {first_person}
    queue = [first_person]

    # Perform BFS to find all connected people
    while queue:
        person = queue.pop(0)
        if person in friend_network:
            for friend in friend_network[person]:
                if friend not in visited:
                    visited.add(friend)
                    queue.append(friend)

    # Verify that everyone is connected
    return len(visited) == number_people

# This is an example of usage for this function
# number_people = 4
# friendships = [[0, 1, 2], [1, 2, 3], [2, 1, 4]]
# result = earliest_moment_everyone_friends(number_people, friendships)
# print(result)

def find_earliest_moment(number_of_people, connections):

    parent = list(range(number_of_people))
    number_of_groups = number_of_people

    def find(person):
        if parent[person] != person:
            parent[person] = find(parent[person])
        return parent[person]

    def union(person1, person2):
        nonlocal number_of_groups
        root_person1 = find(person1)
        root_person2 = find(person2)

        if root_person1 != root_person2:
            parent[root_person1] = root_person2
            number_of_groups -= 1

    for timestamp, person1, person2 in connections:
        # Process connections in chronological order.

        union(person1 - 1, person2 - 1)

        # Check if all people are now in a single group.
        if number_of_groups == 1:

            return timestamp

    # If no such moment exists.
    return -1