LeetCode：721.Accounts Merge账户合并（C语言）

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

现在，我们想合并这些账户。如果两个账户都有一些共同的邮箱地址，则两个账户必定属于同一个人。请注意，即使两个账户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的账户，但其所有账户都具有相同的名称。

合并账户后，按以下格式返回账户：每个账户的第一个元素是名称，其余元素是按顺序排列的邮箱地址。账户本身可以以任意顺序返回。

示例 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’]] 也是正确的。

提示：

accounts的长度将在[1，1000]的范围内。
accounts[i]的长度将在[1，10]的范围内。
accounts[i][j]的长度将在[1，30]的范围内。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/accounts-merge
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解答：

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
#define MAXSTRLEN 35
struct HashMap{
    char key[MAXSTRLEN];
    char name[MAXSTRLEN];
    char parent[MAXSTRLEN];
    UT_hash_handle hh;
};
struct HashMap *g_hashHead = NULL;
char ***g_res = NULL;
int *g_col = NULL;
int g_resIndex = 0;
#define MAXNUM 10000

void InitMem(int accountsSize)
{
    g_hashHead = NULL;
    g_res = (char ***)malloc(sizeof(char **) * accountsSize);
    for(int i = 0; i < accountsSize; i++) {
        g_res[i] = calloc(MAXNUM, sizeof(char*));
    }
    g_col = calloc(accountsSize, sizeof(int));
    g_resIndex = 0;
    return;
}

void FreeMem()
{
    struct HashMap *s = NULL;
    struct HashMap *tmp = NULL;
    HASH_ITER(hh,g_hashHead,s,tmp) {
        HASH_DEL(g_hashHead,s);
        free(s);
    }
    return; 
}

struct HashMap *InsertHash(char *key, char *name, char *parent)
{
    struct HashMap *s = NULL;
    HASH_FIND_STR(g_hashHead,key,s);
    if(s == NULL) {
        s = malloc(sizeof(struct HashMap));
        strcpy(s->key, key);
        strcpy(s->name, name);
        strcpy(s->parent, parent);
        HASH_ADD_STR(g_hashHead,key,s);
    }
    return s;
}

struct HashMap *UpadatHash(char *key, char *name, char *parent)
{
    struct HashMap *s = NULL;
    HASH_FIND_STR(g_hashHead,key,s);
    if(s == NULL) {
        return NULL;
    }
    strcpy(s->name, name);
    strcpy(s->parent, parent);
    return s;
}

struct HashMap *Find(struct HashMap *x )
{
    struct HashMap *s = x;
    while(strcmp(s->key, s->parent) != 0) {
        char parent[MAXSTRLEN] = {0};
        strcpy(parent,s->parent);
        HASH_FIND_STR(g_hashHead,parent,s);
    }
    return s;
}

void Union(struct HashMap *a, struct HashMap *b) 
{
    struct HashMap *aParent = Find(a);
    struct HashMap *bParent = Find(b);
    //printf("FIND a %s parent  %s %s\r\n",a->key,aParent->key,aParent->parent);
    //printf("FIND b %s parent  %s %s\r\n",b->key,bParent->key,bParent->parent);
    if(strcmp(aParent->parent, bParent->parent) != 0) {
        (void)UpadatHash(bParent->key, aParent->name, aParent->parent);
        (void)UpadatHash(b->key, aParent->name, aParent->parent);
    }
    return;
}

void ProcessAccount(char *** accounts, int accountsSize, int* accountsColSize)
{
    struct HashMap *a = NULL;
    struct HashMap *b = NULL;
    for (int i = 0; i < accountsSize; i++) {
        a = NULL;
        b = NULL;
        char *name = accounts[i][0];
        char *key = accounts[i][0];
        char *parent = accounts[i][0];
        for(int j = 1; j < accountsColSize[i]; j++) {
            key = accounts[i][j];
            parent = accounts[i][j];
            if(j == 1) {
                a = InsertHash(key, name, parent);
                continue;
            }else{
                b = InsertHash(key, name, parent);
            }
            Union(a,b);
        }
    }
    return;
}

bool IsSameParent(char *aKey, char *bKey)
{
    struct HashMap *a = NULL;
    struct HashMap *b = NULL;
    HASH_FIND_STR(g_hashHead,aKey,a);
    HASH_FIND_STR(g_hashHead,bKey,b);
    struct HashMap *aParent = Find(a);
    struct HashMap *bParent = Find(b);
    if(aParent != bParent) {
        return false;
    }
    return true;
}

int SortCmp(const void *a, const void *b)
{
    char *aPtr = *(char**)a;
    char *bPtr = *(char**)b;
    return strcmp(aPtr,bPtr); 
}

int GetResIndex(char *key)
{
    struct HashMap *s = NULL;
    HASH_FIND_STR(g_hashHead,key,s);
    for(int i = 0; i < g_resIndex; i++) {
        if(g_col[i] > 1) {
            if(IsSameParent(s->parent, g_res[i][1])) {
                return i;
            }
        }
    }
    return -1;
}

void OutPutRes() 
{
    struct HashMap *s = NULL;
    struct HashMap *tmp = NULL;
    char parent[MAXSTRLEN] = {0};
    HASH_ITER(hh,g_hashHead,s,tmp) {
        int resIndex = GetResIndex(s->key);
        if(resIndex == -1) {
            g_res[g_resIndex][0] = calloc(MAXSTRLEN, sizeof(char));
            strcpy(g_res[g_resIndex][0],s->name);
            g_res[g_resIndex][1] = calloc(MAXSTRLEN, sizeof(char));
            strcpy(g_res[g_resIndex][1],s->key);
            g_col[g_resIndex] = 2;
            g_resIndex++;
        }else{
            int index = g_col[resIndex];
            g_res[resIndex][index] = calloc(MAXSTRLEN, sizeof(char));
            strcpy(g_res[resIndex][index],s->key);
            g_col[resIndex]++;
        }
    }
    return;
}

void PrintHash()
{
    struct HashMap *s = NULL;
    struct HashMap *tmp = NULL;
    printf("PrintHash:\r\n");
    HASH_ITER(hh,g_hashHead,s,tmp) {
        printf("hash: %s %s %s\r\n",s->name,s->key,s->parent);
    }
    return;
}

void PrintRes()
{
    for (int i = 0; i < g_resIndex; i++) {
        for(int j = 0; j < g_col[i]; j++) {
            printf("%s ",g_res[i][j]);
        }
        printf("\r\n");
    }
    return;
}

void SortRes()
{
    for(int i = 0; i < g_resIndex; i++) {
        qsort(&g_res[i][1], g_col[i] - 1, sizeof(char*), SortCmp);//去掉NAME后 开始排序
    }
    return;
}

char *** accountsMerge(char *** accounts, int accountsSize, int* accountsColSize, int* returnSize, int** returnColumnSizes){
    InitMem(accountsSize);
    ProcessAccount(accounts, accountsSize, accountsColSize);
    //PrintHash();
    OutPutRes();
    SortRes();
    //PrintRes();
    FreeMem();
    *returnSize = g_resIndex;
    *returnColumnSizes = g_col;
    return g_res;
}

运行结果：

Notes：
参考文档：https://leetcode-cn.com/problems/accounts-merge/solution/cyu-yan-bing-cha-ji-hashjie-fa-by-tan-shao-yu-dou-/