力扣刷题之721.账户合并

最新推荐文章于 2024-08-06 11:09:15 发布
最新推荐文章于 2024-08-06 11:09:15 发布
阅读量691 收藏 25
点赞数 33
文章标签： leetcode 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75213259/article/details/140473852
版权

题干描述：

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

题干分析：

题干描述：

     给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是名称（name），其余元素是邮箱地址（emails），表示该账户的邮箱地址。

      目标是合并这些账户，如果两个账户有共同的邮箱地址，则认为这两个账户属于同一个人。即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。

合并后的账户要求如下：

  • 每个账户的第一个元素是名称。
  • 其余元素是按字符 ASCII 顺序排列的邮箱地址。
  • 账户本身可以以任意顺序返回。

题目理解：

        题目要求将多个账号合并，如果两个账户有共同的账号合并，如果两个账户有共同的邮箱地址则视为同一账户。解决这个问题的思路主要有以下几个步骤：

1.数据结构选择：

  1. 使用并查集来管理邮箱的合并操作。
  2. 使用哈希表来建立邮箱到ID以及邮箱到用户名的映射。

 2.初始化并查集和哈希表

  1. 初始化并查集，用于处理邮箱之间的合并操作。
  2. 初始化哈希表，用于邮箱到ID的映射以及邮箱到用户名的映射。

3.处理输入数据：

  1. 遍历输入的账户列表，对每个账户的每个邮箱进行处理。
  2. 为每个邮箱分配一个唯一的ID，并将该邮箱与其所属账户的第一个邮箱进行合并操作。 

4.建立邮箱与其根节点的映射：

  1. 再次遍历所有邮箱，通过并查集找到每个邮箱的根节点，将同一个根节点的邮箱合并在一起。

5.构建最终结果

  1. 根据每个根节点对应的邮箱列表，构建最终的结果列表，并进行排序。 

6.释放内存

  1. 释放并查集和哈希表占用的内存。 

 解题思路：

1.定义并查集结构：

        UnionFind结构体包含两个数组：parent和rank，分别用于存储每个节点的父节点和排名。

//定义并查集结构
typedef struct {
	int* parent;//定义父节点数组
	int* rank;//定义排名数组用于优化合并操作

}UnionFind;

 2.初始化并查集：

        createUnionFind函数初始化并查集，设置每个节点的父节点为其自身，排名为0。

//初始化并查集
UnionFind* createUnionFind(int size) {
	UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
	uf->parent = (int*)malloc(size * sizeof(int));
	uf->rank = (int*)malloc(size * sizeof(int));
	//将每个节点的父节点初始化为其自身，将每个节点的排名初始化为0
	for (int i = 0; i < size; i++)
	{
		uf->parent[i] = i;
		uf->rank[i] = 0;
	}
	return uf;
}

3.查找根节点：

      find函数通过路径压缩优化查找根节点。

//定义一个函数用于查找根节点，带路径压缩优化
int find(UnionFind* uf, int x) {
	if (uf->parent[x] != x)
	{
		uf->parent[x] = find(uf, uf->parent[x]);//路径压缩
	}
}

4.合并两个集合：

       unionSets函数通过按秩合并优化合并两个集合。

//定义一个函数用于合并两个集合，并按秩合并优化
void unionSets(UnionFind* uf, int x, int y) {
	int rootX = find(uf, x);
	int rootY = find(uf, y);
	if (rootX != rootY) {
		if (uf->rank[rootX] > uf->rank[rootY])
		{
			uf->parent[rootY] = rootX;
		}
		else if (uf->rank[rootX] < uf->rank[rootY]) {
			uf->parent[rootX] = rootY;
		}
		else
		{
			uf->parent[rootY] = rootX;
			uf->parent[rootX]++;
		}
	}
}

5.哈希表节点和结构定义：

    HashNode 和 HashMap 用于定义哈希表节点和哈希表结构。

//定义一个函数将并查集释放掉
void freeUnionFind(UnionFind* uf) {
	free(uf->parent);
	free(uf->rank);
	free(uf);
}
//定义一个哈希表节点结构
typedef struct HashNode {
	char* key;//哈希表的键
	int value;//定义哈希表的值
	struct HashNode* next;//定义链表中的下一个指针
};
//定义哈希表的结构
typedef struct {
	int size;//定义哈希表的大小
	HashNode** table;//定义指向哈希表数组的指针
}HashMap;

6.创建哈希表：

   createHashMap 函数创建并初始化哈希表。

