599. Minimum Index Sum of Two Lists-优快云博客

本文介绍了一种算法，用于解决两个人如何从各自的餐厅列表中找到共同喜爱且列表索引和最小的餐厅。通过使用哈希表存储每个餐厅及其在列表中的位置，可以有效地找到满足条件的餐厅。

Suppose Andy and Doris want to choose a restaurant for dinner, and they both have a list of favorite restaurants represented by strings.

You need to help them find out their common interest with the least list index sum. If there is a choice tie between answers, output all of them with no order requirement. You could assume there always exists an answer.

Example 1:

Input:
["Shogun", "Tapioca Express", "Burger King", "KFC"]
["Piatti", "The Grill at Torrey Pines", "Hungry Hunter Steakhouse", "Shogun"]
Output: ["Shogun"]
Explanation: The only restaurant they both like is "Shogun".

Example 2:

Input:
["Shogun", "Tapioca Express", "Burger King", "KFC"]
["KFC", "Shogun", "Burger King"]
Output: ["Shogun"]
Explanation: The restaurant they both like and have the least index sum is "Shogun" with index sum 1 (0+1).

Note:

The length of both lists will be in the range of [1, 1000].
The length of strings in both lists will be in the range of [1, 30].
The index is starting from 0 to the list length minus 1.
No duplicates in both lists.

思路：存储对应字符和索引（map）,利用map.count是否重合

代码1：

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        map<string,int> m;
        int i=0;
        for(string s:list1){
            m.insert(pair<string,int>(s,3000+i));
            i++;
        }
        i=0;
        for(string s:list2){
            if(m.find(s)!=m.end()){
                m[s] += (i-3000);
            }
            i++;
        }
        vector<string> result;
        int min=2000;
        map<string,int>::iterator pos;
        for(pos=m.begin();pos!=m.end();pos++){
            if(pos->second<=min){
                if(pos->second<min){
                    result.clear();
                    result.push_back(pos->first);
			        min = pos->second;
                }
                else{
                    result.push_back(pos->first);
                }
                
            }
        }
        
        return result;
    }
};

代码2：

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        map<string,int> m;
        int loop=1;
        for(string s:list1){
            m[s]++;
            m[s]=m[s]*(-1)*loop;
            loop++;
        }
        loop=1;
        for(string s:list2){
            if(m.count(s)){m[s]=m[s]*(-1)+loop;}
            loop++;
        }
        vector<string> res;
        int sum=INT_MAX;
        for(pair<string,int> mm:m){
            if(mm.second>0 && mm.second<sum){
                res.clear();
                res.push_back(mm.first);
                sum=mm.second;
            }
            else if(mm.second>0 && mm.second==sum){res.push_back(mm.first);}
        }
        return res;
    }
};

代码3：

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        if (list1.empty() || list2.empty()) 
            return {};
        
        const int m = list1.size(), n = list2.size();
        if (m > n)
            return findRestaurant(list2, list1);
        unordered_map<string, int> lookup;
        for (int i = 0; i < m; ++i)
            lookup[list1[i]] = i;
        
        int sum = m+n;
        vector<string> result;
        for (int j = 0; j < n; ++j) {
            if (lookup.count(list2[j])) {
                if (lookup[list2[j]]+j == sum)
                    result.push_back(list2[j]);
                if (lookup[list2[j]]+j < sum) {
                    result.clear();
                    result.push_back(list2[j]);
                    sum = lookup[list2[j]] + j;
                }
            }
        }
        return result;
    }
};

代码2和代码3同一思路，但是3更简洁高效。