LEECODE-哈希-map

---

---

---

500. 键盘行

难度简单222

给你一个字符串数组 words ，只返回可以使用在 美式键盘 同一行的字母打印出来的单词。键盘如下图所示。

美式键盘 中：

• 第一行由字符 "qwertyuiop" 组成。
• 第二行由字符 "asdfghjkl" 组成。
• 第三行由字符 "zxcvbnm" 组成。

示例 1：

输入：words = ["Hello","Alaska","Dad","Peace"]
输出：["Alaska","Dad"]

示例 2：

输入：words = ["omk"]
输出：[]

示例 3：

输入：words = ["adsdf","sfd"]
输出：["adsdf","sfd"]

提示：

• 1 <= words.length <= 20
• 1 <= words[i].length <= 100
• words[i] 由英文字母（小写和大写字母）组成

class Solution {
public:
    vector<string> findWords(vector<string>& words) 
    {
          int h;//行号
          map<char, int> Map = {{'q', 0}, {'w', 0}, {'e', 0}, {'r', 0}, {'t', 0}, {'y', 0}, {'u', 0}, {'i', 0}, {'o', 0}, {'p', 0}, {'a', 1}, {'s', 1}, {'d', 1}, {'f', 1}, {'g', 1}, {'h', 1}, {'j', 1}, {'k', 1}, {'l', 1}, {'z', 2}, {'x', 2}, {'c', 2}, {'v', 2}, {'b', 2}, {'n', 2}, {'m', 2}};
          vector<string>ans;
            for(int i=0;i<words.size();i++){
                h=Map[tolower(words[i][0])];//map[key]=value
                    for (int j = 0; j < words[i].size(); ++j) //开始遍历单词
                    {
                        if (Map[tolower(words[i][j])] != h){//查询到不在同一行的单词，跳出查询下一个单词
                            break;}
                        if (j == words[i].size()-1)//全部字符都匹配
                            ans.push_back(words[i]);
            }
            }
            return ans;
        }
};

---

---

---

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

难度简单228

假设 Andy 和 Doris 想在晚餐时选择一家餐厅，并且他们都有一个表示最喜爱餐厅的列表，每个餐厅的名字用字符串表示。

你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。 如果答案不止一个，则输出所有答案并且不考虑顺序。 你可以假设答案总是存在。

示例 1:

输入: list1 = ["Shogun", "Tapioca Express", "Burger King", "KFC"]，list2 = ["Piatti", "The Grill at Torrey Pines", "Hungry Hunter Steakhouse", "Shogun"]
输出: ["Shogun"]
解释: 他们唯一共同喜爱的餐厅是“Shogun”。

示例 2:

输入:list1 = ["Shogun", "Tapioca Express", "Burger King", "KFC"]，list2 = ["KFC", "Shogun", "Burger King"]
输出: ["Shogun"]
解释: 他们共同喜爱且具有最小索引和的餐厅是“Shogun”，它有最小的索引和1(0+1)。

提示:

• 1 <= list1.length, list2.length <= 1000
• 1 <= list1[i].length, list2[i].length <= 30 
• list1[i] 和 list2[i] 由空格 ' ' 和英文字母组成。
• list1 的所有字符串都是 唯一 的。
• list2 中的所有字符串都是 唯一 的。

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
    map<string,int> Map;
    for(int i=0;i<list1.size();i++){
        //Map.insert(pair<string,int>(list1[i],i));   
        Map[list1[i]]=i;
    }

    vector<string>ans;
    int indexSum = INT_MAX;
        for (int i = 0; i < list2.size(); i++) {
            if (Map.count(list2[i]) > 0) {//map::count()是C++ STL中的内置函数，如果在映射容器中存在带有键K的元素，则该函数返回1。如果容器中不存在键为K的元素，则返回0。
                int j = Map[list2[i]];
                if (i + j < indexSum) {
                    ans.clear();
                    ans.push_back(list2[i]);
                    indexSum = i + j;
                } else if (i + j == indexSum) {
                    ans.push_back(list2[i]);
                }
            }
        }
        return ans;
    }
};

748. 最短补全词

难度简单120

给你一个字符串 licensePlate 和一个字符串数组 words ，请你找出 words 中的 最短补全词 。

补全词 是一个包含 licensePlate 中所有字母的单词。忽略 licensePlate 中的 数字和空格 。不区分大小写。如果某个字母在 licensePlate 中出现不止一次，那么该字母在补全词中的出现次数应当一致或者更多。

例如：licensePlate = "aBc 12c"，那么它的补全词应当包含字母 'a'、'b' （忽略大写）和两个 'c' 。可能的 补全词 有 "abccdef"、"caaacab" 以及 "cbca" 。

请返回 words 中的 最短补全词 。题目数据保证一定存在一个最短补全词。当有多个单词都符合最短补全词的匹配条件时取 words 中 第一个 出现的那个。

示例 1：

输入：licensePlate = "1s3 PSt", words = ["step", "steps", "stripe", "stepple"]
输出："steps"
解释：最短补全词应该包括 "s"、"p"、"s"（忽略大小写） 以及 "t"。
"step" 包含 "t"、"p"，但只包含一个 "s"，所以它不符合条件。
"steps" 包含 "t"、"p" 和两个 "s"。
"stripe" 缺一个 "s"。
"stepple" 缺一个 "s"。
因此，"steps" 是唯一一个包含所有字母的单词，也是本例的答案。

示例 2：

输入：licensePlate = "1s3 456", words = ["looks", "pest", "stew", "show"]
输出："pest"
解释：licensePlate 只包含字母 "s" 。所有的单词都包含字母 "s" ，其中 "pest"、"stew"、和 "show" 三者最短。答案是 "pest" ，因为它是三个单词中在 words 里最靠前的那个。

提示：

• 1 <= licensePlate.length <= 7
• licensePlate 由数字、大小写字母或空格 ' ' 组成
• 1 <= words.length <= 1000
• 1 <= words[i].length <= 15
• words[i] 由小写英文字母组成

 

class Solution {
public:
    //判断dict2∈dict1
    bool isValid(unordered_map<char, int>& dict1, unordered_map<char, int>& dict2)
    {
        for (auto& c : dict2)
        {
            if (dict1[c.first] < c.second)
                return false;
        }
        return true;
    }

    string shortestCompletingWord(string licensePlate, vector<string>& words) {
        unordered_map<char,int> lp;
        for(auto c : licensePlate){
            if(tolower(c)>='a'&&tolower(c)<='z'){
                lp[tolower(c)]++;
            }
        }

        string ans;
        for(auto word : words){
            unordered_map<char,int> wd;

            for(auto c : word){
                wd[tolower(c)]++;
            }

            //判断lp∈wd
           if (isValid(wd, lp))
            {
                if (ans.empty() || ans.size() > word.size())
                    ans = word;
            }
        }
            return ans;
    

        }

};