// 创建哈希表
HashMap* createHashMap(int size) {
    HashMap* map = (HashMap*)malloc(sizeof(HashMap));
    map->size = size;
    map->table = (HashNode**)malloc(size * sizeof(HashNode*)); // 确保分配的类型正确
    for (int i = 0; i < size; i++) {
        map->table[i] = NULL; // 初始化哈希表数组为空
    }
    return map;
}

7.哈希函数：

   hashFunction 函数计算字符串的哈希值。

//定一个哈希表函数
int hashFunction(HashMap* map, char* key) {
	int hash = 0;
	while (*key)
	{
		hash = (hash * 31 + *key) % map->size;//计算哈希值
		key++;

	}
	return hash;
}

8.插入哈希表：

   hashMapInsert 函数将键值对插入哈希表。

//插入哈希表
void hashMapInsert(HashMap* map, char* key, int value) {
    int hash = hashFunction(map, key);
    HashNode* node = map->table[hash];
    while (node) {
        if (strcmp(node->key, key) == 0) { // 如果键已经存在，更新值
            node->value = value;
            return;
        }
        node = node->next;
    }
    // 创建新节点
    node = (HashNode*)malloc(sizeof(HashNode));
    node->key = strdup(key);
    node->value = value;
    node->next = map->table[hash];
    map->table[hash] = node;
}

9.查找哈希表：

    hashMapFind 函数在哈希表中查找键对应的值。

// 查找哈希表
int hashMapFind(HashMap* map, char* key) {
    int hash = hashFunction(map, key);
    HashNode* node = map->table[hash];
    while (node) {
        if (strcmp(node->key, key) == 0) { // 找到键，返回值
            return node->value;
        }
        node = node->next;
    }
    return -1; // 键不存在，返回-1
}

10.释放哈希表：

    freeHashMap 函数释放哈希表占用的内存。

// 释放哈希表
void freeHashMap(HashMap* map) {
    for (int i = 0; i < map->size; i++) {
        HashNode* node = map->table[i];
        while (node) {
            HashNode* temp = node;
            node = node->next;
            free(temp->key);
            free(temp);
        }
    }
    free(map->table);
    free(map);
}

11.合并账户：

    accountsMerge 函数合并账户列表，使用并查集和哈希表进行邮箱的合并和映射。

12.辅助函数：

    createAccounts 函数用于创建和初始化账户数据。

// 合并账户
char*** accountsMerge(char*** accounts, int accountsSize, int* accountsColSize, int* returnSize, int** returnColumnSizes) {
    UnionFind* uf = createUnionFind(accountsSize * 10); // 假设每个账户最多有10个邮箱
    HashMap* emailToID = createHashMap(accountsSize * 10); // 邮箱到ID的映射
    HashMap* emailToName = createHashMap(accountsSize * 10); // 邮箱到用户名的映射

    int id = 0;
    for (int i = 0; i < accountsSize; i++) {
        char* name = accounts[i][0]; // 获取账户名称
        for (int j = 1; j < accountsColSize[i]; j++) {
            char* email = accounts[i][j]; // 获取邮箱
            if (hashMapFind(emailToID, email) == -1) { // 如果邮箱未映射，添加映射
                hashMapInsert(emailToID, email, id++);
                hashMapInsert(emailToName, email, (int)name);
            }
            int emailID = hashMapFind(emailToID, email);
            unionSets(uf, hashMapFind(emailToID, accounts[i][1]), emailID); // 合并集合
        }
    }

    HashMap* components = createHashMap(id); // 创建组件哈希表
    for (int i = 0; i < accountsSize; i++) {
        for (int j = 1; j < accountsColSize[i]; j++) {
            char* email = accounts[i][j];
            int rootID = find(uf, hashMapFind(emailToID, email)); // 查找根节点ID
            if (hashMapFind(components, (char*)rootID) == -1) {
                hashMapInsert(components, (char*)rootID, rootID); // 插入组件
            }
        }
    }

    *returnSize = id;
    *returnColumnSizes = (int*)malloc(id * sizeof(int)); // 初始化返回列大小数组
    char*** result = (char***)malloc(id * sizeof(char**)); // 初始化结果数组
    int* tempSizes = (int*)calloc(id, sizeof(int)); // 初始化临时大小数组
    for (int i = 0; i < id; i++) {
        result[i] = (char**)malloc(20 * sizeof(char*)); // 假设最多有20个邮箱
    }

    for (int i = 0; i < accountsSize; i++) {
        for (int j = 1; j < accountsColSize[i]; j++) {
            char* email = accounts[i][j];
            int rootID = find(uf, hashMapFind(emailToID, email)); // 查找根节点ID
            result[rootID][tempSizes[rootID]++] = email; // 添加邮箱到结果中
        }
    }

    for (int i = 0; i < id; i++) {
        qsort(result[i], tempSizes[i], sizeof(char*), (int(*)(const void*, const void*))strcmp); // 排序邮箱
        char* name = (char*)hashMapFind(emailToName, result[i][0]); // 查找用户名
        result[i][0] = name; // 将用户名添加到结果的第一个位置
        (*returnColumnSizes)[i] = tempSizes[i]; // 设置每个账户的列大小
    }

    free(tempSizes); // 释放临时大小数组
    freeUnionFind(uf); // 释放并查集
    freeHashMap(emailToID); // 释放邮箱到ID的哈希表
    freeHashMap(emailToName); // 释放邮箱到名称的哈希表
    freeHashMap(components); // 释放组件哈希表

    return result; // 返回合并后的账户数组
}

