代码随想录Day9-哈希表：力扣383、49、438题

本文链接：https://blog.csdn.net/Jerome_zp/article/details/132033120

383. 赎金信

方法一：哈希表

思路

简单的哈希表。

时间复杂度： $O (n + m)$ ，n和m分别是两个输入字符串的长度。
空间复杂度： $O (c)$ ，c是magazine含有的字符种类数。

C++代码

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        if (ransomNote.size() > magazine.size()) return false;
        unordered_map<char, int> hashMap;
        for (char& c : magazine) ++hashMap[c];
        for (char& c : ransomNote) if (hashMap.find(c) == hashMap.end() || --hashMap[c] < 0) return false;
        return true;
    }
};

看完讲解的思考

无。

代码实现遇到的问题

无。

49. 字母异位词分组

题目链接

方法一：排序+哈希表

思路

由于字母异位词排序后的结果都是一样的，所以可以用排序后的结果作为哈希表的键来查询，哈希表的值则为字符串数组，将字母异位词存在同一个数组中。
遍历每一个字符串，将字符串的字符排序后得到哈希表的键，然后查询哈希表中是否存在。

时间复杂度： $\cdot m\log m)$ ，n为字符串数组的长度，m为字符串最大长度。要遍历n个字符串，每个字符串需要 $O(m\log m)$ 的时间排序。
空间复杂度： $O (nm)$ 。

C++代码

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> hashMap;
        vector<vector<string>> res;
        for (string & s : strs) {
            string tmp = s;
            sort(tmp.begin(), tmp.end());
            if (hashMap.find(tmp) == hashMap.end()) hashMap[tmp] = vector<string>{s};
            else hashMap[tmp].push_back(s);
        }
        for (auto & [key, val] : hashMap) res.push_back(val);
        return res;
    }
};

方法二：计数+哈希表

思路

由于字符串仅包含26个小写字母，所以可以统计每个字符串各个字符出现的频数，并将频数保存为字符串作为哈希表的键（例如："#2#1#4#…“或者"a2b1c4…”），其余地方与方法一一致。

时间复杂度： $O (nm)$ 。
空间复杂度： $O (nm)$ 。

C++代码

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> hashMap;
        vector<vector<string>> res;
        for (string & s : strs) {
            int freq[26] = {0};
            string freqStr;
            // 统计每个字符出现的频数
            for (char & c : s) ++freq[c - 'a'];
            // 将频数数组转换成字符串
            for (int & i : freq) {
                freqStr.push_back('#');
                freqStr.push_back(char(i));
            }
            // 以频数字符串为键值，将字符串添加到哈希表中
            if (hashMap.find(freqStr) == hashMap.end()) hashMap[freqStr] = vector<string>{s};
            else hashMap[freqStr].push_back(s);
        }
        for (auto & [key, val] : hashMap) res.push_back(val);
        return res;
    }
};

看完讲解的思考

搞清楚用什么作为哈希表的键值。

代码实现遇到的问题

unordered_map的键必须是可哈希的，一开始想着用unorder_map<char, int>>作为哈希表的键，但是哈希表不可哈希，所以哈希表不能作为哈希表的键。
c++中数组是用{ }框起来的，不是[ ]，平时python用多了，和python的list搞混淆了。

438. 找到字符串中所有字母异位词

题目链接

方法一：滑动窗口+哈希表

思路

首先记录下字符串p中各个字符出现的频数，然后使用一个滑动窗口维护字符串t中的子串，并记录子串中各个字符出现的频数，若子串字符频数等于p的字符频数则该子串为异位词。

时间复杂度： $\cdot c)$ ，n为字符串p的长度，m为字符串s的长度，c为字符串p的字符种类。遍历p获得p的频数是 $O (n)$ ，遍历s的过程中，每次比较两个频数是否一致需要 $O (c)$ 。
空间复杂度： $O (c)$ 。

C++代码

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int sSize = s.size();
        int pSize = p.size();
        if (sSize < pSize) return {};

        unordered_map<char, int> pFreq;
        unordered_map<char, int> subFreq;
        int left = 0;
        int right = p.size() - 1;
        vector<int> res;

        // 记录字符串p中各个字符出现的频数
        for (char & c : p) ++pFreq[c];
        // 初始化滑动窗口内子串中各个字符出现的频数
        for (int i = 0; i <= right; ++i) ++subFreq[s[i]];
        if (pFreq == subFreq) res.push_back(left);
        // 滑动窗口
        while (right < sSize - 1) {
            // 移动左边界
            if (--subFreq[s[left]] == 0) subFreq.erase(s[left]);
            ++left;
            // 移动右边界
            ++subFreq[s[++right]];
            // 判断子串是否是异位词
            if (pFreq == subFreq) res.push_back(left);
        }
        return res;
    }
};

方法二：优化滑动窗口+哈希表

思路

方法一每次判断当前子串是否是异位词的时候都需要遍历一遍哈希表，此处可以优化。
不再使用两个哈希表来存储两个字符串（s的子串和字符串p）的字符频数，而是使用一个哈希表来存储各个字符在两个字符串中的差值，当差值为0说明该字符的数量在两个字符串中相等，然后使用一个变量diff记录哈希表中不为0的数量，当diff为0说明此时两个字符串互为异位词，窗口滑动过程中只需更新哈希表和diff，判断当前子串是否是异位词只需查看diff即可。

时间复杂度： $O (n + m + c)$ 。
空间复杂度： $O (c)$ ，只用一个哈希表，方法一需要两个哈希表。

C++代码

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int sSize = s.size();
        int pSize = p.size();
        if (sSize < pSize) return {};

        int count[26] = {0};
        int diff = 0;
        vector<int> res;

        // 滑动窗口一开始在s的最左端，与p一样长，统计有多少的字符的频数不一样
        for (int i = 0; i < pSize; ++i) {
            ++count[s[i] - 'a'];
            --count[p[i] - 'a'];
        }
        for (int i = 0; i < 26; ++i) if (count[i] != 0) ++diff;
        if (diff == 0) res.push_back(0);

        for (int i = 0; i < sSize - pSize; ++i) {
            if (count[s[i] - 'a'] == 1) --diff;
            else if (count[s[i] - 'a'] == 0) ++diff;
            --count[s[i] - 'a'];
            if (count[s[i + pSize] - 'a'] == -1) --diff;
            else if (count[s[i + pSize] - 'a'] == 0) ++diff;
            ++count[s[i + pSize] - 'a'];
            if (diff == 0) res.push_back(i + 1);
        }
        return res;
    }
};