Accounts Merge Problem using Disjoint Set Union

Problem and examples

You're given a list of accounts. Each account is a list where the first element is a user name and the rest are email addresses belonging to that person. Your task is to merge the accounts if any two accounts share at least one common email.

Important: Two accounts with the same name are not necessarily the same person unless they share an email. After merging, return each account with the name followed by the sorted list of unique emails.

Input Accounts	Merged Output	Description
[ ["John", "johnsmith@mail.com", "john00@mail.com"], ["John", "johnnybravo@mail.com"], ["John", "johnsmith@mail.com", "john_newyork@mail.com"], ["Mary", "mary@mail.com"] ]	[ ["John", "john00@mail.com", "john_newyork@mail.com", "johnsmith@mail.com"], ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"] ]	First and third John accounts are merged via common email
[ ["Alex", "a@mail.com"], ["Alex", "b@mail.com"], ["Alex", "a@mail.com", "b@mail.com"] ]	[ ["Alex", "a@mail.com", "b@mail.com"] ]	All Alex accounts are connected through emails
[]	[]	No accounts to process
[ ["Bob", "bob@mail.com"] ]	[ ["Bob", "bob@mail.com"] ]	Single account, no merging needed

How it works

Understanding the Problem

We are given a list of accounts where each account belongs to a person and contains a list of emails. Some people may have multiple accounts, and emails may appear in more than one account. Our goal is to merge all the accounts that belong to the same person, meaning any accounts that share at least one common email should be merged into one.

For example, if "John" has one account with ["john@gmail.com", "john@yahoo.com"] and another with ["john@yahoo.com", "john@outlook.com"], these two should be merged into a single account with all three emails, since "john@yahoo.com" is common to both.

We will solve this using Disjoint Set Union (DSU), which is great for managing groups of connected elements efficiently.

Step-by-Step Solution with Example

Step 1: Visualize the Problem as a Graph

Think of each email as a node in a graph. If two emails are part of the same account, draw an edge between them. This way, all emails that are connected form a cluster that belongs to the same user.

Step 2: Initialize DSU

We create a DSU (also known as Union-Find) structure to manage which emails are connected. Each email will be a node in this structure, and we'll use union and find operations to group them.

Step 3: Build Connections Using Union Operation

Iterate through each account. For every account, pick the first email and union it with all other emails in that account. This connects all emails in that account together.

Step 4: Map Emails to User Names

As we process each email, we also maintain a mapping from email to user name so that we can retrieve the correct name when building the final result.

Step 5: Group Emails by Root

After all unions are done, go through every email and use the find operation to determine its representative (root parent). Group all emails with the same root together. These are emails that belong to the same person.

Step 6: Sort and Format the Result

For each group of emails, sort them alphabetically and prepend the user name (using our earlier mapping). This gives us the merged account in the correct format.

Example:


Input: 
[
  ["John", "john@gmail.com", "john@yahoo.com"],
  ["John", "john@yahoo.com", "john@outlook.com"],
  ["Mary", "mary@gmail.com"]
]

Process:
- Union "john@gmail.com" with "john@yahoo.com"
- Union "john@yahoo.com" with "john@outlook.com"
- Map all emails to "John"
- Map "mary@gmail.com" to "Mary"

Result:
[
  ["John", "john@gmail.com", "john@outlook.com", "john@yahoo.com"],
  ["Mary", "mary@gmail.com"]
]

Edge Cases

Multiple accounts with no overlapping emails: Each account will remain separate.
One email used by multiple accounts of the same name: All such accounts should be merged using that common email as the connector.
Emails that belong to different users but look similar: Be careful; merge only if the actual email strings match exactly.
Empty account list: Simply return an empty result.

Finally

This problem is a great example of applying DSU to a real-world scenario involving connected data. By modeling emails as a graph and using DSU to manage the components, we can efficiently merge related accounts. Always remember to handle mapping and sorting properly when preparing the final answer.

Initialize a parent map for DSU: parent[email] = email.
Iterate through each account:

For each email in the account, perform union(email, first_email).
Record email_to_name[email] = account[0].

For each email, find its root parent using find(email) and group emails by root.
For each group, sort the emails and prepend the name.
Return the list of merged accounts.

Implementation and efficiency

C implementation

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

#define MAX_ACCOUNTS 4
#define MAX_EMAILS 5
#define MAX_EMAIL_LEN 50
#define MAX_NAME_LEN 20

// Simple structure to hold account data
typedef struct {
    char name[MAX_NAME_LEN];
    int emailCount;
    char emails[MAX_EMAILS][MAX_EMAIL_LEN];
} Account;

// Helper function to check if email exists in an array
int emailExists(char emails[][MAX_EMAIL_LEN], int count, const char *email) {
    for (int i = 0; i < count; i++) {
        if (strcmp(emails[i], email) == 0) {
            return 1;
        }
    }
    return 0;
}

int main() {
    Account accounts[MAX_ACCOUNTS] = {
        {"John", 2, {"johnsmith@mail.com", "john00@mail.com"}},
        {"John", 1, {"johnnybravo@mail.com"}},
        {"John", 2, {"johnsmith@mail.com", "john_newyork@mail.com"}},
        {"Mary", 1, {"mary@mail.com"}}
    };

    // Merging accounts that share emails (naive approach for demonstration)
    // Result stored in merged accounts
    Account merged[MAX_ACCOUNTS];
    int mergedCount = 0;

    for (int i = 0; i < MAX_ACCOUNTS; i++) {
        int mergedIndex = -1;
        for (int j = 0; j < mergedCount; j++) {
            // Check if any email overlaps
            for (int e1 = 0; e1 < accounts[i].emailCount; e1++) {
                if (emailExists(merged[j].emails, merged[j].emailCount, accounts[i].emails[e1])) {
                    mergedIndex = j;
                    break;
                }
            }
            if (mergedIndex != -1) break;
        }

        if (mergedIndex == -1) {
            // Add new merged account
            merged[mergedCount++] = accounts[i];
        } else {
            // Merge emails without duplicates
            for (int e1 = 0; e1 < accounts[i].emailCount; e1++) {
                if (!emailExists(merged[mergedIndex].emails, merged[mergedIndex].emailCount, accounts[i].emails[e1])) {
                    strcpy(merged[mergedIndex].emails[merged[mergedIndex].emailCount++], accounts[i].emails[e1]);
                }
            }
        }
    }

    // Print merged accounts
    for (int i = 0; i < mergedCount; i++) {
        printf("%s: ", merged[i].name);
        for (int e = 0; e < merged[i].emailCount; e++) {
            printf("%s%s", merged[i].emails[e], (e == merged[i].emailCount - 1) ? "\n" : ", ");
        }
    }
    return 0;
}

C++ implementation

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>

using namespace std;

class Solution {
public:
    vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
        unordered_map<string, string> emailToName;
        unordered_map<string, string> parent;

        function<string(string)> find = [&](string x) {
            if (parent.find(x) == parent.end())
                parent[x] = x;
            if (parent[x] != x)
                parent[x] = find(parent[x]);
            return parent[x];
        };

        auto unite = [&](string x, string y) {
            parent[find(x)] = find(y);
        };

        for (auto &account : accounts) {
            string name = account[0];
            for (int i = 1; i < account.size(); ++i) {
                emailToName[account[i]] = name;
                if (i > 1)
                    unite(account[i], account[i-1]);
            }
        }

        unordered_map<string, vector<string>> unions;
        for (auto &p : emailToName) {
            string root = find(p.first);
            unions[root].push_back(p.first);
        }

        vector<vector<string>> result;
        for (auto &p : unions) {
            sort(p.second.begin(), p.second.end());
            vector<string> account;
            account.push_back(emailToName[p.first]);
            account.insert(account.end(), p.second.begin(), p.second.end());
            result.push_back(account);
        }
        return result;
    }
};