// 辅助函数：创建和初始化accounts数据
char*** createAccounts(int accountsSize, int* accountsColSize, char* values[][5]) {
    char*** accounts = (char***)malloc(accountsSize * sizeof(char**));
    for (int i = 0; i < accountsSize; i++) {
        accounts[i] = (char**)malloc(accountsColSize[i] * sizeof(char*));
        for (int j = 0; j < accountsColSize[i]; j++) {
            accounts[i][j] = values[i][j]; // 初始化账户数组
        }
    }
    return accounts;
}

完整的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//定义并查集结构
typedef struct {
	int* parent;//定义父节点数组
	int* rank;//定义排名数组用于优化合并操作

}UnionFind;
//初始化并查集
UnionFind* createUnionFind(int size) {
	UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
	uf->parent = (int*)malloc(size * sizeof(int));
	uf->rank = (int*)malloc(size * sizeof(int));
	//将每个节点的父节点初始化为其自身，将每个节点的排名初始化为0
	for (int i = 0; i < size; i++)
	{
		uf->parent[i] = i;
		uf->rank[i] = 0;
	}
	return uf;
}
//定义一个函数用于查找根节点，带路径压缩优化
int find(UnionFind* uf, int x) {
	if (uf->parent[x] != x)
	{
		uf->parent[x] = find(uf, uf->parent[x]);//路径压缩
	}
}
//定义一个函数用于合并两个集合，并按秩合并优化
void unionSets(UnionFind* uf, int x, int y) {
	int rootX = find(uf, x);
	int rootY = find(uf, y);
	if (rootX != rootY) {
		if (uf->rank[rootX] > uf->rank[rootY])
		{
			uf->parent[rootY] = rootX;
		}
		else if (uf->rank[rootX] < uf->rank[rootY]) {
			uf->parent[rootX] = rootY;
		}
		else
		{
			uf->parent[rootY] = rootX;
			uf->parent[rootX]++;
		}
	}
}
//定义一个函数将并查集释放掉
void freeUnionFind(UnionFind* uf) {
	free(uf->parent);
	free(uf->rank);
	free(uf);
}
//定义一个哈希表节点结构
typedef struct HashNode {
	char* key;//哈希表的键
	int value;//定义哈希表的值
	struct HashNode* next;//定义链表中的下一个指针
};
//定义哈希表的结构
typedef struct {
	int size;//定义哈希表的大小
	HashNode** table;//定义指向哈希表数组的指针
}HashMap;
// 创建哈希表
HashMap* createHashMap(int size) {
    HashMap* map = (HashMap*)malloc(sizeof(HashMap));
    map->size = size;
    map->table = (HashNode**)malloc(size * sizeof(HashNode*)); // 确保分配的类型正确
    for (int i = 0; i < size; i++) {
        map->table[i] = NULL; // 初始化哈希表数组为空
    }
    return map;
}
//定一个哈希表函数
int hashFunction(HashMap* map, char* key) {
	int hash = 0;
	while (*key)
	{
		hash = (hash * 31 + *key) % map->size;//计算哈希值
		key++;

	}
	return hash;
}
//插入哈希表
void hashMapInsert(HashMap* map, char* key, int value) {
    int hash = hashFunction(map, key);
    HashNode* node = map->table[hash];
    while (node) {
        if (strcmp(node->key, key) == 0) { // 如果键已经存在，更新值
            node->value = value;
            return;
        }
        node = node->next;
    }
    // 创建新节点
    node = (HashNode*)malloc(sizeof(HashNode));
    node->key = strdup(key);
    node->value = value;
    node->next = map->table[hash];
    map->table[hash] = node;
}

