LeetCode 599: 两个列表的最小索引总和

LeetCode 599: 两个列表的最小索引总和

题目描述

假设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。
两个列表都没有重复的元素。

解题

硬解

    我的思路是最小索引总和在$[0,len1+len2-2]$范围内，其中$len1$和$len2$分别为两个字符串数组的长度，那么从索引和为0的开始，找到索引和为当前长度的所有组合，如果存在相同的字符串，则保存到结果中，否则总和递增1。比如当前索引总和为3，如果两个字符串数组长度都不小于4的话，那么对应的索引可能为(0，3)、(1，2)、(2，1)、(3，0)，然后依次对比这些组合对应的字符串对是否相同，如果想同则表明当前字符串是共同喜好的餐厅，且索引和是目前发现的最短的，因此将字符串存入数组中，直到所有组合都判定完成。如果当前索引和对应的所有组合没有包含共同喜好的餐厅，那么遍历更大一些长度的组合，直到得到最终结果。这里为了美观，另写了一个区分长短的重载。

class Solution {
public:
    void findRestaurant(vector<string>&list_l, vector<string> &list_s, vector<string> &result){
        int len_s = list_s.size()-1, len_l = list_l.size()-1;
        int len = len_s + len_l;
        for (int l=0; l <= len; ++l){
            int i=min(len_s, l), j=l-i;
            while (i >= 0 && j <= len_l){
                if (list_s[i]==list_l[j])
                    result.emplace_back(list_s[i]);
                --i;
                ++j;
            }
            if (!result.empty())
                return;
        }
        return;
    }
    
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        vector<string> choices;
        if (list1.size() <= list2.size())
            findRestaurant(list2, list1, choices);
        else
            findRestaurant(list1, list2, choices);
        return choices;        
    }
};

哈希

    利用哈希表可以建立字符串到索引之间的映射关系，同时借助哈希表可以快速查找，判断当前字符串是否是共同喜好的餐厅，最开始用了两个哈希表测试下速度。

class Solution {
public:    
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        map<string, int>dict1, dict2;
        int len1 = list1.size(), len2 = list2.size();
        for (int i=0; i< len1; ++i)
            dict1[list1[i]] = i;
        for (int i=0; i< len2; ++i)
            dict2[list2[i]] = i;
        
        vector<string> choices;
        int min_sum = len1+len2, cur_sum;
        if (list1.size() < list2.size()){
            for (int i=0; i<len1; ++i){
                if (dict2.find(list1[i]) != dict2.end()){
                    cur_sum = dict1[list1[i]] + dict2[list1[i]];
                    dict1[list1[i]] = cur_sum;
                    if (cur_sum < min_sum){
                        min_sum = cur_sum;
                    }
                }
                else
                    dict1[list1[i]] = len1+len2;
            }
            
            for (int i=0; i<len1; ++i){
                if (dict1[list1[i]] == min_sum)
                    choices.emplace_back(list1[i]);
            }
        }
        else{
            for (int i=0; i<len2; ++i){
                if (dict1.find(list2[i]) != dict1.end()){
                    cur_sum = dict1[list2[i]] + dict2[list2[i]];
                    dict2[list2[i]] = cur_sum;
                    if (cur_sum < min_sum){
                        min_sum = cur_sum;
                    }
                }
                else
                    dict2[list2[i]] = len1+len2;
                
            }
            
            for (int i=0; i<len2; ++i){
                if (dict2[list2[i]] == min_sum)
                    choices.emplace_back(list2[i]);
            }
        }
        return choices;
    }
};

    后来发现原题目中给了很多可以直接用的信息，比如总长，这样只用一个哈希表就可以了，处理方法是如果是共有字符串，那么赋值为对应索引和加上2000， 这样所有共有字符串对应的索引和都在[2000+min_len，2000+max_len]范围之内，非共有字符串不会为止带来干扰。如果直接保存对应索引和的话，比如当前索引和为10，但是在建立字符串到索引的映射的时候，比如建立的是第一个字符串数组的映射关系，而该字符串数组长度为20，且索引为10的字符串恰不是共有字符串，那么这个字符串在最终会被错误地添加到结果中，因此要避开原有映射索引值地范围。

class Solution {
public: 
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        vector<string> choices;
        unordered_map<string, int> str_int;
        for (int i=0; i<list1.size(); ++i){
            str_int[list1[i]] = i;
        }
        int min_len = 2000, cur_len;
        for (int i=0; i<list2.size(); ++i){
            if (str_int.find(list2[i]) != str_int.end()){
                cur_len = i + str_int[list2[i]];
                str_int[list2[i]] = cur_len+2000;
                if (cur_len < min_len)
                    min_len = cur_len;
            }
        }
        
        for (const auto &i:str_int){
            if (i.second == min_len+2000)
                choices.emplace_back(i.first);
        }
        return choices;
    }
};