letecode 编程学习（33）

题目

给定一个列表 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']] 也是正确的。

解题思路

• 利用并查集集合的思想来合并字符串列表
• 为了优化字符列表的合并列表，就采用<字符串， index>表的方式进行缓存。

 

代码

class Solution {
public:
    vector<int> fa;
    vector<int> rank;

    void init(int n)
    {
        fa.clear();
        rank.clear();
        fa.resize(n);
        rank.resize(n);
        for(int i = 0; i < n; i++)
        {
            fa[i] = i;
            rank[i] = 1;
        }
    }

    int find(int x)
    {
        return x==fa[x]?x:(fa[x]=find(fa[x]));
    }

    void merge(int i, int j)
    {
        int x = find(i);
        int y = find(j);

        if (rank[x] <= rank[y])
        {
            fa[x] =y;
        }
        else
        {
            fa[y] =x;
        }

        if (rank[x] == rank[y] && x !=y)
        {
            rank[y]++;
        }
    }

    vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
        if (accounts.size() < 2)
        {
            return accounts;
        }

        init(accounts.size());
        unordered_map<string, int> _mp;
        for (int i =0; i < accounts.size(); i++)
        {
            int m = accounts[i].size();

            for (int j = 1; j < m; j++)
            {
                if (_mp.count(accounts[i][j])>0)
                {
                    merge(_mp[accounts[i][j]], i);
                }
                else
                {
                    _mp[accounts[i][j]]= i;
                }
            }
        }

        unordered_map<int, vector<string>> res_mp;
        vector<vector<string>> res;
        for (auto & [k, v] : _mp)
        {
  
            res_mp[find(v)].push_back(k);
        }

        for (auto & [k, v]: res_mp)
        {
            sort(v.begin(), v.end());
            vector<string> tmp(1, accounts[k][0]);
            tmp.insert(tmp.end(), v.begin(), v.end());
            res.push_back(tmp);
        }
        return res;
    }
};

 

新的心得：

C++ 新特性可以采用

• for(auto & [k, v] : _mp)进行遍历
• 需要总结并查集的思想以及相应的优化
• 在并查集中fa[x]和find（x）是不一样的，fa[x]只是子集合的根节点， find(x)返回最终的根节点。