// 查找哈希表
int hashMapFind(HashMap* map, char* key) {
    int hash = hashFunction(map, key);
    HashNode* node = map->table[hash];
    while (node) {
        if (strcmp(node->key, key) == 0) { // 找到键，返回值
            return node->value;
        }
        node = node->next;
    }
    return -1; // 键不存在，返回-1
}

// 释放哈希表
void freeHashMap(HashMap* map) {
    for (int i = 0; i < map->size; i++) {
        HashNode* node = map->table[i];
        while (node) {
            HashNode* temp = node;
            node = node->next;
            free(temp->key);
            free(temp);
        }
    }
    free(map->table);
    free(map);
}

// 合并账户
char*** accountsMerge(char*** accounts, int accountsSize, int* accountsColSize, int* returnSize, int** returnColumnSizes) {
    UnionFind* uf = createUnionFind(accountsSize * 10); // 假设每个账户最多有10个邮箱
    HashMap* emailToID = createHashMap(accountsSize * 10); // 邮箱到ID的映射
    HashMap* emailToName = createHashMap(accountsSize * 10); // 邮箱到用户名的映射

    int id = 0;
    for (int i = 0; i < accountsSize; i++) {
        char* name = accounts[i][0]; // 获取账户名称
        for (int j = 1; j < accountsColSize[i]; j++) {
            char* email = accounts[i][j]; // 获取邮箱
            if (hashMapFind(emailToID, email) == -1) { // 如果邮箱未映射，添加映射
                hashMapInsert(emailToID, email, id++);
                hashMapInsert(emailToName, email, (int)name);
            }
            int emailID = hashMapFind(emailToID, email);
            unionSets(uf, hashMapFind(emailToID, accounts[i][1]), emailID); // 合并集合
        }
    }

    HashMap* components = createHashMap(id); // 创建组件哈希表
    for (int i = 0; i < accountsSize; i++) {
        for (int j = 1; j < accountsColSize[i]; j++) {
            char* email = accounts[i][j];
            int rootID = find(uf, hashMapFind(emailToID, email)); // 查找根节点ID
            if (hashMapFind(components, (char*)rootID) == -1) {
                hashMapInsert(components, (char*)rootID, rootID); // 插入组件
            }
        }
    }

    *returnSize = id;
    *returnColumnSizes = (int*)malloc(id * sizeof(int)); // 初始化返回列大小数组
    char*** result = (char***)malloc(id * sizeof(char**)); // 初始化结果数组
    int* tempSizes = (int*)calloc(id, sizeof(int)); // 初始化临时大小数组
    for (int i = 0; i < id; i++) {
        result[i] = (char**)malloc(20 * sizeof(char*)); // 假设最多有20个邮箱
    }

    for (int i = 0; i < accountsSize; i++) {
        for (int j = 1; j < accountsColSize[i]; j++) {
            char* email = accounts[i][j];
            int rootID = find(uf, hashMapFind(emailToID, email)); // 查找根节点ID
            result[rootID][tempSizes[rootID]++] = email; // 添加邮箱到结果中
        }
    }

    for (int i = 0; i < id; i++) {
        qsort(result[i], tempSizes[i], sizeof(char*), (int(*)(const void*, const void*))strcmp); // 排序邮箱
        char* name = (char*)hashMapFind(emailToName, result[i][0]); // 查找用户名
        result[i][0] = name; // 将用户名添加到结果的第一个位置
        (*returnColumnSizes)[i] = tempSizes[i]; // 设置每个账户的列大小
    }

    free(tempSizes); // 释放临时大小数组
    freeUnionFind(uf); // 释放并查集
    freeHashMap(emailToID); // 释放邮箱到ID的哈希表
    freeHashMap(emailToName); // 释放邮箱到名称的哈希表
    freeHashMap(components); // 释放组件哈希表

    return result; // 返回合并后的账户数组
}

