def accounts_merge_brute_force(accounts):
    merged_accounts = accounts[:] # Start with a copy

    number_of_accounts = len(accounts)

    for first_index in range(number_of_accounts):
        for second_index in range(number_of_accounts):
            # Ensure we don't compare the same account to itself
            if first_index == second_index:
                continue

            first_account = merged_accounts[first_index]
            second_account = merged_accounts[second_index]

            first_account_emails = set(first_account[1:])
            second_account_emails = set(second_account[1:])

            # Check if the accounts share any email addresses
            if not first_account_emails.isdisjoint(second_account_emails):
                # Merge the accounts
                merged_name = first_account[0]
                merged_emails = set(first_account[1:] + second_account[1:])
                merged_account = [merged_name] + sorted(list(merged_emails))

                merged_accounts[first_index] = merged_account

                # Mark the second account as empty to avoid reprocessing
                merged_accounts[second_index] = [""]

    # Remove any empty accounts from the final result
    final_accounts = [account for account in merged_accounts if account != [""]]

    # Need to remove dupes after all merging is complete
    final_result = []
    for account in final_accounts:
        if account not in final_result:
            final_result.append(account)

    return final_result

def accounts_merge(accounts):
    email_to_name = {}
    email_to_account_index = {}
    graph = {}

    # Build the graph and email mappings
    for account_index, account in enumerate(accounts):
        account_name = account[0]
        for email_index in range(1, len(account)):
            email = account[email_index]
            email_to_name[email] = account_name
            email_to_account_index[email] = account_index
            if email not in graph:
                graph[email] = []
            if email_index > 1:
                previous_email = account[email_index - 1]
                graph[email].append(previous_email)
                graph[previous_email].append(email)

    merged_accounts = []
    visited = set()

    # Iterate through all emails
    for email in email_to_name:
        if email not in visited:
            # Perform DFS to find connected emails
            stack = [email]
            visited.add(email)
            connected_emails = [email]

            while stack:
                current_email = stack.pop()
                for neighbor in graph.get(current_email, []):
                    if neighbor not in visited:
                        visited.add(neighbor)
                        stack.append(neighbor)
                        connected_emails.append(neighbor)

            # Sort and add the merged account
            connected_emails.sort()
            account_name = email_to_name[email]
            merged_accounts.append([account_name] + connected_emails)

    return merged_accounts