int main() {
    vector<vector<string>> accounts = {
        {"John", "johnsmith@mail.com", "john00@mail.com"},
        {"John", "johnnybravo@mail.com"},
        {"John", "johnsmith@mail.com", "john_newyork@mail.com"},
        {"Mary", "mary@mail.com"}
    };

    Solution solution;
    auto merged = solution.accountsMerge(accounts);

    for (auto &account : merged) {
        cout << account[0] << ": ";
        for (int i = 1; i < account.size(); i++) {
            cout << account[i];
            if (i < account.size() - 1) cout << ", ";
        }
        cout << endl;
    }

    return 0;
}

Python implementation

def accounts_merge(accounts):
    parent = {}
    email_to_name = {}

    def find(x):
        if parent.setdefault(x, x) != x:
            parent[x] = find(parent[x])
        return parent[x]

    def union(x, y):
        parent[find(x)] = find(y)

    for account in accounts:
        name, *emails = account
        for email in emails:
            email_to_name[email] = name
            union(emails[0], email)

    unions = {}
    for email in parent:
        root = find(email)
        unions.setdefault(root, []).append(email)

    result = []
    for emails in unions.values():
        emails.sort()
        result.append([email_to_name[emails[0]]] + emails)
    return result

if __name__ == "__main__":
    accounts = [
        ["John", "johnsmith@mail.com", "john00@mail.com"],
        ["John", "johnnybravo@mail.com"],
        ["John", "johnsmith@mail.com", "john_newyork@mail.com"],
        ["Mary", "mary@mail.com"]
    ]

    merged_accounts = accounts_merge(accounts)
    for account in merged_accounts:
        print(account)

