Day6&7 哈希表相关

写给二刷时候的自己：着重看 15. 三数之和、18. 四数之和 和 349. 两个数组的交集、202. 快乐数

1. 242.有效的字母异位词

最基本的哈希表型题目，没有什么太多可以说的。

class Solution {
public:
    bool isAnagram(string s, string t) {
        vector hash(26, 0);
        for (char ch : s) {
            int index = ch - 'a';
            hash[index]++;
        }
        for (char ch : t) {
            int index = ch - 'a';
            hash[index]--;
        }
        for (int i : hash) {
            if (i != 0) return false;
        }
        return true;
    }
};

2. 349. 两个数组的交集

初识unordered_set，注意写注释的地方！

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;
        unordered_set<int> nums_map(nums1.begin(), nums1.end()); // 1. 利用迭代器创建set的方式
        for (int num : nums2) {
            if (nums_map.find(num) != nums_map.end()) { // 2. 查找元素是否在set中出现的方式
                result.insert(num); // 3. 向set中插入元素的方式
            }
        }
        return vector<int>(result.begin(), result.end()); // 4. 将set转换为vector的方式
    }
};

3. 202. 快乐数

可以着重再看一下快乐数的计算函数是怎么写的，反而实际的判断逻辑做到过了就很简单了。

class Solution {
public:
    int getNumber(int n) { // 这里可以看一下，有点容易忘
        int sum = 0;
        while (n) {
            sum += (n % 10) * (n % 10);
            n = n / 10;
        }
        return sum;
    }

    bool isHappy(int n) {
        unordered_set<int> num_set;
        while (n != 1) {
            n = getNumber(n);
            if (num_set.find(n) == num_set.end()) {num_set.insert(n);}
            else return false;
        }
        return true;
    }
};

4. 1. 两数之和

初识unordered_map。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> res_map;
        for (int i = 0; i < nums.size(); i++) {
            auto iter = res_map.find(target - nums[i]);
            if (iter != res_map.end()) {
                return {iter->second, i};
            } else {
                res_map.insert(pair<int, int>(nums[i], i));
            }
        }
        return {};
    }
};

5. 454. 四数相加 II

只要可以重复，就很简单，用unordered_map就搞定了。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;
        for (int i : nums1) {
            for (int j : nums2) {
                umap[i + j]++;
            }
        }
        int sum = 0;
        for (int i : nums3) {
            for (int j : nums4) {
                if (umap[0 - (i + j)] != 0) {
                    sum += umap[0 - (i + j)];
                }
            }
        }
        return sum;
    }
};

6. 383. 赎金信

可以理解为#1的变体。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        if (ransomNote.size() > magazine.size()) {
            return false;
        }
        vector<int> letters(26, 0);
        for (char ch : magazine) {
            letters[ch - 'a']++;
        }
        for (char ch : ransomNote) {
            letters[ch - 'a']--;
            if (letters[ch - 'a'] < 0) {
                return false;
            }
        }

        return true;
    }
};

7. 15. 三数之和

真正的难点来了！ 一定注意去重逻辑怎么写。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        int size = nums.size();
        for (int i = 0; i < size; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) { // 去重逻辑，注意要加上i > 0否则可能会直接跳出
                continue;
            }
            int start = i + 1;
            int end = size - 1;
            while (start < end) {
                if (nums[start] + nums[end] + nums[i] > 0)
                    end--;
                else if (nums[start] + nums[end] + nums[i] < 0)
                    start++;
                else {
                    result.push_back(
                        vector<int>{nums[i], nums[start], nums[end]}); // 注意这里的构造函数的大括号
                    while (start < end && nums[start] == nums[start + 1])
                        start++;
                    start++;
                    while (start < end && nums[end] == nums[end - 1])
                        end--;
                    end--;
                }
            }
        }
        return result;
    }
};

8. 18. 四数之和

这是这种不能重复的多数之和的究极模板！

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        int size = nums.size();
        sort(nums.begin(), nums.end());
        for (int i = 0; i < size; i++) {
            if (nums[i] > target && nums[i] >= 0) { // 一级剪枝
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            for (int j = i + 1; j < size; j++) {
                if (nums[i] + nums[j] > target &&
                    nums[i] + nums[j] >= 0) { // 二级剪枝
                    break;
                }
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }

                // twoSum
                int start = j + 1;
                int end = size - 1;
                while (start < end) {
                    if ((long) nums[i] + nums[j] + nums[start] + nums[end] == target) { // 注意这里一定要加个long，要不然可能会溢出
                        result.push_back(vector<int>{nums[i], nums[j],
                                                     nums[start], nums[end]});
                        while (start < end && nums[start] == nums[start + 1])
                            start++;
                        start++;

                        while (start < end && nums[end] == nums[end - 1])
                            end--;
                        end--;
                    } else if ((long)nums[i] + nums[j] + nums[start] + nums[end] <
                               target)
                        start++;
                    else
                        end--;
                }
            }
        }
        return result;
    }
};