链接

一、题目描述

给定一个列表 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"]]

提示：

• 1 <= accounts.length <= 1000

• 2 <= accounts[i].length <= 10

• 1 <= accounts[i][j].length <= 30

• accounts[i][0] 由英文字母组成

• accounts[i][j] (for j > 0) 是有效的邮箱地址

二、实现

并查集+哈希表

type UnionFind struct {
	parent map[string]string
}

func (uf *UnionFind) Find(mail string) string {
	rootMail, exist := uf.parent[mail]
	if !exist {
		uf.parent[mail] = mail
		return mail
	}
	// 状态压缩
	if rootMail != mail {
		uf.parent[mail] = uf.Find(rootMail)
	}
	return uf.parent[mail]
}

func (uf *UnionFind) Union(x, y string) {
	rootx := uf.Find(x)
	rooty := uf.Find(y)
	// ascii
	if rootx == rooty {
		return
	}
	if rootx < rooty {
		uf.parent[rooty] = rootx
	} else {
		uf.parent[rooty] = rootx
	}
}

func accountsMerge(accounts [][]string) [][]string {
	// 1. 并查集，以邮箱为维度，合并同一个人的邮箱
	uf := &UnionFind{parent: map[string]string{}}
	for _, account := range accounts {
		for _, mail := range account[1:] {
			uf.Union(account[1], mail)
		}
	}
	// 2. 按照并查集结果, 去重分组
	groups := map[string]map[string]struct{}{}
	// rootmail -> name映射
	mapping := map[string]string{}
	for _, account := range accounts {
		name := account[0]
		rootmail := uf.Find(account[1])
		mapping[rootmail] = name
		if _, exist := groups[rootmail]; !exist {
			groups[rootmail] = map[string]struct{}{}
		}
		for _, mail := range account[1:] {
			groups[rootmail][mail] = struct{}{}
		}
	}
	// 3. 返回分组结果
	ans := make([][]string, 0, len(groups))
	for rootmail, mails := range groups {
		name := mapping[rootmail]
		accont := make([]string, 0, 1+len(mails))
		accont = append(accont, name)
		for mail := range mails {
			accont = append(accont, mail)
		}
		// 地址按照ascii编码排序
		sort.Slice(accont[1:], func(i, j int) bool {
			return accont[1:][i] < accont[1:][j]
		})
		ans = append(ans, accont)
	}
	return ans
}