// 辅助函数：创建和初始化accounts数据
char*** createAccounts(int accountsSize, int* accountsColSize, char* values[][5]) {
    char*** accounts = (char***)malloc(accountsSize * sizeof(char**));
    for (int i = 0; i < accountsSize; i++) {
        accounts[i] = (char**)malloc(accountsColSize[i] * sizeof(char*));
        for (int j = 0; j < accountsColSize[i]; j++) {
            accounts[i][j] = values[i][j]; // 初始化账户数组
        }
    }
    return accounts;
}
// 测试函数
int main() {
    // 测试用例中的数组定义部分
    int accountsSize1 = 4;
    int accountsColSize1[] = { 3, 2, 3, 2 };
    char* values1[4][5] = {
        {"John", "johnsmith@mail.com", "john00@mail.com", NULL, NULL},
        {"John", "johnnybravo@mail.com", NULL, NULL, NULL},
        {"John", "johnsmith@mail.com", "john_newyork@mail.com", NULL, NULL},
        {"Mary", "mary@mail.com", NULL, NULL, NULL}
    };

    // 第二个测试用例
    int accountsSize2 = 5;
    int accountsColSize2[] = { 4, 4, 4, 4, 4 };
    char* values2[5][5] = {
        {"Gabe", "Gabe0@m.co", "Gabe3@m.co", "Gabe1@m.co", NULL},
        {"Kevin", "Kevin3@m.co", "Kevin5@m.co", "Kevin0@m.co", NULL},
        {"Ethan", "Ethan5@m.co", "Ethan4@m.co", "Ethan0@m.co", NULL},
        {"Hanzo", "Hanzo3@m.co", "Hanzo1@m.co", "Hanzo0@m.co", NULL},
        {"Fern", "Fern5@m.co", "Fern1@m.co", "Fern0@m.co", NULL}
    };


    // 创建账户数据
    char*** accounts1 = createAccounts(accountsSize1, accountsColSize1, values1);
    char*** accounts2 = createAccounts(accountsSize2, accountsColSize2, values2);

    int returnSize1, returnSize2;
    int* returnColumnSizes1;
    int* returnColumnSizes2;

    // 合并账户
    char*** result1 = accountsMerge(accounts1, accountsSize1, accountsColSize1, &returnSize1, &returnColumnSizes1);
    char*** result2 = accountsMerge(accounts2, accountsSize2, accountsColSize2, &returnSize2, &returnColumnSizes2);

    // 打印结果
    printf("测试用例 1:\n");
    for (int i = 0; i < returnSize1; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes1[i]; j++) {
            printf("%s", result1[i][j]);
            if (j < returnColumnSizes1[i] - 1) {
                printf(", ");
            }
        }
        printf("]\n");
    }

    printf("\n测试用例 2:\n");
    for (int i = 0; i < returnSize2; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes2[i]; j++) {
            printf("%s", result2[i][j]);
            if (j < returnColumnSizes2[i] - 1) {
                printf(", ");
            }
        }
        printf("]\n");
    }

    // 释放内存
    free(accounts1);
    free(accounts2);
    free(result1);
    free(result2);
    free(returnColumnSizes1);
    free(returnColumnSizes2);

    return 0;
}

