Accounts Merge

Accounts Merge - Problem

Imagine you're working at a tech company where employees can have multiple email accounts, but sometimes they create duplicate profiles in your system. Your task is to merge accounts that belong to the same person by identifying shared email addresses.

Given a list of accounts where each account contains:

First element: name (string)
Remaining elements: emails associated with that account

The Challenge: Two accounts belong to the same person if they share at least one email address. Even accounts with the same name might belong to different people, but accounts belonging to the same person will always have the same name.

Your Goal: Return merged accounts where:

First element is the person's name
Remaining elements are all their emails in sorted order
No duplicate emails within each account

Example:
[["John", "a@gmail.com", "b@gmail.com"], ["John", "c@gmail.com"], ["John", "a@gmail.com", "d@gmail.com"]]
→ [["John", "a@gmail.com", "b@gmail.com", "c@gmail.com", "d@gmail.com"]]

The first and third accounts share a@gmail.com, so all three accounts belong to the same John!

Input & Output

Basic Account Merging

$ Input: accounts = [["John","johnsmith@mail.com","john_newyork@mail.com"],["John","johnsmith@mail.com","john00@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]

› Output: [["John","john00@mail.com","john_newyork@mail.com","johnsmith@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]

💡 Note: The first and second John accounts share 'johnsmith@mail.com', so they merge. The third John has no shared emails with others, so stays separate. Mary remains unchanged.

Transitive Merging

$ Input: accounts = [["Gabe","Gabe0@m.co","Gabe3@m.co","Gabe1@m.co"],["Kevin","Kevin3@m.co","Kevin5@m.co","Kevin0@m.co"],["Ethan","Ethan5@m.co","Ethan4@m.co","Ethan0@m.co"],["Hanzo","Hanzo3@m.co","Hanzo1@m.co","Hanzo0@m.co"],["Fern","Fern5@m.co","Fern1@m.co","Fern0@m.co"]]

› Output: [["Ethan","Ethan0@m.co","Ethan4@m.co","Ethan5@m.co"],["Gabe","Gabe0@m.co","Gabe1@m.co","Gabe3@m.co"],["Hanzo","Hanzo0@m.co","Hanzo1@m.co","Hanzo3@m.co"],["Fern","Fern0@m.co","Fern1@m.co","Fern5@m.co"],["Kevin","Kevin0@m.co","Kevin3@m.co","Kevin5@m.co"]]

💡 Note: No accounts share emails, so each person remains as a separate account with their emails sorted.

Single Account

$ Input: accounts = [["David","David0@m.co","David1@m.co"]]

› Output: [["David","David0@m.co","David1@m.co"]]

💡 Note: Edge case with only one account - return it with emails in sorted order.

Constraints

1 ≤ accounts.length ≤ 1000
2 ≤ accounts[i].length ≤ 10
1 ≤ accounts[i][j].length ≤ 30
accounts[i][0] consists of English letters
accounts[i][j] (for j > 0) is a valid email address
All emails within the same account are unique

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses Union-Find (Disjoint Set Union) to efficiently group accounts that share emails. We map each email to its first occurrence, then union accounts that share emails. Finally, we group accounts by their root parent and merge all emails in each group, returning them sorted. Time complexity: O(n × m × α(n)) where α is the inverse Ackermann function.

Common Approaches

✓ Brute Force (Graph Building)

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

Create a graph where each account is connected to other accounts that share at least one email. Then use DFS to find all connected components (groups of accounts belonging to the same person).

Union-Find (Disjoint Set Union)

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

Map each email to its first occurrence, then use Union-Find to group accounts. This avoids the expensive pairwise comparison of the brute force approach by leveraging the fact that if accounts A and B share an email, and accounts B and C share an email, then A and C are also connected.

Brute Force (Graph Building) — Algorithm Steps

Build a graph by comparing each account with every other account
Connect accounts that share at least one email and have the same name
Use DFS to find connected components
For each component, collect all unique emails and sort them
Return merged accounts with name and sorted emails

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Connect accounts that share emails and have same name

DFS Traversal

Find connected components using depth-first search

Merge Accounts

Collect all emails in each component and sort them

Code -

solution.c — C

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

#define MAX_ACCOUNTS 1000
#define MAX_EMAILS 10
#define MAX_EMAIL_LEN 31
#define MAX_NAME_LEN 31
#define MAX_INPUT 10000

typedef struct {
    char emails[MAX_EMAILS * MAX_ACCOUNTS][MAX_EMAIL_LEN];
    int emailCount;
} EmailSet;

typedef struct {
    int connections[MAX_ACCOUNTS];
    int count;
} AdjList;

static int visited[MAX_ACCOUNTS];
static AdjList graph[MAX_ACCOUNTS];
static EmailSet componentEmails;

void dfs(int accountIdx, char*** accounts, int* accountsColSize) {
    visited[accountIdx] = 1;
    
    for (int i = 1; i < accountsColSize[accountIdx]; i++) {
        strcpy(componentEmails.emails[componentEmails.emailCount], accounts[accountIdx][i]);
        componentEmails.emailCount++;
    }
    
    for (int i = 0; i < graph[accountIdx].count; i++) {
        int neighbor = graph[accountIdx].connections[i];
        if (!visited[neighbor]) {
            dfs(neighbor, accounts, accountsColSize);
        }
    }
}

void removeDuplicates(EmailSet* set) {
    int newCount = 0;
    for (int i = 0; i < set->emailCount; i++) {
        int isDuplicate = 0;
        for (int j = 0; j < newCount; j++) {
            if (strcmp(set->emails[i], set->emails[j]) == 0) {
                isDuplicate = 1;
                break;
            }
        }
        if (!isDuplicate) {
            if (i != newCount) {
                strcpy(set->emails[newCount], set->emails[i]);
            }
            newCount++;
        }
    }
    set->emailCount = newCount;
}

int compareEmails(const void* a, const void* b) {
    return strcmp((const char*)a, (const char*)b);
}

char*** parseInput(char* input, int* accountsSize, int** accountsColSize) {
    char*** accounts = (char***)malloc(MAX_ACCOUNTS * sizeof(char**));
    *accountsColSize = (int*)malloc(MAX_ACCOUNTS * sizeof(int));
    *accountsSize = 0;
    
    char* ptr = input + 2; // Skip initial [[
    
    while (*ptr && *ptr != '\n') {
        if (*accountsSize >= MAX_ACCOUNTS) break;
        
        accounts[*accountsSize] = (char**)malloc(MAX_EMAILS * sizeof(char*));
        (*accountsColSize)[*accountsSize] = 0;
        
        while (*ptr && *ptr != ']') {
            if (*ptr == '"') {
                ptr++; // Skip opening quote
                char* start = ptr;
                while (*ptr && *ptr != '"') ptr++;
                
                int len = ptr - start;
                accounts[*accountsSize][(*accountsColSize)[*accountsSize]] = (char*)malloc((len + 1) * sizeof(char));
                strncpy(accounts[*accountsSize][(*accountsColSize)[*accountsSize]], start, len);
                accounts[*accountsSize][(*accountsColSize)[*accountsSize]][len] = '\0';
                (*accountsColSize)[*accountsSize]++;
                
                if (*ptr == '"') ptr++; // Skip closing quote
            } else {
                ptr++;
            }
        }
        
        if (*ptr == ']') ptr++; // Skip ]
        while (*ptr && (*ptr == ',' || *ptr == '[' || *ptr == ' ')) ptr++; // Skip separators
        
        (*accountsSize)++;
        
        if (*ptr == ']') break; // End of input
    }
    
    return accounts;
}

int main() {
    static char input[MAX_INPUT];
    fgets(input, MAX_INPUT, stdin);
    
    int accountsSize;
    int* accountsColSize;
    char*** accounts = parseInput(input, &accountsSize, &accountsColSize);
    
    // Initialize graph
    for (int i = 0; i < accountsSize; i++) {
        graph[i].count = 0;
        visited[i] = 0;
    }
    
    // Build graph - connect accounts that share emails and have same name
    for (int i = 0; i < accountsSize; i++) {
        for (int j = i + 1; j < accountsSize; j++) {
            if (strcmp(accounts[i][0], accounts[j][0]) == 0) {
                int hasCommon = 0;
                for (int ei = 1; ei < accountsColSize[i] && !hasCommon; ei++) {
                    for (int ej = 1; ej < accountsColSize[j]; ej++) {
                        if (strcmp(accounts[i][ei], accounts[j][ej]) == 0) {
                            hasCommon = 1;
                            break;
                        }
                    }
                }
                
                if (hasCommon) {
                    graph[i].connections[graph[i].count++] = j;
                    graph[j].connections[graph[j].count++] = i;
                }
            }
        }
    }
    
    printf("[");
    int resultCount = 0;
    
    for (int i = 0; i < accountsSize; i++) {
        if (!visited[i]) {
            componentEmails.emailCount = 0;
            dfs(i, accounts, accountsColSize);
            
            removeDuplicates(&componentEmails);
            qsort(componentEmails.emails, componentEmails.emailCount, MAX_EMAIL_LEN, compareEmails);
            
            if (resultCount > 0) printf(",");
            printf("[\"%s\"", accounts[i][0]);
            
            for (int j = 0; j < componentEmails.emailCount; j++) {
                printf(",\"%s\"", componentEmails.emails[j]);
            }
            
            printf("]");
            resultCount++;
        }
    }
    
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m²)

n accounts, each comparison takes O(m²) where m is max emails per account

⚠ Quadratic Growth

Space Complexity

O(n × m)

Store graph adjacency list and visited arrays

⚡ Linearithmic Space

125.0K Views

High Frequency

~25 min Avg. Time

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

Brute Force (Graph Building) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler