题目

721. 账户合并

难度中等332

给定一个列表 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. 邮箱相同，账户所属的人一定相同
2. 同一个人，名下所有账户名称一定相同

具体思路步骤如下：

1. 先建立申明一个并查集实例，用来维护账户之间的连通关系。
2. 建立{邮箱：账户下标}的哈希表emailToIndex，遍历所有账户，把邮箱和所属原始账户下标记录下来
3. 建立{邮箱：账户名称}的哈希表emailToName，把邮箱和所属原始账户名称记录下来，用于后序组装账户
4. 遍历所有账户，判断邮箱是否在哈希表emailToIndex,在，则将当前邮箱所属账户和哈希表中该邮箱所属账户在并查集中合并；不在，则将该邮箱加入emailToIndex哈希表
5. 建立一个{连通分量父元素下标：个人账户}的哈希表indexToAccount，用于维护每一个连通分量对应的个人账户，并且会将所有属于该连通分量的原始账户内的邮箱去重后加入该新的个人账户
6. 遍历处理好的indexToAccount，通过emailToName哈希表找到每个账户的名称，并拼接
7. 最终返回结果数组。

代码如下

/**
 * @param {string[][]} accounts
 * @return {string[][]}
 */
var accountsMerge = function(accounts) {
    let len = accounts.length;
    let uf = new unionFind(len); // 新建一个并查集
    let emailToIndex = new Map(); // 用于记录每个邮箱对应的原始账号下标
    let emailToName = new Map(); // 用于记录每个邮件对应的账户名称
    for (let i = 0; i < len; i++) {
        let size = accounts[i].length;
        let name = accounts[i][0];
        for (let j = 1; j < size; j++) {
            let email = accounts[i][j];
            if (!emailToIndex.has(email)) {
                // 判断邮箱哈希表中没有当前邮箱，则加入哈希表，{邮箱名：账户index}
                emailToIndex.set(email,i);
                // 同时加入名称哈希表，{邮箱名：账户名}
                emailToName.set(email,name);
            } else {
                // 如果改邮箱已经遍历过，那么当前账户和邮箱之前所在账户合并
                uf.union(i, emailToIndex.get(email));
            }
        }
    }

    // 维护账户下标对应邮箱账户 {index:aoccount:<Array>}
    let indexToAccount = new Map();
    // 由于遍历的是哈希表中的所有邮箱，天然有去重处理效果
    for (let email of emailToIndex.keys()) {
        // 遍历邮箱对应账户下标，找到当前下标对应连通分量的父元素下标
        let index = uf.find(emailToIndex.get(email));
        // 判断该账户下标是否有重新注册账户，有的话直接取，没有赋值[]
        let account = indexToAccount.get(index) ? indexToAccount.get(index) : [];
        // 将当前邮箱推入账户
        account.push(email);
        // 更新哈希表
        indexToAccount.set(index, account);
    }
    let result = [];
     // 遍历处理好的所有账户
    for (let account of indexToAccount.values()) {
        // 将账户内邮箱排序
        account.sort();
        // 由于他们属于同一人的账户，那么账户名称都相同，我们取出第一个邮箱对应的账户名
        let name = emailToName.get(account[0]);
        // 重新处理账户
        account = [name,...account];
        result.push(account);
    }
    return result;
};


class unionFind{
    constructor(size){
        this.parent = Array(size).fill(0).map((el,i)=>i)
        this.rank = Array(size).fill(0);
        this.count = size;
    }
    size(){
        return this.count;
    }
    find(x){
        if(this.parent[x] != x){
            this.parent[x] = this.find(this.parent[x]);
        }
        return this.parent[x];
    }
    union(p,q){
        let rootP = this.find(p);
        let rootQ = this.find(q);
        if(this.rank[rootP]>this.rank[rootQ]){
            this.parent[rootQ] = rootP;
        }else{
            this.parent[rootP] = rootQ;
            if(this.parent[rootP] == this.parent[rootQ]){
                this.rank[rootQ]++;
            }
        }
        this.count--;
    }
}

复杂度分析

以下复杂度分析，摘抄自leetcode该题的官方题解

时间复杂度：O(nlogn)，其中 n 是不同邮箱地址的数量。 需要遍历所有邮箱地址，在并查集内进行查找和合并操作，对于两个不同的邮箱地址，如果它们的祖先不同则需要进行合并，需要进行 2 次查找和最多 1 次合并。一共需要进行 2n 次查找和最多 n 次合并，因此时间复杂度是O(2nlogn)=O(nlogn)。这里的并查集使用了路径压缩，但是没有使用按秩合并，最坏情况下的时间复杂度是O(nlogn)，平均情况下的时间复杂度依然是O(nα(n))，其中α为阿克曼函数的反函数α(n) 可以认为是一个很小的常数。 整理出题目要求的返回账户的格式时需要对邮箱地址排序，时间复杂度是O(nlogn)。 其余操作包括遍历所有邮箱地址，在哈希表中记录相应的信息，时间复杂度是O(n)，在渐进意义下 O(n) 小于O(nlogn)。 因此总时间复杂度是O(nlogn)。

空间复杂度：O(n)，其中 n 是不同邮箱地址的数量。空间复杂度主要取决于哈希表和并查集，每个哈希表存储的邮箱地址的数量为 n，并查集的大小为 n。