Dada una lista de cuentas, cada elemento cuentas [i] es una lista de cadenas, donde el primer elemento cuentas [i] [0] es el nombre (nombre), y los elementos restantes son correos electrónicos que representan la dirección de correo electrónico de la cuenta.
Ahora, queremos fusionar estas cuentas. Si dos cuentas tienen algunas direcciones de correo electrónico en común, las dos cuentas deben pertenecer a la misma persona. Tenga en cuenta que incluso si dos cuentas tienen el mismo nombre, pueden pertenecer a diferentes personas porque las personas pueden tener el mismo nombre. Una persona puede tener inicialmente cualquier número de cuentas, pero todas sus cuentas tienen el mismo nombre.
Después de fusionar las cuentas, las cuentas se devuelven en el siguiente formato: el primer elemento de cada cuenta es el nombre y los elementos restantes son las direcciones de correo electrónico en orden. La cuenta en sí se puede devolver en cualquier orden.
Ejemplo 1:
Ingresa:
cuentas = [["John", "[email protected]", "[email protected]"], ["John", "[email protected]"], ["John", "johnsmith @ mail .com "," [email protected] "], [" Mary "," [email protected] "]]
salida:
[[" John ", '[email protected]', '[email protected]' , 'johnsmith @ mail.com'], ["John", "[email protected]"], ["Mary", "[email protected]"]]
Explicación: El
primer y tercer John son las mismas personas, porque tienen una dirección de correo electrónico común "[email protected]".
El segundo John y Mary son personas diferentes porque sus direcciones de correo electrónico no son utilizadas por otras cuentas.
Estas listas se pueden devolver en cualquier orden, como las respuestas [['Mary', '[email protected]'], ['John', '[email protected]'],
['John', 'john00 @ mail .com ',' john_newyork @ mail.com ',' [email protected] ']] también son correctas.
rápido:
La longitud de las cuentas estará en el rango de [1, 1000].
La longitud de las cuentas [i] estará en el rango de [1, 10].
La longitud de las cuentas [i] [j] estará en el rango de [1, 30].
Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/accounts-merge
Copyright es propiedad de LeetCode . Para reimpresiones comerciales, comuníquese con la autorización oficial. Para reimpresiones no comerciales, indique la fuente.
class Solution {
public List<List<String>> accountsMerge(List<List<String>> accounts) {
Map<String, Integer> emailToIndex = new HashMap<String, Integer>();
Map<String, String> emailToName = new HashMap<String, String>();
int emailsCount = 0;
//初步的数据处理，通过将email当为key
for (List<String> account : accounts) {
String name = account.get(0);
int size = account.size();
for (int i = 1; i < size; i++) {
String email = account.get(i);
if (!emailToIndex.containsKey(email)) {
emailToIndex.put(email, emailsCount++);
emailToName.put(email, name);
}
}
}
UnionFind uf = new UnionFind(emailsCount);
for (List<String> account : accounts) {
String firstEmail = account.get(1);
int firstIndex = emailToIndex.get(firstEmail);
int size = account.size();
for (int i = 2; i < size; i++) {
String nextEmail = account.get(i);
int nextIndex = emailToIndex.get(nextEmail);
//这两个账户一定是一个人的，所以将他们合并
uf.union(firstIndex, nextIndex);
}
}
//这一步就是把分散开来的email，回归到他们的主人下面
Map<Integer, List<String>> indexToEmails = new HashMap<Integer, List<String>>();
for (String email : emailToIndex.keySet()) {
int index = uf.find(emailToIndex.get(email));
List<String> account = indexToEmails.getOrDefault(index, new ArrayList<String>());
account.add(email);
indexToEmails.put(index, account);
}
//处理数据，让他们变成题目要求的样子
List<List<String>> merged = new ArrayList<List<String>>();
for (List<String> emails : indexToEmails.values()) {
Collections.sort(emails);
String name = emailToName.get(emails.get(0));
List<String> account = new ArrayList<String>();
account.add(name);
account.addAll(emails);
merged.add(account);
}
return merged;
}
}
class UnionFind {
int[] parent;
public UnionFind(int n) {
parent = new int[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
public void union(int index1,int index2){
parent[find(index1)] = find(index2);
}
public int find(int index){
if(parent[index]!=index){
parent[index] = find(parent[index]);
}
return parent[index];
}
}