Accounts Merge

721. Accounts Merge

Given a list accounts, each element accounts[i] is a list of strings, where the first element accounts[i][0] is a name, and the rest of the elements are emails representing emails of the account.

Now, we would like to merge these accounts. Two accounts definitely belong to the same person if there is some email that is common to both accounts. Note that even if two accounts have the same name, they may belong to different people as people could have the same name. A person can have any number of accounts initially, but all of their accounts definitely have the same name.

After merging the accounts, return the accounts in the following format: the first element of each account is the name, and the rest of the elements are emails in sorted order. The accounts themselves can be returned in any order.

Example 1:

Input: 
accounts = [["John", "johnsmith@mail.com", "john00@mail.com"], ["John", "johnnybravo@mail.com"], ["John", "johnsmith@mail.com", "john_newyork@mail.com"], ["Mary", "mary@mail.com"]]
Output: [["John", 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com'],  ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"]]
Explanation: 
The first and third John's are the same person as they have the common email "johnsmith@mail.com".
The second John and Mary are different people as none of their email addresses are used by other accounts.
We could return these lists in any order, for example the answer [['Mary', 'mary@mail.com'], ['John', 'johnnybravo@mail.com'], 
['John', 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com']] would still be accepted.

Note:

• The length of accounts will be in the range [1, 1000].
• The length of accounts[i] will be in the range [1, 10].
• The length of accounts[i][j] will be in the range [1, 30].

1.解析

题目大意，将邮箱名相同的用户进行合并。

2.分析

这道题抽象出来就是求解有多少个不同的用户。是否是同一个用户可以通过注册的邮箱进行识别，若当前两个不同用户拥有相同的邮箱地址，就可以认为是同一个用户，基于以上分析，本题就是查找一共有多少种不同的种类，一般涉及到种类或者是连通性的问题，使用并查集union_find无非是最合适的，不过这里的每个元素要换成string类型，但本质是一样的，首先将每个用户邮箱和所对应的用户名保存起来，然后利用并查集查询两个不同邮箱是否存在共同的根节点，如果存在，意味着这是同一个用户，注意一点是：加上路径压缩之后，并不能保证同一类中的元素的根节点都是最上层的根节点。所以，当我们建立好并查集之后，还得根据最上层的根节点来进行分类。思路参考@Grandyang

class Solution {
public:
	vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
		unordered_map<string, string> root, owner;
		unordered_map< string, set<string> > m;
		for (auto account : accounts) {
			for (int i = 1; i < account.size(); ++i) {
				owner[account[i]] = account[0]; //建立邮箱和用户名的映射
				root[account[i]] = account[i];  //初始化并查集
			}
		}
		for (auto account : accounts) {
			string root1 = unoin_find(root, account[1]);
			for (int i = 2; i < account.size(); ++i) {
				string root2 = unoin_find(root, account[i]);
				if (root1 != root2) //不在同一颗树
					root[root2] = root1;
			}
		}
		for (auto account : accounts) 
			for (int i = 1; i < account.size(); ++i)                   
				m[unoin_find(root, account[i])].insert(account[i]); //根据最上层的根节点，进行分类
		
		vector<vector<string>> res;
		for (auto cur : m) { //输出题目要求的格式
			vector<string> v(cur.second.begin(), cur.second.end());
			v.insert(v.begin(), owner[cur.first]);
			res.push_back(v);
		}

		return res;
	}
        //并查集
	string unoin_find(unordered_map<string, string>& root, string node) { 
		string son = node;
		while (root[node] != node) node = root[node];
		while (son != node) { //路径压缩
			string t = son; //中间变量
			root[son] = node;
			son = root[t];
		}
		return node;
	}
};

[1]https://www.cnblogs.com/grandyang/p/7829169.html