Leetcode599. 两个列表的最小索引总和(哈希，字符串）

最新推荐文章于 2022-02-22 16:59:14 发布

while_false_

最新推荐文章于 2022-02-22 16:59:14 发布

阅读量144

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode题解

本文链接：https://blog.youkuaiyun.com/qq_34595352/article/details/92805710

LeetCode题解专栏收录该内容

101 篇文章

订阅专栏

博客围绕帮助Andy和Doris找出共同喜爱且索引和最小的餐厅展开。给出了具体示例，如输入两个餐厅列表，输出符合条件的餐厅。还给出了列表长度、字符串长度等提示信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://leetcode-cn.com/problems/minimum-index-sum-of-two-lists/submissions/

假设Andy和Doris想在晚餐时选择一家餐厅，并且他们都有一个表示最喜爱餐厅的列表，每个餐厅的名字用字符串表示。
你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。如果答案不止一个，则输出所有答案并且不考虑顺序。你可以假设总是存在一个答案。

示例 1:
输入:
[“Shogun”, “Tapioca Express”, “Burger King”, “KFC”]
[“Piatti”, “The Grill at Torrey Pines”, “Hungry Hunter Steakhouse”, “Shogun”]
输出: [“Shogun”]
解释: 他们唯一共同喜爱的餐厅是“Shogun”。
示例 2:
输入:
[“Shogun”, “Tapioca Express”, “Burger King”, “KFC”]
[“KFC”, “Shogun”, “Burger King”]
输出: [“Shogun”]
解释: 他们共同喜爱且具有最小索引和的餐厅是“Shogun”，它有最小的索引和1(0+1)。
提示:
两个列表的长度范围都在 [1, 1000]内。
两个列表中的字符串的长度将在[1，30]的范围内。
下标从0开始，到列表的长度减1。
两个列表都没有重复的元素。

/* 使用哈希表
将list1  存入哈希表（key:字符串首字母， value:索引值 + 完整字符串）
遍历list2即可
*/

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
// hash值结构
typedef struct HASH_KV{
    int key;
    int index;
    char *str;
}hash_kv;

// hash结构
typedef struct HASHTAB{
    int  hashsize;
    hash_kv *val;
}hashtab;

// hash 初始化
void hash_init(int size, hashtab *ha){
    ha->hashsize = size;
    ha->val = (hash_kv *)calloc(size, sizeof(hash_kv));
    int i = 0;
    for(; i < size; i++){
        ha->val[i].key = -1;
        ha->val[i].str = malloc(31 * sizeof(char));
    }
}

// hash 函数
int hash(hashtab *ha, int key){
     return key % ha->hashsize;
}

// hash insert
void hash_insert(hashtab *ha, hash_kv kv){
    int addr = hash(ha, kv.key);
    
    while(ha->val[addr].key != -1){
        addr = (addr + 1)% ha->hashsize;
    }
    ha->val[addr].key = kv.key;
    ha->val[addr].index = kv.index;
    strncpy(ha->val[addr].str, kv.str ,strlen(kv.str));
    ha->val[addr].str[strlen(kv.str)] = '\0';
}

// hash find
int hash_find(hashtab *ha, hash_kv kv){
    int addr = hash(ha, kv.key);
    
    while(ha->val[addr].key != kv.key || (0 != strcmp(ha->val[addr].str, kv.str))){
        addr = (addr + 1) % ha->hashsize;
        if(addr == hash(ha, kv.key) || ha->val[addr].key == -1){
            return -1;
        }
    }
    return ha->val[addr].index;
}

int get_key(char *str){
    return str[0] - 'A';
}

char ** findRestaurant(char ** list1, int list1Size, char ** list2, int list2Size, int* returnSize){
    hashtab *ht = (hashtab *)calloc(1, sizeof(hashtab));
    hash_init(list1Size, ht);
    
    int i = 0;
    for(; i < list1Size; i++){
        hash_kv kv;
        kv.key = get_key(list1[i]);
        kv.index = i;
        kv.str = list1[i];
        hash_insert(ht, kv);
    }
    
    int index1 = -1;
    int min = INT_MAX;
    int count = 0;
    for(i = 0; i < list2Size; i++){  // find min
        hash_kv kv;
        kv.key = get_key(list2[i]);
        kv.str = list2[i];
        index1 = hash_find(ht, kv);
        if(-1 == index1) continue;
        if(min > (index1 + i)){
            count = 1;
            min = index1 + i;
        }else if (min == index1 + i){
            count++;
        }
    }

    *returnSize = count;
    char **ret = (char **)calloc(count, sizeof(char *));
    int j = 0;
    for(i = 0; i < list2Size; i++){  // return
        hash_kv kv;
        kv.key = get_key(list2[i]);
        kv.str = list2[i];
        index1 = hash_find(ht, kv);
        if(min == i + index1 && index1 != -1){
            ret[j] = (char *)malloc(31 * sizeof(char));
            strncpy(ret[j], list2[i], strlen(list2[i]));
            ret[j][strlen(list2[i])] = '\0';
            j++;
        }
    }
    return ret;
}