丹柒七
关注
并查集-力扣-721. 账户合并
dailinqing1984的博客
05-04 339
题目链接 给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该账户的邮箱地址。 现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。 合并账户后，按以下格式返回账户：每个账户的第一个.
LeetCode 721.账户合并 题解
veatheroe的博客
01-01 1017
LeetoCode地址: 力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台原题使用的是名称和账号的邮箱地址，好多字母，可能有些人会不太好理解。我换了一种场景：联想一下，诸如《魔兽世界》《地下城与勇士》这样的网络游戏，每个玩家都可以创建多个游戏角色，每个游戏角色的ID都是服务器唯一的。注意，玩家的姓名在现实生活中是完全可以重复的。在下图上半部分里，有一些玩家: 两位周小董， 两位张小涵，他们都拥有一些游戏角色。按照题目的意思，因为两个周小董都拥有角色《战斗至死》，所以这两个周小董其实同一个人，他们
721 账户合并
weixin_44171872的博客
01-12 274
题目描述： 给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该账户的邮箱地址。 现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。 合并账户后，按以下格式返回账户：每个账户的第一个元素
LeetCode刷题（每日一题） --721. 账户合并（并查集）
Hanzoe的博客
01-18 286
题目 给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该账户的邮箱地址。 现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。 合并账户后，按以下格式返回账户：每个账户的第一个元素是名称
Leetcode每日一题 20240715 721.账户合并
2301_76443687的博客
07-15 722
Leetcode每日一题 20240715
力扣：账户合并
ZhangyiA的博客
12-07 613
题目描述   给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该帐户的邮箱地址。   现在，我们想合并这些帐户。如果两个帐户都有一些共同的邮件地址，则两个帐户必定属于同一个人。请注意，即使两个帐户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的帐户，但其所有帐户都具有相同的名称。   合并帐户后，按以下格式返回帐户：每个帐
721. 账户合并
顺子的专栏
01-18 164
给定一个列表accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该账户的邮箱地址。 现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。 合并账户后，按以下格式返回账户：每个账户的第一个元素是名称，其余元
使用力扣刷题的经验.pdf
04-21
在使用力扣平台刷题提升编程和算法能力的过程中，需要把握几个关键的知识点，以及遵循一定的学习方法和策略。 首先，对于编程初学者来说，掌握一门编程语言是进行算法练习的前提。C语言和Java是比较常见的选择，...
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
"力扣刷题"通常指的是用户通过反复练习这些题目来提高自己的编程能力。 在力扣上刷题的过程中，你可以接触到以下几个核心知识点： 1. **数据结构**： - 数组：基础的数据结构，用于存储固定大小的同类型元素集合...
力扣刷题c++贪心算法.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 ...
Java实现 LeetCode 721 账户合并（并查集）
12-21
721. 账户合并 给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该帐户的邮箱地址。 现在，我们想合并这些帐户。如果两个帐户都有一些共同的邮件地址，则两个帐户必定属于同一个人。请注意，即使两个帐户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的帐户，但其所有帐户都具有相同的名称。 合并帐户后，按以下格式返回帐户：每个帐户的第一个元素是名称，其余元素是按顺序排列的邮箱地址。accounts 本身可以以任意顺序返回
Leetcode力扣刷题——182.查找重复的电子邮箱
最新发布
weixin_74681777的博客
08-06 299
编写解决方案来报告所有重复的电子邮件。请注意，可以保证电子邮件字段不为 NULL。以返回结果表。结果格式如下例。
力扣刷题-733.图像渲染
BigData_Mr_wang的博客
07-13 331
有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小。你也被给予三个整数 sr , sc 和 newColor 。你应该从像素 image[sr][sc] 开始对图像进行上色填充 。为了完成上色工作 ，从初始像素开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为 newColor
leetcode 721. 账户合并
Rolandxxx的博客
12-16 543
输入：accounts = [[“John”, “johnsmith@mail.com”, “john00@mail.com”], [“John”, “johnnybravo@mail.com”], [“John”, “johnsmith@mail.com”, “john_newyork@mail.com”], [“Mary”, “mary@mail.com”]]现在，我们想合并这些账户。合并账户后，按以下格式返回账户：每个账户的第一个元素是名称，其余元素是 按字符 ASCII 顺序排列 的邮箱地址。
LeetCode 账户合并（深度优先搜索）
hestyle的博客
04-28 1321
给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该帐户的邮箱地址。 现在，我们想合并这些帐户。如果两个帐户都有一些共同的邮件地址，则两个帐户必定属于同一个人。请注意，即使两个帐户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有...
LeetCode刷题笔记（Java）---更新至729题
gongsenlin341的博客
02-05 636
文章目录前言笔记导航721. 账户合并722. 删除注释724. 寻找数组的中心索引738. 单调递增的数字725. 分隔链表 前言 需要开通vip的题目暂时跳过 笔记导航 点击链接可跳转到所有刷题笔记的导航链接 721. 账户合并 给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称 (name)，其余元素是 emails 表示该账户的邮箱地址。 现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必
力扣leetcode刷题：并查集相关题目
代码届的小白的博客
01-31 2851
这里写目录标题并查集的思想与介绍力扣721.账户合并题目描述题目解读 方法：哈希表+并查集详细代码和注释839.相似字符串组题目描述题目解读 方法：并查集详细代码和注释 并查集的思想与介绍 可以查看这片文章！ https://blog.csdn.net/weixin_42305672/article/details/112699785 力扣721.账户合并 题目描述 给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称
JAVA程序设计：账户合并（LeetCode：721）
信仰.的博客
02-14 647
给定一个列表 accounts，每个元素 accounts[i]是一个字符串列表，其中第一个元素 accounts[i][0]是名称 (name)，其余元素是 emails 表示该帐户的邮箱地址。 现在，我们想合并这些帐户。如果两个帐户都有一些共同的邮件地址，则两个帐户必定属于同一个人。请注意，即使两个帐户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥...
力扣刷题笔记.pdf
12-11
力扣刷题笔记.pdf是一份非常重要的学习资料，里面记录了刷力扣题目时的一些关键思路、解题方法和总结。在这份笔记中，可以记录下每道题的解法和思路，以及一些常见的错误和易错点。这样在以后复习和总结的时候，就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值