哈希表实现的并查集：Leetcode 721. 账户合并

描述

给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该账户的邮箱地址。

现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。

合并账户后，按以下格式返回账户：每个账户的第一个元素是名称，其余元素是 按字符 ASCII 顺序排列 的邮箱地址。账户本身可以以 任意顺序 返回。

示例 1：
输入：accounts = [[“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”]]
解释：
第一个和第三个 John 是同一个人，因为他们有共同的邮箱地址 “johnsmith@mail.com”。
第二个 John 和 Mary 是不同的人，因为他们的邮箱地址没有被其他帐户使用。
可以以任何顺序返回这些列表，例如答案 [[‘Mary’，‘mary@mail.com’]，[‘John’，‘johnnybravo@mail.com’]，
[‘John’，‘john00@mail.com’，‘john_newyork@mail.com’，‘johnsmith@mail.com’]] 也是正确的。

示例 2：
输入：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”]]
输出：[[“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”],[“Kevin”,“Kevin0@m.co”,“Kevin3@m.co”,“Kevin5@m.co”],[“Fern”,“Fern0@m.co”,“Fern1@m.co”,“Fern5@m.co”]]

理解

一开始自己写了个笨方法，后来看了官解原来还可以用并查集写
官解的并查集中的每个结点是输入的每个account条目，这是个很好的思路
本人实现的并查集，每个结点直接是一个email，每个email对应根email。由于名字不同肯定属于不同账户，每个名字维护对应的并查集，由于结点是email，因此并查集用散列表实现

代码

class UnionMap:
    def __init__(self):
        self.union_map = {}
    
    def __contains__(self,other):
        return other in self.union_map
    
    def merge(self,i,j):
        if(i not in self.union_map):
            self.union_map[i] = i
        if(j not in self.union_map):
            self.union_map[j] = j
        ri = self.root(i)
        rj = self.root(j)
        self.union_map[ri] = rj
    
    def root(self,i):
        if(i == self.union_map[i]): return i
        self.union_map[i] = self.root(self.union_map[i])
        return self.union_map[i]   

class Solution:
    def accountsMerge(self, accounts: List[List[str]]) -> List[List[str]]:
        name_union_map = {}
        for account in accounts:
            name = account[0]
            if(name not in name_union_map): name_union_map[name] = UnionMap()
            union_map = name_union_map[name]

            pre_root = account[1]
            for i in range(1,len(account)):
                email = account[i]
                union_map.merge(email,pre_root)
        
        ret = []
        for name,union_map in name_union_map.items():
            root_email_map = {}
            for email in union_map.union_map.keys():
                r = union_map.root(email)
                if(r not in root_email_map): root_email_map[r] = set()
                root_email_map[r].add(email)
            for email_set in root_email_map.values():
                ret.append([name] + sorted(email_set))
        return ret

再附上自己原来写的笨方法

class Solution:
    def accountsMerge(self, accounts: List[List[str]]) -> List[List[str]]:
        accounts_map = {}
        for account in accounts:
            emails = set(account[1:])
            if(account[0] not in accounts_map):
                accounts_map[account[0]] = []
            
            found_i = []
            for i,temp_emails in enumerate(accounts_map[account[0]]):
                if emails & temp_emails:
                    emails.update(temp_emails)
                    found_i.append(i)  
            while(found_i):
                accounts_map[account[0]].pop(found_i.pop())
            accounts_map[account[0]].append(emails)
                    
        ret = []
        for name,all_emails in accounts_map.items():
            for emails in all_emails:
                ret.append([name] + sorted(list(emails)))
        return ret