Java implementation

import java.util.*;

public class AccountsMerge {
    private Map<String, String> parent = new HashMap<>();
    private Map<String, String> emailToName = new HashMap<>();

    private String find(String x) {
        parent.putIfAbsent(x, x);
        if (!parent.get(x).equals(x)) {
            parent.put(x, find(parent.get(x)));
        }
        return parent.get(x);
    }

    private void union(String x, String y) {
        parent.put(find(x), find(y));
    }

    public List<List<String>> accountsMerge(List<List<String>> accounts) {
        for (List<String> account : accounts) {
            String name = account.get(0);
            for (int i = 1; i < account.size(); i++) {
                emailToName.put(account.get(i), name);
                if (i > 1) {
                    union(account.get(i), account.get(i-1));
                }
            }
        }

        Map<String, List<String>> unions = new HashMap<>();
        for (String email : emailToName.keySet()) {
            String root = find(email);
            unions.computeIfAbsent(root, k -> new ArrayList<>()).add(email);
        }

        List<List<String>> result = new ArrayList<>();
        for (List<String> emails : unions.values()) {
            Collections.sort(emails);
            List<String> account = new ArrayList<>();
            account.add(emailToName.get(emails.get(0)));
            account.addAll(emails);
            result.add(account);
        }
        return result;
    }

    public static void main(String[] args) {
        AccountsMerge am = new AccountsMerge();
        List<List<String>> accounts = Arrays.asList(
            Arrays.asList("John", "johnsmith@mail.com", "john00@mail.com"),
            Arrays.asList("John", "johnnybravo@mail.com"),
            Arrays.asList("John", "johnsmith@mail.com", "john_newyork@mail.com"),
            Arrays.asList("Mary", "mary@mail.com")
        );

        List<List<String>> merged = am.accountsMerge(accounts);
        for (List<String> account : merged) {
            System.out.println(account);
        }
    }
}

JavaScript implementation

function accountsMerge(accounts) {
  const parent = {};
  const emailToName = {};

  function find(x) {
    if (parent[x] !== x) {
      parent[x] = find(parent[x]);
    }
    return parent[x];
  }

  function union(x, y) {
    parent[find(x)] = find(y);
  }

  for (const account of accounts) {
    const [name, ...emails] = account;
    for (const email of emails) {
      if (!parent[email]) parent[email] = email;
      emailToName[email] = name;
      union(emails[0], email);
    }
  }

  const unions = {};
  for (const email of Object.keys(parent)) {
    const root = find(email);
    if (!unions[root]) unions[root] = [];
    unions[root].push(email);
  }

  const result = [];
  for (const emails of Object.values(unions)) {
    emails.sort();
    result.push([emailToName[emails[0]], ...emails]);
  }

  return result;
}

