刷题 -哈希

面试面试经典 150 题 - 哈希

383. 赎金信 - 一个哈希表搞定

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int hash[26] = {0};
        for (auto& ch : magazine) {
            hash[ch - 'a']++;
        }
        for (auto& ch : ransomNote) {
            if (--hash[ch - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

205. 同构字符串⭐️⭐️⭐️ - 双向映射 - 两个哈希表

错误写法

// 错误写法
class Solution {
public:
    bool isIsomorphic(string s, string t) {
        if (s.size() != t.size()) return false;
        int hash_s[26] = {0}, hash_t[26] = {0};
        for (int i = 0; i < s.size(); ++i) {
            if (++hash_s[s[i] - 'a'] != ++hash_t[t[i] - 'a']) {
                return false;
            }
        }
        return true;
    }
};

双向映射 - 两个大小为128 的array

class Solution {
public:
    // 注意：s 和 t 由任意有效的 ASCII 字符组成
    // --> array 大小为128，而不是 26
    bool isIsomorphic(string s, string t) {
        if (s.size() != t.size()) return false;
        array<char, 128> s2t = {0};
        array<char, 128> t2s = {0}; 
        for (int i = 0; i < s.size(); ++i) {
            char s_char = s[i];
            char t_char = t[i];
            if (s2t[s_char] == 0 && t2s[t_char] == 0) {
                s2t[s_char] = t_char;
                t2s[t_char] = s_char;
            } else if (s2t[s_char] != t_char || t2s[t_char] != s_char) {
                return false;
            }
        }
        return true;
    }
};

290. 单词规律⭐️⭐️⭐️ - 双向映射 - 两个哈希表

class Solution {
public:
    // 两个哈希表建立一一对应关系
    bool wordPattern(string pattern, string s) {
        unordered_map<char, string> p2s;
        unordered_map<string, char> s2p;
        size_t start = 0;
        for (size_t i = 0; i < pattern.size(); ++i) {
            if (start >= s.size()) return false;    // *** 不够用，返回false ***
            size_t j = start;
            while (j < s.size() && s[j] != ' ') {
                ++j;
            }
            char& ch = pattern[i];
            string str = s.substr(start, j - start);
            start = j + 1;
            if (p2s.find(ch) != p2s.end() && p2s[ch] != str) {
                return false;
            } 
            if (s2p.find(str) != s2p.end() && s2p[str] != ch) {
                return false;
            }
            p2s[ch] = str;
            s2p[str] = ch;
        }
        if (start < s.size()) return false; // *** 没用完，返回 false ***
        return true;
    }
};

242. 有效的字母异位词

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size()) return false;
        array<int, 26> hash;
        for (auto& ch : s) {
            hash[ch - 'a']++;
        }
        for (auto& ch : t) {
            if (--hash[ch - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

❤️49. 字母异位词分组⭐️⭐️⭐️ - 手动构建哈希索引

将排序后的字母作为哈希索引

将字母出现频次拼成字符串作为索引

1. 两数之和 - 哈希表存储 {val, index}

class Solution {
public:
    // 哈希表存储 {val, index}
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> map;
        int n = nums.size();
        for (int i = 0; i < n; ++i) {
            if (map.find(target - nums[i]) != map.end()) {
                return {i, map[target - nums[i]]};
            }
            map[nums[i]] = i;
        }
        return {-1, -1};
    }
};

202. 快乐数⭐️⭐️⭐️ - 循环问题- 双指针

哈希表存储循环过程

class Solution {
public:
    int transfer(int n) {
        int sum = 0;
        while (n) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    // 哈希表
    bool isHappy(int n) {
        unordered_set<int> st;
        while (n != 1) {
            if (st.find(n) != st.end()) {
                return false;
            }
            st.insert(n);
            n = transfer(n);
        }
        return true;
    }
};

快慢指针

class Solution {
public:
    int transfer(int n) {
        int sum = 0;
        while (n) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    // 判断循环可以使用快慢指针
    bool isHappy(int n) {
        int slow = n, fast = transfer(n);
        // 使用快慢指针检测循环
        while (fast != 1 && slow != fast) {
            slow = transfer(slow);       // 慢指针走一步
            fast = transfer(transfer(fast));  // 快指针走两步
        }
        return fast == 1;
    }
};

❤️128. 最长连续序列

❤️219. 存在重复元素 II