#721 Leetcode Accounts Merge Solution in C, C++, Java, JavaScript, Python, C# Leetcode

#1 Code Example with Java Programming

Code - Java Programming

class Solution {
  public List();
    for (List account : accounts) {
      String firstEmail = account.get(1);
      for (int i = 2; i  <  account.size(); i++) {
        adjacencyList.computeIfAbsent(firstEmail, k -> new ArrayList<>()).add(account.get(i));
        adjacencyList.computeIfAbsent(account.get(i), k -> new ArrayList < >()).add(firstEmail);
      }
    }
    Set visited = new HashSet<>();
    List < List();
    for (List account : accounts) {
      String name = account.get(0);
      String firstEmail = account.get(1);
      if (!visited.contains(firstEmail)) {
        Stack < String> stack = new Stack<>();
        stack.push(firstEmail);
        List < String> mergedAccount = new ArrayList<>();
        mergedAccount.add(name);
        while (!stack.isEmpty()) {
          String removedEmail = stack.pop();
          visited.add(removedEmail);
          mergedAccount.add(removedEmail);
          for (String neighbor : adjacencyList.getOrDefault(removedEmail, new ArrayList < >())) {
            if (!visited.contains(neighbor)) {
              visited.add(neighbor);
              stack.push(neighbor);
            }
          }
        }
        Collections.sort(mergedAccount.subList(1, mergedAccount.size()));
        mergedAccounts.add(mergedAccount);
      }
    }
    return mergedAccounts;
  }
}

Input

Output

#2 Code Example with Javascript Programming

Code - Javascript Programming

const accountsMerge = function (accounts) {
  const roots = new Set()
  const owner = {}
  const parent = {}
  const children = {}

  for (let account of accounts) {
    let [user, root, ...emails] = account
    let r1 = find(root)
    owner[root] = user
    children[r1] = children[r1] || [root]
    roots.add(r1)

    for (let email of emails) {
      let r2 = find(email)
      if (r2 !== r1) {
        parent[r2] = r1
        children[r1].push(...(children[r2] ? children[r2] : [email]))
        roots.delete(r2)
        delete children[r2]
      }
    }
  }

  return [...roots].map((r) => [owner[r], ...children[r].sort()])

  function find(a) {
    parent[a] = parent[a] || a
    return a === parent[a] ? a : find(parent[a])
  }
}

Input

Output

#3 Code Example with Python Programming

Code - Python Programming

class Solution:
    def accountsMerge(self, accounts):
        def explore(mail, q):
            q += mail,
            visited.add(mail)
            for v in edges[mail]:
                if v not in visited: explore(v, q)
            return q
        edges, owner, visited, res = collections.defaultdict(list), {}, set(), []
        for acc in accounts:
            owner[acc[1]] = acc[0]
            for i in range(1, len(acc) - 1): 
                if acc[i] != acc[i + 1]:
                    edges[acc[i]] += acc[i + 1],
                    edges[acc[i + 1]] += acc[i],
        for acc in accounts:
            if acc[1] not in visited: res += [acc[0]] + sorted(explore(acc[1], [])),
        return res

Input

#4 Code Example with C# Programming

Code - C# Programming

using System;
using System.Collections.Generic;
using System.Linq;

namespace LeetCode
{
    public class _0721_AccountsMerge
    {
        public IList < IList();
            var emailToId = new Dictionary();

            var id = 0;
            foreach (var account in accounts)
            {
                var name = string.Empty;
                foreach (var str in account)
                {
                    if (name == string.Empty)
                    {
                        name = str;
                        continue;
                    }

                    emailToName[str] = name;
                    if (!emailToId.ContainsKey(str))
                        emailToId[str] = id++;
                    uf.Union(emailToId[account[1]], emailToId[str]);
                }
            }

            var map = new Dictionary < int, IList();
                map[index].Add(email);
            }

            return map.Values.Select(list =>
            {
                IList < string> temp = list.OrderBy(e => e, StringComparer.Ordinal).ToList();
                temp.Insert(0, emailToName[list[0]]);
                return temp;
            }).ToList();
        }

        public class UnionFind
        {
            private int[] parents;

            public UnionFind()
            {
                parents = new int[10001];
                for (int i = 0; i  <  10001; i++)
                    parents[i] = i;
            }

            public int Find(int index)
            {
                if (parents[index] != index)
                    parents[index] = Find(parents[index]);
                return parents[index];
            }

            public void Union(int index1, int index2)
            {
                parents[Find(index1)] = Find(index2);
            }
        }
    }
}

Input

Output