console.log(accountsMerge([
  ["John", "johnsmith@mail.com", "john00@mail.com"],
  ["John", "johnnybravo@mail.com"],
  ["John", "johnsmith@mail.com", "john_newyork@mail.com"],
  ["Mary", "mary@mail.com"]
]));

Go implementation

package main

import (
	"fmt"
	"sort"
)

var parent map[string]string
var emailToName map[string]string

func find(x string) string {
	if p, ok := parent[x]; !ok {
		parent[x] = x
	} else if p != x {
		parent[x] = find(p)
	}
	return parent[x]
}

func union(x, y string) {
	parent[find(x)] = find(y)
}

func accountsMerge(accounts [][]string) [][]string {
	parent = make(map[string]string)
	emailToName = make(map[string]string)

	for _, account := range accounts {
		name := account[0]
		emails := account[1:]
		for _, email := range emails {
			emailToName[email] = name
			if _, ok := parent[email]; !ok {
				parent[email] = email
			}
			union(emails[0], email)
		}
	}

	unions := make(map[string][]string)
	for email := range parent {
		root := find(email)
		unions[root] = append(unions[root], email)
	}

	var result [][]string
	for _, emails := range unions {
		sort.Strings(emails)
		account := []string{emailToName[emails[0]]}
		account = append(account, emails...)
		result = append(result, account)
	}

	return result
}

func main() {
	accounts := [][]string{
		{"John", "johnsmith@mail.com", "john00@mail.com"},
		{"John", "johnnybravo@mail.com"},
		{"John", "johnsmith@mail.com", "john_newyork@mail.com"},
		{"Mary", "mary@mail.com"},
	}

	merged := accountsMerge(accounts)
	for _, account := range merged {
		fmt.Println(account)
	}
}

Rust implementation

use std::collections::{HashMap, HashSet};

fn find(parent: &mut HashMap<String, String>, x: &str) -> String {
    if !parent.contains_key(x) {
        parent.insert(x.to_string(), x.to_string());
    }
    if parent[x] != x {
        let p = find(parent, &parent[x]);
        parent.insert(x.to_string(), p.clone());
        p
    } else {
        x.to_string()
    }
}

fn union(parent: &mut HashMap<String, String>, x: &str, y: &str) {
    let px = find(parent, x);
    let py = find(parent, y);
    parent.insert(px, py);
}

fn accounts_merge(accounts: Vec<Vec<String>>) -> Vec<Vec<String>> {
    let mut parent: HashMap<String, String> = HashMap::new();
    let mut email_to_name: HashMap<String, String> = HashMap::new();

    for account in &accounts {
        let name = &account[0];
        for email in account.iter().skip(1) {
            email_to_name.insert(email.clone(), name.clone());
        }
        for i in 2..account.len() {
            union(&mut parent, &account[i], &account[i - 1]);
        }
    }

    let mut unions: HashMap<String, Vec<String>> = HashMap::new();
    for email in email_to_name.keys() {
        let root = find(&mut parent, email);
        unions.entry(root).or_default().push(email.clone());
    }

    let mut result = Vec::new();
    for (_root, mut emails) in unions {
        emails.sort();
        let mut account = Vec::new();
        account.push(email_to_name[&emails[0]].clone());
        account.extend(emails);
        result.push(account);
    }
    result
}

fn main() {
    let accounts = vec![
        vec!["John".to_string(), "johnsmith@mail.com".to_string(), "john00@mail.com".to_string()],
        vec!["John".to_string(), "johnnybravo@mail.com".to_string()],
        vec!["John".to_string(), "johnsmith@mail.com".to_string(), "john_newyork@mail.com".to_string()],
        vec!["Mary".to_string(), "mary@mail.com".to_string()],
    ];

    let merged = accounts_merge(accounts);

    for account in merged {
        println!("{:?}", account);
    }
}

Kotlin implementation

fun main() {
    val accounts = listOf(
        listOf("John", "johnsmith@mail.com", "john00@mail.com"),
        listOf("John", "johnnybravo@mail.com"),
        listOf("John", "johnsmith@mail.com", "john_newyork@mail.com"),
        listOf("Mary", "mary@mail.com")
    )

    val parent = mutableMapOf<String, String>()
    val emailToName = mutableMapOf<String, String>()

    fun find(x: String): String {
        parent.putIfAbsent(x, x)
        if (parent[x] != x) {
            parent[x] = find(parent[x]!!)
        }
        return parent[x]!!
    }

    fun union(x: String, y: String) {
        parent[find(x)] = find(y)
    }

    for (account in accounts) {
        val name = account[0]
        for (email in account.drop(1)) {
            emailToName[email] = name
            if (email != account[1]) {
                union(email, account[1])
            }
        }
    }

    val unions = mutableMapOf<String, MutableList<String>>()
    for (email in emailToName.keys) {
        val root = find(email)
        unions.computeIfAbsent(root) { mutableListOf() }.add(email)
    }

    val result = mutableListOf<List<String>>()
    for (emails in unions.values) {
        emails.sort()
        val account = listOf(emailToName[emails[0]]!!) + emails
        result.add(account)
    }

    for (account in result) {
        println(account)
    }
}

Swift implementation

import Foundation

func accountsMerge(_ accounts: [[String]]) -> [[String]] {
    var parent = [String: String]()
    var emailToName = [String: String]()

    func find(_ x: String) -> String {
        if parent[x] == nil {
            parent[x] = x
        }
        if parent[x] != x {
            parent[x] = find(parent[x]!)
        }
        return parent[x]!
    }

    func union(_ x: String, _ y: String) {
        parent[find(x)] = find(y)
    }

    for account in accounts {
        let name = account[0]
        let emails = Array(account.dropFirst())
        for email in emails {
            emailToName[email] = name
            if email != emails[0] {
                union(email, emails[0])
            }
        }
    }

    var unions = [String: [String]]()
    for email in emailToName.keys {
        let root = find(email)
        unions[root, default: []].append(email)
    }

    var result = [[String]]()
    for (_, emails) in unions {
        let sortedEmails = emails.sorted()
        if let name = emailToName[sortedEmails[0]] {
            result.append([name] + sortedEmails)
        }
    }

    return result
}

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

let merged = accountsMerge(accounts)
for account in merged {
    print(account)
}

TypeScript implementation

function accountsMerge(accounts: string[][]): string[][] {
  const parent: Record<string, string> = {};
  const emailToName: Record<string, string> = {};

  function find(x: string): string {
    if (parent[x] !== x) {
      parent[x] = find(parent[x]);
    }
    return parent[x];
  }

  function union(x: string, y: string): void {
    parent[find(x)] = find(y);
  }

  for (const account of accounts) {
    const [name, ...emails] = account;
    for (const email of emails) {
      if (!parent[email]) parent[email] = email;
      emailToName[email] = name;
      union(emails[0], email);
    }
  }

  const unions: Record<string, string[]> = {};
  for (const email of Object.keys(parent)) {
    const root = find(email);
    if (!unions[root]) unions[root] = [];
    unions[root].push(email);
  }

  const result: string[][] = [];
  for (const emails of Object.values(unions)) {
    emails.sort();
    result.push([emailToName[emails[0]], ...emails]);
  }

  return result;
}

console.log(accountsMerge([
  ["John", "johnsmith@mail.com", "john00@mail.com"],
  ["John", "johnnybravo@mail.com"],
  ["John", "johnsmith@mail.com", "john_newyork@mail.com"],
  ["Mary", "mary@mail.com"]
]));